ts-file-router 5.0.0 → 6.0.0

package/README.md

@@ -39,7 +39,6 @@ import { generateRoutes } from 'ts-file-router';
 generateRoutes({
   baseFolder: 'src/screens',
   outputFile: 'src/screens/routes.ts',
-  routeFileName: 'page.tsx',
 });
 ```
 
@@ -100,7 +99,7 @@ or setup generateRoutesPlugin in vite.config.ts
 export const routes = {
   page: {
     path: '/',
-    import: () => import('./page'),
+    import: import('./page'),
   },
 } as const;
 ```

package/dist/generator.d.ts

@@ -1,3 +1,3 @@
 import type { TGenerateRoutesConfig } from './types.js';
-export declare const generateRoutes: ({ baseFolder, outputFile, routeFileName, options, }: TGenerateRoutesConfig) => void;
+export declare const generateRoutes: ({ baseFolder, outputFile, options, }: TGenerateRoutesConfig) => void;
 //# sourceMappingURL=generator.d.ts.map

package/dist/generator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generator.d.ts","sourceRoot":"","sources":["../src/generator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAe,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAgBrE,eAAO,MAAM,cAAc,GAAI,qDAK5B,qBAAqB,SA2IvB,CAAC"}
+{"version":3,"file":"generator.d.ts","sourceRoot":"","sources":["../src/generator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAe,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAKrE,eAAO,MAAM,cAAc,GAAI,sCAI5B,qBAAqB,SA6IvB,CAAC"}

package/dist/generator.js

@@ -1,12 +1,7 @@
-import { serialize } from './serialize.js';
+import { FileHelper, SerializeHelper } from './helpers/index.js';
 import fs from 'fs/promises';
 import path from 'path';
-const getIgnoredOutputFile = (file, output) => file.includes(output);
-const getIgnoredFiles = (file, output) => file.includes('index') ||
-    file.startsWith('_') ||
-    getIgnoredOutputFile(file, output);
-const cleanPaths = (path) => path.replaceAll(/\\/gi, '/').replaceAll(/.(tsx|ts|jsx|js)/gi, '');
-export const generateRoutes = ({ baseFolder, outputFile, routeFileName = 'page.tsx', options = { exitCodeOnResolution: true }, }) => {
+export const generateRoutes = ({ baseFolder, outputFile, options = { exitCodeOnResolution: true }, }) => {
     // Get the pages dir to resolve routes
     const basePath = path.resolve(process.cwd(), baseFolder);
     // Output file for routes
@@ -14,12 +9,12 @@ export const generateRoutes = ({ baseFolder, outputFile, routeFileName = 'page.t
     const mapRoutes = async (dir) => {
         const routes = {};
         const directory = await fs.readdir(dir);
-        if (!directory.includes(routeFileName)) {
-            throw new Error(`Invalid pages structure: The folder "${dir}" must contain a ${routeFileName} file.`);
-        }
         for (const file of directory) {
+            if (!directory.length || directory.length === 0) {
+                throw new Error(`Invalid pages structure: The folder "${dir}" must contain at least one valid file.`);
+            }
             // ignore index files, underscore marked, or route file generated
-            if (getIgnoredFiles(file, outputFile)) {
+            if (FileHelper.getIgnoredFiles(file, outputFile)) {
                 continue;
             }
             const fullPath = path.join(dir, file);
@@ -27,7 +22,6 @@ export const generateRoutes = ({ baseFolder, outputFile, routeFileName = 'page.t
             const dirInfo = await fs.stat(fullPath);
             // Path to browser sync if necessary
             const relativePath = '/' + path.relative(basePath, dir);
-            // Normalize import path to esm pattern
             const importPath = './' + path.relative(basePath, fullPath);
             // Remove extension from file to naming the route
             const key = path.basename(file, path.extname(file));
@@ -39,10 +33,12 @@ export const generateRoutes = ({ baseFolder, outputFile, routeFileName = 'page.t
                 continue;
             }
             // Mount the route object with path like "/folder" and import
-            // import will be like "(./baseFolder/file or ./baseFolder/folders).extension"
+            // import will be like "import((./baseFolder/file or ./baseFolder/folders).extension)"
             routes[key] = {
-                path: cleanPaths(relativePath),
-                import: cleanPaths(importPath),
+                // Normalize path
+                path: FileHelper.cleanPaths(relativePath),
+                // Normalize import path to esm pattern
+                import: FileHelper.cleanPaths(importPath),
             };
         }
         return routes;
@@ -52,7 +48,7 @@ export const generateRoutes = ({ baseFolder, outputFile, routeFileName = 'page.t
             // Create routes
             const routes = await mapRoutes(basePath);
             // Create ts file
-            await serialize(routes, output);
+            await SerializeHelper.serializeOutputFile(routes, output);
             // Promise writeFile was successfully resolved
             console.log('🚀 Routes generated successfully!\n');
             if (options.exitCodeOnResolution) {
@@ -85,7 +81,7 @@ export const generateRoutes = ({ baseFolder, outputFile, routeFileName = 'page.t
             }, debounce);
         };
         watcher.on('all', (ev, file) => {
-            const ignoredOuput = getIgnoredOutputFile(file, outputFile);
+            const ignoredOuput = FileHelper.getIgnoredOutputFile(file, outputFile);
             // If output file as deleted regenerate it
             if (ignoredOuput && ev === 'unlink') {
                 console.log(`🚨 ${outputFile} was deleted, regenerating...`);
@@ -94,11 +90,12 @@ export const generateRoutes = ({ baseFolder, outputFile, routeFileName = 'page.t
             }
             const watchOnEvents = [
                 'add',
+                'addDir',
                 'change',
                 'unlink',
                 'unlinkDir',
             ];
-            const ignoredGeneralFiles = getIgnoredFiles(file, outputFile);
+            const ignoredGeneralFiles = FileHelper.getIgnoredFiles(file, outputFile);
             // If added, or change (renamed) or deleted, update routes
             if (watchOnEvents.includes(ev) && !ignoredGeneralFiles) {
                 console.log(`🔎 Watching files from path: "${file}" for changes...`);

package/dist/helpers/fileHelper.d.ts

@@ -0,0 +1,6 @@
+export declare const FileHelper: {
+    readonly cleanPaths: (path: string) => string;
+    readonly getIgnoredFiles: (file: string, output: string) => boolean;
+    readonly getIgnoredOutputFile: (file: string, output: string) => boolean;
+};
+//# sourceMappingURL=fileHelper.d.ts.map

package/dist/helpers/fileHelper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fileHelper.d.ts","sourceRoot":"","sources":["../../src/helpers/fileHelper.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,UAAU;gCAHG,MAAM;qCALD,MAAM,UAAU,MAAM;0CAHjB,MAAM,UAAU,MAAM;CAehD,CAAC"}

package/dist/helpers/fileHelper.js

@@ -0,0 +1,10 @@
+const getIgnoredOutputFile = (file, output) => file.includes(output);
+const getIgnoredFiles = (file, output) => file.includes('index') ||
+    file.startsWith('_') ||
+    getIgnoredOutputFile(file, output);
+const cleanPaths = (path) => path.replaceAll(/\\/gi, '/').replaceAll(/.(tsx|ts|jsx|js)/gi, '');
+export const FileHelper = {
+    cleanPaths,
+    getIgnoredFiles,
+    getIgnoredOutputFile,
+};

package/dist/helpers/index.d.ts

@@ -0,0 +1,3 @@
+export * from './serializeHelper.js';
+export * from './fileHelper.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/helpers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/helpers/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,iBAAiB,CAAC"}

package/dist/helpers/index.js

@@ -0,0 +1,2 @@
+export * from './serializeHelper.js';
+export * from './fileHelper.js';

package/dist/helpers/serializeHelper.d.ts

@@ -0,0 +1,7 @@
+import { TRouteLeaf, TRoutesTree } from '../types.js';
+export declare const SerializeHelper: {
+    readonly isRouteLeaf: (value: unknown) => value is TRouteLeaf;
+    readonly serializeOutputFile: (routes: TRoutesTree, outputPath: string) => Promise<void>;
+    readonly formatAndWriteOutputFile: (filePath: string, code: string) => Promise<void>;
+};
+//# sourceMappingURL=serializeHelper.d.ts.map

package/dist/helpers/serializeHelper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serializeHelper.d.ts","sourceRoot":"","sources":["../../src/helpers/serializeHelper.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAqJtD,eAAO,MAAM,eAAe;kCAnHA,OAAO,KAAG,KAAK,IAAI,UAAU;2CAoGd,WAAW,cAAc,MAAM;kDAlBxB,MAAM,QAAQ,MAAM;CAqC5D,CAAC"}

package/dist/helpers/serializeHelper.js

@@ -0,0 +1,81 @@
+import { Biome, Distribution } from '@biomejs/js-api';
+import ts from 'typescript';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+const biomeInstance = {
+    biome: null,
+    project: null,
+};
+const getBiomeSingleton = async () => {
+    if (!biomeInstance.biome) {
+        biomeInstance.biome = await Biome.create({
+            distribution: Distribution.NODE,
+        });
+    }
+    if (!biomeInstance.project) {
+        biomeInstance.project = biomeInstance.biome.openProject();
+        biomeInstance.biome.applyConfiguration(biomeInstance.project.projectKey, {
+            formatter: { enabled: true, indentStyle: 'space', lineWidth: 100 },
+            javascript: { formatter: { quoteStyle: 'single' } },
+        });
+    }
+    return {
+        projectKey: biomeInstance.project.projectKey,
+        formatContent: biomeInstance.biome.formatContent,
+    };
+};
+// Type guard
+const isRouteLeaf = (value) => {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'path' in value &&
+        'import' in value);
+};
+const createRouteObject = (obj) => {
+    const properties = Object.entries(obj).map(([key, value]) => {
+        if (isRouteLeaf(value)) {
+            return ts.factory.createPropertyAssignment(ts.factory.createIdentifier(key), ts.factory.createObjectLiteralExpression([
+                ts.factory.createPropertyAssignment('path', ts.factory.createStringLiteral(value.path)),
+                ts.factory.createPropertyAssignment('import', ts.factory.createCallExpression(ts.factory.createIdentifier('import'), undefined, [ts.factory.createStringLiteral(value.import)])),
+            ], true));
+        }
+        // Recursive object
+        return ts.factory.createPropertyAssignment(ts.factory.createIdentifier(key), createRouteObject(value));
+    });
+    return ts.factory.createObjectLiteralExpression(properties, true);
+};
+const createRoutesFile = (obj) => {
+    const routesObject = createRouteObject(obj);
+    // Create AST from routes variable
+    const exportStatement = ts.factory.createVariableStatement([ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)], ts.factory.createVariableDeclarationList([
+        ts.factory.createVariableDeclaration('routes', undefined, undefined, ts.factory.createAsExpression(routesObject, ts.factory.createTypeReferenceNode('const'))),
+    ], ts.NodeFlags.Const));
+    // Add the comment
+    ts.addSyntheticLeadingComment(exportStatement, ts.SyntaxKind.SingleLineCommentTrivia, ' GENERATED WITH TS-FILE-ROUTER DO NOT EDIT', true);
+    // Create the source file
+    return ts.factory.createSourceFile([exportStatement], ts.factory.createToken(ts.SyntaxKind.EndOfFileToken), ts.NodeFlags.None);
+};
+const formatAndWriteOutputFile = async (filePath, code) => {
+    const biomeInstance = await getBiomeSingleton();
+    const formatted = biomeInstance.formatContent(biomeInstance.projectKey, code, {
+        filePath: path.basename(filePath),
+    });
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, formatted.content, 'utf8');
+};
+const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
+const serializeOutputFile = async (routes, outputPath) => {
+    const code = createRoutesFile(routes);
+    try {
+        await formatAndWriteOutputFile(path.resolve(outputPath), printer.printFile(code));
+        console.log('✨ File was parsed succesfully');
+    }
+    catch (err) {
+        console.error('❌ Error parsing file:\n', err);
+    }
+};
+export const SerializeHelper = {
+    isRouteLeaf,
+    serializeOutputFile,
+    formatAndWriteOutputFile,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-file-router",
-  "version": "5.0.0",
+  "version": "6.0.0",
   "description": "router based on project files using typescript",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/dist/serialize.d.ts

@@ -1,3 +0,0 @@
-import type { TRoutesTree } from './types.js';
-export declare const serialize: (routes: TRoutesTree, outputPath: string) => Promise<void>;
-//# sourceMappingURL=serialize.d.ts.map

package/dist/serialize.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"serialize.d.ts","sourceRoot":"","sources":["../src/serialize.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAc,WAAW,EAAE,MAAM,YAAY,CAAC;AAmD1D,eAAO,MAAM,SAAS,GAAU,QAAQ,WAAW,EAAE,YAAY,MAAM,kBActE,CAAC"}

package/dist/serialize.js

@@ -1,51 +0,0 @@
-import { Biome, Distribution } from '@biomejs/js-api';
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-const isRouteLeaf = (value) => {
-    return (typeof value === 'object' &&
-        value !== null &&
-        'path' in value &&
-        'import' in value);
-};
-const stringifyRoutes = (obj) => {
-    const entries = Object.entries(obj).map(([key, value]) => {
-        if (isRouteLeaf(value)) {
-            return `'${key}': { 
-          path: '${value.path}', 
-          import: import('${value.import}')
-        }`;
-        }
-        return `'${key}': ${stringifyRoutes(value)}`;
-    });
-    return `{ ${entries.join(',\n')} }`;
-};
-let biome = null;
-const format = async (filePath, content) => {
-    if (biome === null) {
-        biome = await Biome.create({ distribution: Distribution.NODE });
-    }
-    const project = biome.openProject();
-    biome.applyConfiguration(project.projectKey, {
-        formatter: { enabled: true, indentStyle: 'space', lineWidth: 100 },
-        javascript: { formatter: { quoteStyle: 'single' } },
-    });
-    const formatted = biome.formatContent(project.projectKey, content, {
-        filePath: path.basename(filePath),
-    });
-    fs.mkdirSync(path.dirname(filePath), { recursive: true });
-    fs.writeFileSync(filePath, formatted.content, 'utf8');
-};
-export const serialize = async (routes, outputPath) => {
-    const rawCode = `
-  // GENERATED WITH TS-FILE-ROUTER DO NOT EDIT
-
-  export const routes = ${stringifyRoutes(routes)} as const;
-  \n`;
-    try {
-        await format(path.resolve(outputPath), rawCode);
-        console.log('✨ File was parsed succesfully');
-    }
-    catch (err) {
-        console.error('❌ Error parsing file:\n', err);
-    }
-};