native-document 1.0.92 → 1.0.94

package/src/router/Route.js

@@ -5,11 +5,16 @@ export const RouteParamPatterns = {
 };
 
 /**
+ * Creates a new Route instance.
  *
- * @param {string} $path
- * @param {Function} $component
- * @param {{name:?string, middlewares:Function[], shouldRebuild:Boolean, with: Object }}$options
- * @class
+ * @param {string} $path - URL pattern with optional parameters (e.g., '/user/{id:number}')
+ * @param {Function} $component - Component function that returns HTMLElement or DocumentFragment
+ * @param {Object} [$options={}] - Route configuration options
+ * @param {string} [$options.name] - Unique name for the route (used for navigation)
+ * @param {Function[]} [$options.middlewares] - Array of middleware functions
+ * @param {boolean} [$options.shouldRebuild] - Whether to rebuild component on each navigation
+ * @param {Object} [$options.with] - Custom parameter validation patterns
+ * @param {Function} [$options.layout] - Layout component wrapper function
  */
 export function Route($path, $component, $options = {}) {
 

package/src/router/Router.js

@@ -14,7 +14,7 @@ export const DEFAULT_ROUTER_NAME = 'default';
 /**
  *
  * @param {{mode: 'memory'|'history'|'hash'}} $options
- * @constructor
+ * @class
  */
 export default function Router($options = {}) {
 
@@ -72,11 +72,20 @@ export default function Router($options = {}) {
     };
 
     /**
+     * Groups routes under a common path prefix with shared options.
      *
-     * @param {string} suffix
-     * @param {{ middlewares: Function[], name: string}} options
-     * @param {Function} callback
-     * @returns {this}
+     * @param {string} suffix - Path prefix to prepend to all routes in the group
+     * @param {Object} options - Group configuration options
+     * @param {Function[]} [options.middlewares] - Middlewares applied to all routes in group
+     * @param {string} [options.name] - Name prefix for all routes in group
+     * @param {Function} [options.layout] - Layout component for all routes in group
+     * @param {Function} callback - Function that defines routes within the group
+     * @returns {this} Router instance for chaining
+     * @example
+     * router.group('/admin', { middlewares: [authMiddleware], layout: AdminLayout }, () => {
+     *   router.add('/users', UsersPage, { name: 'users' });
+     *   router.add('/settings', SettingsPage, { name: 'settings' });
+     * });
      */
     this.group = function(suffix, options, callback) {
         if(!Validator.isFunction(callback)) {
@@ -194,14 +203,24 @@ export default function Router($options = {}) {
 Router.routers = {};
 
 /**
+ * Creates and initializes a new router instance.
  *
- * @param {{mode: 'memory'|'history'|'hash', name?:string, entry?: string}} options
- * @param {Function} callback
- * @param {Element} container
+ * @param {Object} options - Router configuration
+ * @param {'memory'|'history'|'hash'} options.mode - Routing mode
+ * @param {string} [options.name] - Router name for multi-router apps
+ * @param {string} [options.entry] - Initial route path
+ * @param {Function} callback - Setup function that receives the router instance
+ * @returns {Router} The configured router instance with mount() method
+ * @example
+ * const router = Router.create({ mode: 'history' }, (r) => {
+ *   r.add('/home', HomePage, { name: 'home' });
+ *   r.add('/about', AboutPage, { name: 'about' });
+ * });
+ * router.mount('#app');
  */
 Router.create = function(options, callback) {
     if(!Validator.isFunction(callback)) {
-        DebugManager.error('Router', 'Callback must be a function', e);
+        DebugManager.error('Router', 'Callback must be a function');
         throw new RouterError('Callback must be a function');
     }
     const router = new Router(options);

package/src/router/errors/RouterError.js

@@ -5,5 +5,4 @@ export default class RouterError extends Error {
         super(message);
         this.context = context;
     }
-
 }

package/types/control-flow.d.ts

@@ -12,7 +12,10 @@ export interface HideIfFunction {
 }
 
 export interface MatchFunction {
-    <T extends string | number>(condition: ObservableItem<T> | ObservableChecker<T>, values: Record<T, ValidChild>, shouldKeepInCache?: boolean): DocumentFragment;
+    <T extends string | number>(condition: ObservableItem<T> | ObservableChecker<T>, values: Record<T, ValidChild>, shouldKeepInCache?: boolean): DocumentFragment & {
+        add(key: T, child: ValidChild, shouldFocusOn?: boolean): void;
+        remove(key: T): void;
+    };
 }
 
 export interface SwitchFunction {
@@ -30,14 +33,14 @@ export interface WhenFunction {
 export interface ForEachFunction {
     <T>(data: T[] | Record<string, T> | ObservableItem<T[]> | ObservableItem<Record<string, T>>,
         callback: (item: T, index?: ObservableItem<number>) => ValidChild,
-        key?: string | ((item: T, defaultKey: string | number) => string),
-        configs?: { shouldKeepItemsInCache: boolean, isParentUniqueChild: boolean,  }): DocumentFragment,
+        key?: string | ((item: T, defaultKey: string | number) => string | number),
+        options?: { shouldKeepItemsInCache: boolean, isParentUniqueChild: boolean,  }): DocumentFragment,
 }
 
 export interface ForEachArrayFunction {
     <T>(data: ObservableArray<T>,
         callback: (item: T, index?: ObservableItem<number>) => ValidChild,
-        configs?: { pushDelay?: (items: T[]) => number, isParentUniqueChild: boolean, shouldKeepItemsInCache?: boolean }): DocumentFragment;
+        configs?: { isParentUniqueChild: boolean, shouldKeepItemsInCache?: boolean }): DocumentFragment;
 }
 
 export interface HideIfNotFunction {
@@ -45,8 +48,8 @@ export interface HideIfNotFunction {
 }
 
 
-export function ShowWhen(observer: ObservableWhen, target: any): ReturnType<typeof ShowIf>;
-export function ShowWhen(observer: ObservableWhen, target: any, view: any): ReturnType<typeof ShowIf>;
+export function ShowWhen(observerWhenResult: ObservableWhen, view: ValidChild): ReturnType<typeof ShowIf>;
+export function ShowWhen(observer: ObservableItem, target: any, view: ValidChild): ReturnType<typeof ShowIf>;
 
 // Control Flow Components
 export declare const ShowIf: ShowIfFunction;