@avstantso/ts 1.0.4 → 1.1.0

package/dist/_global/literal.d.ts

@@ -1,180 +0,0 @@
-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 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

@@ -1,62 +0,0 @@
-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 { }
-        }
-    }
-}