@mpen/rerouter 0.1.9 → 0.3.0

package/examples/routes.gen.ts

@@ -0,0 +1,125 @@
+// Do not modify this file. It was auto-generated with the following command:
+// $ rerouter ./examples/routes.ts -w
+
+type AllOrNone<T> =
+    | Required<T>
+    | { [K in keyof T]?: never }
+
+type ParamType = string | number | boolean
+type WildcardType = Iterable<ParamType>
+
+export function home(): string {
+    let sb = ""
+
+    sb += "/"
+
+    return sb
+}
+
+export function kitchenSink(
+    params: {
+    "foo": ParamType
+    "baz": ParamType
+    "splat": WildcardType
+} & AllOrNone<{
+    "optional": ParamType
+    "two": ParamType
+}>
+): string {
+    let sb = ""
+
+    if (params["foo"] == null) throw new Error("Missing param: foo")
+    if (params["baz"] == null) throw new Error("Missing param: baz")
+    if (params["splat"] == null) throw new Error("Missing param: splat")
+    sb += "/hello/"
+    sb += (encodeURIComponent)(String(params["foo"]))
+    sb += "/bar/"
+    sb += (encodeURIComponent)(String(params["baz"]))
+    sb += "/"
+    sb += Array.from(params["splat"], v => (encodeURIComponent)(String(v))).join("/")
+    sb += "/xxx"
+    if (params["optional"] != null && params["two"] != null) {
+        sb += "/"
+        sb += (encodeURIComponent)(String(params["optional"]))
+        sb += "/lol/"
+        sb += (encodeURIComponent)(String(params["two"]))
+    } else if (!(params["optional"] == null && params["two"] == null)) {
+        throw new Error("Group requires all-or-none: \"optional\", \"two\"")
+    }
+
+    return sb
+}
+
+export function blogPost(
+    params: {
+    "id": ParamType
+} & AllOrNone<{
+    "title": ParamType
+}>
+): string {
+    let sb = ""
+
+    if (params["id"] == null) throw new Error("Missing param: id")
+    sb += "/blog/"
+    sb += (encodeURIComponent)(String(params["id"]))
+    if (params["title"] != null) {
+        sb += "-"
+        sb += (encodeURIComponent)(String(params["title"]))
+    } else if (!(params["title"] == null)) {
+        throw new Error("Group requires all-or-none: \"title\"")
+    }
+
+    return sb
+}
+
+export function slowLoading(): string {
+    let sb = ""
+
+    sb += "/slow-loading"
+
+    return sb
+}
+
+export function fetchLoading(): string {
+    let sb = ""
+
+    sb += "/fetch-loading"
+
+    return sb
+}
+
+export function fetchLoadingItem(
+    params: {
+    "id": ParamType
+}
+): string {
+    let sb = ""
+
+    if (params["id"] == null) throw new Error("Missing param: id")
+    sb += "/fetch-loading/"
+    sb += (encodeURIComponent)(String(params["id"]))
+
+    return sb
+}
+
+export function login(): string {
+    let sb = ""
+
+    sb += "/login"
+
+    return sb
+}
+
+export function match(
+    params: {
+    "id": ParamType
+}
+): string {
+    let sb = ""
+
+    if (params["id"] == null) throw new Error("Missing param: id")
+    sb += "/matches/"
+    sb += (encodeURIComponent)(String(params["id"]))
+
+    return sb
+}

package/examples/routes.ts

@@ -0,0 +1,40 @@
+import type { RouteObject } from '../src'
+
+const loadFetchLoading = () => import('./pages/FetchLoading')
+
+const ROUTES: readonly RouteObject[] = [
+    { name: 'home', pattern: '/', component: () => import('./pages/Home') },
+    {
+        name: 'kitchenSink',
+        pattern: '/hello/:foo/bar/:baz/*splat/xxx{/:optional/lol/:two}',
+        component: () => import('./pages/KitchenSink'),
+    },
+    {
+        name: 'blogPost',
+        pattern: '/blog/:id(\\d+){-:title}?',
+        component: () => import('./pages/BlogPost'),
+    },
+    {
+        name: 'slowLoading',
+        pattern: '/slow-loading',
+        component: () =>
+            new Promise((resolve) => {
+                setTimeout(resolve, 2000)
+            }).then(() => import('./pages/SlowLoading')),
+    },
+    {
+        name: 'fetchLoading',
+        pattern: '/fetch-loading',
+        component: loadFetchLoading,
+    },
+    {
+        name: 'fetchLoadingItem',
+        pattern: '/fetch-loading/:id',
+        component: loadFetchLoading,
+    },
+    { name: 'login', pattern: '/login', component: () => import('./pages/Login') },
+    { name: 'match', pattern: '/matches/:id', component: () => import('./pages/Match') },
+    { name: 'notFound', pattern: '*', component: () => import('./pages/NotFound') },
+]
+
+export default ROUTES

package/package.json

@@ -1,39 +1,44 @@
 {
   "name": "@mpen/rerouter",
-  "version": "0.1.9",
-  "packageManager": "bun",
-  "exports": "./dist/bundle.cjs",
-  "module": "./dist/bundle.mjs",
-  "types": "./dist/bundle.d.ts",
-  "files": [
-    "./dist"
-  ],
+  "version": "0.3.0",
+  "exports": {
+    ".": "./dist/index.js",
+    "./bin": "./dist/bin.js",
+    "./hooks": "./dist/hooks.js",
+    "./package.json": "./package.json"
+  },
+  "bin": {
+    "rerouter": "./dist/bin.js"
+  },
   "type": "module",
-  "devDependencies": {
-    "@rollup/plugin-commonjs": "^25.0.4",
-    "@rollup/plugin-node-resolve": "^15.2.1",
-    "@rollup/plugin-replace": "^5.0.2",
-    "@rollup/plugin-terser": "^0.4.3",
-    "@rollup/plugin-typescript": "^11.1.3",
-    "bun-types": "^1.0.2",
-    "chalk": "^5.3.0",
-    "npm-run-all": "^4.1.5",
-    "rimraf": "^5.0.1",
-    "rollup": "^3.29.2",
-    "tslib": "^2.6.2",
-    "typescript": "^5.2.2"
+  "dependencies": {
+    "@mpen/classcat": "0.1.3",
+    "@mpen/ts-types": "0.1.1",
+    "path-to-regexp": "^8.3.0"
   },
-  "engines": {
-    "node": ">=10"
+  "peerDependencies": {
+    "react": "^19",
+    "typescript": "^5"
+  },
+  "devDependencies": {
+    "@testing-library/react": "^16.3.2",
+    "@types/node": "^22",
+    "@types/react": "^19",
+    "@types/react-dom": "^19.2.3",
+    "happy-dom": "^20.9.0",
+    "react-dom": "^19.2.3",
+    "tsdown": "^0.21"
   },
-  "license": "MIT",
   "scripts": {
-    "test": "bun test --watch src",
-    "dev": "bun run --hot src/dev.ts",
-    "bundle:clean": "rimraf -g \"dist/*\"",
-    "bundle:build": "rollup -c",
-    "bundle": "run-s bundle:clean bundle:build",
-    "patch": "npm version patch && VER=$(jq -r '.version' package.json) && hg ci -m \"Publish v$VER\" && hg tag \"v$VER\"",
-    "release": "run-s bundle patch && npm publish && hg push"
-  }
+    "build": "tsdown",
+    "gen": "bun src/bin.ts ./examples/routes.ts -w",
+    "serve": "bun --hot examples/index.html",
+    "dev": "bun run --sequential gen serve"
+  },
+  "types": "./dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js"
 }

package/src/bin.test.ts

@@ -0,0 +1,199 @@
+#!/usr/bin/env bun test
+import { expect, test, describe, it, afterAll, beforeAll } from 'bun:test'
+import { $ } from 'bun'
+import fs from 'node:fs/promises'
+import path from 'node:path'
+import process from 'node:process'
+import { pathToFileURL } from 'node:url'
+import { runRerouterBin } from './bin'
+
+const TEMP_DIR = path.resolve(import.meta.dirname, 'temp_bin_test')
+const FIXTURES_DIR = path.resolve(import.meta.dirname, 'fixtures/bin')
+const BIN_PATH = path.resolve(import.meta.dirname, 'bin.ts')
+const BUN_PATH = process.execPath
+
+async function ensureDir(dir: string) {
+    await fs.mkdir(dir, { recursive: true })
+}
+
+describe('rerouter bin', () => {
+    beforeAll(async () => {
+        await ensureDir(TEMP_DIR)
+    })
+
+    test('writes to stdout by default', async () => {
+        const routesFile = path.join(FIXTURES_DIR, 'simple.tsx')
+
+        const result = await runRerouterBin([routesFile])
+        expect(result.stdout).toContain('export function home()')
+        expect(result.stderr).toBe('')
+    })
+
+    test('writes to file with -o', async () => {
+        const routesFile = path.join(FIXTURES_DIR, 'simple.tsx')
+        const outputFile = path.join(TEMP_DIR, 'explicit-output.ts')
+
+        const result = await runRerouterBin([routesFile, '-o', outputFile])
+
+        const outputContent = await fs.readFile(outputFile, 'utf8')
+        expect(outputContent).toContain('export function home()')
+        expect(result.stderr).toContain(`Wrote ${outputFile}`)
+    })
+
+    test('writes to adjacent file with -w', async () => {
+        const routesFile = path.join(TEMP_DIR, 'write-adjacent.tsx')
+        const expectedOutputFile = path.join(TEMP_DIR, 'write-adjacent.gen.ts')
+        await fs.copyFile(path.join(FIXTURES_DIR, 'simple.tsx'), routesFile)
+
+        await runRerouterBin([routesFile, '-w'])
+
+        const outputContent = await fs.readFile(expectedOutputFile, 'utf8')
+        expect(outputContent).toContain('export function home()')
+    })
+
+    test('handles optional groups', async () => {
+        const routesFile = path.join(FIXTURES_DIR, 'optional.tsx')
+
+        const { stdout: outputContent } = await runRerouterBin([routesFile])
+
+        expect(outputContent).toContain('export function optional(')
+        expect(outputContent).toContain('AllOrNone<')
+        expect(outputContent).toContain('"bar": ParamType')
+    })
+
+    test('skips unnamed routes', async () => {
+        const routesFile = path.join(FIXTURES_DIR, 'unnamed.tsx')
+
+        const { stdout: outputContent } = await runRerouterBin([routesFile])
+
+        expect(outputContent).toContain('export function home()')
+        expect(outputContent).not.toContain('layout')
+    })
+
+    test('handles regexp params with optional groups', async () => {
+        const routesFile = path.join(FIXTURES_DIR, 'regexp-groups.tsx')
+        const outputFile = path.join(TEMP_DIR, 'regexp-groups.gen.ts')
+
+        await runRerouterBin([routesFile, '-o', outputFile])
+
+        const outputContent = await fs.readFile(outputFile, 'utf8')
+        expect(outputContent).toContain('export function blogPost(')
+        expect(outputContent).toContain('"id": ParamType')
+        expect(outputContent).toContain('"title": ParamType')
+
+        const { blogPost } = await import(pathToFileURL(outputFile).href)
+        expect(blogPost({ id: 123 })).toBe('/blog/123')
+        expect(blogPost({ id: 123, title: 'hello world' })).toBe('/blog/123-hello%20world')
+    })
+
+    test('generates importable path helpers', async () => {
+        const routesFile = path.join(FIXTURES_DIR, 'kitchen-sink.tsx')
+        const outputFile = path.join(TEMP_DIR, 'importable.gen.ts')
+
+        await runRerouterBin([
+            routesFile,
+            '-o',
+            outputFile,
+            '--wildcard-delimiter',
+            ',',
+            '--encode-function',
+            'encodeURI',
+        ])
+
+        const { home, kitchenSink, login, match } = await import(pathToFileURL(outputFile).href)
+
+        expect(home()).toBe('/')
+        expect(login()).toBe('/login')
+        expect(match({ id: 'a/b' })).toBe('/matches/a/b')
+        expect(kitchenSink({ foo: 'a/b', baz: 'c', splat: ['x', 'y'] })).toBe(
+            '/hello/a/b/bar/c/x,y/xxx',
+        )
+        expect(
+            kitchenSink({
+                foo: 'a/b',
+                baz: 'c',
+                splat: ['x', 'y'],
+                optional: 'opt',
+                two: 'two',
+            }),
+        ).toBe('/hello/a/b/bar/c/x,y/xxx/opt/lol/two')
+    })
+
+    describe('generated path helpers with default options', () => {
+        let home: () => string
+        let login: () => string
+        let match: (params: { id: string }) => string
+        let kitchenSink: (params: {
+            foo: string
+            baz: string
+            splat: string[]
+            optional?: string
+            two?: string
+        }) => string
+
+        beforeAll(async () => {
+            const routesFile = path.join(FIXTURES_DIR, 'kitchen-sink.tsx')
+            const outputFile = path.join(TEMP_DIR, 'importable-defaults.gen.ts')
+
+            const result = await runRerouterBin([routesFile])
+            await fs.writeFile(outputFile, result.stdout, 'utf8')
+
+            const generated = await import(pathToFileURL(outputFile).href)
+            home = generated.home
+            login = generated.login
+            match = generated.match
+            kitchenSink = generated.kitchenSink
+        })
+
+        it('home()', () => {
+            expect(home()).toBe('/')
+        })
+
+        it('login()', () => {
+            expect(login()).toBe('/login')
+        })
+
+        it('match()', () => {
+            expect(match({ id: '123' })).toBe('/matches/123')
+        })
+
+        it('match() uses encodeURIComponent', () => {
+            expect(match({ id: 'a/b' })).toBe('/matches/a%2Fb')
+        })
+
+        it('kitchenSink() without optional group', () => {
+            expect(kitchenSink({ foo: 'a', baz: 'b', splat: ['x', 'y'] })).toBe(
+                '/hello/a/bar/b/x/y/xxx',
+            )
+        })
+
+        it('kitchenSink() with optional group', () => {
+            expect(
+                kitchenSink({
+                    foo: 'a',
+                    baz: 'b',
+                    splat: ['x', 'y'],
+                    optional: 'opt',
+                    two: 'two',
+                }),
+            ).toBe('/hello/a/bar/b/x/y/xxx/opt/lol/two')
+        })
+
+        it('kitchenSink() requires all-or-none optional group', () => {
+            expect(() =>
+                kitchenSink({ foo: 'a', baz: 'b', splat: ['x', 'y'], optional: 'opt' } as any),
+            ).toThrow('Group requires all-or-none: "optional", "two"')
+        })
+    })
+
+    test('can be invoked as a CLI script', async () => {
+        const routesFile = path.join(FIXTURES_DIR, 'simple.tsx')
+
+        const result = await $`${BUN_PATH} ${BIN_PATH} ${routesFile}`.text()
+        expect(result).toContain('export function home()')
+    })
+
+    afterAll(async () => {
+        await fs.rm(TEMP_DIR, { recursive: true, force: true })
+    })
+})