@owlmeans/client-route 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 OwlMeans Common — Fullstack typescript framework
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,368 @@
+# @owlmeans/client-route
+
+Client-side routing library for OwlMeans applications that extends the base `@owlmeans/route` package with client-specific functionality.
+
+## Overview
+
+The `@owlmeans/client-route` package is a client-side extension of the `@owlmeans/route` module, providing additional functionality specifically designed for frontend applications. It extends the base routing capabilities with client-specific features such as partial path preservation and parameter extraction.
+
+This package is part of the OwlMeans Common library suite and follows the OwlMeans Common Module approach (described in `@owlmeans/context`). Like other modules in the suite, it's designed to work within the OwlMeans Common Module ecosystem and is not self-sufficient.
+
+### Key Features
+
+- **Client Route Models** - Extends base route models with client-specific behavior
+- **Partial Path Preservation** - Maintains original path patterns for client-side processing
+- **Parameter Extraction** - Utility functions for extracting route parameters
+- **Promise-based Resolution** - Manages asynchronous route resolution with state tracking
+- **Type Safety** - Full TypeScript support with proper type definitions
+
+## Installation
+
+```bash
+npm install @owlmeans/client-route
+```
+
+**Note:** This package depends on `@owlmeans/route` and `@owlmeans/client-context`, which will be installed automatically.
+
+## Core Concepts
+
+### Client Route
+A client route extends the base `CommonRoute` with additional client-specific properties, particularly the `partialPath` which preserves the original path pattern for client-side processing.
+
+### Client Route Model
+A client route model wraps a client route with additional behavior, including promise-based resolution tracking and client-specific resolution logic.
+
+### Parameter Extraction
+The package provides utilities to extract parameters from route paths, useful for client-side routing and navigation.
+
+## API Reference
+
+### Types
+
+#### ClientRoute
+Extended route interface with client-specific properties.
+
+```typescript
+interface ClientRoute extends CommonRoute {
+  partialPath: string  // Original path pattern preserved for client use
+}
+```
+
+**Properties:**
+- **partialPath**: `string` - The original path pattern before resolution, useful for client-side routing logic
+
+#### ClientRouteModel
+Extended route model with client-specific resolution behavior.
+
+```typescript
+interface ClientRouteModel extends CommonRouteModel {
+  route: ClientRoute           // The wrapped client route
+  _resolved?: Promise<void>    // Promise tracking resolution state
+  _client: true               // Client route marker
+}
+```
+
+**Properties:**
+- **route**: `ClientRoute` - The wrapped client route object
+- **_resolved**: `Promise<void>` - Optional promise that tracks the resolution state
+- **_client**: `true` - Marker indicating this is a client route model
+
+#### ClientRouteOptions
+Options for configuring client routes.
+
+```typescript
+interface ClientRouteOptions {
+  overrides?: Partial<ClientRoute>  // Route parameter overrides
+}
+```
+
+**Properties:**
+- **overrides**: `Partial<ClientRoute>` - Optional route parameter overrides
+
+### Core Functions
+
+#### route(route, opts?)
+Wraps a base route model with client-specific functionality.
+
+```typescript
+const route: (route: CommonRouteModel, opts?: ClientRouteOptions) => ClientRouteModel
+```
+
+**Parameters:**
+- `route: CommonRouteModel` - Base route model from `@owlmeans/route`
+- `opts?: ClientRouteOptions` - Optional configuration options
+
+**Returns:** `ClientRouteModel` - Client route model with enhanced functionality
+
+**Features:**
+- Preserves original path as `partialPath`
+- Adds promise-based resolution tracking
+- Provides client-specific resolution logic
+- Supports parameter overrides
+
+**Example:**
+```typescript
+import { route as baseRoute } from '@owlmeans/route'
+import { route as clientRoute } from '@owlmeans/client-route'
+
+// Create a base route
+const userRoute = baseRoute('user', '/users/:id')
+
+// Wrap with client functionality
+const clientUserRoute = clientRoute(userRoute, {
+  overrides: {
+    secure: true
+  }
+})
+
+// Use client-specific features
+console.log(clientUserRoute.route.partialPath) // '/users/:id'
+const resolved = await clientUserRoute.resolve(context)
+```
+
+### Helper Functions
+
+#### isClientRouteModel(route)
+Type guard to check if a route object is a client route model.
+
+```typescript
+const isClientRouteModel: (route: Object) => route is ClientRouteModel
+```
+
+**Parameters:**
+- `route: Object` - Object to check
+
+**Returns:** `boolean` - True if the object is a client route model
+
+**Example:**
+```typescript
+import { isClientRouteModel } from '@owlmeans/client-route'
+
+if (isClientRouteModel(routeObject)) {
+  // TypeScript knows this is a ClientRouteModel
+  console.log(routeObject.route.partialPath)
+}
+```
+
+#### extractParams(path)
+Extracts parameter names from a route path.
+
+```typescript
+const extractParams: (path: string) => string[]
+```
+
+**Parameters:**
+- `path: string` - Route path pattern
+
+**Returns:** `string[]` - Array of parameter names
+
+**Example:**
+```typescript
+import { extractParams } from '@owlmeans/client-route'
+
+const params = extractParams('/users/:id/posts/:postId')
+console.log(params) // ['id', 'postId']
+
+const simpleParams = extractParams('/api/users/:userId')
+console.log(simpleParams) // ['userId']
+
+const noParams = extractParams('/api/users')
+console.log(noParams) // []
+```
+
+## Usage Examples
+
+### Basic Client Route Creation
+
+```typescript
+import { route as baseRoute } from '@owlmeans/route'
+import { route as clientRoute } from '@owlmeans/client-route'
+
+// Create a base route
+const apiRoute = baseRoute('api', '/api/users/:id')
+
+// Wrap with client functionality
+const clientApiRoute = clientRoute(apiRoute)
+
+// Access client-specific features
+console.log(clientApiRoute.route.partialPath) // '/api/users/:id'
+console.log(clientApiRoute._client) // true
+```
+
+### Route Resolution with State Tracking
+
+```typescript
+import { route as baseRoute } from '@owlmeans/route'
+import { route as clientRoute } from '@owlmeans/client-route'
+
+const userRoute = baseRoute('user', '/users/:id')
+const clientUserRoute = clientRoute(userRoute)
+
+// Resolve the route
+const resolved = await clientUserRoute.resolve(context)
+
+// The partial path is preserved
+console.log(resolved.partialPath) // '/users/:id'
+console.log(resolved.path) // '/users/123' (resolved)
+```
+
+### Parameter Extraction
+
+```typescript
+import { extractParams } from '@owlmeans/client-route'
+
+// Extract parameters from different path patterns
+const userParams = extractParams('/users/:id')
+console.log(userParams) // ['id']
+
+const nestedParams = extractParams('/users/:userId/posts/:postId/comments/:commentId')
+console.log(nestedParams) // ['userId', 'postId', 'commentId']
+
+// Handle paths with no parameters
+const staticParams = extractParams('/api/health')
+console.log(staticParams) // []
+```
+
+### Type Guards and Validation
+
+```typescript
+import { isClientRouteModel } from '@owlmeans/client-route'
+import { route as baseRoute } from '@owlmeans/route'
+import { route as clientRoute } from '@owlmeans/client-route'
+
+const baseRouteModel = baseRoute('api', '/api')
+const clientRouteModel = clientRoute(baseRouteModel)
+
+console.log(isClientRouteModel(baseRouteModel)) // false
+console.log(isClientRouteModel(clientRouteModel)) // true
+
+// Type-safe access
+if (isClientRouteModel(someRoute)) {
+  console.log(someRoute.route.partialPath) // TypeScript knows this exists
+}
+```
+
+### Route Overrides
+
+```typescript
+import { route as baseRoute } from '@owlmeans/route'
+import { route as clientRoute } from '@owlmeans/client-route'
+
+const baseUserRoute = baseRoute('user', '/users/:id')
+
+// Override route properties
+const clientUserRoute = clientRoute(baseUserRoute, {
+  overrides: {
+    secure: true,
+    method: RouteMethod.GET
+  }
+})
+
+console.log(clientUserRoute.route.secure) // true
+console.log(clientUserRoute.route.partialPath) // '/users/:id'
+```
+
+## Integration with OwlMeans Context
+
+The client-route package integrates seamlessly with the OwlMeans context system and works in conjunction with other OwlMeans Common modules:
+
+```typescript
+import { route as baseRoute, frontend } from '@owlmeans/route'
+import { route as clientRoute } from '@owlmeans/client-route'
+import { makeClientContext } from '@owlmeans/client-context'
+
+// Create a frontend route
+const homeRoute = baseRoute('home', '/', frontend())
+
+// Wrap with client functionality
+const clientHomeRoute = clientRoute(homeRoute)
+
+// Use with client context
+const context = makeClientContext(config)
+const resolved = await clientHomeRoute.resolve(context)
+```
+
+## Advanced Usage
+
+### Custom Resolution Logic
+
+```typescript
+import { route as baseRoute } from '@owlmeans/route'
+import { route as clientRoute } from '@owlmeans/client-route'
+
+const baseRoute = baseRoute('api', '/api/:version')
+const clientApiRoute = clientRoute(baseRoute)
+
+// The client route preserves the original path pattern
+const resolved = await clientApiRoute.resolve(context)
+
+// Use partial path for client-side routing
+const navigationPath = clientApiRoute.route.partialPath
+const resolvedPath = resolved.path
+
+console.log(navigationPath) // '/api/:version' (for client routing)
+console.log(resolvedPath) // '/api/v1' (resolved for actual requests)
+```
+
+### Parameter-Based Navigation
+
+```typescript
+import { extractParams } from '@owlmeans/client-route'
+
+const buildNavigationUrl = (pathPattern: string, params: Record<string, string>) => {
+  const paramNames = extractParams(pathPattern)
+  let url = pathPattern
+  
+  paramNames.forEach(param => {
+    url = url.replace(`:${param}`, params[param] || '')
+  })
+  
+  return url
+}
+
+// Usage
+const pattern = '/users/:userId/posts/:postId'
+const url = buildNavigationUrl(pattern, { userId: '123', postId: '456' })
+console.log(url) // '/users/123/posts/456'
+```
+
+## Error Handling
+
+The package provides comprehensive error handling:
+
+- **SyntaxError** - Thrown when attempting to resolve a route that's already resolved without proper promise handling
+- **Type Guards** - Use `isClientRouteModel` to ensure type safety
+- **Promise Management** - The `_resolved` promise prevents multiple resolution attempts
+
+## Best Practices
+
+1. **Use Type Guards** - Always use `isClientRouteModel` when working with mixed route types
+2. **Handle Promises** - Properly handle the `_resolved` promise to avoid resolution conflicts
+3. **Preserve Partial Paths** - Use the `partialPath` property for client-side routing logic
+4. **Parameter Extraction** - Use `extractParams` for dynamic route handling
+5. **Integration** - Combine with other OwlMeans Common modules for full functionality
+
+## Related Modules
+
+- **@owlmeans/route** - Base routing functionality (required dependency)
+- **@owlmeans/client-context** - Client-side context management (required dependency)
+- **@owlmeans/context** - Core context system for route resolution
+- **@owlmeans/server-route** - Server-side route implementations
+
+## Migration from @owlmeans/route
+
+If you're upgrading from using `@owlmeans/route` directly in a client application:
+
+```typescript
+// Before
+import { route } from '@owlmeans/route'
+const userRoute = route('user', '/users/:id')
+
+// After
+import { route as baseRoute } from '@owlmeans/route'
+import { route as clientRoute } from '@owlmeans/client-route'
+const userRoute = clientRoute(baseRoute('user', '/users/:id'))
+
+// Additional client functionality is now available
+console.log(userRoute.route.partialPath) // '/users/:id'
+```

package/build/helper.d.ts

@@ -0,0 +1,4 @@
+import { ClientRouteModel } from './types.js';
+export declare const isClientRouteModel: (route: Object) => route is ClientRouteModel;
+export declare const extractParams: (path: string) => string[];
+//# sourceMappingURL=helper.d.ts.map

package/build/helper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helper.d.ts","sourceRoot":"","sources":["../src/helper.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAA;AAE7C,eAAO,MAAM,kBAAkB,UAAW,MAAM,KAAG,KAAK,IAAI,gBACxC,CAAA;AAEpB,eAAO,MAAM,aAAa,SAAU,MAAM,KAAG,MAAM,EAIlD,CAAA"}

package/build/helper.js

@@ -0,0 +1,8 @@
+import { PARAM, SEP, normalizePath } from '@owlmeans/route';
+export const isClientRouteModel = (route) => '_client' in route;
+export const extractParams = (path) => {
+    path = normalizePath(path);
+    return path.split(SEP).map(item => item.startsWith(PARAM) ? item.slice(1) : null)
+        .filter(param => param);
+};
+//# sourceMappingURL=helper.js.map

package/build/helper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"helper.js","sourceRoot":"","sources":["../src/helper.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAG3D,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,KAAa,EAA6B,EAAE,CAC7E,SAAS,IAAI,KAAK,CAAA;AAEpB,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,IAAY,EAAY,EAAE;IACtD,IAAI,GAAG,aAAa,CAAC,IAAI,CAAC,CAAA;IAC1B,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;SAC9E,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,CAAa,CAAA;AACvC,CAAC,CAAA"}

package/build/index.d.ts

@@ -0,0 +1,4 @@
+export * from './model.js';
+export type * from './types.js';
+export * from './helper.js';
+//# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,cAAc,YAAY,CAAA;AAC1B,mBAAmB,YAAY,CAAA;AAC/B,cAAc,aAAa,CAAA"}

package/build/index.js

@@ -0,0 +1,3 @@
+export * from './model.js';
+export * from './helper.js';
+//# sourceMappingURL=index.js.map

package/build/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,cAAc,YAAY,CAAA;AAE1B,cAAc,aAAa,CAAA"}

package/build/model.d.ts

@@ -0,0 +1,4 @@
+import type { CommonRouteModel } from '@owlmeans/route';
+import type { ClientRouteModel, ClientRouteOptions } from './types.js';
+export declare const route: (route: CommonRouteModel, opts?: ClientRouteOptions) => ClientRouteModel;
+//# sourceMappingURL=model.d.ts.map

package/build/model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model.d.ts","sourceRoot":"","sources":["../src/model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAA;AACvD,OAAO,KAAK,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAA;AAItE,eAAO,MAAM,KAAK,UAAW,gBAAgB,SAAS,kBAAkB,KAAG,gBAoC1E,CAAA"}

package/build/model.js

@@ -0,0 +1,27 @@
+import { resolve, overrideParams } from '@owlmeans/route/utils';
+export const route = (route, opts) => {
+    const unresolvedPath = route.route.path;
+    const model = {
+        ...route,
+        _client: true,
+        resolve: async (context) => {
+            if (model.route.resolved) {
+                if (model._resolved == null) {
+                    throw new SyntaxError('Cannot reach resolved state twice without resolving promise');
+                }
+                await model._resolved;
+                return model.route;
+            }
+            const resolver = {};
+            model._resolved = new Promise(resolve => resolver.resolve = resolve);
+            await resolve(model.route)(context);
+            model.route.partialPath = unresolvedPath;
+            resolver.resolve?.();
+            return model.route;
+        }
+    };
+    overrideParams(model.route, opts?.overrides);
+    model.route.partialPath = unresolvedPath;
+    return model;
+};
+//# sourceMappingURL=model.js.map

package/build/model.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"model.js","sourceRoot":"","sources":["../src/model.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAA;AAG/D,MAAM,CAAC,MAAM,KAAK,GAAG,CAAC,KAAuB,EAAE,IAAyB,EAAoB,EAAE;IAC5F,MAAM,cAAc,GAAG,KAAK,CAAC,KAAK,CAAC,IAAI,CAAA;IAEvC,MAAM,KAAK,GAAqB;QAC9B,GAAI,KAA0B;QAE9B,OAAO,EAAE,IAAI;QAEb,OAAO,EAAE,KAAK,EAAK,OAAU,EAAE,EAAE;YAC/B,IAAI,KAAK,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC;gBACzB,IAAI,KAAK,CAAC,SAAS,IAAI,IAAI,EAAE,CAAC;oBAC5B,MAAM,IAAI,WAAW,CAAC,6DAA6D,CAAC,CAAA;gBACtF,CAAC;gBACD,MAAM,KAAK,CAAC,SAAS,CAAA;gBAErB,OAAO,KAAK,CAAC,KAAK,CAAA;YACpB,CAAC;YAED,MAAM,QAAQ,GAA6B,EAAE,CAAA;YAC7C,KAAK,CAAC,SAAS,GAAG,IAAI,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,QAAQ,CAAC,OAAO,GAAG,OAAO,CAAC,CAAA;YAEpE,MAAM,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,OAAoC,CAAC,CAAA;YAEhE,KAAK,CAAC,KAAK,CAAC,WAAW,GAAG,cAAc,CAAA;YAExC,QAAQ,CAAC,OAAO,EAAE,EAAE,CAAA;YAEpB,OAAO,KAAK,CAAC,KAAK,CAAA;QACpB,CAAC;KACF,CAAA;IAED,cAAc,CAAC,KAAK,CAAC,KAAK,EAAE,IAAI,EAAE,SAAS,CAAC,CAAA;IAE5C,KAAK,CAAC,KAAK,CAAC,WAAW,GAAG,cAAc,CAAA;IAExC,OAAO,KAAK,CAAA;AACd,CAAC,CAAA"}

package/build/types.d.ts

@@ -0,0 +1,13 @@
+import type { CommonRoute, CommonRouteModel } from '@owlmeans/route';
+export interface ClientRoute extends CommonRoute {
+    partialPath: string;
+}
+export interface ClientRouteModel extends CommonRouteModel {
+    route: ClientRoute;
+    _resolved?: Promise<void>;
+    _client: true;
+}
+export interface ClientRouteOptions {
+    overrides?: Partial<ClientRoute>;
+}
+//# sourceMappingURL=types.d.ts.map

package/build/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAA;AAEpE,MAAM,WAAW,WAAY,SAAQ,WAAW;IAC9C,WAAW,EAAE,MAAM,CAAA;CACpB;AAED,MAAM,WAAW,gBAAiB,SAAQ,gBAAgB;IACxD,KAAK,EAAE,WAAW,CAAA;IAClB,SAAS,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,CAAA;IACzB,OAAO,EAAE,IAAI,CAAA;CACd;AAED,MAAM,WAAW,kBAAkB;IACjC,SAAS,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,CAAA;CACjC"}

package/build/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/build/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":""}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@owlmeans/client-route",
+  "version": "0.1.0",
+  "type": "module",
+  "scripts": {
+    "build": "tsc -b",
+    "dev": "sleep 126 && nodemon -e ts,tsx,json --watch src --exec \"tsc -p ./tsconfig.json\"",
+    "watch": "tsc -b -w --preserveWatchOutput --pretty"
+  },
+  "main": "build/index.js",
+  "module": "build/index.js",
+  "types": "build/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./build/index.js",
+      "require": "./build/index.js",
+      "default": "./build/index.js",
+      "module": "./build/index.js",
+      "types": "./build/index.d.ts"
+    }
+  },
+  "dependencies": {
+    "@owlmeans/client-context": "^0.1.0",
+    "@owlmeans/route": "^0.1.0"
+  },
+  "devDependencies": {
+    "nodemon": "^3.1.7",
+    "typescript": "^5.6.3"
+  },
+  "private": false,
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/helper.ts

@@ -0,0 +1,11 @@
+import { PARAM, SEP, normalizePath } from '@owlmeans/route'
+import { ClientRouteModel } from './types.js'
+
+export const isClientRouteModel = (route: Object): route is ClientRouteModel => 
+  '_client' in route
+
+export const extractParams = (path: string): string[] => {
+  path = normalizePath(path)
+  return path.split(SEP).map(item => item.startsWith(PARAM) ? item.slice(1) : null)
+    .filter(param => param) as string[]
+}

package/src/index.ts

@@ -0,0 +1,4 @@
+
+export * from './model.js'
+export type * from './types.js'
+export * from './helper.js'

package/src/model.ts

@@ -0,0 +1,42 @@
+import type { CommonRouteModel } from '@owlmeans/route'
+import type { ClientRouteModel, ClientRouteOptions } from './types.js'
+import { resolve, overrideParams } from '@owlmeans/route/utils'
+import type { BasicConfig, BasicContext } from '../../context/build/types.js'
+
+export const route = (route: CommonRouteModel, opts?: ClientRouteOptions): ClientRouteModel => {
+  const unresolvedPath = route.route.path
+
+  const model: ClientRouteModel = {
+    ...(route as ClientRouteModel),
+
+    _client: true,
+
+    resolve: async <C>(context: C) => {
+      if (model.route.resolved) {
+        if (model._resolved == null) {
+          throw new SyntaxError('Cannot reach resolved state twice without resolving promise')
+        }
+        await model._resolved
+
+        return model.route
+      }
+
+      const resolver: { resolve?: () => void } = {}
+      model._resolved = new Promise(resolve => resolver.resolve = resolve)
+
+      await resolve(model.route)(context as BasicContext<BasicConfig>)
+
+      model.route.partialPath = unresolvedPath
+
+      resolver.resolve?.()
+
+      return model.route
+    }
+  }
+
+  overrideParams(model.route, opts?.overrides)
+
+  model.route.partialPath = unresolvedPath
+
+  return model
+}

package/src/types.ts

@@ -0,0 +1,15 @@
+import type { CommonRoute, CommonRouteModel } from '@owlmeans/route'
+
+export interface ClientRoute extends CommonRoute {
+  partialPath: string
+}
+
+export interface ClientRouteModel extends CommonRouteModel {
+  route: ClientRoute
+  _resolved?: Promise<void>
+  _client: true
+}
+
+export interface ClientRouteOptions {
+  overrides?: Partial<ClientRoute>
+}

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "extends": [
+    "../tsconfig.default.json",
+  ],
+  "compilerOptions": {
+    "rootDir": "./src/", /* Specify the root folder within your source files. */
+    "outDir": "./build/", /* Specify an output folder for all emitted files. */
+    "moduleResolution": "Bundler"
+  },
+  "exclude": [
+    "./dist/**/*",
+    "./build/**/*",
+    "./*.ts"
+  ]
+}

package/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["./src/helper.ts","./src/index.ts","./src/model.ts","./src/types.ts"],"version":"5.6.3"}