@avstantso/ts 1.1.0 → 1.2.1

package/dist/_global/union.d.ts

@@ -0,0 +1,79 @@
+declare namespace AVStantso.TS {
+    namespace Union {
+        /**
+         * @summary Convert a union to an intersection: `X | Y | Z` ==> `X & Y & Z`
+         * @template U Union type
+         */
+        export type ToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+        /**
+         * Convert a union to an overloaded function `X | Y` ==> `((x: X)=>void) & ((y:Y)=>void)`
+         */
+        type UnionToOvlds<U> = ToIntersection<U extends any ? (f: U) => void : never>;
+        /**
+         * @summary Takes last from union: `X | Y | Z` ==> `Z`\
+         * _⚠ May take not last_
+         * @template U Union type
+         * @example
+         * type n = CheckType<Pop<never>, never>;
+         * type u = CheckType<Pop<undefined>, undefined>;
+         * 
+         * type r1 = CheckType<Pop<string>, string>;
+         * type r2 = CheckType<Pop<number>, number>;
+         * type r3 = CheckType<Pop<1 | 2 | 3>, 3>;
+         * type r4 = CheckType<Pop<'A' | 'B' | 'C'>, 'C'>;
+         */
+        export type Pop<U> = UnionToOvlds<U> extends ((a: infer A) => void) ? A : never;
+        type _ToTuple<U, R extends ArrR = [], L = Pop<U>> = [
+            U
+        ] extends [never] ? R : _ToTuple<Exclude<U, L>, [L, ...R]>;
+        /**
+         * @summary Convert union to tuple: `X | Y | Z` ==> `[X, Y, Z]`\
+         * _⚠ Order of items not warrant_
+         * @template U Union type
+         * @example
+         * type n = CheckType<ToTuple<never>, []>;
+         * type u = CheckType<ToTuple<undefined>, [undefined]>;
+         * 
+         * type r1 = CheckType<ToTuple<string>, [string]>;
+         * type r2 = CheckType<TS.Array.Sort<ToTuple<1 | 2 | 3>>, [1, 2, 3]>;
+         * 
+         * type n100 = Array.Numbers<100>;
+         * type k100 = n100[number];
+         * type t100 = ToTuple<k100>;
+         * 
+         * interface Person {
+         *   firstName: string;
+         *   lastName: string;
+         *   dob: Date;
+         *   hasCats: false;
+         * }
+         * type Test = CheckType<
+         *   ToTuple<keyof Person>,
+         *   ['firstName', 'lastName', 'dob', 'hasCats']
+         * >;
+         */
+        export type ToTuple<U> = _ToTuple<U>;
+        export {};
+    }
+    /**
+     * @summaru Test type is union
+     * @template T Tested type
+     * @template IfTrue Result, if `Condition` is `true`
+     * @template IfFalse Result, if `Condition` is NOT `true`
+     * @returns `IfFalse` or `IfTrue` param
+     * @example
+     * type MyUnion = 'a' | 'b' | 'c';
+     * type NotAUnion = string;
+     * type AnotherUnion = number | boolean;
+     * 
+     * type n = CheckType<IsUnion<never>, false>;
+     * type u = CheckType<IsUnion<undefined>, false>;
+     * 
+     * type CheckMyUnion = CheckType<IsUnion<MyUnion>, true>;
+     * type CheckNotAUnion = CheckType<IsUnion<NotAUnion>, false>;
+     * type CheckAnotherUnion = CheckType<IsUnion<AnotherUnion>, true>;
+     * type CheckSingleLiteral = CheckType<IsUnion<'hello'>, false>;
+     * type CheckNever = CheckType<IsUnion<never>, false>;
+     */
+    type IsUnion<T, IfTrue = true, IfFalse = false> = [T] extends [Union.ToIntersection<T>] ? IfFalse : IfTrue;
+}

package/dist/_global/utility/alt.d.ts

@@ -0,0 +1,58 @@
+declare namespace AVStantso.TS {
+    type _AltItem<T extends readonly object[], C extends object, R extends object = {}> = T extends readonly [infer F extends object, ...infer Rest extends object[]] ? _AltItem<Rest, C, R & (F extends C ? {
+        [K in keyof F]: F[K];
+    } : {
+        [K in keyof F]?: never;
+    })> : {
+        [K in keyof R]: R[K];
+    };
+    type _Alt<T extends readonly object[], O extends readonly object[] = T, R extends object = never> = O extends readonly [infer F extends object, ...infer Rest extends object[]] ? _Alt<T, Rest, R | _AltItem<T, F>> : R;
+    /**
+     * @summary Create object with [`Alt`]ernative fields, but not everybody fields simultaneously
+     * @template T If `object` — each field will be alternative, if `array` each array item will be alternative
+     * @return Object with alternatives
+     * @example
+     * type n = CheckType<Alt<never>, never>;
+     * type u = CheckType<Alt<undefined>, undefined>;
+     * 
+     * type o = { a: number; b: string; c: { x: bigint } };
+     * type alt_o = CheckType<
+     *   Alt<o>,
+     *   {
+     *     a: number;
+     *     b?: never;
+     *     c?: never;
+     *   } | {
+     *     a?: never;
+     *     b: string;
+     *     c?: never;
+     *   } | {
+     *     a?: never;
+     *     b?: never;
+     *     c: {
+     *       x: bigint;
+     *     };
+     *   }
+     * >;
+     * 
+     * type a = [{ a: number; b: string }, { c: { x: bigint }, d: unknown }];
+     * type alt_a = CheckType<
+     *   Alt<a>,
+     *   {
+     *     a: number;
+     *     b: string;
+     *     c?: never;
+     *     d?: never;
+     *   } | {
+     *     a?: never;
+     *     b?: never;
+     *     c: {
+     *       x: bigint;
+     *     };
+     *     d: unknown;
+     *   }
+     * >;
+     */
+    export type Alt<T extends object | readonly object[]> = T extends undefined ? undefined : T extends readonly object[] ? _Alt<T> : _Alt<Structure.Split<T>>;
+    export {};
+}

package/dist/_global/utility/flat.d.ts

@@ -0,0 +1,60 @@
+declare namespace AVStantso.TS {
+    type _Flat<Depth extends number, P, S, D = {
+        [K in keyof S as keyof S[K]]: S[K];
+    }, C = P & {
+        [K in keyof D]: D[K][Extract<K, keyof D[K]>];
+    } & {
+        [K in keyof S as S[K] extends Func ? K : never]: S[K] extends Func<infer R, infer P> ? (...params: P) => R : unknown;
+    }, R = Flat<C, Decrement<Depth>>> = {
+        [K in keyof R]: R[K];
+    };
+    /**
+     * @summary Flatting object structure to `Depth`
+     * @template T Type for flatting
+     * @template Depth Depth of flatting. If `0`, flatting hasn't effect
+     * @return If `T` is object structure — flatted structure of `T`, else unchanged `T`
+     * @example
+     * type n = CheckType<Flat<never>, never>;
+     * type u = CheckType<Flat<undefined>, undefined>;
+     * 
+     * type t = {
+     *   v: () => Buffer,
+     *   w: (() => string) & { n: string },
+     *   x: { a: string; b: number };
+     *   y: { c: { d: boolean } };
+     *   z: bigint
+     * };
+     * type f0_0 = CheckType<Flat<t, 0>, t>;
+     * type f0_1 = CheckType<Flat<t, undefined>, t>;
+     * 
+     * type f1 = CheckType<
+     *   Flat<t>,
+     *   {
+     *     v: () => Buffer,
+     *     z: bigint;
+     *     n: string;
+     *     a: string;
+     *     b: number;
+     *     c: {
+     *       d: boolean;
+     *     };
+     *     w: () => string,
+     *   }
+     * >;
+     * 
+     * type f2 = CheckType<
+     *   Flat<t, 2>,
+     *   {
+     *     v: () => Buffer;
+     *     z: bigint;
+     *     n: string;
+     *     a: string;
+     *     b: number;
+     *     d: boolean;
+     *     w: () => string,
+     *   }
+     * >;
+     */
+    export type Flat<T, Depth extends number = 1> = T extends undefined ? undefined : Depth extends undefined | 0 ? T : Structure.Separate<T> extends readonly [infer P, infer S] ? _Flat<Depth, P, S> : T;
+    export {};
+}

package/dist/_global/utility/if-def.d.ts

@@ -0,0 +1,22 @@
+declare namespace AVStantso.TS {
+    /**
+     * @summary Select `TExtended` type or `TBase` if `TExtended` is `undefined` or `TElse`
+     */
+    type IfDef<TBase, TExtended extends TBase, TElse = TBase> = TExtended extends TBase ? TExtended : TElse;
+    /**
+     * @summary Select `TExtended[TKey]` type or `TBase[TKey]` if `TExtended[TKey]` is `undefined` or `TElse`
+     * @example
+     * type A = {
+     *   x?: number;
+     *   y?: number;
+     * };
+     * 
+     * type B = {
+     *   x?: 1 | 2 | 3;
+     * };
+     * 
+     * type x = CheckType<IfDefKey<'x', A, B>, 1 | 2 | 3>;
+     * type y = CheckType<IfDefKey<'y', A, B>, number>;
+     */
+    type IfDefKey<TKey extends keyof TBase, TBase extends object, TExtended extends TBase, TElse = TBase[TKey]> = IfDef<TBase[TKey], TExtended[TKey], TElse>;
+}

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

@@ -0,0 +1,9 @@
+import './alt';
+import './flat';
+import './if-def';
+import './opaque';
+import './options';
+import './override';
+import './replace-key';
+import './required-optional';
+import './merge';

package/dist/_global/utility/merge.d.ts

@@ -0,0 +1,29 @@
+declare namespace AVStantso.TS {
+    /**
+     * @summary Merge types. Combine fields for objects, union for others
+     * @example
+     * type u = CheckType<Merge<number, string>, number | string>;
+     * type o = CheckType<
+     *   Merge<{ a?: number; b?: string }, { a: string }>,
+     *   { a: string; b?: string }
+     * >;
+     */
+    type Merge<Base, Extended> = Base extends object ? Extended extends object ? {
+        [K in keyof (Base & Extended)]: K extends keyof Extended ? Extended[K] : K extends keyof Base ? Base[K] : never;
+    } : never : Base | Extended;
+    namespace Merge {
+        /**
+         * @summary Merge fields of object types. Combine fields for objects, union for others
+         * @example
+         * type a = CheckType<
+         *   Merge.Fields<{ a?: number; b?: string }, { a: string }, 'a'>,
+         *   number | string
+         * >;
+         * type b = CheckType<
+         *   Merge.Fields<{ a?: number; b?: string }, { a: string }, 'b', 'a'>,
+         *   string
+         * >;
+         */
+        type Fields<Base extends object, Extended extends object, BaseKey extends Key, ExtendedKey extends Key = BaseKey> = BaseKey extends keyof Base ? ExtendedKey extends keyof Extended ? Merge<Base[BaseKey], Extended[ExtendedKey]> : Base[BaseKey] : never;
+    }
+}

package/dist/_global/utility/opaque.d.ts

@@ -0,0 +1,17 @@
+declare namespace AVStantso.TS {
+    /**
+     * @summary Opaque type without direct asignment
+     * @see https://stackoverflow.com/questions/56720355/typescript-type-string-of-specific-characters
+     * @example
+     * type ID = Opaque<'ID', string>;
+     *
+     * //@ts-expect-error Type 'string' is not assignable to type 'ID'.
+     * const id1: ID = 'abc';
+     * const id2: ID = 'def' as ID;
+     *
+     * const s: string = id1 + id2;
+     */
+    type Opaque<TypeMeta, T> = T & {
+        __META__: TypeMeta;
+    };
+}

package/dist/_global/utility/options.d.ts

@@ -0,0 +1,34 @@
+declare namespace AVStantso.TS {
+    /**
+     * @summary Options for type declaration
+     * @template TTypeMap All available options
+     * @template TDefaults Default values for options
+     */
+    type Options<TTypeMap extends object, TDefaults extends Partial<TTypeMap> = undefined> = {
+        TypeMap: Partial<TTypeMap>;
+        Defaults: Partial<TDefaults>;
+    };
+    namespace Options {
+        /**
+         * @summary Structure of options for type declaration
+         */
+        type Structure = {
+            TypeMap: object;
+            Defaults: object;
+        };
+        /**
+         * @summary Get option from options or default
+         */
+        type Get<TOptionsStructure extends Options.Structure, TOptions extends TOptionsStructure['TypeMap'], TKey extends keyof TOptionsStructure['TypeMap'], TDefault extends TOptionsStructure['TypeMap'][TKey] = TOptionsStructure['Defaults'][TKey] extends TOptionsStructure['TypeMap'][TKey] ? TOptionsStructure['Defaults'][TKey] : undefined> = TOptions extends undefined ? TDefault : TOptions[TKey] extends undefined ? TDefault : TOptions[TKey];
+        /**
+         * @summary Apply defaults from structure
+         */
+        type Apply<TOptionsStructure extends Options.Structure, TOptions extends TOptionsStructure['TypeMap']> = {
+            [K in keyof TOptionsStructure['TypeMap']]: Get<TOptionsStructure, TOptions, K>;
+        };
+        /**
+         * @summary Check `TOptions` satisfy the `TOptionsStructure`
+         */
+        type Check<TOptionsStructure extends Options.Structure, TOptions extends TOptionsStructure['TypeMap']> = TOptions;
+    }
+}

package/dist/_global/utility/override.d.ts

@@ -0,0 +1,100 @@
+declare namespace AVStantso.TS {
+    /**
+     * @summary Override `TBase` properties by `TExtended` properties if `TExtended[K]` is NOT `undefined`
+     * or `never` for all `TBase` keys
+     * @example
+     * type A = {
+     *   x?: number;
+     *   y?: number;
+     *   z?: number;
+     * };
+     * 
+     * type B = {
+     *   x?: 1 | 2 | 3;
+     *   y?: 12
+     * };
+     * 
+     * type R = CheckType<Override<A, B>, { x?: 1 | 2 | 3; y?: 12; z?: number; }>;
+     */
+    type Override<TBase extends object, TExtended extends TBase, TOptional extends boolean = false> = TOptional extends true ? {
+        [K in keyof TBase]?: IfDefKey<K, TBase, TExtended>;
+    } : {
+        [K in keyof TBase]: IfDefKey<K, TBase, TExtended>;
+    };
+    /**
+     * @summary Test `TBase` was overrided by `TCurrent`
+     * @example
+     * type A = CheckType<IfIsOverrided<number, 1 | 2 | 3>, true>;
+     * type B = CheckType<IfIsOverrided<number, number>, false>;
+     * type C = CheckType<IfIsOverrided<unknown, unknown>, false>;
+     * type D = CheckType<IfIsOverrided<unknown, {}>, true>;
+     */
+    type IfIsOverrided<TBase, TCurrent extends TBase, IfTrue = true, IfFalse = false> = TBase extends TCurrent ? TCurrent extends object ? TCurrent extends TBase ? IfTrue : IfFalse : IfFalse : IfTrue;
+    /**
+     * @summary Test `TBase[Key]` was overrided by `TCurrent[Key]`
+     * @example
+     * type A = CheckType<
+     *   IfIsOverridedKey<'a', { a: number; b: string }, { a: 1 | 2 | 3, b: string }>,
+     *   true
+     * >;
+     * 
+     * type B = CheckType<
+     *   IfIsOverridedKey<'a', { a: number; b: string }, { a: number, b: string }>,
+     *   false
+     * >;
+     */
+    type IfIsOverridedKey<TKey extends keyof TBase, TBase, TCurrent extends TBase, IfTrue = true, IfFalse = false> = IfIsOverrided<TBase[TKey], TCurrent[TKey], IfTrue, IfFalse>;
+    /**
+     * @summary Select `TExtended` type if `TBase` and `TCurrent` is equals
+     * @example
+     * type A = CheckType<IfNotOverrided<number, 1 | 2 | 3, 2>, 1 | 2 | 3>;
+     * type B = CheckType<IfNotOverrided<number, number, 4>, 4>;
+     * type C = CheckType<IfNotOverrided<unknown, unknown, 'A!'>, 'A!'>;
+     */
+    type IfNotOverrided<TBase, TCurrent extends TBase, TExtended extends TBase> = IfIsOverrided<TBase, TCurrent, TCurrent, TExtended>;
+    /**
+     * @summary Select `TExtended[TKey]` if `TBase[TKey]` and `TCurrent[TKey]` is equals
+     * @example
+     * type A = CheckType<
+     *   IfNotOverridedKey<'a', { a: number }, { a: 1 | 2 | 3 }, { a: 2 } >,
+     *   1 | 2 | 3
+     * >;
+     */
+    type IfNotOverridedKey<TKey extends keyof TBase, TBase, TCurrent extends TBase, TExtended extends TBase> = IfDef<TBase[TKey], IfNotOverrided<TBase[TKey], TCurrent[TKey], TExtended[TKey]>>;
+    /**
+     * @summary Override `TCurrent` properties by `TExtended` properties if `TCurrent[K]` equals `TBase[K]`
+     * @example
+     * type A = {
+     *   a?: string;
+     *   b?: string;
+     *   x?: number;
+     *   y?: number;
+     *   z?: number;
+     * };
+     * 
+     * type B = {
+     *   x?: 1 | 2 | 3;
+     *   y?: 12;
+     * };
+     * 
+     * type C = {
+     *   b: 'b' | 'bb';
+     *   x?: 4;
+     *   z?: 72;
+     * };
+     * 
+     * type R = CheckType<
+     *   OverrideIfNot<A, B, C>,
+     *   { a?: string;
+     *     b?: 'b' | 'bb';
+     *     x?: 1 | 2 | 3;
+     *     y?: 12;
+     *     z?: 72; }
+     * >;
+     */
+    type OverrideIfNot<TBase extends object, TCurrent extends TBase, TExtended extends TBase, TOptional extends boolean = false> = TOptional extends true ? {
+        [K in keyof TBase]?: IfNotOverridedKey<K, TBase, TCurrent, TExtended>;
+    } : {
+        [K in keyof TBase]: IfNotOverridedKey<K, TBase, TCurrent, TExtended>;
+    };
+}

package/dist/_global/utility/replace-key.d.ts

@@ -0,0 +1,33 @@
+declare namespace AVStantso.TS {
+    type _ReplaceKey<TKey extends keyof TBase, TBase extends object, TReplacement, TOptional extends boolean = false, R = Omit<TBase, TKey> & (TOptional extends true ? {
+        [K in TKey]?: TReplacement;
+    } : {
+        [K in TKey]: TReplacement;
+    })> = {
+        [K in keyof R]: R[K];
+    };
+    /**
+     * @summary Replace key `TKey` in object or function `TBase` for `TReplacement`
+     * @example
+     * type r1 = CheckType<
+     *   ReplaceKey<'a', { a: string; b: number }, []>,
+     *   { a: [], b: number }
+     * >;
+     * 
+     * type r2 = CheckType<
+     *   ReplaceKey<'a', { a: string; b: number }, [], true>,
+     *   { a?: [], b: number }
+     * >;
+     */
+    export type ReplaceKey<TKey extends keyof TBase, TBase extends object, TReplacement, TOptional extends boolean = false> = _ReplaceKey<TKey, TBase, TReplacement, TOptional>;
+    /**
+     * @summary Replace key `TKey` in object or function `TBase` for `TReplacement` optionally
+     * @example
+     * type r1 = CheckType<
+     *   ReplaceKeyOpt<'a', { a: string; b: number }, []>,
+     *   { a?: [], b: number }
+     * >;
+     */
+    export type ReplaceKeyOpt<TKey extends keyof TBase, TBase extends object, TReplacement> = ReplaceKey<TKey, TBase, TReplacement, true>;
+    export {};
+}

package/dist/_global/utility/required-optional.d.ts

@@ -0,0 +1,24 @@
+declare namespace AVStantso.TS {
+    /**
+     * @summary Get list of required keys
+     * @example
+     * type n = CheckType<RequiredKeys<never>, never>;
+     * type u = CheckType<RequiredKeys<undefined>, never>;
+     * 
+     * type rk = CheckType<RequiredKeys<{ a: 1, b?: 2 }>, 'a'>;
+     */
+    type RequiredKeys<T> = {
+        [K in keyof T]-?: object extends Pick<T, K> ? never : K;
+    }[keyof T];
+    /**
+     * @summary Get list of optional keys
+     * @example
+     * type n = CheckType<OptionalKeys<never>, never>;
+     * type u = CheckType<OptionalKeys<undefined>, never>;
+     * 
+     * type ok = CheckType<OptionalKeys<{ a: 1, b?: 2 }>, 'b'>;
+     */
+    type OptionalKeys<T> = {
+        [K in keyof T]-?: object extends Pick<T, K> ? K : never;
+    }[keyof T];
+}

package/dist/_std-ext/index.d.ts

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

package/dist/_std-ext/object.d.ts

@@ -0,0 +1,23 @@
+declare interface ObjectConstructor {
+    /**
+     * Returns typed the names of the enumerable string properties and methods of an object.
+     * @param o — Object that contains the properties and methods.
+     * This can be an object that you created
+     * or an existing Document Object Model (DOM) object.
+     */
+    keysEx<O extends object>(o: O): AVStantso.TS.Structure.ToKeysArray<O>;
+    /**
+     * Returns an array of typed values of the enumerable own properties of an object
+     * @param o — Object that contains the properties and methods.
+     * This can be an object that you created
+     * or an existing Document Object Model (DOM) object.
+     */
+    valuesEx<O extends object>(o: O): AVStantso.TS.Structure.ToValuesArray<O>;
+    /**
+     * Returns an array of typed key/values of the enumerable own properties of an object
+     * @param o — Object that contains the properties and methods.
+     * This can be an object that you created
+     * or an existing Document Object Model (DOM) object.
+     */
+    entriesEx<O extends object>(o: O): AVStantso.TS.Structure.ToEntriesArray<O>;
+}

package/dist/export.d.ts

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

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import '@avstantso/core';
+import './_global';
+import './_std-ext';
+export * from './export';