@avstantso/ts 1.1.0 → 1.2.1

package/dist/_global/string.d.ts

@@ -0,0 +1,306 @@
+declare namespace AVStantso.TS.String {
+    /**
+     * @summary Type possible to convert ``` `${x}` ``` to string literal
+     * @example
+     * type p = CheckType<`${Possible}`, string>;
+     * 
+     * type S<T> = T extends Possible ? `${T}` : never;
+     * type sn = CheckType<S<number>, string>;
+     * type ss = CheckType<S<symbol>, never>;
+     */
+    export type Possible = string | number | bigint | boolean;
+    /**
+    * @summary Some shortcuts for regular expression patterns
+    */
+    export interface Pattern {
+        '\\s': ' \r\n\t\f\v';
+    }
+    /**
+     * @summary Calc `string` literal length. ⚠ Unsafe, internal
+     * @template S Tested `string` literal
+     * @returns `string` literal length
+     * @example
+     * type n = CheckType<_Length<never>, never>;
+     * type u = CheckType<_Length<undefined>, 0>; // ⚠
+     * 
+     * type l0 = CheckType<_Length<''>, 0>;
+     * type l1 = CheckType<_Length<'A'>, 1>;
+     * type l2 = CheckType<_Length<'AB'>, 2>;
+     */
+    export type _Length<S extends string, R extends number = 0> = S extends `${string}${infer Rest}` ? _Length<Rest, Increment<R>> : R;
+    /**
+     * @summary Calc `string` literal length
+     * @template S Tested `string` literal
+     * @returns `string` literal length
+     * @example
+     * type n = CheckType<Length<never>, never>;
+     * type u = CheckType<Length<undefined>, undefined>;
+     * 
+     * type l0 = CheckType<Length<''>, 0>;
+     * type l1 = CheckType<Length<'A'>, 1>;
+     * type l2 = CheckType<Length<'AB'>, 2>;
+     */
+    export type Length<S extends string> = S extends undefined ? undefined : _Length<S>;
+    type _IsLengthBetween<S extends string, Min extends number, Max extends number, L extends number = _Length<S>> = LT<L, Min> extends true ? false : GT<L, Max> extends true ? false : true;
+    /**
+     * @summary Is `string` literal length in `[Min, Max]`.
+     *
+     * Shortcut for `GTE<Length<S>, Min> & LTE<Length<S>, Max>`
+     * @template S Tested `string` literal
+     * @template Min Minimal length
+     * @template Max Maximal length
+     * @template IfTrue Result, if `S` length in `[Min, Max]`
+     * @template IfFalse Result, if ``S` length NOT in `[Min, Max]`
+     * @returns `IfFalse` or `IfTrue` param
+     * @example
+     * type n0 = CheckType<IsLengthBetween<never, number, number>, never>;
+     * type n1 = CheckType<IsLengthBetween<string, never, number>, never>;
+     * type n2 = CheckType<IsLengthBetween<string, number, never>, never>;
+     * type n3 = CheckType<IsLengthBetween<string, 2, 1>, never>;
+     * 
+     * type u0 = CheckType<IsLengthBetween<string, undefined, number>, undefined>;
+     * type u1 = CheckType<IsLengthBetween<string, undefined, number>, undefined>;
+     * type u2 = CheckType<IsLengthBetween<string, number, undefined>, undefined>;
+     * 
+     * type t0 = CheckType<IsLengthBetween<'', 0>, true>;
+     * type f0 = CheckType<IsLengthBetween<'', 1>, false>;
+     * 
+     * type t1 = CheckType<IsLengthBetween<'A', 1, 2>, true>;
+     * type f1 = CheckType<IsLengthBetween<'A', 2>, false>;
+     * 
+     * type t2_02 = CheckType<IsLengthBetween<'AB', 0, 2>, true>;
+     * type t2_12 = CheckType<IsLengthBetween<'AB', 1, 2>, true>;
+     * type t2_22 = CheckType<IsLengthBetween<'AB', 2, 2>, true>;
+     * type t2_23 = CheckType<IsLengthBetween<'AB', 2, 3>, true>;
+     * type f2_1 = CheckType<IsLengthBetween<'AB', 1>, false>;
+     */
+    export type IsLengthBetween<S extends string, Min extends number, Max extends number = Min, IfTrue = true, IfFalse = false> = S extends undefined ? undefined : Min extends undefined ? undefined : Max extends undefined ? undefined : GT<Min, Max> extends true ? never : _IsLengthBetween<S, Min, Max> extends true ? IfTrue : IfFalse;
+    /**
+     * @summary Split `string` literal to chars array. ⚠ Unsafe, internal
+     * @example
+     * type n = CheckType<_SplitToChars<never>, never>;
+     * type u = CheckType<_SplitToChars<undefined>, []>; // ⚠
+     * 
+     * type l0 = CheckType<_SplitToChars<''>, []>;
+     * type l1 = CheckType<_SplitToChars<'A'>, ['A']>;
+     * type l2 = CheckType<_SplitToChars<'AB'>, ['A', 'B']>;
+     */
+    export type _SplitToChars<S extends string, R extends string[] = []> = S extends `${infer C}${infer E}` ? _SplitToChars<E, [...R, C]> : R;
+    /**
+     * @summary Split `string` literal to chars array
+     * @example
+     * type n = CheckType<SplitToChars<never>, never>;
+     * type u = CheckType<SplitToChars<undefined>, undefined>;
+     * 
+     * type l0 = CheckType<SplitToChars<''>, []>;
+     * type l1 = CheckType<SplitToChars<'A'>, ['A']>;
+     * type l2 = CheckType<SplitToChars<'AB'>, ['A', 'B']>;
+     */
+    export type SplitToChars<S extends string> = S extends undefined ? S : _SplitToChars<S>;
+    type _Repeat<S extends Possible, N extends number, R extends string = ''> = N extends 0 ? R : _Repeat<S, Decrement<N>, `${R}${S}`>;
+    /**
+     * @summary Repeat string possible `S` by `N` times
+     * @example
+     * type n0 = CheckType<Repeat<never, any>, never>;
+     * type n1 = CheckType<Repeat<any, never>, never>;
+     * type u0 = CheckType<Repeat<undefined, any>, never>;
+     * type u1 = CheckType<Repeat<any, undefined>, never>;
+     * 
+     * type l0 = CheckType<Repeat<'', any>, ''>;
+     * type l1 = CheckType<Repeat<'AB', 0>, ''>;
+     * type l2 = CheckType<Repeat<'A1', 3>, 'A1A1A1'>;
+     */
+    export type Repeat<S extends Possible, N extends number> = S extends undefined ? never : N extends undefined ? never : LT<N, 0> extends true ? never : S extends '' ? S : _Repeat<S, N>;
+    type _Includes<S extends string, P extends Possible, IfTrue, IfFalse> = S extends `${string}${P}${string}` ? IfTrue : IfFalse;
+    /**
+     * @summary String `S` includes possible `P`
+     * @template S String for test
+     * @template P String possible for match
+     * @template IfTrue Result, if `S` length in `[Min, Max]`
+     * @template IfFalse Result, if ``S` length NOT in `[Min, Max]`
+     * @returns `IfFalse` or `IfTrue` param
+     * @example
+     * type n0 = CheckType<Includes<never, any>, never>;
+     * type n1 = CheckType<Includes<any, never>, never>;
+     * type u0 = CheckType<Includes<undefined, any>, never>;
+     * type u1 = CheckType<Includes<any, undefined>, never>;
+     * 
+     * type t0 = CheckType<Includes<'', ''>, true>;
+     * type t1 = CheckType<Includes<'AB', ''>, true>;
+     * type t2 = CheckType<Includes<'AB', 'A'>, true>;
+     * type t3 = CheckType<Includes<'AB', 'B'>, true>;
+     * type t4 = CheckType<Includes<'AB', 'AB'>, true>;
+     * 
+     * type num = CheckType<Includes<'A8B', 8>, true>;
+     * type bool = CheckType<Includes<'AfalseB', false>, true>;
+     * 
+     * type f0 = CheckType<Includes<'AB', 'C'>, false>;
+     */
+    export type Includes<S extends string, P extends Possible, IfTrue = true, IfFalse = false> = S extends undefined ? never : P extends undefined ? never : _Includes<S, P, IfTrue, IfFalse>;
+    type _IndexOf<S extends string, P extends Possible> = S extends `${infer F}${P}${string}` ? _Length<F> : -1;
+    namespace _IndexOfMultiple {
+        type GetAllStep<S extends string, P extends readonly Possible[], R extends readonly [number, Possible][], F extends Possible, I extends number = _IndexOf<S, F>> = I extends -1 ? GetAll<S, P, R> : GetAll<S, P, [...R, [I, F]]>;
+        type GetAll<S extends string, P extends readonly Possible[], R extends readonly [number, Possible][] = []> = P extends readonly [infer F extends Possible, ...infer Rest extends Possible[]] ? GetAllStep<S, Rest, R, F> : R;
+        export type Calculate<S extends string, P extends readonly Possible[], A extends readonly [number, Possible][] = Array.Sort<GetAll<S, P>>> = A;
+        export {};
+    }
+    /**
+     * @summary Index of possible `P` in string `S`. `-1` if not includes.\
+     * Returns sorted array of pairs for union `P`
+     * @template S String for test
+     * @template P String possible for match
+     * @example
+     * type n0 = CheckType<IndexOf<never, any>, never>;
+     * type n1 = CheckType<IndexOf<any, never>, never>;
+     * type u0 = CheckType<IndexOf<undefined, any>, never>;
+     * type u1 = CheckType<IndexOf<any, undefined>, never>;
+     * 
+     * type t0 = CheckType<IndexOf<'', ''>, never>;
+     * type t1 = CheckType<IndexOf<'AB', ''>, never>;
+     * type t2 = CheckType<IndexOf<'AB', 'A'>, 0>;
+     * type t3 = CheckType<IndexOf<'AB', 'B'>, 1>;
+     * type t4 = CheckType<IndexOf<'AB', 'AB'>, 0>;
+     * 
+     * type num = CheckType<IndexOf<'A8B', 8>, 1>;
+     * type bool = CheckType<IndexOf<'AfalseB', false>, 1>;
+     * 
+     * type f0 = CheckType<IndexOf<'AB', 'C'>, -1>;
+     * 
+     * type m = CheckType<IndexOf<'AfalseB', 'B' | false | 'l'>, [[1, false], [3, 'l'], [6, 'B']]>;
+     */
+    export type IndexOf<S extends string, P extends Possible> = IsUnion<P> extends false ? S extends undefined ? never : P extends undefined | '' ? never : _IndexOf<S, P> : _IndexOfMultiple.Calculate<S, Extract<Union.ToTuple<P>, readonly Possible[]>>;
+    type _ReplaceOne<S extends string, M extends Possible, T extends Possible, N extends number, R extends string = ''> = N extends 0 ? `${R}${S}` : S extends `${infer F}${M}${infer E}` ? _ReplaceOne<E, M, T, Decrement<N>, `${R}${F}${T}`> : `${R}${S}`;
+    type _ReplaceComplex<S extends string, M extends Possible, T extends Possible, N extends number, R extends string = ''> = N extends 0 ? `${R}${S}` : IndexOf<S, M> extends readonly [
+        [
+            number,
+            infer M0 extends Possible
+        ],
+        ...unknown[]
+    ] ? S extends `${infer F}${M0}${infer E}` ? _ReplaceComplex<E, M, T, Decrement<N>, `${R}${F}${T}`> : `${R}${S}` : `${R}${S}`;
+    /**
+     * @summary Replace in string `S` all substrings matched to `M` to `T` string `N` times or less
+     * @template S String for change
+     * @template M String possible for match.
+     * @template T String possible for substitute
+     * @example
+     * type n0 = CheckType<Replace<never, any>, never>;
+     * type n1 = CheckType<Replace<any, never>, never>;
+     * type u0 = CheckType<Replace<undefined, any>, never>;
+     * type u1 = CheckType<Replace<any, undefined>, never>;
+     * 
+     * type r1 = CheckType<Replace<Replace<'a-b_c_d', '_'>, '-'>, 'abcd'>;
+     * type r2 = CheckType<Replace<'123456_246', '2' | '4' | '6', '#', 3>, '1#3#5#_246'>;
+     * type r3 = CheckType<Replace<'abcde', 'a' | 'b' | 'c' | 'd' | 'e', 'ae '>, 'ae ae ae ae ae '>;
+     */
+    export type Replace<S extends string, M extends Possible, T extends Possible = '', N extends number = 4000> = IsUnion<M> extends false ? S extends undefined ? never : M extends undefined ? never : LTE<N, 0> extends true ? S : _ReplaceOne<S, M, T, N> : _ReplaceComplex<S, M, T, N>;
+    type SpaceCharsUnion = SplitToChars<Pattern['\\s']>[number];
+    type _Trim<S extends string, Start extends boolean, End extends boolean, SU extends string = Start extends true ? SpaceCharsUnion : '', EU extends string = End extends true ? SpaceCharsUnion : ''> = S extends `${SU}${infer Rest}${EU}` ? S extends Rest ? S : _Trim<Rest, Start, End> : S;
+    /**
+     * @summary Replace spaces chars in string `S` start and end
+     * @template S String for change
+     * @example
+     * type n0 = CheckType<Trim<never>, never>;
+     * type u0 = CheckType<Trim<undefined>, never>;
+     * type a0 = CheckType<Trim<any>, any>;
+     * 
+     * type t1 = CheckType<Trim<'abcd'>, 'abcd'>;
+     * type r2 = CheckType<Trim<' \r\n\t\f\v \r\n\t\f\v123456 \r\n\t\f\v \r\n\t\f\v'>, '123456'>;
+     */
+    export type Trim<S extends string> = S extends undefined ? never : _Trim<_Trim<S, true, false>, false, true>;
+    export namespace Trim {
+        /**
+         * @summary Replace spaces chars in string `S` start
+         * @template S String for change
+         * @example
+         * type n0 = CheckType<Trim.Start<never>, never>;
+         * type u0 = CheckType<Trim.Start<undefined>, never>;
+         * type a0 = CheckType<Trim.Start<any>, any>;
+         * 
+         * type t1 = CheckType<Trim.Start<'abcd'>, 'abcd'>;
+         * type r2 = CheckType<
+         *   Trim.Start<' \r\n\t\f\v \r\n\t\f\v123456 \r\n\t\f\v \r\n\t\f\v'>,
+         *   '123456 \r\n\t\f\v \r\n\t\f\v'
+         * >;
+         */
+        type Start<S extends string> = S extends undefined ? never : _Trim<S, true, false>;
+        /**
+         * @summary Replace spaces chars in string `S` end
+         * @template S String for change
+         * @example
+         * type n0 = CheckType<Trim.End<never>, never>;
+         * type u0 = CheckType<Trim.End<undefined>, never>;
+         * type a0 = CheckType<Trim.End<any>, any>;
+         * 
+         * type t1 = CheckType<Trim.End<'abcd'>, 'abcd'>;
+         * type r2 = CheckType<
+         *   Trim.End<' \r\n\t\f\v \r\n\t\f\v123456 \r\n\t\f\v \r\n\t\f\v'>,
+         *   ' \r\n\t\f\v \r\n\t\f\v123456'
+         * >;
+         */
+        type End<S extends string> = S extends undefined ? never : _Trim<S, false, true>;
+    }
+    /**
+     * @summary String cases
+     * @example
+     * type w =
+     *   'Oh! Jingle bells, jingle bells Jingle all the way';
+     * type c = CheckType<Camel<w>, 'ohJingleBellsJingleBellsJingleAllTheWay'>;
+     * type p = CheckType<Pascal<w>, 'OhJingleBellsJingleBellsJingleAllTheWay'>;
+     * type s = CheckType<Snake<w>, 'oh_jingle_bells_jingle_bells_jingle_all_the_way'>;
+     * type S = CheckType<Snake.Up<w>, 'OH_JINGLE_BELLS_JINGLE_BELLS_JINGLE_ALL_THE_WAY'>;
+     * type k = CheckType<Kebab<w>, 'oh-jingle-bells-jingle-bells-jingle-all-the-way'>;
+     */
+    export namespace Case {
+        /**
+         * @summary String cases settings
+         */
+        export namespace Settings {
+            /**
+             * @summary String cases global removes settings
+             */
+            namespace Removes {
+                /**
+                 * @summary String cases global removes map for keys. Values ignored
+                 */
+                interface Map {
+                    ' ': 0;
+                    '-': 0;
+                    _: 0;
+                    ',': 0;
+                    '.': 0;
+                    '!': 0;
+                }
+            }
+            type Removes = keyof Removes.Map;
+        }
+        type _CamelPascal<S extends string, RM extends string, U extends boolean = false, R extends string = ''> = S extends `${infer C}${infer E}` ? C extends RM ? _CamelPascal<E, RM, true, R> : _CamelPascal<E, RM, false, `${R}${U extends true ? Uppercase<C> : Lowercase<C>}`> : R;
+        type _SnakeKebab<S extends string, Sep extends string, RM extends string, U extends boolean = false, F extends boolean = true, R extends string = ''> = S extends `${infer C}${infer E}` ? C extends RM ? _SnakeKebab<E, Sep, RM, true, F, R> : _SnakeKebab<E, Sep, RM, false, false, `${R}${F extends true ? '' : U extends true ? Sep : C extends Uppercase<C> ? Sep : ''}${Lowercase<C>}`> : R;
+        /**
+         * @summary Camel case
+         */
+        export type Camel<S extends string, R extends string = Settings.Removes> = _CamelPascal<S, R>;
+        /**
+         * @summary Pascal case
+         */
+        export type Pascal<S extends string, R extends string = Settings.Removes> = _CamelPascal<S, R, true>;
+        /**
+         * @summary Snake case
+         */
+        export type Snake<S extends string, R extends string = Settings.Removes> = _SnakeKebab<S, '_', R>;
+        export namespace Snake {
+            /**
+             * @summary Snake UPPER_CASE
+             */
+            type Up<S extends string, R extends string = Settings.Removes> = Uppercase<_SnakeKebab<S, '_', R>>;
+        }
+        /**
+         * @summary Kebab case
+         */
+        export type Kebab<S extends string, R extends string = Settings.Removes> = _SnakeKebab<S, '-', R>;
+        export {};
+    }
+    export type Case<Type extends 'c' | 'p' | 's' | 'S' | 'k', S extends string, R extends string = Case.Settings.Removes> = Type extends 'c' ? Case.Camel<S, R> : Type extends 'p' ? Case.Pascal<S, R> : Type extends 's' ? Case.Snake<S, R> : Type extends 'S' ? Case.Snake.Up<S, R> : Type extends 'k' ? Case.Kebab<S, R> : never;
+    export namespace Case {
+    }
+    export {};
+}

package/dist/_global/structure/_register.d.ts

@@ -0,0 +1,93 @@
+declare namespace AVStantso {
+    namespace Code {
+        namespace TS {
+            namespace Structure {
+                /**
+                 * @summary Not strict Structure.
+                 */
+                type Wildcard = AVStantso.TS.Structure.Wildcard;
+                /**
+                 * @summary Find structure `object` `T` key by `value` `V`
+                 * @template T Structure
+                 * @template V Structure value or provider subvalue
+                 * @template TProviderFiled Sub key of `object` values for extract value
+                 * @param structure Structure for search
+                 * @param value Structure value or provider subvalue
+                 * @param field Sub key of `object` values for extract value
+                 */
+                interface KeyByValue {
+                    /**
+                     * @summary Find structure `object` `T` key by `value` `V`
+                     * @template T Structure
+                     * @template V Structure value
+                     * @param structure Structure for search
+                     * @param value Structure value or provider subvalue
+                     */
+                    <T extends Structure.Wildcard, V>(structure: T, value: V): AVStantso.TS.Structure.Reverse<T> extends infer R ? V extends keyof R ? R[V] : unknown : unknown;
+                    /**
+                     * @summary Find structure `object` `T` key by `value` `V`
+                     * @template T Structure
+                     * @template V Structure value or provider subvalue
+                     * @template TProviderFiled Sub key of `object` values for extract value
+                     * @param field Sub key of `object` values for extract value
+                     * @param structure Structure for search
+                     * @param value Structure value or provider subvalue
+                     */
+                    <T extends Structure.Wildcard, V, TProviderFiled extends AVStantso.TS.Key = undefined>(field: TProviderFiled, structure: T, value: V): AVStantso.TS.Structure.Reverse<T, TProviderFiled> extends infer R ? V extends keyof R ? R[V] : unknown : unknown;
+                }
+            }
+            /**
+             * @summary TypeScript structure helpers utility
+             */
+            interface Structure {
+                /**
+                 * @summary Check `candidate` is `Structure` and cast to `T`.
+                 * @param candidate Tested value
+                 * @param noSpecialClasses If setted, returns `false` for `Array`, `Map`, `Set` etc.
+                 */
+                is<T extends Structure.Wildcard>(candidate: unknown, noSpecialClasses?: boolean): candidate is T;
+                /**
+                 * @summary Find structure `object` `T` key by `value` `V`
+                 * @template T Structure
+                 * @template V Structure value or provider subvalue
+                 * @template TProviderFiled Sub key of `object` values for extract value
+                 * @param field Sub key of `object` values for extract value
+                 * @param structure Structure for search
+                 * @param value Structure value or provider subvalue
+                 */
+                keyByValue: Structure.KeyByValue;
+                /**
+                 * @summary Reverse structure `object` `T` to map value-key.\
+                 * Non keyable values is ignored\
+                 * except `object` if defined `TProviderFiled` and it's have this key
+                 * @template T Structure object for reverse
+                 * @template TProviderFiled Sub key of `object` values for extract value
+                 * @example
+                 * type r_simple = CheckType<
+                 *   Reverse<{ x: 1; y: 'ABC'; z: { a: true } }>,
+                 *   {
+                 *     1: 'x';
+                 *     ABC: 'y';
+                 *   }
+                 * >;
+                 * 
+                 * type r_provider = CheckType<
+                 *   Reverse<{ x: 1; y: 'ABC'; z: { a: 15 } }, 'a'>,
+                 *   {
+                 *     1: 'x';
+                 *     ABC: 'y';
+                 *     15: 'z';
+                 *   }
+                 * >;
+                 */
+                reverse<T extends object, TProviderFiled extends AVStantso.TS.Key = undefined>(structure: T, field?: TProviderFiled): AVStantso.TS.Structure.Reverse<T, TProviderFiled>;
+            }
+        }
+        interface TS {
+            /**
+             * @summary TypeScript structure helpers utility
+             */
+            Structure: TS.Structure;
+        }
+    }
+}

package/dist/_global/structure/index.d.ts

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