@owlmeans/module 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,521 @@
+# OwlMeans Module — Shared library
+
+The `@owlmeans/module` package provides a comprehensive module system for OwlMeans Common Libraries, designed for fullstack microservices and microclients development.
+
+## Overview
+
+In the context of OwlMeans Common Libraries, a **module** is not a programmatic module but a **URL unit** in the system. Modules allow you to:
+
+- Declare URLs and their nesting relationships
+- Transform URLs into routes with attached handlers (backend) or specify components to render (frontend)
+- Generate final URLs for navigation or API calls on both backend and frontend
+- Provide a centralized place where all possible routes are registered
+- Enable micro-applications or micro-services to flawlessly address different parts of the system
+
+For **client-side applications**, the [`@owlmeans/client-module`](../client-module) package extends this base module system with client-specific capabilities such as API calls, URL generation, and request validation.
+
+## Core Concepts
+
+### Module
+A module represents a URL unit that can be transformed into routes or components depending on the environment (frontend/backend). It consists of:
+- A route with URL path and alias
+- Optional guards for authentication/authorization
+- Optional gates for parameter validation
+- Optional filters for request/response validation
+- Optional handlers for processing requests
+
+### Parent-Child Relationships
+Modules can be organized in hierarchical structures where child modules inherit properties from their parents, such as guards and gates.
+
+### Fullstack Consistency
+A key architectural benefit of the module system is that all validators are defined at the module level using **AJV (Another JSON Schema Validator)** format. Since the system is designed for fullstack development (existing on both frontend and backend), these validation schemas are consistently accessible across all application services and clients. This ensures:
+
+- **Unified validation**: Same validation rules apply on both frontend and backend
+- **Consistent data contracts**: API contracts are shared between client and server
+- **Reduced duplication**: No need to define validation schemas separately for frontend and backend
+- **Type safety**: AJV schemas provide runtime validation that complements TypeScript's compile-time checking
+
+## API Reference
+
+### Types
+
+#### CommonModule
+The main module interface that extends `BasicModule` from `@owlmeans/context`.
+
+```typescript
+interface CommonModule extends BasicModule {
+  route: CommonRouteModel
+  sticky: boolean                    // If true, router attaches this module unconditionally
+  filter?: Filter                    // Request/response validation schemas
+  guards?: string[]                  // Authentication guards
+  gate?: string                      // Authorization gate
+  gateParams?: string | string[]     // Gate parameters
+  handle?: ModuleHandler             // Request handler function
+  
+  // Methods
+  getAlias(): string
+  getPath(): string
+  getParentAlias(): string | null
+  hasParent(): boolean
+  resolve<M extends CommonModule>(): Promise<M>
+  getParent<M extends CommonModule>(): M
+  setService(service: string): void
+  getGuards(): string[]
+  getGates(): [string, string[]][]
+}
+```
+
+#### ModuleHandler
+Function signature for handling module requests.
+
+```typescript
+interface ModuleHandler {
+  <T, R extends AbstractRequest<any> = AbstractRequest<any>,
+   P extends AbstractResponse<any> = AbstractResponse<any>>
+  (req: R, res: P): T | Promise<T>
+}
+```
+
+#### Filter
+Schema definitions for request/response validation using **AJV (Another JSON Schema Validator)** format. All validators are defined at the module level, ensuring consistent validation schemas across both frontend and backend environments in fullstack applications.
+
+```typescript
+interface Filter {
+  query?: AnySchemaObject      // Query parameters validation (AJV schema)
+  params?: AnySchemaObject     // Path parameters validation (AJV schema)
+  body?: AnySchemaObject       // Request body validation (AJV schema)
+  response?: AnySchemaObject   // Response validation (AJV schema)
+  headers?: AnySchemaObject    // Headers validation (AJV schema)
+}
+```
+
+Since the module system is designed for fullstack development, these AJV validation schemas are accessible and consistent across all application services and clients, providing unified data validation throughout the entire application stack.
+
+#### AbstractRequest
+Generic request interface for both frontend and backend.
+
+```typescript
+interface AbstractRequest<T extends {} = {}> {
+  alias: string
+  auth?: Auth
+  params: Record<string, string | number | undefined | null> | Partial<T>
+  body?: Record<string, any> | Partial<T>
+  headers: Record<string, string[] | string | undefined>
+  query: Record<string, string | number | undefined | null> | Partial<T>
+  path: string
+  original?: any
+  canceled?: boolean
+  cancel?: () => void
+  host?: string
+  base?: string | boolean
+}
+```
+
+#### AbstractResponse
+Generic response interface for handling module responses.
+
+```typescript
+interface AbstractResponse<T> {
+  responseProvider?: any
+  value?: T
+  outcome?: ModuleOutcome
+  error?: Error
+  resolve(value: T, outcome?: ModuleOutcome): void
+  reject(error: Error): void
+}
+```
+
+### Core Functions
+
+#### module(route, opts?)
+Creates a new module instance.
+
+```typescript
+function module(route: CommonRouteModel, opts?: CommonModuleOptions): CommonModule
+```
+
+**Parameters:**
+- `route`: CommonRouteModel - The route configuration
+- `opts`: CommonModuleOptions - Optional module configuration
+
+**Returns:** CommonModule instance
+
+**Example:**
+```typescript
+import { module } from '@owlmeans/module'
+import { route } from '@owlmeans/route'
+
+const userModule = module(route('users', '/users'), {
+  sticky: true,
+  guards: ['authenticated']
+})
+```
+
+#### parent(module, aliasOrParent, _parent?)
+Sets parent-child relationships between modules.
+
+```typescript
+function parent<T extends CommonModule | CommonModule[]>(
+  module: T, 
+  aliasOrParent: string, 
+  _parent?: string
+): T
+```
+
+**Parameters:**
+- `module`: CommonModule or CommonModule[] - Module(s) to set parent for
+- `aliasOrParent`: string - Parent alias or module alias (when working with arrays)
+- `_parent`: string - Parent name (required when working with arrays)
+
+**Returns:** The module(s) with parent relationship set
+
+**Example:**
+```typescript
+const userModule = module(route('users', '/users'))
+const userProfileModule = module(route('user-profile', '/profile'))
+
+parent(userProfileModule, 'users') // Sets users as parent of user-profile
+```
+
+### Helper Functions
+
+#### filter(filter, opts?)
+Creates module options with filter configuration.
+
+```typescript
+function filter(filter: Filter, opts?: CommonModuleOptions): CommonModuleOptions
+```
+
+**Example:**
+```typescript
+const userModule = module(route('users', '/users'), filter({
+  query: { type: 'object', properties: { limit: { type: 'number' } } }
+}))
+```
+
+#### guard(guard, opts?)
+Adds authentication guard to module options.
+
+```typescript
+function guard(guard: string, opts?: CommonModuleOptions): CommonModuleOptions
+```
+
+**Example:**
+```typescript
+const adminModule = module(route('admin', '/admin'), guard('admin'))
+```
+
+#### gate(gate, params, opts?)
+Adds authorization gate with parameters to module options.
+
+```typescript
+function gate(gate: string, params: string | string[], opts?: CommonModuleOptions): CommonModuleOptions
+```
+
+**Example:**
+```typescript
+const userModule = module(route('user', '/user/:id'), gate('user-access', ['id']))
+```
+
+#### provideResponse(originalResponse?)
+Creates an abstract response handler.
+
+```typescript
+function provideResponse<T>(originalResponse?: unknown): AbstractResponse<T>
+```
+
+**Example:**
+```typescript
+const response = provideResponse<UserData>()
+response.resolve(userData, ModuleOutcome.Ok)
+```
+
+#### clone(modules, from, to, service)
+Clones an existing module with new alias and service.
+
+```typescript
+function clone<M extends CommonModule>(
+  modules: M[], 
+  from: string, 
+  to: string, 
+  service: string
+): void
+```
+
+**Parameters:**
+- `modules`: M[] - Array of modules to add cloned module to
+- `from`: string - Source module alias
+- `to`: string - New module alias
+- `service`: string - Service name for the cloned module
+
+### Filter Building Functions
+
+These functions create validation filters using **AJV (Another JSON Schema Validator)** format. All schemas are defined at the module level and remain consistent across both frontend and backend environments, ensuring unified validation throughout your fullstack application.
+
+#### body(schema, filter?)
+Creates or extends a filter with body validation schema using AJV format.
+
+```typescript
+function body<T>(schema: JSONSchemaType<T>, filter?: Filter): Filter
+```
+
+#### query(schema, filter?)
+Creates or extends a filter with query parameters validation schema using AJV format.
+
+```typescript
+function query<T>(schema: JSONSchemaType<T>, filter?: Filter): Filter
+```
+
+#### params(schema, filter?)
+Creates or extends a filter with path parameters validation schema using AJV format.
+
+```typescript
+function params<T>(schema: JSONSchemaType<T>, filter?: Filter): Filter
+```
+
+#### response(schema, code?, filter?)
+Creates or extends a filter with response validation schema using AJV format.
+
+```typescript
+function response<T>(schema: JSONSchemaType<T>, code?: number, filter?: Filter): Filter
+```
+
+#### headers(schema, filter?)
+Creates or extends a filter with headers validation schema using AJV format.
+
+```typescript
+function headers<T>(schema: JSONSchemaType<T>, filter?: Filter): Filter
+```
+
+**Example with AJV Schema Format:**
+```typescript
+import { body, query, params, response } from '@owlmeans/module'
+
+// AJV schema for request body validation
+const userFilter = body({
+  type: 'object',
+  properties: {
+    name: { type: 'string' },
+    email: { type: 'string' }
+  },
+  required: ['name', 'email']
+}, query({
+  type: 'object',
+  properties: {
+    include: { type: 'string', enum: ['profile', 'preferences'] }
+  }
+}))
+
+// These AJV schemas are accessible on both frontend and backend
+// providing consistent validation across your fullstack application
+```
+
+### Utility Functions
+
+#### isModule(object)
+Type guard to check if an object is a CommonModule.
+
+```typescript
+function isModule(module: Object): module is CommonModule
+```
+
+**Example:**
+```typescript
+if (isModule(someObject)) {
+  // someObject is definitely a CommonModule
+  console.log(someObject.getAlias())
+}
+```
+
+### Constants
+
+#### ModuleOutcome
+Enumeration of possible module response outcomes.
+
+```typescript
+enum ModuleOutcome {
+  Ok = 'ok',
+  Accepted = 'accepted',
+  Created = 'created',
+  Finished = 'finished'
+}
+```
+
+### Service Interfaces
+
+#### GuardService
+Service interface for implementing authentication guards.
+
+```typescript
+interface GuardService extends InitializedService {
+  token?: string
+  authenticated(req?: Partial<AbstractRequest>): Promise<string | null>
+  match: ModuleMatch
+  handle: ModuleHandler
+}
+```
+
+#### GateService
+Service interface for implementing authorization gates.
+
+```typescript
+interface GateService extends LazyService {
+  assert: ModuleAssert  // Throws Error if assertion fails
+}
+```
+
+## Usage Examples
+
+### Basic Module Creation
+
+```typescript
+import { module, guard, filter, body } from '@owlmeans/module'
+import { route } from '@owlmeans/route'
+
+// Create a simple module
+const homeModule = module(route('home', '/'))
+
+// Create a protected module with authentication
+const dashboardModule = module(
+  route('dashboard', '/dashboard'),
+  guard('authenticated')
+)
+
+// Create a module with request validation
+const createUserModule = module(
+  route('create-user', '/users', { method: 'POST' }),
+  filter(body({
+    type: 'object',
+    properties: {
+      name: { type: 'string' },
+      email: { type: 'string' }
+    },
+    required: ['name', 'email']
+  }))
+)
+```
+
+### Module Hierarchies
+
+```typescript
+// Create parent module
+const apiModule = module(route('api', '/api'))
+
+// Create child modules
+const usersModule = module(route('users', '/users'))
+const postsModule = module(route('posts', '/posts'))
+
+// Set parent relationships
+parent(usersModule, 'api')
+parent(postsModule, 'api')
+
+// Child modules inherit parent guards and gates
+const userProfileModule = module(
+  route('user-profile', '/profile'),
+  guard('user-access')
+)
+parent(userProfileModule, 'users')
+```
+
+### Module with Handler
+
+```typescript
+const userModule = module(route('get-user', '/users/:id'), {
+  handle: async (req, res) => {
+    const userId = req.params.id
+    const user = await getUserById(userId)
+    res.resolve(user, ModuleOutcome.Ok)
+  }
+})
+```
+
+### Complex Filter Example
+
+```typescript
+import { filter, body, query, params, response } from '@owlmeans/module'
+
+const complexModule = module(
+  route('complex-api', '/api/users/:id'),
+  filter(
+    params({
+      type: 'object',
+      properties: {
+        id: { type: 'string', pattern: '^[0-9]+$' }
+      },
+      required: ['id']
+    },
+    query({
+      type: 'object',
+      properties: {
+        include: { type: 'string', enum: ['profile', 'posts'] },
+        limit: { type: 'number', minimum: 1, maximum: 100 }
+      }
+    },
+    response({
+      type: 'object',
+      properties: {
+        user: { type: 'object' },
+        profile: { type: 'object' }
+      },
+      required: ['user']
+    })))
+  )
+)
+```
+
+## Integration Patterns
+
+### Backend Integration
+On the backend, modules are typically transformed into Express-like routes:
+
+```typescript
+// Transform module to route with handler
+app.get(userModule.getPath(), async (req, res) => {
+  const moduleReq = adaptRequest(req)
+  const moduleRes = provideResponse()
+  
+  await userModule.handle(moduleReq, moduleRes)
+  
+  if (moduleRes.error) {
+    res.status(500).json({ error: moduleRes.error.message })
+  } else {
+    res.json(moduleRes.value)
+  }
+})
+```
+
+### Frontend Integration
+On the frontend, modules help generate URLs and determine which components to render:
+
+```typescript
+// Generate URL for navigation
+const userUrl = userModule.getPath() // '/users/:id'
+const finalUrl = userUrl.replace(':id', userId)
+
+// Navigate to the route
+router.push(finalUrl)
+```
+
+## Best Practices
+
+1. **Organize modules hierarchically** to take advantage of guard and gate inheritance
+2. **Use meaningful aliases** for modules to make them easy to reference
+3. **Apply filters consistently** to ensure proper validation
+4. **Leverage guards and gates** for security at the module level
+5. **Keep modules focused** on a single responsibility
+6. **Use the clone function** to create variations of existing modules for different services
+
+## Dependencies
+
+This package depends on:
+- `@owlmeans/route` - For route management
+- `@owlmeans/context` - For contextual module support
+- `@owlmeans/auth` - For authentication integration
+- `ajv` - For JSON schema validation using AJV format, providing consistent validation across fullstack applications
+
+## Related Packages
+
+- [`@owlmeans/client-module`](../client-module) - Client-side extension with API calls and URL generation
+- [`@owlmeans/server-module`](../server-module) - Server-side module implementation
+- [`@owlmeans/route`](../route) - Core routing functionality
+- [`@owlmeans/context`](../context) - Context management system

package/build/consts.d.ts

@@ -0,0 +1,7 @@
+export declare enum ModuleOutcome {
+    Ok = "ok",
+    Accepted = "accepted",
+    Created = "created",
+    Finished = "finished"
+}
+//# sourceMappingURL=consts.d.ts.map

package/build/consts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consts.d.ts","sourceRoot":"","sources":["../src/consts.ts"],"names":[],"mappings":"AACA,oBAAY,aAAa;IACvB,EAAE,OAAO;IACT,QAAQ,aAAa;IACrB,OAAO,YAAY;IACnB,QAAQ,aAAa;CACtB"}

package/build/consts.js

@@ -0,0 +1,8 @@
+export var ModuleOutcome;
+(function (ModuleOutcome) {
+    ModuleOutcome["Ok"] = "ok";
+    ModuleOutcome["Accepted"] = "accepted";
+    ModuleOutcome["Created"] = "created";
+    ModuleOutcome["Finished"] = "finished";
+})(ModuleOutcome || (ModuleOutcome = {}));
+//# sourceMappingURL=consts.js.map

package/build/consts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"consts.js","sourceRoot":"","sources":["../src/consts.ts"],"names":[],"mappings":"AACA,MAAM,CAAN,IAAY,aAKX;AALD,WAAY,aAAa;IACvB,0BAAS,CAAA;IACT,sCAAqB,CAAA;IACrB,oCAAmB,CAAA;IACnB,sCAAqB,CAAA;AACvB,CAAC,EALW,aAAa,KAAb,aAAa,QAKxB"}

package/build/filter.d.ts

@@ -0,0 +1,8 @@
+import type { JSONSchemaType } from 'ajv';
+import type { Filter } from './types.js';
+export declare const body: <T>(schema: JSONSchemaType<T>, filter?: Filter) => Filter;
+export declare const query: <T>(schema: JSONSchemaType<T>, filter?: Filter) => Filter;
+export declare const params: <T>(schema: JSONSchemaType<T>, filter?: Filter) => Filter;
+export declare const response: <T>(schema: JSONSchemaType<T>, code?: number, filter?: Filter) => Filter;
+export declare const headers: <T>(schema: JSONSchemaType<T>, filter?: Filter) => Filter;
+//# sourceMappingURL=filter.d.ts.map

package/build/filter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter.d.ts","sourceRoot":"","sources":["../src/filter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,KAAK,CAAA;AACzC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAA;AAExC,eAAO,MAAM,IAAI,GAAI,CAAC,UAAU,cAAc,CAAC,CAAC,CAAC,WAAW,MAAM,KAAG,MAEpE,CAAA;AAED,eAAO,MAAM,KAAK,GAAI,CAAC,UAAU,cAAc,CAAC,CAAC,CAAC,WAAW,MAAM,KAAG,MAErE,CAAA;AAED,eAAO,MAAM,MAAM,GAAI,CAAC,UAAU,cAAc,CAAC,CAAC,CAAC,WAAW,MAAM,KAAG,MAEtE,CAAA;AAED,eAAO,MAAM,QAAQ,GAAI,CAAC,UAAU,cAAc,CAAC,CAAC,CAAC,SAAS,MAAM,WAAW,MAAM,KAAG,MAMvF,CAAA;AAED,eAAO,MAAM,OAAO,GAAI,CAAC,UAAU,cAAc,CAAC,CAAC,CAAC,WAAW,MAAM,KAAG,MAEvE,CAAA"}

package/build/filter.js

@@ -0,0 +1,20 @@
+export const body = (schema, filter) => {
+    return { ...filter, body: schema };
+};
+export const query = (schema, filter) => {
+    return { ...filter, query: schema };
+};
+export const params = (schema, filter) => {
+    return { ...filter, params: schema };
+};
+export const response = (schema, code, filter) => {
+    let _schema = schema;
+    if (filter?.response != null && code != null) {
+        _schema = { ...filter.response, [code]: schema };
+    }
+    return { ...filter, response: _schema };
+};
+export const headers = (schema, filter) => {
+    return { ...filter, headers: schema };
+};
+//# sourceMappingURL=filter.js.map

package/build/filter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter.js","sourceRoot":"","sources":["../src/filter.ts"],"names":[],"mappings":"AAGA,MAAM,CAAC,MAAM,IAAI,GAAG,CAAI,MAAyB,EAAE,MAAe,EAAU,EAAE;IAC5E,OAAO,EAAE,GAAG,MAAM,EAAE,IAAI,EAAE,MAAa,EAAE,CAAA;AAC3C,CAAC,CAAA;AAED,MAAM,CAAC,MAAM,KAAK,GAAG,CAAI,MAAyB,EAAE,MAAe,EAAU,EAAE;IAC7E,OAAO,EAAE,GAAG,MAAM,EAAE,KAAK,EAAE,MAAa,EAAE,CAAA;AAC5C,CAAC,CAAA;AAED,MAAM,CAAC,MAAM,MAAM,GAAG,CAAI,MAAyB,EAAE,MAAe,EAAU,EAAE;IAC9E,OAAO,EAAE,GAAG,MAAM,EAAE,MAAM,EAAE,MAAa,EAAE,CAAA;AAC7C,CAAC,CAAA;AAED,MAAM,CAAC,MAAM,QAAQ,GAAG,CAAI,MAAyB,EAAE,IAAa,EAAE,MAAe,EAAU,EAAE;IAC/F,IAAI,OAAO,GAAQ,MAAM,CAAA;IACzB,IAAI,MAAM,EAAE,QAAQ,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,EAAE,CAAC;QAC7C,OAAO,GAAG,EAAE,GAAG,MAAM,CAAC,QAAQ,EAAE,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAA;IAClD,CAAC;IACD,OAAO,EAAE,GAAG,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAA;AACzC,CAAC,CAAA;AAED,MAAM,CAAC,MAAM,OAAO,GAAG,CAAI,MAAyB,EAAE,MAAe,EAAU,EAAE;IAC/E,OAAO,EAAE,GAAG,MAAM,EAAE,OAAO,EAAE,MAAa,EAAE,CAAA;AAC9C,CAAC,CAAA"}

package/build/helper.d.ts

@@ -0,0 +1,7 @@
+import { Filter, CommonModuleOptions, AbstractResponse, CommonModule } from './types.js';
+export declare const filter: (filter: Filter, opts?: CommonModuleOptions) => CommonModuleOptions;
+export declare const guard: (guard: string, opts?: CommonModuleOptions) => CommonModuleOptions;
+export declare const gate: (gate: string, params: string | string[], opts?: CommonModuleOptions) => CommonModuleOptions;
+export declare const provideResponse: <T>(originalResponse?: unknown) => AbstractResponse<T>;
+export declare const clone: <M extends CommonModule>(modules: M[], from: string, to: string, service: string) => void;
+//# 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,MAAM,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAGxF,eAAO,MAAM,MAAM,WAAY,MAAM,SAAS,mBAAmB,KAAG,mBAA4C,CAAA;AAEhH,eAAO,MAAM,KAAK,UAAW,MAAM,SAAS,mBAAmB,KAAG,mBACK,CAAA;AAEvE,eAAO,MAAM,IAAI,SAAU,MAAM,UAAU,MAAM,GAAG,MAAM,EAAE,SAAS,mBAAmB,KAAG,mBAClD,CAAA;AAEzC,eAAO,MAAM,eAAe,GAAI,CAAC,qBAAqB,OAAO,KAAG,gBAAgB,CAAC,CAAC,CAejF,CAAA;AAED,eAAO,MAAM,KAAK,GAAI,CAAC,SAAS,YAAY,WAAW,CAAC,EAAE,QAAQ,MAAM,MAAM,MAAM,WAAW,MAAM,SAOpG,CAAA"}

package/build/helper.js

@@ -0,0 +1,26 @@
+import { route } from '@owlmeans/route';
+import { module } from './module.js';
+export const filter = (filter, opts) => ({ filter, ...opts });
+export const guard = (guard, opts) => ({ ...opts, guards: [...new Set([guard, ...(opts?.guards ?? [])])] });
+export const gate = (gate, params, opts) => ({ ...opts, gate, gateParams: params });
+export const provideResponse = (originalResponse) => {
+    const hanlder = {
+        responseProvider: originalResponse,
+        resolve: (value, outcome) => {
+            hanlder.value = value;
+            hanlder.outcome = outcome;
+        },
+        reject: (error) => {
+            hanlder.error = error;
+        }
+    };
+    return hanlder;
+};
+export const clone = (modules, from, to, service) => {
+    const source = modules.find(m => m.alias === from);
+    if (source?.route.route != null) {
+        const _route = { ...source.route.route, service, resolved: false, alias: to };
+        modules.push(module(route(to, _route.path, _route)));
+    }
+};
+//# 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,MAAM,iBAAiB,CAAA;AAEvC,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AAEpC,MAAM,CAAC,MAAM,MAAM,GAAG,CAAC,MAAc,EAAE,IAA0B,EAAuB,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,CAAC,CAAA;AAEhH,MAAM,CAAC,MAAM,KAAK,GAAG,CAAC,KAAa,EAAE,IAA0B,EAAuB,EAAE,CACtF,CAAC,EAAE,GAAG,IAAI,EAAE,MAAM,EAAE,CAAC,GAAG,IAAI,GAAG,CAAC,CAAC,KAAK,EAAE,GAAG,CAAC,IAAI,EAAE,MAAM,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAA;AAEvE,MAAM,CAAC,MAAM,IAAI,GAAG,CAAC,IAAY,EAAE,MAAyB,EAAE,IAA0B,EAAuB,EAAE,CAC/G,CAAC,EAAE,GAAG,IAAI,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,CAAC,CAAA;AAEzC,MAAM,CAAC,MAAM,eAAe,GAAG,CAAI,gBAA0B,EAAuB,EAAE;IACpF,MAAM,OAAO,GAAwB;QACnC,gBAAgB,EAAE,gBAAgB;QAElC,OAAO,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE;YAC1B,OAAO,CAAC,KAAK,GAAG,KAAK,CAAA;YACrB,OAAO,CAAC,OAAO,GAAG,OAAO,CAAA;QAC3B,CAAC;QAED,MAAM,EAAE,CAAC,KAAK,EAAE,EAAE;YAChB,OAAO,CAAC,KAAK,GAAG,KAAK,CAAA;QACvB,CAAC;KACF,CAAA;IAED,OAAO,OAAO,CAAA;AAChB,CAAC,CAAA;AAED,MAAM,CAAC,MAAM,KAAK,GAAG,CAAyB,OAAY,EAAE,IAAY,EAAE,EAAU,EAAE,OAAe,EAAE,EAAE;IACvG,MAAM,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,KAAK,IAAI,CAAC,CAAA;IAElD,IAAI,MAAM,EAAE,KAAK,CAAC,KAAK,IAAI,IAAI,EAAE,CAAC;QAChC,MAAM,MAAM,GAAG,EAAE,GAAG,MAAM,CAAC,KAAK,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,EAAE,CAAA;QAC7E,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,EAAE,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,CAAM,CAAC,CAAA;IAC3D,CAAC;AACH,CAAC,CAAA"}

package/build/index.d.ts

@@ -0,0 +1,6 @@
+export type * from './types.js';
+export * from './module.js';
+export * from './filter.js';
+export * from './helper.js';
+export * from './consts.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,mBAAmB,YAAY,CAAA;AAC/B,cAAc,aAAa,CAAA;AAC3B,cAAc,aAAa,CAAA;AAC3B,cAAc,aAAa,CAAA;AAC3B,cAAc,aAAa,CAAA"}

package/build/index.js

@@ -0,0 +1,5 @@
+export * from './module.js';
+export * from './filter.js';
+export * from './helper.js';
+export * from './consts.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":"AAEA,cAAc,aAAa,CAAA;AAC3B,cAAc,aAAa,CAAA;AAC3B,cAAc,aAAa,CAAA;AAC3B,cAAc,aAAa,CAAA"}

package/build/module.d.ts

@@ -0,0 +1,5 @@
+import type { CommonModule } from './types.js';
+import type { CreateModuleSignature } from './utils/types.js';
+export declare const module: CreateModuleSignature<CommonModule>;
+export declare const parent: <T extends CommonModule | CommonModule[]>(module: T, aliasOrParent: string, _parent?: string) => T;
+//# sourceMappingURL=module.d.ts.map