@avstantso/ts 1.1.0 → 1.3.0

package/dist/_global/comparisons.d.ts

@@ -0,0 +1,85 @@
+declare namespace AVStantso.TS {
+    type Args<Item1 = unknown, Item2 = Item1, IfTrue = unknown, IfFalse = unknown> = [Item1, Item2, IfTrue, IfFalse];
+    namespace Number {
+        type _LT_For<Ag extends Args<number>, I extends number = 0> = I extends Ag[0] ? Ag[2] : I extends Ag[1] ? Ag[3] : _LT_For<Ag, Increment<I>>;
+        type _LT_Digit<Ag extends Args<Arr>> = Ag[0] extends [`${infer AF extends number}`, ...infer ARest] ? Ag[1] extends [`${infer BF extends number}`, ...infer BRest] ? AF extends BF ? _LT_Digit<[ARest, BRest, Ag[2], Ag[3]]> : _LT_For<[AF, BF, Ag[2], Ag[3]]> : never : never;
+        type _LT_Length<Ag extends Args<number>, LA extends number = TS.String._Length<`${Ag[0]}`>, LB extends number = TS.String._Length<`${Ag[1]}`>> = LA extends LB ? _LT_Digit<[
+            TS.String._SplitToChars<`${Ag[0]}`>,
+            TS.String._SplitToChars<`${Ag[1]}`>,
+            Ag[2],
+            Ag[3]
+        ]> : _LT_For<[LA, LB, Ag[2], Ag[3]]>;
+        type _LT_Sign<Ag extends Args<number>> = `${Ag[0]}` extends `-${infer A extends number}` ? `${Ag[1]}` extends `-${infer B extends number}` ? _LT_Length<[B, A, Ag[2], Ag[3]]> : Ag[2] : `${Ag[1]}` extends `-${number}` ? Ag[3] : _LT_Length<Ag>;
+    }
+    namespace String {
+        type _LT<Ag extends Args<string>> = Ag[0] extends `${infer AC}${infer AE}` ? Ag[1] extends `${infer BC}${infer BE}` ? AC extends BC ? _LT<[AE, BE, Ag[2], Ag[3]]> : Number._LT_Length<[ASCII.Code<AC>, ASCII.Code<BC>, Ag[2], Ag[3]]> : Ag[3] : Ag[2];
+    }
+    /**
+     * @summary Low-level test `Eq===true ? A <= B : A < B`
+     * @template Ag Arguments `[A, B, IfTrue, IfFalse]`
+     * @template Eq `true` — `<=`, `false` — `<`
+     * @returns `Ag[2] | Ag[3]`
+     * @example
+     * type nt = CheckType<_LT<[1, 2, true, false]>, true>;
+     * type st = CheckType<_LT<['a', 'b', true, false]>, true>;
+     * type nf = CheckType<_LT<[2, 1, true, false]>, false>;
+     * type sf = CheckType<_LT<['c', 'b', true, false]>, false>;
+     * 
+     * type n_large_p = CheckType<_LT<[9999998, 9999999, true, false]>, true>;
+     * type n_large_n = CheckType<_LT<[-9999999, -9999998, true, false]>, true>;
+     */
+    export type _LT<Ag extends Args, Eq extends boolean = false> = Ag[0] extends Ag[1] ? Eq extends true ? Ag[2] : Ag[3] : Ag extends [number, number, unknown, unknown] ? Number._LT_Sign<Ag> : Ag extends [string, string, unknown, unknown] ? String._LT<Ag> : never;
+    /**
+     * @summary Low-level test `Eq===true ? IsLT===true ? A <= B : A => B : IsLT ? A < B : A > B`
+     * @template Ag Arguments `[A, B, IfTrue, IfFalse]`
+     * @template IsLT `true` — `<`, `false` — `>`
+     * @template Eq `true` — `<=`, `false` — `<`
+     * @returns `Ag[2] | Ag[3]`
+     * @example
+     * type nt = CheckType<_LT_GT<[1, 2, true, false], true>, true>;
+     * type st = CheckType<_LT_GT<['a', 'b', true, false], true>, true>;
+     * type nf = CheckType<_LT_GT<[2, 1, true, false], true>, false>;
+     * type sf = CheckType<_LT_GT<['c', 'b', true, false], true>, false>;
+     * 
+     * type n_large_p = CheckType<_LT_GT<[9999998, 9999999, true, false], true>, true>;
+     * type n_large_n = CheckType<_LT_GT<[-9999999, -9999998, true, false], true>, true>;
+     */
+    export type _LT_GT<Ag extends Args, IsLT extends boolean, Eq extends boolean = false> = _LT<IsLT extends true ? Ag : [Ag[1], Ag[0], Ag[2], Ag[3]], Eq>;
+    /**
+     * @summary Test `A < B`
+     * @template A argument for comparision
+     * @template B argument for comparision
+     * @template IfTrue Result, if `A < B`
+     * @template IfFalse Result, if `A >= B`
+     * @returns `IfFalse` or `IfTrue` param
+     */
+    export type LT<A extends number | string, B extends number | string, IfTrue = true, IfFalse = false> = _LT<[A, B, IfTrue, IfFalse]>;
+    /**
+     * @summary Test `A <= B`
+     * @template A argument for comparision
+     * @template B argument for comparision
+     * @template IfTrue Result, if `A <= B`
+     * @template IfFalse Result, if `A > B`
+     * @returns `IfFalse` or `IfTrue` param
+     */
+    export type LTE<A extends number | string, B extends number | string, IfTrue = true, IfFalse = false> = _LT<[A, B, IfTrue, IfFalse], true>;
+    /**
+     * @summary Test `A > B`
+     * @template A argument for comparision
+     * @template B argument for comparision
+     * @template IfTrue Result, if `A > B`
+     * @template IfFalse Result, if `A <= B`
+     * @returns `IfFalse` or `IfTrue` param
+     */
+    export type GT<A extends number | string, B extends number | string, IfTrue = true, IfFalse = false> = _LT<[B, A, IfTrue, IfFalse]>;
+    /**
+     * @summary Test `A >= B`
+     * @template A argument for comparision
+     * @template B argument for comparision
+     * @template IfTrue Result, if `A >= B`
+     * @template IfFalse Result, if `A < B`
+     * @returns `IfFalse` or `IfTrue` param
+     */
+    export type GTE<A extends number | string, B extends number | string, IfTrue = true, IfFalse = false> = _LT<[B, A, IfTrue, IfFalse], true>;
+    export {};
+}

package/dist/_global/func.d.ts

@@ -0,0 +1,17 @@
+declare namespace AVStantso.TS.Func {
+    /**
+     * @summary Nested function type
+     * @template Depth nesting depth
+     * @example
+     * type n = CheckType<Nested<never>, never>;
+     * type u = CheckType<Nested<undefined>, (...params: Arr) => unknown>;
+     * 
+     * type r0 = CheckType<Nested<0>, (...params: Arr) => unknown>;
+     * type r1 = CheckType<Nested<1>, (...params: Arr) => (...params: Arr) => unknown>;
+     * type r2 = CheckType<
+     *   Nested<2>,
+     *   (...params: Arr) => (...params: Arr) => (...params: Arr) => unknown
+     * >;
+     */
+    type Nested<Depth extends number = 1, R = unknown, P extends Arr = Arr> = Depth extends 0 ? Func<R, P> : Func<Nested<Decrement<Depth>, R, P>>;
+}

package/dist/_global/index.d.ts

@@ -0,0 +1,14 @@
+import './_register';
+import './func';
+import './union';
+import './array';
+import './ascii';
+import './boolean';
+import './comparisons';
+import './numeric';
+import './string';
+import './literal';
+import './structure';
+import './resolve';
+import './type';
+import './utility';

package/dist/_global/literal.d.ts

@@ -0,0 +1,184 @@
+declare namespace AVStantso {
+    namespace TS {
+        /**
+         * @summary Literal for available types for value
+         */
+        type Literal = keyof Literal.Map & {};
+        namespace Literal {
+            /**
+             * @summary Map for available builtin types for value
+             */
+            type Builtins = {
+                string: string;
+                number: number;
+                bigint: bigint;
+                boolean: boolean;
+                symbol: symbol;
+                undefined: undefined;
+                object: object;
+                function: Function;
+            };
+            /**
+             * @summary Union for available builtin types for value
+             */
+            type Builtin = keyof Builtins & {};
+            /**
+             * @summary Map for available types for value
+             */
+            interface Map extends AtomicObjects, Builtins {
+            }
+            /**
+             * @summary Map for number-like types.
+             *
+             * ⚠ Key is significant, value ignored
+             */
+            interface NumberLike {
+                number: 0;
+                bigint: 0;
+                Date: 0;
+            }
+            /**
+             * @summary If `L` is number-like returns `IfTrue` else `IfFalse`
+             * @template L Tested literal
+             * @template IfTrue Result, if `L` is number-like
+             * @template IfFalse Result, if `L` NOT is number-like
+             * @returns `IfFalse` or `IfTrue` param
+             * @example
+             * type n = CheckType<IsNumberLike<never>, never>;
+             * type u = CheckType<IsNumberLike<undefined>, undefined>;
+             * 
+             * type t = CheckType<IsNumberLike<'number'>, true>;
+             * type f = CheckType<IsNumberLike<'object'>, false>;
+             */
+            type IsNumberLike<L extends Literal, IfTrue = true, IfFalse = false> = L extends undefined ? undefined : [Extract<L, keyof NumberLike>] extends [never] ? IfFalse : IfTrue;
+            /**
+             * @summary Map for string-like types.
+             *
+             * ⚠ Key is significant, value ignored
+             */
+            interface StringLike {
+                string: 0;
+                Buffer: 0;
+            }
+            /**
+             * @summary If `L` is string-like returns `IfTrue` else `IfFalse`
+             * @template L Tested literal
+             * @template IfTrue Result, if `L` is string-like
+             * @template IfFalse Result, if `L` NOT is string-like
+             * @returns `IfFalse` or `IfTrue` param
+             * @example
+             * type n = CheckType<IsStringLike<never>, never>;
+             * type u = CheckType<IsStringLike<undefined>, undefined>;
+             * 
+             * type t = CheckType<IsStringLike<'string'>, true>;
+             * type f = CheckType<IsStringLike<'object'>, false>;
+             */
+            type IsStringLike<L extends Literal, IfTrue = true, IfFalse = false> = L extends undefined ? undefined : [Extract<L, keyof StringLike>] extends [never] ? IfFalse : IfTrue;
+            /**
+             * @summary Literals array for available types for value
+             */
+            type List = Union.ToTuple<Literal>;
+            namespace List {
+                /**
+                 * @summary Literals array for available builtin types for value
+                 */
+                type Builtins = Union.ToTuple<keyof Literal.Builtins>;
+                /**
+                 * @summary Literals array for available builtin object key types for value
+                 */
+                type CanBeObjKey = ['string', 'number', 'symbol'];
+                /**
+                 * @summary Literals array for available builtin structural types for value
+                 */
+                type Structural = ['object', 'function'];
+            }
+            /**
+             * @summary Literals key-to-key record
+             */
+            type Key2KeyRec = Array._ToKey2Key<List>;
+        }
+    }
+    namespace Code {
+        namespace TS {
+            /**
+             * @summary Literals key-to-key record + utils
+             */
+            interface Literal extends AVStantso.TS.Literal.Key2KeyRec {
+                /**
+                 * @summary Literals array for available builtin types for value
+                 */
+                Builtins: readonly [...AVStantso.TS.Literal.List.Builtins];
+                /**
+                 * @summary Literals array for available builtin object key types for value
+                 */
+                CanBeObjKey: readonly [...AVStantso.TS.Literal.List.CanBeObjKey];
+                /**
+                 * @summary Literals array for available builtin structural types for value
+                 */
+                Structural: readonly [...AVStantso.TS.Literal.List.Structural];
+                /**
+                 * @summary Literals array for available types for value
+                 */
+                List: AVStantso.TS.Literal.List;
+                /**
+                 * @summary Empty value for `Literal`
+                 * @param type Type literal
+                 * @returns Resolved literal empty value
+                 */
+                Empty: {
+                    /**
+                     * @summary Empty value for `Literal`
+                     * @param type Type literal
+                     * @returns Resolved literal empty value
+                     */
+                    <L extends AVStantso.TS.Literal>(type: L): AVStantso.TS.Resolve<L>;
+                } & {
+                    [K in AVStantso.TS.Literal]: AVStantso.TS.Resolve<K>;
+                };
+                /**
+                 * @summary Is `value` a resolved `type` of `L`
+                 * @param type Type literal
+                 * @param value Tested value
+                 */
+                IsValue: {
+                    /**
+                     * @summary Is `value` a resolved `type` of `L`
+                     * @param type Type literal
+                     * @param value Tested value
+                     */
+                    <L extends AVStantso.TS.Literal>(type: L, value: unknown): value is AVStantso.TS.Resolve<L>;
+                } & {
+                    [K in AVStantso.TS.Literal]: (value: unknown) => value is AVStantso.TS.Resolve<K>;
+                };
+                /**
+                 * @summary Registrate extended literal
+                 * @template L Literal type
+                 * @param literal Literal value
+                 * @example
+                 * type XYZ = {x: string; y: number; z: boolean; };
+                 *
+                 * namespace AVStantso.TS.Literal {
+                 *   export interface Map {
+                 *     xyz: XYZ;
+                 *   }
+                 * }
+                 *
+                 * avstantso.TS.Literal._Register('xyz');
+                 *
+                 * ///////////////
+                 *
+                 * type t = CheckType<AVStantso.TS.Resolve<'xyz'>, XYZ>;
+                 *
+                 * console.log(avstantso.TS.Literal.List.includes('xyz')); // prints true
+                 */
+                _Register<L extends AVStantso.TS.Literal>(literal: L, empty?: AVStantso.TS.Resolve<L>): void;
+            }
+        }
+        interface TS {
+            /**
+             * @summary Literals key-to-key record + utils
+             */
+            Literal: TS.Literal;
+        }
+    }
+}

package/dist/_global/numeric/domain/describes.d.ts

@@ -0,0 +1,62 @@
+declare namespace AVStantso.TS {
+    /**
+     * @summary Numeric types and "functions"
+     */
+    namespace Numeric {
+        /**
+         * @summary Domain of a functions of `Numeric` type
+         */
+        namespace Domain {
+            /**
+             * @summary Numeric literals `1-max(Domain.Positive)`.
+             *
+             * Used in `Numeric` type "functions"
+             *
+             * For full ASCII need `255`
+             *
+            */
+            namespace Positive { }
+            /**
+             * @summary Numeric literals `-1-(-max(Domain.Negative))`.
+             *
+             * Used in `Numeric` type "functions"
+             *
+            */
+            namespace Negative { }
+            /**
+             * @summary Summs `0—9 x 0—9` by table.
+             *
+             * Used in `Numeric.Summ` type "functions"
+             */
+            namespace Summs {
+                /**
+                 * @summary Calc summ `0—9 x 0—9` by table.
+                 *
+                 * Used in `Numeric.Summ` type "functions"
+                 * @return `[<Current digit>, <Next digit coef>]`
+                 */
+                type Calc<X extends number, Y extends number> = Summs[X][Y];
+            }
+            /**
+             * @summary Diffs `0—9 x -1—9` table.
+             *
+             * Used in `Numeric.Summ` type "functions"
+             */
+            namespace Diffs {
+                /**
+                 * @summary Calc summ `0—9 x -9—9` by table.
+                 *
+                 * Used in `Numeric.Diff` type "functions"
+                 * @return `[<Current digit>, <Next digit coef>]`
+                 */
+                type Calc<X extends number, Y extends number> = Diffs[X][Increment<Y>];
+            }
+            /**
+             * @summary Power map.
+             *
+             * Used in `Numeric.Power` type "functions"
+             */
+            namespace Power { }
+        }
+    }
+}