@avstantso/react-router-utils 0.1.2 → 0.2.1

package/dist/types/navigates.d.ts

@@ -1,4 +1,3 @@
-import TS = AVStantso.TS;
 import type React from 'react';
 import type { NavigateFunction, NavigateOptions, NavigateProps } from 'react-router-dom';
 import type { BindedPath, BindProps } from '../core';
@@ -33,20 +32,23 @@ export declare namespace NavigatesTree {
         /**
          * @summary Navigate node component
          */
-        type Leaf<P extends object = undefined> = React.FC<BindedNavigate.Props & ([
-            keyof P
-        ] extends [never] ? unknown : {
-            params: P;
-        })>;
+        type Leaf<TTypeMap extends UrlsTree.TypeMap> = React.FC<BindedNavigate.Props & UrlsTree.ResolveParams<TTypeMap, 'field'>>;
         /**
          * @summary Navigate component node based on url tree
          */
-        type Node<TTree extends UrlsTree, TNode extends object, TParams extends object = {}, P extends TS.Keys = []> = (TNode extends UrlsTree.Node ? Leaf<TParams> : unknown) & {
-            [K in UrlsTree.Key<TTree, TNode> as UrlsTree.ResolveKey<TTree, TParams, TNode, K>]: Node<TTree, Extract<TNode[K], UrlsTree.Node>, UrlsTree.ResolveParam<TTree, TParams, TNode, K>, [
-                K,
-                ...P
-            ]>;
+        type Node<TTypeMap extends UrlsTree.TypeMap, F extends UrlsTree.IsFind<TTypeMap> = UrlsTree.IsFind<TTypeMap>> = F extends 'found' ? Node<Omit<TTypeMap, 'Find'>> : F extends 'not-found' ? {
+            [K in UrlsTree.Key<TTypeMap>]: Node<UrlsTree.TypeMap.Next<TTypeMap, K>>;
+        }[UrlsTree.Key<TTypeMap>] : (TTypeMap extends {
+            Node: UrlsTree.Node;
+        } ? Leaf<TTypeMap> : unknown) & {
+            [K in UrlsTree.Key<TTypeMap> as UrlsTree.ResolveKey<TTypeMap, K>]: Node<UrlsTree.TypeMap.Next<TTypeMap, K>>;
         };
+        namespace Node {
+            type Root<TTree extends UrlsTree, TFind extends string | UrlsTree.Node = undefined> = Node<UrlsTree.TypeMap.Init<TTree, TFind, {
+                ParamReplacePrefix: '$';
+                Casing: 'p';
+            }>>;
+        }
     }
     /**
      * `useNavigate` tree
@@ -55,19 +57,29 @@ export declare namespace NavigatesTree {
         /**
          * @summary Navigate hook node function
          */
-        type Leaf<P extends object = undefined> = BindedNavigate.UseFunction<P>;
+        type Leaf<TTypeMap extends UrlsTree.TypeMap> = BindedNavigate.UseFunction<UrlsTree.ResolveParam<TTypeMap>>;
         /**
          * @summary Navigate hook node based on url tree
          */
-        type Node<TTree extends UrlsTree, TNode extends object, TParams extends object = {}, P extends TS.Keys = []> = (TNode extends UrlsTree.Node ? Leaf<TParams> : unknown) & {
-            [K in UrlsTree.Key<TTree, TNode> as UrlsTree.ResolveKey<TTree, TParams, TNode, K>]: Node<TTree, Extract<TNode[K], UrlsTree.Node>, UrlsTree.ResolveParam<TTree, TParams, TNode, K>, [
-                K,
-                ...P
-            ]>;
+        type Node<TTypeMap extends UrlsTree.TypeMap, F extends UrlsTree.IsFind<TTypeMap> = UrlsTree.IsFind<TTypeMap>> = F extends 'found' ? Node<Omit<TTypeMap, 'Find'>> : F extends 'not-found' ? {
+            [K in UrlsTree.Key<TTypeMap>]: Node<UrlsTree.TypeMap.Next<TTypeMap, K>>;
+        }[UrlsTree.Key<TTypeMap>] : (TTypeMap extends {
+            Node: UrlsTree.Node;
+        } ? Leaf<TTypeMap> : unknown) & {
+            [K in UrlsTree.Key<TTypeMap> as UrlsTree.ResolveKey<TTypeMap, K>]: Node<UrlsTree.TypeMap.Next<TTypeMap, K>>;
         };
+        namespace Node {
+            type Root<TTree extends UrlsTree, TFind extends string | UrlsTree.Node = undefined> = Node<UrlsTree.TypeMap.Init<TTree, TFind, {
+                ParamReplacePrefix: '$';
+                Casing: 'p';
+            }>>;
+        }
     }
 }
-export type NavigatesTree<TTree extends UrlsTree> = NavigatesTree.Component.Node<TTree, TTree & object> & {
-    useNavigate(): NavigateFunction & NavigatesTree.Hook.Node<TTree, TTree & object>;
+export type NavigatesTree<TTree extends UrlsTree> = NavigatesTree.Component.Node.Root<TTree> & {
+    AT<TNode extends UrlsTree.Node>(node: TNode): NavigatesTree.Component.Node.Root<TTree, TNode>;
+    useNavigate(): NavigateFunction & NavigatesTree.Hook.Node.Root<TTree> & {
+        AT<TNode extends UrlsTree.Node>(node: TNode): NavigatesTree.Hook.Node.Root<TTree, TNode>;
+    };
 };
 export {};

package/dist/types/route-creator.d.ts

@@ -8,18 +8,29 @@ type BRO = RouteCreator.BindedRouteObject;
 export declare namespace RouteCreator {
     type Type = 'url' | 'name';
     type BindedRouteObject = Omit<RouteObject, 'path'>;
-    type Method = (routeObject: BRO) => RouteObject;
     /**
      * @summary Create node route function
      */
-    type Leaf = Method;
+    type Leaf<TNode> = {
+        (routeObject: BRO): RouteObject;
+        (makeRouteObjectCallback: (node: TNode) => BRO): RouteObject;
+    };
     /**
      * @summary Component node based on url tree
      */
-    type Node<TTree extends UrlsTree, TNode extends object> = (TNode extends UrlsTree.Node ? Leaf : unknown) & {
-        [K in UrlsTree.Key<TTree, TNode> as UrlsTree.ResolveKey<TTree, undefined, TNode, K>]: Node<TTree, Extract<TNode[K], UrlsTree.Node>>;
-    };
+    type Node<TTypeMap extends UrlsTree.TypeMap, F extends UrlsTree.IsFind<TTypeMap> = UrlsTree.IsFind<TTypeMap>> = F extends 'found' ? Node<Omit<TTypeMap, 'Find'>> : F extends 'not-found' ? {
+        [K in UrlsTree.Key<TTypeMap>]: Node<UrlsTree.TypeMap.Next<TTypeMap, K>>;
+    }[UrlsTree.Key<TTypeMap>] : {
+        [K in UrlsTree.Key<TTypeMap> as UrlsTree.ResolveKey<TTypeMap, K>]: Node<UrlsTree.TypeMap.Next<TTypeMap, K>>;
+    } extends infer Children ? (TTypeMap extends {
+        Node: UrlsTree.Node;
+    } ? Leaf<Children> : unknown) & Children : never;
+    namespace Node {
+        type Root<TTree extends UrlsTree, TFind extends string | UrlsTree.Node = undefined> = Node<UrlsTree.TypeMap.Init<TTree, TFind, {
+            Casing: 'p';
+        }>>;
+    }
     type Factory = <TTree extends UrlsTree>(urlsTree: TTree) => RouteCreator<TTree>;
 }
-export type RouteCreator<TTree extends UrlsTree> = (type: CRT, commonProps?: BRO) => RouteCreator.Node<TTree, TTree & object>;
+export type RouteCreator<TTree extends UrlsTree> = (type: CRT, commonProps?: BRO) => RouteCreator.Node.Root<TTree>;
 export {};

package/dist/types/urls-tree.d.ts

@@ -1,5 +1,6 @@
 import TS = AVStantso.TS;
 import { NamesTree } from '@avstantso/utils-names-tree';
+type _Casing = 'c' | 'p' | 's' | 'S' | 'k';
 /**
  * @summary Routes url tree
  */
@@ -8,21 +9,140 @@ export declare namespace UrlsTree {
      * @summary One route url tree node
      */
     type Node = NamesTree.Presets.Urls.Constraint;
+    namespace Node {
+        type _Params<TParts extends readonly string[], R extends TS.Key[] = []> = TParts extends readonly [infer C extends string, ...infer Rest extends readonly string[]] ? _Params<Rest, C extends `:${infer P extends string}` ? [...R, P] : R> : R;
+        /**
+         * @summary Get node params names array
+         */
+        export type Params<TNode extends Node> = _Params<TS.String.Split<TNode['_path'], '/'>>;
+        export {};
+    }
     /**
      * @summary Urls tree `rootAlias` type
      */
     type RootAlias<TTree extends UrlsTree> = TTree[Extract<typeof NamesTree.symbolRootAlias, keyof TTree>];
     /**
-     * @summary Tree node url key for components generation
+     * @summary Typemap for complex generic
      */
-    type Key<TTree extends UrlsTree, N extends object, K extends keyof N = keyof N> = K extends string ? K extends UrlsTree.RootAlias<TTree> ? K : K extends (N[K] extends Function ? TS.Func.RestrictionsForExt : never) | `${'_' | '$' | TS.Letter.Upper}${string}` ? never : N[K] extends UrlsTree.Node ? K : never : never;
+    type TypeMap = {
+        /**
+         * @summary Initial tree type
+         */
+        Tree: UrlsTree;
+        /**
+         * @summary Initial tree current node type
+         */
+        Node?: Node;
+        /**
+         * @summary Params keys array
+         */
+        Params?: TS.Keys;
+        /**
+         * @summary Params is required
+         */
+        ParamsIsRequired?: boolean;
+        /**
+         * @summary Find criteria `_url` or `Node`
+         */
+        Find?: string | Node;
+        /**
+         * @summary Param replace prefix
+         */
+        ParamReplacePrefix?: string;
+        /**
+         * @summary Param replace casing
+         */
+        Casing?: _Casing;
+    };
+    namespace TypeMap {
+        /**
+         * @summary Init typemap for complex generic
+         */
+        type Init<TTree extends UrlsTree, TFind extends string | UrlsTree.Node = undefined, TExtends extends object = {}> = {
+            Tree: TTree;
+        } & (TFind extends undefined ? unknown : {
+            Find: TFind;
+        }) & TExtends;
+        /**
+         * @summary Next node typemap for complex generic
+         */
+        type Next<TTypeMap extends TypeMap, TKey extends TypeMap.Key<TTypeMap>> = (TTypeMap extends {
+            Node: infer TParentNode extends Node;
+        } ? TParentNode[Extract<TKey, keyof TParentNode>] : TTypeMap['Tree'][Extract<TKey, keyof TTypeMap['Tree']>]) extends infer TNode extends Node ? TTypeMap extends {
+            Tree: infer TTree extends UrlsTree;
+        } ? {
+            Tree: TTree;
+            Node: TNode;
+        } & ((TNode extends {
+            _name: `:${infer TParam extends string}`;
+        } ? [TParam] : []) extends infer TParams extends TS.Keys ? TTypeMap extends {
+            Params: infer TParentParams extends TS.Keys;
+        } ? {
+            Params: [...TParentParams, ...TParams];
+        } : {
+            Params: TParams;
+        } : never) & (TTypeMap extends {
+            ParamsIsRequired: infer PIR extends boolean;
+        } ? {
+            ParamsIsRequired: PIR;
+        } : unknown) & (TTypeMap extends {
+            Find: infer TFind extends string | Node;
+        } ? {
+            Find: TFind;
+        } : unknown) & (TTypeMap extends {
+            ParamReplacePrefix: infer PRP extends string;
+        } ? {
+            ParamReplacePrefix: PRP;
+        } : unknown) & (TTypeMap extends {
+            Casing: infer C extends _Casing;
+        } ? {
+            Casing: C;
+        } : unknown) : never : never;
+        /**
+         * @summary Typemap curent node key union
+         */
+        type Key<TTypeMap extends TypeMap> = TTypeMap extends {
+            Node: infer TNode extends Node;
+        } ? keyof TNode : keyof TTypeMap['Tree'];
+        /**
+         * @summary Typemap based casing
+         */
+        type Casing<TTypeMap extends TypeMap, S extends string> = TTypeMap extends {
+            Casing: infer C extends _Casing;
+        } ? TS.String.Case<C, S> : S;
+    }
+    /**
+     * @summary Filtered tree node url key for components generation
+     */
+    type Key<TTypeMap extends TypeMap, K extends TypeMap.Key<TTypeMap> = TypeMap.Key<TTypeMap>> = K extends string ? K extends UrlsTree.RootAlias<TTypeMap['Tree']> ? K : K extends (TTypeMap['Node'][K] extends Function ? TS.Func.RestrictionsForExt : never) | `${'_' | '$' | TS.Letter.Upper}${string}` ? never : K : never;
     /**
      * @summary Component node key resolving
      */
-    type ResolveKey<TTree extends UrlsTree, P extends object, N extends object, K extends UrlsTree.Key<TTree, N>> = K extends `:${infer C extends string}` ? P extends undefined ? K : `$${TS.String.Case.Pascal<C>}` : TS.String.Case.Pascal<K>;
+    type ResolveKey<TTypeMap extends TypeMap, K extends Key<TTypeMap> = Key<TTypeMap>> = K extends `:${infer C extends string}` ? TTypeMap extends {
+        ParamReplacePrefix: infer PRP extends string;
+    } ? `${PRP}${TypeMap.Casing<TTypeMap, C>}` : K : TypeMap.Casing<TTypeMap, K>;
     /**
      * @summary Component node params resolving
      */
-    type ResolveParam<TTree extends UrlsTree, P extends object, N extends object, K extends UrlsTree.Key<TTree, N>, Required extends boolean = false> = K extends `:${infer C extends string}` ? Record<C, string> extends infer X ? P & (Required extends true ? X : Partial<X>) : never : P;
+    type ResolveParam<TTypeMap extends TypeMap> = ((TTypeMap extends {
+        Params: infer P extends TS.Keys;
+    } ? P : [])) extends infer P extends TS.Keys ? TTypeMap extends {
+        ParamsIsRequired: true;
+    } ? Record<P[number], string> : Partial<Record<P[number], string>> : never;
+    /**
+     * @summary Component node params resolving to:
+     * - `optional` — `[params?: P]` / `[]`
+     * - `required` — `[params: P]` / `[]`
+     * - `field` — `{ [K in Field]: P }` / `{}`
+     */
+    type ResolveParams<TTypeMap extends TypeMap, Kind extends 'optional' | 'required' | 'field', Field extends Kind extends 'field' ? string : never = Kind extends 'field' ? 'params' : never, P extends ResolveParam<TTypeMap> = ResolveParam<TTypeMap>> = [keyof P] extends [never] ? Kind extends 'optional' | 'required' ? [] : unknown : Kind extends 'optional' ? [params?: P] : Kind extends 'required' ? [params: P] : {
+        [K in Field]: P;
+    };
+    type IsFind<TTypeMap extends UrlsTree.TypeMap> = TTypeMap extends {
+        Find: infer F extends string | Node;
+    } ? TTypeMap extends {
+        Node: infer N extends Node;
+    } ? (F extends Node ? F['_url'] : F) extends N['_url'] ? 'found' : 'not-found' : 'not-found' : 'node';
 }
 export type UrlsTree<T extends NamesTree.Source.Root = any, O extends NamesTree.Options = any> = NamesTree.Presets.Urls.Tree<T, O>;
+export {};

package/package.json

@@ -2,7 +2,7 @@
   "name": "@avstantso/react-router-utils",
   "license": "MIT",
   "author": "avstantso",
-  "version": "0.1.2",
+  "version": "0.2.1",
   "description": "AVStantso react-router-dom enhancement package",
   "keywords": [
     "react-router-dom",
@@ -24,8 +24,8 @@
     "test": "NODE_ENV=test jest --coverage"
   },
   "dependencies": {
-    "@avstantso/utils-misc": "^1.2.4",
-    "@avstantso/utils-names-tree": "^1.3.2",
+    "@avstantso/utils-misc": "^1.2.5",
+    "@avstantso/utils-names-tree": "^1.3.3",
     "react": "^18.3.1",
     "react-dom": "^18.3.1",
     "react-router-dom": "^7.12.0"