@mpen/rerouter 0.3.0 → 0.3.2

package/README.md

@@ -65,6 +65,10 @@ function App() {
 }
 ```
 
+`loading` is delayed by 400ms by default to avoid flashing fallback UI during quick route
+loads. Pass `loadingDelayMs={0}` to show it immediately, or another millisecond value to tune
+the delay.
+
 ### Link
 
 ```tsx

package/{src → cli}/bin.test.ts

@@ -37,7 +37,27 @@ describe('rerouter bin', () => {
 
         const outputContent = await fs.readFile(outputFile, 'utf8')
         expect(outputContent).toContain('export function home()')
-        expect(result.stderr).toContain(`Wrote ${outputFile}`)
+        expect(result.stderr).toBe(`Wrote ${path.relative(process.cwd(), outputFile)}\n`)
+    })
+
+    test('formats output files with --pretty', async () => {
+        const routesFile = path.join(FIXTURES_DIR, 'simple.tsx')
+        const outputFile = path.join(TEMP_DIR, 'pretty-output.ts')
+
+        await runRerouterBin([routesFile, '-o', outputFile, '--pretty'])
+
+        const outputContent = await fs.readFile(outputFile, 'utf8')
+        expect(outputContent).toContain("export function home(): string {\n  let sb = ''")
+        expect(outputContent).toContain("  sb += '/'")
+    })
+
+    test('ignores --pretty when writing to stdout', async () => {
+        const routesFile = path.join(FIXTURES_DIR, 'simple.tsx')
+
+        const { stdout } = await runRerouterBin([routesFile, '-p'])
+
+        expect(stdout).toContain('export function home(): string {\n    let sb = ""')
+        expect(stdout).toContain('    sb += "/"')
     })
 
     test('writes to adjacent file with -w', async () => {
@@ -56,7 +76,9 @@ describe('rerouter bin', () => {
 
         const { stdout: outputContent } = await runRerouterBin([routesFile])
 
-        expect(outputContent).toContain('export function optional(')
+        expect(outputContent).toContain(
+            'export function optional(params: {} & AllOrNone<{ "bar": ParamType }>): string {',
+        )
         expect(outputContent).toContain('AllOrNone<')
         expect(outputContent).toContain('"bar": ParamType')
     })

package/{src → cli}/bin.ts

@@ -5,12 +5,13 @@ import process from 'node:process'
 import { fileURLToPath, pathToFileURL } from 'node:url'
 import { parseArgs, type ParseArgsConfig } from 'node:util'
 import { parse } from 'path-to-regexp'
-import { normalizeLegacyPathToRegexpSyntax, normalizeRoutes, type Route } from './lib/routes'
+import { normalizeLegacyPathToRegexpSyntax, normalizeRoutes, type Route } from '../src/lib/routes'
 
 const PARSE_CONFIG = {
     options: {
         output: { type: 'string', short: 'o' },
         write: { type: 'boolean', short: 'w' },
+        pretty: { type: 'boolean', short: 'p' },
         'wildcard-delimiter': { type: 'string' },
         'encode-function': { type: 'string' },
     },
@@ -62,6 +63,10 @@ function compilePathGenerator(
 
     const typeOfParam = (t: any) => (t.type === 'wildcard' ? 'WildcardType' : 'ParamType')
     const makeProp = (name: string, t: any): Prop => ({ name, type: typeOfParam(t) })
+    const renderPropsType = (props: readonly Prop[]): string =>
+        props.length
+            ? `{ ${props.map((p) => `${escapeString(p.name)}: ${p.type}`).join('; ')} }`
+            : '{}'
 
     function collectGroupProps(ts2: any[]): Prop[] {
         const props: Prop[] = []
@@ -79,12 +84,7 @@ function compilePathGenerator(
             } else if (t.type === 'group') {
                 const groupProps = collectGroupProps(t.tokens)
                 if (groupProps.length) {
-                    const some = [
-                        '{',
-                        ...groupProps.map((p) => `    ${escapeString(p.name)}: ${p.type}`),
-                        '}',
-                    ].join('\n')
-                    groupTypes.push(`AllOrNone<${some}>`)
+                    groupTypes.push(`AllOrNone<${renderPropsType(groupProps)}>`)
                 }
                 collectTypes(t.tokens, false)
             }
@@ -93,11 +93,7 @@ function compilePathGenerator(
 
     collectTypes(tokens)
 
-    const baseParamsType = [
-        '{',
-        ...baseProps.map((p) => `    ${escapeString(p.name)}: ${p.type}`),
-        '}',
-    ].join('\n')
+    const baseParamsType = renderPropsType(baseProps)
     const paramsType = groupTypes.length
         ? `${baseParamsType} & ${groupTypes.join(' & ')}`
         : baseParamsType
@@ -111,9 +107,7 @@ function compilePathGenerator(
     const hasAnyParams = baseProps.length > 0 || groupTypes.length > 0
 
     if (hasAnyParams) {
-        lines.push(`export function ${functionName}(`)
-        lines.push(`    params: ${paramsType}`)
-        lines.push(`): string {`)
+        lines.push(`export function ${functionName}(params: ${paramsType}): string {`)
     } else {
         lines.push(`export function ${functionName}(): string {`)
     }
@@ -197,6 +191,18 @@ async function importRoutes(routesPath: string): Promise<readonly Route[]> {
     return mod.default as readonly Route[]
 }
 
+async function formatWithPrettier(source: string, outputPath: string): Promise<string> {
+    let prettier: typeof import('prettier')
+    try {
+        prettier = await import('prettier')
+    } catch (cause) {
+        throw new Error('The --pretty option requires prettier to be installed.', { cause })
+    }
+
+    const options = (await prettier.resolveConfig(outputPath)) ?? {}
+    return prettier.format(source, { ...options, filepath: outputPath })
+}
+
 function extractRoutes(routes: readonly Route[]): ExtractedRoute[] {
     return normalizeRoutes(routes).flatMap((route) => {
         if (!route.name || typeof route.pattern !== 'string') return []
@@ -218,7 +224,7 @@ async function main(
         return {
             exitCode: 1,
             stdout: '',
-            stderr: 'Usage: rerouter <routes-file> [-o <output-file>] [-w] [--wildcard-delimiter <string>] [--encode-function <identifier>]\n',
+            stderr: 'Usage: rerouter <routes-file> [-o <output-file>] [-w] [-p|--pretty] [--wildcard-delimiter <string>] [--encode-function <identifier>]\n',
         }
     }
 
@@ -280,10 +286,13 @@ async function main(
         }
     }
 
-    const finalOutput = out.join('\n')
+    let finalOutput = out.join('\n')
     if (outputPath) {
+        if (options.pretty) {
+            finalOutput = await formatWithPrettier(finalOutput, outputPath)
+        }
         await fs.writeFile(outputPath, finalOutput, 'utf8')
-        return { stdout: '', stderr: `Wrote ${outputPath}\n` }
+        return { stdout: '', stderr: `Wrote ${path.relative(cwd, outputPath) || '.'}\n` }
     } else {
         return { stdout: finalOutput, stderr: '' }
     }

package/cli/tsconfig.json

@@ -0,0 +1,9 @@
+{
+    "extends": "../tsconfig.json",
+    "compilerOptions": {
+        "lib": ["DOM", "DOM.Iterable", "ESNext"],
+        "types": ["node"]
+    },
+    "include": ["**/*"],
+    "exclude": ["**/*.test.*"]
+}