)
258 | | ({ isReady: true } & PaQ);
259 |
260 | export type NextRouter =
261 | BaseRouter> &
262 | Omit<
263 | Router,
264 | | "defaultLocale"
265 | | "domainLocales"
266 | | "isReady"
267 | | "locale"
268 | | "locales"
269 | | "pathname"
270 | | "push"
271 | | "query"
272 | | "replace"
273 | | "route"
274 | > & {
275 | defaultLocale${
276 | i18n.defaultLocale ? `: "${i18n.defaultLocale}"` : "?: undefined"
277 | };
278 | domainLocales${
279 | i18n.domains?.length ? `: ${print(i18n.domains, 8)}` : "?: undefined"
280 | };
281 | locale${!i18n.locales.length ? "?:" : ":"} Locale;
282 | locales${
283 | i18n.locales.length ? `: ${print(i18n.locales, 8)}` : "?: undefined"
284 | };
285 | push(
286 | url: Route | StaticRoute | Omit,
287 | as?: string,
288 | options?: TransitionOptions
289 | ): Promise;
290 | replace(
291 | url: Route | StaticRoute | Omit,
292 | as?: string,
293 | options?: TransitionOptions
294 | ): Promise;
295 | route: P;
296 | };
297 |
298 | export function useRouter(): NextRouter
;
299 | }
300 | `;
301 |
302 | if (config.usingAppDirectory) {
303 | output += `\
304 |
305 | // prettier-ignore
306 | declare module "next/navigation" {
307 | export * from "next/dist/client/components/navigation";
308 | import type { Route, RouteLiteral, RoutedQuery } from "nextjs-routes";
309 | import type { AppRouterInstance as NextAppRouterInstance, NavigateOptions, PrefetchOptions } from "next/dist/shared/lib/app-router-context.shared-runtime";
310 |
311 | type StaticRoute = Exclude["pathname"];
312 |
313 | /**
314 | * A [Client Component](https://nextjs.org/docs/app/building-your-application/rendering/client-components) hook
315 | * that lets you read the current URL's pathname.
316 | *
317 | * @example
318 | * \`\`\`ts
319 | * "use client"
320 | * import { usePathname } from 'next/navigation'
321 | *
322 | * export default function Page() {
323 | * const pathname = usePathname() // returns "/dashboard" on /dashboard?foo=bar
324 | * // ...
325 | * }
326 | * \`\`\`
327 | *
328 | * Read more: [Next.js Docs: \`usePathname\`](https://nextjs.org/docs/app/api-reference/functions/use-pathname)
329 | */
330 | export const usePathname: () => RouteLiteral;
331 |
332 | type AppRouterInstance = Omit & {
333 | push(href: StaticRoute | RouteLiteral, options?: NavigateOptions): void;
334 | replace(href: StaticRoute | RouteLiteral, options?: NavigateOptions): void;
335 | prefetch(href: StaticRoute | RouteLiteral, options?: PrefetchOptions): void;
336 | }
337 |
338 | /**
339 | *
340 | * This hook allows you to programmatically change routes inside [Client Component](https://nextjs.org/docs/app/building-your-application/rendering/client-components).
341 | *
342 | * @example
343 | * \`\`\`ts
344 | * "use client"
345 | * import { useRouter } from 'next/navigation'
346 | *
347 | * export default function Page() {
348 | * const router = useRouter()
349 | * // ...
350 | * router.push('/dashboard') // Navigate to /dashboard
351 | * }
352 | * \`\`\`
353 | *
354 | * Read more: [Next.js Docs: \`useRouter\`](https://nextjs.org/docs/app/api-reference/functions/use-router)
355 | */
356 | export function useRouter(): AppRouterInstance;
357 |
358 | /**
359 | * A [Client Component](https://nextjs.org/docs/app/building-your-application/rendering/client-components) hook
360 | * that lets you read a route's dynamic params filled in by the current URL.
361 | *
362 | * @example
363 | * \`\`\`ts
364 | * "use client"
365 | * import { useParams } from 'next/navigation'
366 | *
367 | * export default function Page() {
368 | * // on /dashboard/[team] where pathname is /dashboard/nextjs
369 | * const { team } = useParams() // team === "nextjs"
370 | * }
371 | * \`\`\`
372 | *
373 | * Read more: [Next.js Docs: \`useParams\`](https://nextjs.org/docs/app/api-reference/functions/use-params)
374 | */
375 | export const useParams: () => RoutedQuery;
376 | }
377 | `;
378 | }
379 | return output;
380 | }
381 |
382 | function print(x: unknown, indent: number): string {
383 | return JSON.stringify(x, undefined, 2)
384 | .split("\n")
385 | .join("\n" + " ".repeat(indent));
386 | }
387 |
388 | export interface NextJSRoutesOptions {
389 | /**
390 | * Location of the Next.js project. Defaults to the current working directory.
391 | *
392 | * This is only necessary when working with a non standard NextJS project setup, such as Nx.
393 | *
394 | * Example:
395 | *
396 | * // next.config.js
397 | * const nextRoutes = require("nextjs-routes/config")
398 | * const withRoutes = nextRoutes({ dir: __dirname });
399 | */
400 | dir?: string | undefined;
401 | /**
402 | * The file path indicating the output directory where the generated route types
403 | * should be written to (e.g.: "types").
404 | */
405 | outDir?: string | undefined;
406 | /**
407 | * NextJS config option.
408 | * https://nextjs.org/docs/api-reference/next.config.js/custom-page-extensions
409 | */
410 | pageExtensions?: string[] | undefined;
411 | /**
412 | * Internationalization configuration
413 | *
414 | * @see [Internationalization docs](https://nextjs.org/docs/advanced-features/i18n-routing)
415 | */
416 | i18n?: I18NConfig | null | undefined;
417 | }
418 |
419 | interface Opts {
420 | pageExtensions: string[];
421 | directory: string;
422 | }
423 |
424 | function commonProcessing(paths: string[], opts: Opts): string[] {
425 | return (
426 | paths
427 | // filter page extensions
428 | .filter((file) => {
429 | return opts.pageExtensions.some((ext) => file.endsWith(ext));
430 | })
431 | // remove file extensions (.tsx, .test.tsx)
432 | .map((file) => file.replace(/(\.\w+)+$/, ""))
433 | // remove duplicates from file extension removal (eg foo.ts and foo.test.ts)
434 | .filter((file, idx, array) => array.indexOf(file) === idx)
435 | // remove page directory path
436 | .map((file) => file.replace(opts.directory, ""))
437 | // normalize paths from windows users
438 | .map(convertWindowsPathToUnix)
439 | );
440 | }
441 |
442 | const APP_DIRECTORY_ROUTABLE_DIRECTORIES = ["page", "route"];
443 |
444 | const APP_INTERCEPTING_ROUTE = ["(.)", "(..)", "(..)(..)", "(...)"];
445 |
446 | function appDirectoryRoutable(file: string): boolean {
447 | const name = parse(file).name;
448 | return (
449 | // only consider page and route
450 | APP_DIRECTORY_ROUTABLE_DIRECTORIES.includes(name) &&
451 | // remove any filepaths that contain intercepts
452 | !APP_INTERCEPTING_ROUTE.some((intercept) => file.includes(intercept))
453 | );
454 | }
455 |
456 | export function getAppRoutes(files: string[], opts: Opts): string[] {
457 | return (
458 | commonProcessing(files, opts)
459 | .filter(appDirectoryRoutable)
460 | .map((file) =>
461 | // transform filepath to url path
462 | file
463 | .split("/")
464 | // remove named groups
465 | .filter(
466 | (segment) => !(segment.startsWith("(") && segment.endsWith(")")),
467 | )
468 | // remove page + route from path
469 | .filter(
470 | (segment) =>
471 | !APP_DIRECTORY_ROUTABLE_DIRECTORIES.includes(parse(segment).name),
472 | )
473 | // remove slots
474 | .filter((segment) => !segment.startsWith("@"))
475 | .join("/"),
476 | )
477 | // handle index page
478 | .map((file) => (file === "" ? "/" : file))
479 | );
480 | }
481 |
482 | const NEXTJS_NON_ROUTABLE = ["/_app", "/_document", "/_error", "/middleware"];
483 |
484 | export function getPageRoutes(files: string[], opts: Opts): string[] {
485 | return (
486 | commonProcessing(files, opts)
487 | // remove index if present (/foos/index.ts is the same as /foos.ts)
488 | .map((file) => file.replace(/index$/, ""))
489 | // remove trailing slash if present
490 | .map((file) =>
491 | file.endsWith("/") && file.length > 2 ? file.slice(0, -1) : file,
492 | )
493 | // exclude nextjs special routes
494 | .filter((file) => !NEXTJS_NON_ROUTABLE.includes(file))
495 | );
496 | }
497 |
498 | export function writeNextJSRoutes(options: NextJSRoutesOptions): void {
499 | const defaultOptions = {
500 | usingPagesDirectory: false,
501 | usingAppDirectory: false,
502 | dir: process.cwd(),
503 | outDir: join(options.dir ?? process.cwd(), "@types"),
504 | pageExtensions: ["tsx", "ts", "jsx", "js"],
505 | };
506 | const opts = {
507 | ...defaultOptions,
508 | ...options,
509 | };
510 | const files = [];
511 | const pagesDirectory = getPagesDirectory(opts.dir);
512 | if (pagesDirectory) {
513 | const routes = getPageRoutes(findFiles(pagesDirectory), {
514 | pageExtensions: opts.pageExtensions,
515 | directory: pagesDirectory,
516 | });
517 | files.push(...routes);
518 | opts.usingPagesDirectory = true;
519 | }
520 | const appDirectory = getAppDirectory(opts.dir);
521 | if (appDirectory) {
522 | const routes = getAppRoutes(findFiles(appDirectory), {
523 | pageExtensions: opts.pageExtensions,
524 | directory: appDirectory,
525 | });
526 | files.push(...routes);
527 | opts.usingAppDirectory = true;
528 | }
529 | const outputFilepath = join(opts.outDir, "nextjs-routes.d.ts");
530 | if (opts.outDir && !existsSync(opts.outDir)) {
531 | mkdirSync(opts.outDir, { recursive: true });
532 | }
533 | const routes = nextRoutes(files);
534 | const generated = generate(routes, opts);
535 | writeFileSync(outputFilepath, generated);
536 | }
537 |
--------------------------------------------------------------------------------
/packages/nextjs-routes/src/index.ts:
--------------------------------------------------------------------------------
1 | interface Route {
2 | pathname: string;
3 | query?: { [key: string]: string | string[] | undefined };
4 | hash?: string | null | undefined;
5 | }
6 |
7 | interface OptionalCatchAll extends Route {
8 | query?: { [key: string]: string[] | undefined };
9 | }
10 |
11 | interface CatchAll extends Route {
12 | query: { [key: string]: string[] };
13 | }
14 |
15 | interface Dynamic extends Route {
16 | query: { [key: string]: string };
17 | }
18 |
19 | interface RouteOptions {
20 | trailingSlash?: boolean;
21 | }
22 |
23 | export function route(
24 | r: Route,
25 | options: RouteOptions = { trailingSlash: false },
26 | ): string {
27 | const params = new Set();
28 | let path =
29 | "/" +
30 | r.pathname
31 | .split("/")
32 | .map((segment) => {
33 | // optional catch all
34 | if (segment.startsWith("[[...") && segment.endsWith("]]")) {
35 | const query = segment.slice(5, -2);
36 | params.add(query);
37 | return (r as OptionalCatchAll).query?.[query]?.join("/");
38 | }
39 | // catch all
40 | if (segment.startsWith("[...") && segment.endsWith("]")) {
41 | const query = segment.slice(4, -1);
42 | params.add(query);
43 | return (r as CatchAll).query[query].join("/");
44 | }
45 | // dynamic
46 | if (segment.startsWith("[") && segment.endsWith("]")) {
47 | const query = segment.slice(1, -1);
48 | params.add(query);
49 | return (r as Dynamic).query[query];
50 | }
51 | return segment;
52 | })
53 | // removes optional catch all if no query is supplied
54 | .filter(Boolean)
55 | .join("/");
56 |
57 | if (options.trailingSlash) {
58 | path += "/";
59 | }
60 |
61 | const search = new URLSearchParams();
62 | for (const key in r.query) {
63 | if (!params.has(key)) {
64 | const value = r.query[key];
65 | if (Array.isArray(value)) {
66 | value.forEach((val) => search.append(key, val));
67 | } else if (value !== undefined) {
68 | search.append(key, value);
69 | }
70 | }
71 | }
72 | const qs = search.toString().length > 0 ? "?" + search.toString() : "";
73 | const hash = r.hash ? "#" + r.hash : "";
74 |
75 | return path + qs + hash;
76 | }
77 |
--------------------------------------------------------------------------------
/packages/nextjs-routes/src/logger.ts:
--------------------------------------------------------------------------------
1 | export const logger: Pick = {
2 | error: (str: string) => console.error("[nextjs-routes] " + str),
3 | info: (str: string) => console.info("[nextjs-routes] " + str),
4 | };
5 |
--------------------------------------------------------------------------------
/packages/nextjs-routes/src/test/core.test.ts:
--------------------------------------------------------------------------------
1 | import { existsSync, writeFileSync } from "fs";
2 | import { writeNextJSRoutes } from "../core.js";
3 | import { findFiles } from "../utils.js";
4 |
5 | // eslint-disable-next-line @typescript-eslint/no-unsafe-return
6 | jest.mock("fs", () => ({
7 | ...jest.requireActual("fs"),
8 | writeFileSync: jest.fn(),
9 | existsSync: jest.fn(() => false),
10 | mkdirSync: jest.fn(),
11 | }));
12 | const writeFileSyncMock = writeFileSync as jest.Mock;
13 | const existsSyncMock = existsSync as jest.Mock;
14 | jest.spyOn(process, "cwd").mockReturnValue("");
15 |
16 | // eslint-disable-next-line @typescript-eslint/no-unsafe-return
17 | jest.mock("../utils.js", () => ({
18 | ...jest.requireActual("../utils.js"),
19 | findFiles: jest.fn(),
20 | }));
21 | const findFilesMock = findFiles as jest.Mock;
22 |
23 | describe("route generation", () => {
24 | it("no routes", () => {
25 | // getPageRoutes
26 | existsSyncMock.mockImplementationOnce(() => true);
27 | findFilesMock.mockReturnValueOnce([]);
28 | writeNextJSRoutes({});
29 | expect(writeFileSyncMock.mock.calls).toMatchSnapshot();
30 | });
31 |
32 | it("transforms windows paths", () => {
33 | // getPageRoutes src/pages
34 | existsSyncMock
35 | .mockImplementationOnce(() => false)
36 | .mockImplementationOnce(() => true);
37 | findFilesMock.mockReturnValueOnce(["src\\pages\\[foo]\\bar\\index.ts"]);
38 | writeNextJSRoutes({});
39 | expect(writeFileSyncMock.mock.calls).toMatchSnapshot();
40 | });
41 |
42 | it("dedupes", () => {
43 | // getPageRoutes
44 | existsSyncMock.mockImplementationOnce(() => true);
45 | findFilesMock.mockReturnValueOnce(["pages/index.tsx", "pages/index.ts"]);
46 | writeNextJSRoutes({});
47 | expect(writeFileSyncMock.mock.calls).toMatchSnapshot();
48 | });
49 |
50 | it("typescript", () => {
51 | // getPageRoutes
52 | existsSyncMock.mockImplementationOnce(() => true);
53 | findFilesMock.mockReturnValueOnce([
54 | "pages/404.ts",
55 | "pages/[foo].ts",
56 | "pages/[foo]/[bar]/[baz].ts",
57 | "pages/[foo]/bar/[baz].ts",
58 | "pages/[foo]/bar/[baz]/foo/[bar].ts",
59 | "pages/[foo]/baz.ts",
60 | "pages/_app.ts",
61 | "pages/middleware.ts",
62 | "pages/_debug.ts",
63 | "pages/_debug/health-check.ts",
64 | "pages/_document.ts",
65 | "pages/_error.ts",
66 | "pages/_error/index.ts",
67 | "pages/api/[[...segments]].ts",
68 | "pages/api/[...segments].ts",
69 | "pages/api/bar.ts",
70 | "pages/foo/[slug].ts",
71 | "pages/index.ts",
72 | "pages/not-found.ts",
73 | "pages/settings/bars/[bar].ts",
74 | "pages/settings/bars/[bar]/baz.ts",
75 | "pages/settings/foo.ts",
76 | "pages/settings/index.ts",
77 | ]);
78 | writeNextJSRoutes({});
79 | expect(writeFileSyncMock.mock.calls).toMatchSnapshot();
80 | });
81 |
82 | describe("app directory", () => {
83 | it("generates routes", () => {
84 | // getAppRoutes
85 | existsSyncMock
86 | .mockImplementationOnce(() => false)
87 | .mockImplementationOnce(() => false)
88 | .mockImplementationOnce(() => true);
89 | findFilesMock.mockReturnValueOnce([
90 | "app/page.ts",
91 | "app/bar/page.ts",
92 | "app/foo/page.tsx",
93 | "app/foobar/page.js",
94 | "app/barbaz/page.jsx",
95 | "app/baz/route.js",
96 | "app/foobaz/route.ts",
97 | ]);
98 | writeNextJSRoutes({});
99 | expect(writeFileSyncMock.mock.calls).toMatchSnapshot();
100 | });
101 |
102 | it("handles intercept routes", () => {
103 | // getAppRoutes
104 | existsSyncMock
105 | .mockImplementationOnce(() => false)
106 | .mockImplementationOnce(() => false)
107 | .mockImplementationOnce(() => true);
108 | findFilesMock.mockReturnValueOnce([
109 | "app/(..)photo/[id]/page.ts",
110 | "app/photo/[id]/page.ts",
111 | "app/foo/(...)bar/page.ts",
112 | "app/foobar/(.)baz/page.ts",
113 | "app/foobar/(..)baz/page.ts",
114 | ]);
115 | writeNextJSRoutes({});
116 | expect(writeFileSyncMock.mock.calls).toMatchSnapshot();
117 | });
118 |
119 | it("handles parallel routes", () => {
120 | // getAppRoutes
121 | existsSyncMock
122 | .mockImplementationOnce(() => false)
123 | .mockImplementationOnce(() => false)
124 | .mockImplementationOnce(() => true);
125 | findFilesMock.mockReturnValueOnce([
126 | "app/@team/settings/page.ts",
127 | "app/@analytics/page.ts",
128 | ]);
129 | writeNextJSRoutes({});
130 | expect(writeFileSyncMock.mock.calls).toMatchSnapshot();
131 | });
132 |
133 | it("handles windows paths", () => {
134 | // get AppRoutes
135 | existsSyncMock
136 | .mockImplementationOnce(() => false)
137 | .mockImplementationOnce(() => false)
138 | .mockImplementationOnce(() => true);
139 | findFilesMock.mockReturnValueOnce(["app\\[foo]\\bar\\page.ts"]);
140 | writeNextJSRoutes({});
141 | expect(writeFileSyncMock.mock.calls).toMatchSnapshot();
142 | });
143 | });
144 |
145 | describe("pages and app directory", () => {
146 | it("generates routes", () => {
147 | existsSyncMock
148 | // getPageRoutes
149 | .mockImplementationOnce(() => true)
150 | // getAppRoutes
151 | .mockImplementationOnce(() => true);
152 | findFilesMock
153 | // page routes
154 | .mockReturnValueOnce(["pages/[foo].ts"])
155 | // app routes
156 | .mockReturnValueOnce(["app/bar/page.ts", "app/page.ts"]);
157 | writeNextJSRoutes({});
158 | expect(writeFileSyncMock.mock.calls).toMatchSnapshot();
159 | });
160 | });
161 |
162 | describe("configuration", () => {
163 | describe("pageExtensions", () => {
164 | it("default", () => {
165 | // getPageRoutes
166 | existsSyncMock.mockImplementationOnce(() => true);
167 | findFilesMock.mockReturnValueOnce(["pages/404.ts", "pages/404.md"]);
168 | writeNextJSRoutes({});
169 | expect(writeFileSyncMock.mock.calls).toMatchSnapshot();
170 | });
171 |
172 | it("configured", () => {
173 | // getPageRoutes
174 | existsSyncMock.mockImplementationOnce(() => true);
175 | findFilesMock.mockReturnValueOnce([
176 | "pages/404.ts",
177 | "pages/index.md",
178 | "pages/foo/index.page.tsx",
179 | "pages/foo/index.test.tsx",
180 | ]);
181 | writeNextJSRoutes({
182 | pageExtensions: ["ts", "md", "page.tsx"],
183 | });
184 | expect(writeFileSyncMock.mock.calls).toMatchSnapshot();
185 | });
186 | });
187 |
188 | it("outDir", () => {
189 | // getPageRoutes
190 | existsSyncMock.mockImplementationOnce(() => true);
191 | findFilesMock.mockReturnValueOnce(["pages/404.ts"]);
192 | writeNextJSRoutes({ outDir: "src" });
193 | expect(writeFileSyncMock.mock.calls).toMatchSnapshot();
194 | });
195 |
196 | it("i18n", () => {
197 | // getPageRoutes
198 | existsSyncMock.mockImplementationOnce(() => true);
199 | findFilesMock.mockReturnValueOnce(["pages/index.ts"]);
200 | writeNextJSRoutes({
201 | i18n: {
202 | locales: ["en-US", "fr", "nl-NL"],
203 | defaultLocale: "en-US",
204 | domains: [
205 | {
206 | domain: "example.nl",
207 | defaultLocale: "nl-NL",
208 | locales: ["nl-BE"],
209 | },
210 | {
211 | domain: "example.fr",
212 | defaultLocale: "fr",
213 | http: true,
214 | },
215 | ],
216 | },
217 | });
218 | expect(writeFileSyncMock.mock.calls).toMatchSnapshot();
219 | });
220 | });
221 | });
222 |
--------------------------------------------------------------------------------
/packages/nextjs-routes/src/test/index.test.ts:
--------------------------------------------------------------------------------
1 | import { route } from "../index.js";
2 |
3 | describe(route, () => {
4 | describe("generates paths", () => {
5 | // prettier-ignore
6 | test.each([
7 | [{ pathname: "/404" }, "/404"],
8 | [{ pathname: "/settings/about" }, "/settings/about"],
9 | // dynamic
10 | [{ pathname: "/foos/[foo]", query: { foo: "bar" } }, "/foos/bar"],
11 | [{ pathname: "/foos/[foo]/bars/[bar]", query: { foo: "bar", bar: "baz" } }, "/foos/bar/bars/baz"],
12 | [{ pathname: "/[foo]/[bar]/[baz]", query: { foo: "foo", bar: "bar", baz: "baz" } }, "/foo/bar/baz"],
13 | // catch all
14 | [{ pathname: "/[...segments]", query: { segments: ["foo"] } }, "/foo"],
15 | [{ pathname: "/[...segments]", query: { segments: ["foo", "bar"] } }, "/foo/bar"],
16 | // optional catch all
17 | [{ pathname: "/[[...segments]]", query: { segments: [] } }, "/"],
18 | [{ pathname: "/[[...segments]]", query: { segments: undefined } }, "/"],
19 | [{ pathname: "/[[...segments]]/foos", query: { segments: undefined } }, "/foos"],
20 | // query params
21 | [{ pathname: "/foos/[foo]", query: { foo: "foo", bar: "bar" } }, "/foos/foo?bar=bar"],
22 | [{ pathname: "/foos/[foo]", query: { foo: "foo", bar: "bar", baz: ["1", "2", "3"] } }, "/foos/foo?bar=bar&baz=1&baz=2&baz=3"],
23 | [{ pathname: "/foos/[foo]", query: { foo: "foo", bar: "bar", baz: ["1", "2", "3"] }, hash: "foo" }, "/foos/foo?bar=bar&baz=1&baz=2&baz=3#foo"],
24 | [{ pathname: "/foos/[foo]", query: { foo: "foo", bar: undefined, baz: '', foobar: '' } }, "/foos/foo?baz=&foobar="],
25 | ])("generates paths for %o", (input, expected) => {
26 | expect(route(input)).toEqual(expected);
27 | });
28 | });
29 |
30 | describe("options", () => {
31 | describe("trailingSlash", () => {
32 | describe.each([
33 | ["/settings/about", undefined, true, "/settings/about/"],
34 | ["/settings/about", undefined, false, "/settings/about"],
35 | ["/foos/[foo]", { foo: "bar" }, true, "/foos/bar/"],
36 | ["/foos/[foo]", { foo: "bar" }, false, "/foos/bar"],
37 | ])(
38 | "route(%p, { trailingSlash: %p })",
39 | (pathname, query, trailingSlash, expectedResult) => {
40 | it(`returns ${expectedResult}`, () => {
41 | expect(route({ pathname, query }, { trailingSlash })).toEqual(
42 | expectedResult,
43 | );
44 | });
45 | },
46 | );
47 | });
48 | });
49 | });
50 |
--------------------------------------------------------------------------------
/packages/nextjs-routes/src/test/logger.test.ts:
--------------------------------------------------------------------------------
1 | import { logger } from "../logger.js";
2 |
3 | describe("logger", () => {
4 | describe("#error", () => {
5 | it("prefixes with [nextjs-routes]", () => {
6 | const consoleError = jest
7 | .spyOn(console, "error")
8 | .mockImplementation(() => {});
9 |
10 | logger.error("Some error");
11 | expect(consoleError).toHaveBeenCalledWith("[nextjs-routes] Some error");
12 | });
13 | });
14 |
15 | describe("#info", () => {
16 | it("prefixes with [nextjs-routes]", () => {
17 | const consoleInfo = jest
18 | .spyOn(console, "info")
19 | .mockImplementation(() => {});
20 |
21 | logger.info("Some info");
22 | expect(consoleInfo).toHaveBeenCalledWith("[nextjs-routes] Some info");
23 | });
24 | });
25 | });
26 |
--------------------------------------------------------------------------------
/packages/nextjs-routes/src/test/utils.test.ts:
--------------------------------------------------------------------------------
1 | import {
2 | getPagesDirectory,
3 | getAppDirectory,
4 | findFiles,
5 | isNotUndefined,
6 | } from "../utils.js";
7 | import mockFS from "mock-fs";
8 |
9 | describe(getPagesDirectory, () => {
10 | afterEach(() => {
11 | mockFS.restore();
12 | });
13 |
14 | it("finds pages in top level of directory", () => {
15 | mockFS({
16 | "/my-dir": {
17 | pages: {
18 | "file1.js": "content1",
19 | },
20 | },
21 | });
22 |
23 | expect(getPagesDirectory("/my-dir")).toEqual("/my-dir/pages");
24 | });
25 |
26 | it("finds pages in src directory", () => {
27 | mockFS({
28 | "/my-dir": {
29 | src: {
30 | pages: {
31 | "file1.js": "content1",
32 | },
33 | },
34 | },
35 | });
36 |
37 | expect(getPagesDirectory("/my-dir")).toEqual("/my-dir/src/pages");
38 | });
39 | });
40 |
41 | describe(getAppDirectory, () => {
42 | afterEach(() => {
43 | mockFS.restore();
44 | });
45 |
46 | it("finds app in top level of directory", () => {
47 | mockFS({
48 | "/my-dir": {
49 | app: {
50 | "file1.js": "content1",
51 | },
52 | },
53 | });
54 |
55 | expect(getAppDirectory("/my-dir")).toEqual("/my-dir/app");
56 | });
57 |
58 | it("finds app in src directory", () => {
59 | mockFS({
60 | "/my-dir": {
61 | src: {
62 | app: {
63 | "file1.js": "content1",
64 | },
65 | },
66 | },
67 | });
68 |
69 | expect(getAppDirectory("/my-dir")).toEqual("/my-dir/src/app");
70 | });
71 | });
72 |
73 | describe(findFiles, () => {
74 | afterEach(() => {
75 | mockFS.restore();
76 | });
77 |
78 | it("return a list of files in a directory", () => {
79 | mockFS({
80 | "/my-dir": {
81 | "file1.js": "content1",
82 | "file2.js": "content2",
83 | "sub-dir": {
84 | "file3.js": "content3",
85 | },
86 | },
87 | });
88 |
89 | expect(findFiles("/my-dir")).toEqual([
90 | "/my-dir/file1.js",
91 | "/my-dir/file2.js",
92 | "/my-dir/sub-dir/file3.js",
93 | ]);
94 | });
95 |
96 | it("ignores node_modules", () => {
97 | mockFS({
98 | "/my-dir": {
99 | "file1.js": "content1",
100 | node_modules: {
101 | "file2.js": "content2",
102 | },
103 | },
104 | });
105 |
106 | expect(findFiles("/my-dir")).toEqual(["/my-dir/file1.js"]);
107 | });
108 | });
109 |
110 | describe(isNotUndefined, () => {
111 | it("true when not undefined", () => {
112 | expect(isNotUndefined("hello")).toBe(true);
113 | });
114 |
115 | it("false when undefined", () => {
116 | expect(isNotUndefined(undefined)).toBe(false);
117 | });
118 | });
119 |
--------------------------------------------------------------------------------
/packages/nextjs-routes/src/utils.ts:
--------------------------------------------------------------------------------
1 | import { existsSync, readdirSync, statSync } from "fs";
2 | import { join } from "path";
3 |
4 | function findDir(cwd: string, dir: string): string | undefined {
5 | const paths = [join(cwd, dir), join(cwd, "src", dir)];
6 | for (const path of paths) {
7 | if (existsSync(path)) {
8 | return path;
9 | }
10 | }
11 | }
12 |
13 | export function getPagesDirectory(cwd: string): string | undefined {
14 | return findDir(cwd, "pages");
15 | }
16 |
17 | export function getAppDirectory(cwd: string): string | undefined {
18 | return findDir(cwd, "app");
19 | }
20 |
21 | export function findFiles(entry: string): string[] {
22 | return readdirSync(entry).flatMap((file) => {
23 | const filepath = join(entry, file);
24 | if (filepath.includes("node_modules")) {
25 | return [];
26 | }
27 | if (statSync(filepath).isDirectory()) {
28 | return findFiles(filepath);
29 | }
30 | return filepath;
31 | });
32 | }
33 |
34 | export function isNotUndefined(value: T | undefined): value is T {
35 | return value !== undefined;
36 | }
37 |
--------------------------------------------------------------------------------
/packages/nextjs-routes/src/version.ts:
--------------------------------------------------------------------------------
1 | export const version = "2.2.5";
2 |
--------------------------------------------------------------------------------
/packages/nextjs-routes/tsconfig.json:
--------------------------------------------------------------------------------
1 | {
2 | "extends": "../../tsconfig.json",
3 | "compilerOptions": {
4 | "outDir": "dist",
5 | "rootDir": "src"
6 | },
7 | "include": ["src/**/*"]
8 | }
9 |
--------------------------------------------------------------------------------
/packages/nextjs-routes/webpack.config.cjs:
--------------------------------------------------------------------------------
1 | // eslint-disable-next-line @typescript-eslint/no-require-imports
2 | const { join } = require("path");
3 |
4 | /**
5 | * @type {import('webpack').Configuration}
6 | */
7 | const common = {
8 | mode: "production",
9 | resolve: {
10 | extensionAlias: {
11 | ".js": [".ts", ".js"],
12 | },
13 | },
14 | module: {
15 | rules: [
16 | {
17 | test: /\.(m|c)?tsx?$/,
18 | exclude: /node_modules/,
19 | use: {
20 | loader: "swc-loader",
21 | options: {
22 | jsc: {
23 | target: "es2020",
24 | parser: {
25 | syntax: "typescript",
26 | },
27 | },
28 | },
29 | },
30 | },
31 | ],
32 | },
33 | };
34 |
35 | module.exports = [
36 | {
37 | ...common,
38 | target: "node",
39 | entry: {
40 | index: "./src/config.ts",
41 | },
42 | output: {
43 | filename: "config.cjs",
44 | // eslint-disable-next-line no-undef
45 | path: join(__dirname, "dist"),
46 | library: {
47 | type: "commonjs2",
48 | export: "default",
49 | },
50 | },
51 | externals: {
52 | chokidar: "chokidar",
53 | },
54 | externalsPresets: {
55 | node: true,
56 | },
57 | },
58 | {
59 | ...common,
60 | target: "node",
61 | entry: {
62 | index: "./src/index.ts",
63 | },
64 | output: {
65 | filename: "index.cjs",
66 | // eslint-disable-next-line no-undef
67 | path: join(__dirname, "dist"),
68 | libraryTarget: "commonjs2",
69 | },
70 | },
71 | ];
72 |
--------------------------------------------------------------------------------
/pnpm-workspace.yaml:
--------------------------------------------------------------------------------
1 | packages:
2 | - "packages/*"
3 | - "examples/*"
4 |
--------------------------------------------------------------------------------
/tsconfig.json:
--------------------------------------------------------------------------------
1 | {
2 | "compilerOptions": {
3 | "allowJs": true,
4 | "allowSyntheticDefaultImports": true,
5 | "declaration": true,
6 | "forceConsistentCasingInFileNames": true,
7 | "isolatedModules": true,
8 | "module": "esnext",
9 | "moduleResolution": "Node",
10 | "noEmitOnError": false,
11 | "outDir": "dist",
12 | "resolveJsonModule": true,
13 | "rootDir": "src",
14 | "skipLibCheck": true,
15 | "sourceMap": false,
16 | "strict": true,
17 | "target": "ES2020"
18 | }
19 | }
20 |
--------------------------------------------------------------------------------
9 | 
12 |
13 |
14 | 
15 |
16 |
17 | 
18 |
19 |
20 | 
21 |
22 |
23 |