@avstantso/utils-names-tree 1.1.0 → 1.3.0

package/dist/_global/_register.d.ts

@@ -0,0 +1,467 @@
+declare namespace AVStantso {
+    const BaseKinds: {
+        name: Kinds.Method;
+        backslash: Kinds.Method;
+        slash: Kinds.Method;
+        dot: Kinds.Method;
+        amp: Kinds.Method;
+        hash: Kinds.Method;
+        colon: Kinds.Method;
+        arrow: Kinds.Method;
+        dash: Kinds.Method;
+        underscore: Kinds.Method;
+        doubleColon: Kinds.Method;
+        comma: Kinds.Method;
+        semicolon: Kinds.Method;
+        space: Kinds.Method;
+        pipe: Kinds.Method;
+        path: Kinds.Method;
+        url: Kinds.Method;
+        query: Kinds.Method;
+        i18n: Kinds.Method;
+        domain: Kinds.Method;
+        longArg: Kinds.Method;
+        shortArg: Kinds.Method;
+        envVar: Kinds.Method;
+        cssClass: Kinds.Method;
+        cssId: Kinds.Method;
+        anchor: Kinds.Method;
+        scoped: Kinds.Method;
+        param: Kinds.Method;
+        arg: Kinds.Method;
+        params: Kinds.Method;
+        args: Kinds.Method;
+        snake: Kinds.Method;
+        namespace: Kinds.Method;
+        csv: Kinds.Method;
+        title: Kinds.Method;
+    };
+    const BaseKindsMeta: {
+        readonly name: never;
+        readonly backslash: "\\";
+        readonly slash: "/";
+        readonly dot: ".";
+        readonly amp: "&";
+        readonly hash: "#";
+        readonly colon: ":";
+        readonly arrow: "->";
+        readonly dash: "-";
+        readonly underscore: "_";
+        readonly doubleColon: "::";
+        readonly comma: ",";
+        readonly semicolon: ";";
+        readonly space: " ";
+        readonly pipe: "|";
+        readonly path: "/";
+        readonly url: {
+            readonly prefix: "/";
+            readonly separator: "/";
+        };
+        readonly query: {
+            readonly prefix: "?";
+            readonly separator: "&";
+        };
+        readonly i18n: ".";
+        readonly domain: ".";
+        readonly longArg: {
+            readonly prefix: "--";
+            readonly separator: "-";
+        };
+        readonly shortArg: {
+            readonly beforeEach: "-";
+        };
+        readonly envVar: {
+            readonly separator: "_";
+            readonly up: true;
+        };
+        readonly cssClass: {
+            readonly prefix: ".";
+            readonly separator: "-";
+        };
+        readonly cssId: {
+            readonly prefix: "#";
+            readonly separator: "-";
+        };
+        readonly anchor: {
+            readonly beforeEach: "#";
+        };
+        readonly scoped: {
+            readonly prefix: "@";
+            readonly separator: "/";
+        };
+        readonly param: {
+            readonly beforeEach: ":";
+        };
+        readonly arg: {
+            readonly beforeEach: "{";
+            readonly afterEach: "}";
+        };
+        readonly params: {
+            readonly beforeEach: ":";
+            readonly separator: "/";
+        };
+        readonly args: {
+            readonly beforeEach: "{";
+            readonly afterEach: "}";
+            readonly separator: "/";
+        };
+        readonly snake: "_";
+        readonly namespace: "::";
+        readonly csv: ",";
+        readonly title: " ";
+    };
+    export namespace NamesTree {
+        export namespace Kinds {
+            type Method = (path: string[], options?: Options) => string;
+            /**
+             * @summary List of all allow tree kinds
+             */
+            type All = TS.Union.ToTuple<keyof Kinds>;
+        }
+        type BaseKinds = typeof BaseKinds;
+        export interface Kinds extends BaseKinds {
+        }
+        /**
+         * @summary Allow tree kind
+         */
+        export type Kind = Kinds.All[number];
+        export type KindMeta = {
+            prefix?: string;
+            separator?: string;
+            beforeEach?: string;
+            afterEach?: string;
+            up?: boolean;
+        };
+        type BaseKindsMeta = typeof BaseKindsMeta;
+        export interface KindsMeta extends BaseKindsMeta {
+        }
+        namespace _ResolveKind {
+            type RR<M extends KindMeta, MK extends keyof KindMeta> = M[MK] extends string ? M[MK] : '';
+            export type Step<M extends KindMeta, K extends TS.Key, F extends boolean> = TS.Array.Join<[
+                RR<M, F extends true ? 'prefix' : 'separator'>,
+                RR<M, 'beforeEach'>,
+                TS.String<K>,
+                RR<M, 'afterEach'>
+            ]> extends infer S extends string ? M['up'] extends true ? Uppercase<S> : S : never;
+            export {};
+        }
+        type _ResolveKind<M extends KindMeta, P extends TS.Keys, F extends boolean, R extends string = ''> = P extends readonly [infer C extends TS.Key, ...infer Rest extends TS.Keys] ? _ResolveKind<M, Rest, false, `${R}${_ResolveKind.Step<M, C, F>}`> : R;
+        /**
+         * Resolve kind step
+         * @template KD Kind to resolve
+         * @template P Path stack. E.g. for `a/b/c` must be `['c', 'b', 'a']`
+         * @example
+         * // Stack expected
+         * type P0 = ['node0'];
+         * type P1 = ['node1', 'node0'];
+         * type P2 = ['node2', 'node1', 'node0'];
+         * 
+         * type name0 = CheckType<ResolveKind<'name', P0>, 'node0'>;
+         * type name1 = CheckType<ResolveKind<'name', P1>, 'node1'>;
+         * type name2 = CheckType<ResolveKind<'name', P2>, 'node2'>;
+         * 
+         * type path0 = CheckType<ResolveKind<'path', P0>, 'node0'>;
+         * type path1 = CheckType<ResolveKind<'path', P1>, 'node0/node1'>;
+         * type path2 = CheckType<ResolveKind<'path', P2>, 'node0/node1/node2'>;
+         * 
+         * type url0 = CheckType<ResolveKind<'url', P0>, '/node0'>;
+         * type url1 = CheckType<ResolveKind<'url', P1>, '/node0/node1'>;
+         * type url2 = CheckType<ResolveKind<'url', P2>, '/node0/node1/node2'>;
+         * 
+         * type dot0 = CheckType<ResolveKind<'dot', P0>, 'node0'>;
+         * type dot1 = CheckType<ResolveKind<'dot', P1>, 'node0.node1'>;
+         * type dot2 = CheckType<ResolveKind<'dot', P2>, 'node0.node1.node2'>;
+         * 
+         * type param0 = CheckType<ResolveKind<'params', P0>, ':node0'>;
+         * 
+         * type params0 = CheckType<ResolveKind<'params', P0>, ':node0'>;
+         * type params1 = CheckType<ResolveKind<'params', P1>, ':node0/:node1'>;
+         * type params2 = CheckType<ResolveKind<'params', P2>, ':node0/:node1/:node2'>;
+         * 
+         * type arg0 = CheckType<ResolveKind<'arg', P0>, '{node0}'>;
+         * 
+         * type args0 = CheckType<ResolveKind<'args', P0>, '{node0}'>;
+         * type args1 = CheckType<ResolveKind<'args', P1>, '{node0}/{node1}'>;
+         * type args2 = CheckType<ResolveKind<'args', P2>, '{node0}/{node1}/{node2}'>;
+         * 
+         * type envVar0 = CheckType<ResolveKind<'envVar', P0>, 'NODE0'>;
+         * type envVar1 = CheckType<ResolveKind<'envVar', P1>, 'NODE0_NODE1'>;
+         * type envVar2 = CheckType<ResolveKind<'envVar', P2>, 'NODE0_NODE1_NODE2'>;
+         * 
+         * type query0 = CheckType<ResolveKind<'query', ['a']>, '?a'>;
+         * type query1 = CheckType<ResolveKind<'query', ['b', 'a']>, '?a&b'>;
+         * type query2 = CheckType<ResolveKind<'query', ['c', 'b', 'a']>, '?a&b&c'>;
+         * 
+         * type longArg0 = CheckType<ResolveKind<'longArg', ['dry']>, '--dry'>;
+         * type longArg1 = CheckType<ResolveKind<'longArg', ['run', 'dry']>, '--dry-run'>;
+         * 
+         * type shortArg0 = CheckType<ResolveKind<'shortArg', ['v']>, '-v'>;
+         * type shortArg1 = CheckType<ResolveKind<'shortArg', ['f', 'v']>, '-v-f'>;
+         * 
+         * type cssClass0 = CheckType<ResolveKind<'cssClass', ['btn']>, '.btn'>;
+         * type cssClass1 = CheckType<ResolveKind<'cssClass', ['primary', 'btn']>, '.btn-primary'>;
+         * 
+         * type cssId0 = CheckType<ResolveKind<'cssId', ['main']>, '#main'>;
+         * type cssId1 = CheckType<ResolveKind<'cssId', ['content', 'main']>, '#main-content'>;
+         * 
+         * type anchor0 = CheckType<ResolveKind<'anchor', ['section']>, '#section'>;
+         * type anchor1 = CheckType<ResolveKind<'anchor', ['intro', 'section']>, '#section#intro'>;
+         * 
+         * type scoped0 = CheckType<ResolveKind<'scoped', ['org']>, '@org'>;
+         * type scoped1 = CheckType<ResolveKind<'scoped', ['pkg', 'org']>, '@org/pkg'>;
+         * 
+         * type param0_ = CheckType<ResolveKind<'param', ['id']>, ':id'>;
+         * type param1_ = CheckType<ResolveKind<'param', ['sub', 'id']>, ':id:sub'>;
+         * 
+         * type prefixed = CheckType<ResolveKind<'dash', ['id', 'user'], { prefix: '$' }>, '$user-id'>;
+         */
+        export type ResolveKind<KD extends Kind, P extends TS.Keys, O extends Options = Options> = ([KindsMeta[KD]] extends [never] ? TS.String<P[0]> : (KindsMeta[KD] extends string ? {
+            separator: KindsMeta[KD];
+        } : KindsMeta[KD]) extends infer M extends KindMeta ? _ResolveKind<M, TS.Array.Reverse<P>, true> : string) extends infer R extends string ? O extends {
+            prefix: string;
+        } ? `${O['prefix']}${R}` : R : never;
+        /**
+         * @summary Tree node data source
+         */
+        export type Source = TS.Type.Builtin;
+        export namespace Source {
+            /**
+             * @summary Tree root node data source
+             */
+            type Root = object | Function;
+        }
+        export type _NodeKinds<O extends Options, KDs extends readonly Kind[], P extends TS.Keys, R = unknown> = KDs extends readonly [
+            infer C extends Kind,
+            ...infer Rest extends readonly Kind[]
+        ] ? _NodeKinds<O, Rest, P, R & {
+            [K in `_${C}`]: ResolveKind<C, P>;
+        }> : {
+            [K in keyof R]: R[K];
+        };
+        /**
+         * @summary Tree node for source `T` with allow kinds `KDs`
+         *
+         * If `S = true`, allows tails nodes as string
+         */
+        export type Node<T extends Source = Source, O extends Options = Options, KDs extends readonly Kind[] = Kinds.All, S extends boolean = false, P extends TS.Keys = []> = (S extends true ? unknown : _NodeKinds<O, KDs, P>) & Node.Data<T, O, KDs, S, P>;
+        export namespace Node {
+            type _Constraint<KDs extends readonly Kind[], R = unknown> = KDs extends readonly [
+                infer C extends Kind,
+                ...infer Rest extends readonly Kind[]
+            ] ? _Constraint<Rest, R & {
+                [K in `_${C}`]: string;
+            }> : R;
+            /**
+             * @summary Node constraint
+             */
+            export type Constraint<KDs extends readonly Kind[] = Kinds.All> = _Constraint<KDs> extends infer R ? {
+                [K in keyof R]: R[K];
+            } : never;
+            /**
+             * @summary Node data part
+             */
+            export type Data<T extends Source = Source, O extends Options = Options, KDs extends readonly Kind[] = Kinds.All, S extends boolean = false, P extends TS.Keys = []> = T extends Source.Root ? (T extends Function ? T : unknown) & {
+                [K in keyof T]: Node<Extract<T[K], Source>, O, KDs, S, [
+                    TS.String<K, '?'>,
+                    ...P
+                ]>;
+            } : S extends true ? NamesTree.ResolveKind<KDs[0], P, O> : unknown;
+            export {};
+        }
+        /**
+         * @summary Tree options
+         */
+        export interface Options {
+            /**
+             * @summary Additional prefix for all `Kinds` methods
+             */
+            prefix?: string;
+            /**
+             * @summary Alias for root of tree as additional property.\
+             * E.g. `Home` for urls
+             */
+            rootAlias?: string;
+            /**
+             * @summary If picked and represents in internal array — will be used on `ToString` for nodes.\
+             * Else will be used first kind from tree.
+             */
+            defaultKind?: Kind;
+        }
+        /**
+         * @summary `NamesTree` kinds presets
+         */
+        export namespace Presets {
+            /**
+             * @summary `Names` preset
+             */
+            namespace Names {
+                /**
+                 * @summary `Names` preset kinds
+                 */
+                type Kinds = ['name'];
+                /**
+                 * @summary `Names` preset node constraint
+                 */
+                type Constraint = NamesTree.Node.Constraint<Kinds>;
+                /**
+                 * @summary `Names` preset tree node for source `T`
+                 *
+                 * If `S = true`, allows tails nodes as string
+                 */
+                type Node<T extends Source = Source, O extends Options = Options, S extends boolean = false, P extends TS.Keys = []> = NamesTree.Node<T, O, Kinds, S, P>;
+                /**
+                 * @summary `Names` preset `NamesTree` for data `T`
+                 *
+                 * If `S = true`, allows tails nodes as string
+                 */
+                type Tree<T extends Source.Root, O extends Options, S extends boolean = false> = NamesTree<T, O, Kinds, S>;
+            }
+            /**
+             * @summary `I18ns` preset
+             */
+            namespace I18ns {
+                /**
+                 * @summary `I18ns` preset kinds
+                 */
+                type Kinds = ['i18n', 'name'];
+                /**
+                 * @summary `I18ns` preset node constraint
+                 */
+                type Constraint = NamesTree.Node.Constraint<Kinds>;
+                /**
+                 * @summary `I18ns` preset tree node for source `T`
+                 *
+                 * If `S = true`, allows tails nodes as string
+                 */
+                type Node<T extends Source = Source, O extends Options = Options, S extends boolean = false, P extends TS.Keys = []> = NamesTree.Node<T, O, Kinds, S, P>;
+                /**
+                 * @summary `I18ns` preset `NamesTree` for data `T`
+                 *
+                 * If `S = true`, allows tails nodes as string
+                 */
+                type Tree<T extends Source.Root, O extends Options, S extends boolean = false> = NamesTree<T, O, Kinds, S>;
+            }
+            /**
+             * @summary `Urls` preset
+             */
+            namespace Urls {
+                /**
+                 * @summary `Urls` preset kinds
+                 */
+                type Kinds = ['name', 'path', 'url'];
+                /**
+                 * @summary `Urls` preset node constraint
+                 */
+                type Constraint = NamesTree.Node.Constraint<Kinds>;
+                /**
+                 * @summary `Urls` preset tree node for source `T`
+                 *
+                 * If `S = true`, allows tails nodes as string
+                 */
+                type Node<T extends Source = Source, O extends Options = Options, S extends boolean = false, P extends TS.Keys = []> = NamesTree.Node<T, O, Kinds, S, P>;
+                /**
+                 * @summary `Urls` preset `NamesTree` for data `T`
+                 *
+                 * If `S = true`, allows tails nodes as string
+                 */
+                type Tree<T extends NamesTree.Source.Root, O extends NamesTree.Options, S extends boolean = false> = NamesTree<T, O, Kinds, S>;
+            }
+        }
+        export {};
+    }
+    namespace _NamesTree {
+        type _Splitted<T extends NamesTree.Source.Root, O extends NamesTree.Options, KDs extends readonly NamesTree.Kind[], R extends TS.Arr = []> = KDs extends readonly [
+            infer C extends NamesTree.Kind,
+            ...infer Rest extends readonly NamesTree.Kind[]
+        ] ? _Splitted<T, O, Rest, [
+            ...R,
+            NamesTree<T, O, [C], true>
+        ]> : R;
+        export type Splitted<T extends NamesTree.Source.Root, O extends NamesTree.Options, KDs extends readonly NamesTree.Kind[]> = _Splitted<T, O, KDs>;
+        export type ExtractByKinds<T extends NamesTree.Source.Root, O extends NamesTree.Options, KDs extends readonly NamesTree.Kind[], R = unknown> = KDs extends readonly [
+            infer C extends NamesTree.Kind,
+            ...infer Rest extends readonly NamesTree.Kind[]
+        ] ? ExtractByKinds<T, O, Rest, R & {
+            [K in Capitalize<C>]: NamesTree<T, O, [C], true>;
+        }> : R;
+        export {};
+    }
+    /**
+     * @summary Names tree for data `T` with allow kinds `KDs`
+     *
+     * If `S = true`, allows tails nodes as string
+     */
+    export type NamesTree<T extends NamesTree.Source.Root, O extends NamesTree.Options, KDs extends readonly NamesTree.Kind[], S extends boolean = false> = NamesTree.Node.Data<T, O, KDs, S> & (S extends true ? O extends {
+        rootAlias: infer R extends TS.Key;
+    } ? {
+        [K in R]: NamesTree.ResolveKind<KDs[0], [''], O>;
+    } : unknown : {
+        /**
+         * @summary Get array of splitted trees each with unique kind
+         */
+        $splitted: _NamesTree.Splitted<T, O, KDs>;
+        /**
+         * @summary Modify existing tree by additional data
+         */
+        $merge<M extends NamesTree.Source.Root>(data: M): NamesTree<T & M, O, KDs, S>;
+    } & _NamesTree.ExtractByKinds<T, O, KDs> & (O extends {
+        rootAlias: infer R extends TS.Key;
+    } ? {
+        [K in R]: NamesTree._NodeKinds<O, KDs, ['']>;
+    } : unknown));
+    export namespace Code {
+        /**
+         * @summary `AVStantso.NamesTree` utility
+         */
+        interface NamesTree {
+            <T extends AVStantso.NamesTree.Source.Root, O extends AVStantso.NamesTree.Options, K0 extends AVStantso.NamesTree.Kind, K1 extends Exclude<AVStantso.NamesTree.Kind, K0> = undefined, K2 extends Exclude<AVStantso.NamesTree.Kind, K0 | K1> = undefined, K3 extends Exclude<AVStantso.NamesTree.Kind, K0 | K1 | K2> = undefined, K4 extends Exclude<AVStantso.NamesTree.Kind, K0 | K1 | K2 | K3> = undefined, K5 extends Exclude<AVStantso.NamesTree.Kind, K0 | K1 | K2 | K3 | K4> = undefined, K6 extends Exclude<AVStantso.NamesTree.Kind, K0 | K1 | K2 | K3 | K4 | K5> = undefined, K7 extends Exclude<AVStantso.NamesTree.Kind, K0 | K1 | K2 | K3 | K4 | K5 | K6> = undefined, K8 extends Exclude<AVStantso.NamesTree.Kind, K0 | K1 | K2 | K3 | K4 | K5 | K6 | K7> = undefined, K9 extends Exclude<AVStantso.NamesTree.Kind, K0 | K1 | K2 | K3 | K4 | K5 | K6 | K7 | K8> = undefined>(data: T, options: O, kind0: K0, kind1?: K1, kind2?: K2, kind3?: K3, kind4?: K4, kind5?: K5, kind6?: K6, kind7?: K7, kind8?: K8, kind9?: K9): AVStantso.NamesTree<T, O, AVStantso.TS.Array.Filter<AVStantso.TS.Array.Filter.Unique<[
+                K0,
+                K1,
+                K2,
+                K3,
+                K4,
+                K5,
+                K6,
+                K7,
+                K8,
+                K9
+            ]>>>;
+            <T extends AVStantso.NamesTree.Source.Root, K0 extends AVStantso.NamesTree.Kind, K1 extends Exclude<AVStantso.NamesTree.Kind, K0> = undefined, K2 extends Exclude<AVStantso.NamesTree.Kind, K0 | K1> = undefined, K3 extends Exclude<AVStantso.NamesTree.Kind, K0 | K1 | K2> = undefined, K4 extends Exclude<AVStantso.NamesTree.Kind, K0 | K1 | K2 | K3> = undefined, K5 extends Exclude<AVStantso.NamesTree.Kind, K0 | K1 | K2 | K3 | K4> = undefined, K6 extends Exclude<AVStantso.NamesTree.Kind, K0 | K1 | K2 | K3 | K4 | K5> = undefined, K7 extends Exclude<AVStantso.NamesTree.Kind, K0 | K1 | K2 | K3 | K4 | K5 | K6> = undefined, K8 extends Exclude<AVStantso.NamesTree.Kind, K0 | K1 | K2 | K3 | K4 | K5 | K6 | K7> = undefined, K9 extends Exclude<AVStantso.NamesTree.Kind, K0 | K1 | K2 | K3 | K4 | K5 | K6 | K7 | K8> = undefined>(data: T, kind0: K0, kind1?: K1, kind2?: K2, kind3?: K3, kind4?: K4, kind5?: K5, kind6?: K6, kind7?: K7, kind8?: K8, kind9?: K9): AVStantso.NamesTree<T, undefined, AVStantso.TS.Array.Filter<AVStantso.TS.Array.Filter.Unique<[
+                K0,
+                K1,
+                K2,
+                K3,
+                K4,
+                K5,
+                K6,
+                K7,
+                K8,
+                K9
+            ]>>>;
+            /**
+             * @summary Register external `NamesTree` kinds
+             */
+            _RegKinds(kinds: NodeJS.Dict<AVStantso.NamesTree.Kinds.Method>): void;
+            /**
+             * @summary Make `Name` `NamesTree`
+             */
+            Names<T extends AVStantso.NamesTree.Source.Root, O extends AVStantso.NamesTree.Options = undefined>(data: T, options?: O): AVStantso.NamesTree.Presets.Names.Tree<T, O>;
+            /**
+             * @summary Make `i18n` `NamesTree`
+             */
+            I18ns<T extends AVStantso.NamesTree.Source.Root, O extends AVStantso.NamesTree.Options = undefined>(data: T, options?: O): AVStantso.NamesTree.Presets.I18ns.Tree<T, O>;
+            /**
+             * @summary Make `urls` `NamesTree`
+             */
+            Urls<T extends AVStantso.NamesTree.Source.Root, O extends AVStantso.NamesTree.Options = undefined>(data: T, options?: O): AVStantso.NamesTree.Presets.Urls.Tree<T, O>;
+        }
+    }
+    export interface Code {
+        /**
+         * @summary `AVStantso.NamesTree` utility
+         */
+        NamesTree: Code.NamesTree;
+    }
+    export const NamesTree: Code.NamesTree;
+    export {};
+}

package/dist/_global/index.d.ts

@@ -0,0 +1 @@
+import './_register';

package/dist/export.d.ts

@@ -0,0 +1,2 @@
+import NamesTree = AVStantso.NamesTree;
+export { NamesTree };

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import '@avstantso/errors';
+import '@avstantso/js';
+import './_global';
+export * from './export';