Create route methods implementation

src/types/resolved.ts

@@ -6,6 +6,6 @@ export type Resolved<T extends Route> = {
   name: string,
   path: string,
   regex: RegExp,
-  parentNames: T['name'][],
+  parentNames: string[],
   params: Record<string, Param[]>,
 }

src/types/routeMethods.test-d.ts

@@ -2,8 +2,7 @@ import { test, expectTypeOf } from 'vitest'
 import { ParamGetSet } from '@/types/params'
 import { Routes } from '@/types/routes'
 import { createRouter, path } from '@/utilities'
-
-const component = { template: '<div>This is component</div>' }
+import { component } from '@/utilities/testHelpers'
 
 const boolean: ParamGetSet<boolean> = {
   get: value => Boolean(value),

src/types/routeMethods.ts

@@ -1,5 +1,5 @@
 import { Param, ParamGetSet, ParamGetter } from '@/types/params'
-import { Route, Routes } from '@/types/routes'
+import { Public, Route, Routes } from '@/types/routes'
 import { Identity, IsAny, IsEmptyObject, ReplaceAll, TupleCanBeAllUndefined, UnionToIntersection } from '@/types/utilities'
 import { Path } from '@/utilities/path'
 
@@ -34,22 +34,16 @@ type RouteMethodsOrMethod<
   TParams extends Record<string, unknown>
 > = TRoute extends { path: infer Path, children: infer Children }
   ? Children extends Routes
-    ? IsPublicRoute<TRoute> extends true
+    ? TRoute extends Public<TRoute>
       ? RouteMethods<Children, MergeParams<TParams, ExtractParamsFromPath<Path>>> & CreateRouteMethod<TParams, Path>
       : RouteMethods<Children, MergeParams<TParams, ExtractParamsFromPath<Path>>>
     : never
   : TRoute extends { path: infer Path }
-    ? IsPublicRoute<TRoute> extends true
+    ? TRoute extends Public<TRoute>
       ? CreateRouteMethod<TParams, Path>
       : never
     : never
 
-type IsPublicRoute<TRoute extends Route> = 'public' extends keyof TRoute
-  ? TRoute extends { public: false }
-    ? false
-    : true
-  : true
-
 type CreateRouteMethod<
   TParams extends Record<string, unknown>,
   TPath extends Route['path']

src/types/routes.ts

@@ -44,4 +44,10 @@ export function isParentRoute(value: Route): value is ParentRoute {
 
 export function isNamedRoute(value: Route): value is Route & { name: string } {
   return 'name' in value && !!value.name
+}
+
+export type Public<T extends Route> = T & { public?: true | undefined }
+
+export function isPublicRoute(value: Route): value is Public<Route> {
+  return value.public !== false
 }

src/utilities/createRouteMethods.spec.ts

@@ -0,0 +1,100 @@
+import { describe, expect, test } from 'vitest'
+import { Routes } from '@/types'
+import { createRouteMethods, resolveRoutes } from '@/utilities'
+import { component } from '@/utilities/testHelpers'
+
+describe('createRouteMethods', () => {
+  test.each([
+    [undefined],
+    [true],
+  ])('given route is named and is public, makes parent callable', (isPublic) => {
+    const routes = [
+      {
+        name: 'parent',
+        path: '/parent',
+        public: isPublic,
+        component,
+      },
+    ] as const satisfies Routes
+    const resolved = resolveRoutes(routes)
+
+    const response = createRouteMethods(resolved)
+
+    expect(response.parent).toBeTypeOf('function')
+  })
+
+  test('given route is NOT public, returns empty object', () => {
+    const routes = [
+      {
+        name: 'parent',
+        path: '/parent',
+        public: false,
+        component,
+      },
+    ] as const satisfies Routes
+    const resolved = resolveRoutes(routes)
+
+    const response = createRouteMethods(resolved)
+
+    expect(response).toMatchObject({})
+  })
+
+  test.each([
+    [undefined],
+    [true],
+    [false],
+  ])('given parent route with named children, has property for child name', (isPublic) => {
+    const routes = [
+      {
+        name: 'parent',
+        path: '/parent',
+        children: [
+          {
+            name: 'child',
+            path: '/child',
+            public: isPublic,
+            component,
+          },
+        ],
+      },
+    ] as const satisfies Routes
+    const resolved = resolveRoutes(routes)
+
+    const response = createRouteMethods(resolved)
+
+    expect(response.parent.child).toBeDefined()
+
+    if (isPublic !== false) {
+      expect(response.parent.child).toBeTypeOf('function')
+    }
+  })
+
+  test('given parent route with named children and grandchildren, has path to grandchild all callable', () => {
+    const routes = [
+      {
+        name: 'parent',
+        path: '/parent',
+        children: [
+          {
+            name: 'child',
+            path: '/child',
+            children: [
+              {
+                name: 'grandchild',
+                path: '/grandchild',
+                component,
+              },
+            ],
+          },
+        ],
+      },
+    ] as const satisfies Routes
+    const resolved = resolveRoutes(routes)
+
+    const response = createRouteMethods(resolved)
+
+    expect(response.parent).toBeTypeOf('function')
+    expect(response.parent.child).toBeTypeOf('function')
+    expect(response.parent.child.grandchild).toBeTypeOf('function')
+  })
+})

src/utilities/createRouteMethods.ts

@@ -0,0 +1,55 @@
+import { Resolved, Route, RouteMethodRoute, isPublicRoute } from '@/types'
+import { assembleUrl } from '@/utilities/urlAssembly'
+
+type NonCallableNode = Record<string, any>
+type CallableNode = NonCallableNode & {
+  (values: Record<string, unknown[]>): RouteMethodRoute,
+}
+type Node = CallableNode | NonCallableNode
+
+export function createRouteMethods(routes: Resolved<Route>[]): Record<string, Node> {
+  const methods: Record<string, any> = {}
+
+  routes.forEach(route => {
+    const currentLevel = traverseParents(route, methods)
+    const routeNode = createNodeForRoute(route)
+
+    Object.assign(routeNode, currentLevel[route.name])
+
+    currentLevel[route.name] = routeNode
+  })
+
+  return methods
+}
+
+function traverseParents(route: Resolved<Route>, currentLevel: Record<string, any>): Record<string, any> {
+  route.parentNames.forEach(parentName => {
+    if (!currentLevel[parentName]) {
+      currentLevel[parentName] = {}
+    }
+
+    currentLevel = currentLevel[parentName]
+  })
+
+  return currentLevel
+}
+
+function createNodeForRoute(route: Resolved<Route>): Node {
+  if (isPublicRoute(route.matched)) {
+    return createCallableNode(route)
+  }
+
+  return {}
+}
+
+function createCallableNode(route: Resolved<Route>): CallableNode {
+  const node: CallableNode = (values) => {
+    return {
+      push: () => null,
+      replace: () => null,
+      url: assembleUrl(route, values),
+    }
+  }
+
+  return node
+}

src/utilities/createRouter.spec.ts

@@ -1,8 +1,7 @@
 import { describe, expect, test } from 'vitest'
 import { Routes } from '@/types'
 import { createRouter } from '@/utilities'
-
-const component = { template: '<div>This is component</div>' }
+import { component } from '@/utilities/testHelpers'
 
 describe('router.routeMatch', () => {
   test('given path WITHOUT params, returns match', () => {

src/utilities/createRouter.ts

@@ -1,5 +1,5 @@
 import { Resolved, RouteMethods, Routes } from '@/types'
-import { resolveRoutes, routeParamsAreValid } from '@/utilities'
+import { createRouteMethods, resolveRoutes, routeParamsAreValid } from '@/utilities'
 
 export type Router<
   TRoutes extends Routes
@@ -13,11 +13,6 @@
   routeMatch: (path: string) => Resolved<TRoutes[number]> | undefined,
 }
 
-function createRouteMethods<T extends Routes>(_routes: T): RouteMethods<T> {
-  // use assembleUrl(route, args) to generate string URL
-  return {} as any
-}
-
 export function createRouter<T extends Routes>(routes: T): Router<T> {
   const resolved = resolveRoutes(routes)
 
@@ -46,7 +41,7 @@
   }
 
   const router = {
-    routes: createRouteMethods(routes),
+    routes: createRouteMethods(resolved),
     push,
     replace,
     forward,
@@ -55,4 +50,4 @@
     routeMatch,
   }
 
   return router

src/utilities/index.ts

@@ -1,8 +1,10 @@
+export * from './createRouteMethods'
 export * from './createRouter'
 export * from './mergeParams'
+export * from './paramValidation'
 export * from './params'
 export * from './paramsFinder'
-export * from './paramValidation'
 export * from './path'
-export * from './random'
 export * from './routeResolver'
+export * from './string'
+export * from './urlAssembly'

src/utilities/paramValidation.spec.ts

@@ -1,8 +1,7 @@
 import { describe, expect, test } from 'vitest'
 import { Route } from '@/types'
 import { resolveRoutes, routeParamsAreValid, path } from '@/utilities'
-
-const component = { template: '<div>This is component</div>' }
+import { component } from '@/utilities/testHelpers'
 
 describe('routeParamsAreValid', () => {
   test('given route WITHOUT params, always return true', () => {

src/utilities/routeResolver.spec.ts

@@ -1,8 +1,7 @@
 import { describe, expect, test } from 'vitest'
 import { Route, Routes } from '@/types'
 import { resolveRoutes, generateRouteRegexPattern, path } from '@/utilities'
-
-const component = { template: '<div>This is component</div>' }
+import { component } from '@/utilities/testHelpers'
 
 describe('resolveRoutes', () => {
   test('always returns 1 record per named route', () => {

src/utilities/random.ts → src/utilities/testHelpers.ts

@@ -5,4 +5,6 @@ export const random = {
 
     return randomNumber
   },
-}
+}
+
+export const component = { template: '<div>This is component</div>' }

src/utilities/urlAssembly.spec.ts

@@ -1,10 +1,9 @@
 import { describe, expect, test } from 'vitest'
 import { InvalidRouteParamValueError, Route } from '@/types'
 import { path, resolveRoutes } from '@/utilities'
+import { component } from '@/utilities/testHelpers'
 import { assembleUrl } from '@/utilities/urlAssembly'
 
-const component = { template: '<div>This is component</div>' }
-
 describe('assembleUrl', () => {
   test.each([
     ['/simple'],