@avstantso/concepts 1.1.0 → 1.2.2

package/dist/_global/provider/provider.d.ts

@@ -0,0 +1,85 @@
+declare namespace AVStantso {
+    /**
+     * @summary `Provider` metadata of key
+     * @template K Key
+     */
+    export type ProviderMeta<K extends TS.Key = TS.Key> = {
+        __KEY__?: K;
+    };
+    type _Provider<K extends TS.Key, V> = ProviderMeta<K> & Record<K, V>;
+    /**
+     * @summary Create structural type with specified field and value.\
+     * Add optional metadata field `__KEY__`
+     * @template F First param
+     * @template S Second param
+     * @returns
+     * • If `F` is `TS.Key` — `S` will be interpret as value ⇒ `{[F]:TS.Resolve<S>}`
+     *
+     * • If `F` is `TS.Type.KLD` — `S` will be ignored ⇒ `{[F[0]]:TS.Resolve<F[1]>}`
+     *
+     * • If `F` is other array ⇒ `never`
+     *
+     * • If `F` is `TS.Type.KeyDef` — `S` will be ignored ⇒ `{[F['K']]:TS.Resolve<F>}`
+     *
+     * • If `F` is other object — `S` will be interpret as `keyof F` ⇒ `Peek<F,S>` or `never` if `S` is bad key
+     * @example
+     * type R = { id: string; };
+     * 
+     * type key_value = CheckType<Provider<'id', string>, R>;
+     * 
+     * type bad_array = CheckType<Provider<[1, 2, 3, 4]>, never>;
+     * type good_array = CheckType<Provider<['id', 'string']>, R>;
+     * 
+     * type keydef_l = CheckType<Provider<{ K: 'id'; L: 'string' }>, R>;
+     * type keydef_t = CheckType<Provider<{ K: 'id'; T: string }>, R>;
+     * 
+     * type Obj = { id: string; name: string; active?: boolean };
+     * 
+     * type bad_obj_field = CheckType<Provider<Obj, 'id1'>, never>;
+     * type good_obj_field = CheckType<Provider<Obj, 'id'>, R>;
+     */
+    export type Provider<F extends Provider.First, S = undefined> = F extends TS.Key ? {
+        [K in keyof _Provider<F, TS.Resolve<S>>]: _Provider<F, TS.Resolve<S>>[K];
+    } : F extends object ? F extends TS.ArrR ? F extends TS.Type.KLD<infer K, infer L> ? Provider<K, L> : never : F extends TS.Type.KeyDef ? Provider<F['K'], F> : S extends keyof F ? Provider<S, F[S]> : never : never;
+    export namespace Provider {
+        /**
+         * @summary `Provider` metadata of key
+         * @template K Key
+         */
+        type Meta<K extends TS.Key = TS.Key> = ProviderMeta<K>;
+        /**
+         * @summary `Provider` of metadata or `never`
+         * @template T Tested type
+         * @example
+         * type p = Provider<'id', string>;
+         * 
+         * type provider = CheckType<Of<p>, p>;
+         * type not_provider = CheckType<Of<{ id: string; }>, never>;
+         */
+        type Of<T> = T extends ProviderMeta<infer K> ? T extends Record<K, unknown> ? T : never : never;
+        /**
+         * @summary `Provider` `F` type parameter constraint
+         */
+        type First = object | TS.Key;
+        /**
+         * @summary Constraint for type parameter extends `Provider`
+         */
+        type Constraint = ProviderMeta;
+        /**
+         * @summary Array of constraints for type parameter extends `Provider`
+         */
+        type Constraints = readonly Constraint[];
+        /**
+         * @summary Dry provider without `__KEY__` and extended fields
+         * @example(@Provider.Dry)
+         */
+        type Dry<P extends Constraint> = {
+            [K in globalThis.Extract<P[__KEY__], keyof P>]: P[K];
+        };
+        namespace Of {
+        }
+        namespace Dry {
+        }
+    }
+    export {};
+}

package/dist/_global/provider/strict.d.ts

@@ -0,0 +1,29 @@
+declare namespace AVStantso.Provider {
+    /**
+     * @summary Stricted `Provider` constructors
+     */
+    namespace Strict {
+        /**
+         * @summary Create `Provider` by key `K` and value `V`
+         */
+        type KeyValue<K extends TS.Key, V> = Provider<K, V>;
+        /**
+         * @summary Create `Provider` by `TS.Type.KLD`
+         */
+        type KLD<A extends TS.Type.KLD> = Provider<A>;
+        /**
+         * @summary Create `Provider` by `TS.Type.KeyDef`
+         */
+        type KeyDef<KD extends TS.Type.KeyDef> = Provider<KD>;
+        /**
+         * @summary Create `Provider` by structure `O` and strict key `K`
+         */
+        type Structure<O extends object, K extends keyof O> = Provider<O, K>;
+        namespace Structure {
+            /**
+             * @summary Create `Provider` by structure `O` and NOT strict key `K`
+             */
+            type Raw<O extends object, K extends TS.Key> = Provider<O, K>;
+        }
+    }
+}

package/dist/_global/provider/union.d.ts

@@ -0,0 +1,29 @@
+declare namespace AVStantso.Provider {
+    /**
+     * @summary Union: `Provider | Value<Provider>`
+     * @template P `Provider` (expected)
+     * @returns Union or `never`, if `P` is NOT a `Provider`
+     * @see Provider type
+     * @example
+     * type u_key_value = CheckType<Union<Provider<'id', string>>, string | { id: string; }>;
+     * 
+     * //@ts-expect-error Type '{ id: string; }' has no properties in common with type 'Constraint'.
+     * type not_provider = CheckType<Union<{ id: string }>, never>;
+     */
+    type Union<P extends Provider.Constraint> = {
+        [K in keyof P as K extends __KEY__ ? never : K]: P[K];
+    } | P[Exclude<keyof P, __KEY__>];
+    namespace Union {
+        /**
+         * @summary Make union `Provider | Value<Provider>` from `Provider` params
+         * @template F First `Provider` param
+         * @template S Second `Provider` param
+         * @see Provider type
+         * @example
+         * type u_key_value = CheckType<Union.Make<'id', string>, string | { id: string; }>;
+         * type u_kld = CheckType<Union.Make<['id', 'string']>, string | { id: string; }>;
+         * type u_obj = CheckType<Union.Make<{ id: string; x: null; }, 'id'>, string | { id: string; }>;
+         */
+        type Make<F extends First, S = undefined> = Union<Provider<F, S>>;
+    }
+}

package/dist/_global/provider/value.d.ts

@@ -0,0 +1,26 @@
+declare namespace AVStantso.Provider {
+    /**
+     * @summary Value from `Provider.Union`
+     * @template U `Provider.Union`
+     * @template P `Provider`
+     * @returns Value from `U`
+     * @see Provider type
+     * @example
+     * type p = Provider<'id', string>;
+     * type v_key_value_u1 = CheckType<Value<'abc', p>, 'abc'>;
+     * type v_key_value_u2 = CheckType<Value<{ id: 'defg' }, p>, 'defg'>;
+     */
+    type Value<U extends Union<P>, P extends Constraint> = U extends Record<P[__KEY__], infer V> ? V : U;
+    namespace Value {
+        /**
+         * @summary Make value from `Provider.Union` created by `Provider` params
+         * @template U `Union` for extract value
+         * @template F First `Provider` param
+         * @template S Second `Provider` param
+         * @see Provider type
+         * @example
+         * type u_key_value = CheckType<Value.Make<{ id: 'abc' }, 'id', string>, 'abc'>;
+         */
+        type Make<U extends Union<Provider<F, S>>, F extends First, S = unknown> = Value<U, Provider<F, S>>;
+    }
+}

package/dist/_global/stub.d.ts

@@ -0,0 +1,40 @@
+declare namespace AVStantso {
+    /**
+     * @summary Stub functions to prevent call undefined
+     */
+    namespace Stub {
+        /**
+         * @summary Stub function to prevent call undefined
+         * @param func Original function for call
+         * @returns func or stub
+         */
+        type One = <TFunc extends Function>(func: TFunc) => TFunc;
+        /**
+         * @summary Stub functions to prevent call undefined
+         * @param funcs Original functions for call
+         * @returns (func or stub)[]
+         */
+        type Multiple = <TFuncs extends Function[]>(...funcs: TFuncs) => TFuncs;
+    }
+    namespace Code {
+        namespace Stub {
+            type Overload = AVStantso.Stub.One & AVStantso.Stub.Multiple;
+        }
+        /**
+         * @summary Stub functions to prevent call undefined
+         */
+        interface Stub extends Stub.Overload {
+            /**
+             * @summary Stub by custom function
+             */
+            Custom(stub: AVStantso.Stub.One): Stub.Overload;
+        }
+    }
+    interface Code {
+        /**
+         * @summary Stub functions to prevent call undefined
+         */
+        Stub: Code.Stub;
+    }
+    const Stub: Code.Stub;
+}

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

@@ -0,0 +1,45 @@
+declare namespace AVStantso {
+    namespace Code {
+        /**
+         * @summary Switch helpers utility
+         */
+        namespace Switch {
+            /**
+             * @summary Switch factory overload
+             */
+            interface Overload<TKey extends AVStantso.TS.Key, TOptions extends AVStantso.Switch.Options & {
+                Value?: unknown;
+            } = {}> {
+                /**
+                 * @summary Switch method. `value` first
+                 */
+                <TCase, TKnownCases extends {} = Record<TKey, TCase>>(value: TOptions['Value'], cases: AVStantso.Switch.Cases<TKey, TOptions & {
+                    Case: TCase;
+                    KnownCases: TKnownCases;
+                }>): TCase;
+                /**
+                 * @summary Switch method. `cases` first
+                 */
+                reversed<TCase, TKnownCases extends {} = Record<TKey, TCase>>(cases: AVStantso.Switch.Cases<TKey, TOptions & {
+                    Case: TCase;
+                    KnownCases: TKnownCases;
+                }>, value: TOptions['Value']): TCase;
+            }
+        }
+        /**
+         * @summary Switch helpers utility
+         */
+        interface Switch {
+            <TKey extends AVStantso.TS.Key, TOptions extends AVStantso.Switch.Options & {
+                Value?: unknown;
+            } = {}>(getKey: (value: TOptions['Value']) => TKey | string): Switch.Overload<TKey, TOptions>;
+        }
+    }
+    interface Code {
+        /**
+         * @summary Switch helpers utility
+         */
+        Switch: Code.Switch;
+    }
+    const Switch: Code.Switch;
+}

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

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

package/dist/_global/switch/switch.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @summary Switch case by key of value or default
+ */
+declare namespace AVStantso.Switch {
+    export type StdKeys = 'undefined' | 'null' | 'default';
+    export type Options = {
+        Case?: unknown;
+        KnownCases?: unknown;
+    };
+    type _Cases<TKey extends TS.Key, TOptions extends Options, Case = TOptions['Case'], KnownCases = TS.IfNotOverrided<Options['KnownCases'], TOptions['KnownCases'], Record<TKey, Case>>> = Partial<KnownCases & Record<StdKeys, Case>>;
+    export type Cases<TKey extends TS.Key, TOptions extends Options = {}> = _Cases<TKey, TOptions>;
+    export {};
+}

package/dist/_global/transition.d.ts

@@ -0,0 +1,62 @@
+declare namespace AVStantso {
+    /**
+     * @summary Set `state` to `begin` -> await `action` -> `state` to `end`
+     */
+    namespace Transition {
+        /**
+         * @summary Transition action defalt template
+         */
+        type Action = Perform.Promise.Sync<TS.Type.Not.Function>;
+        /**
+         * @summary Set state function. ~Like `React`
+         */
+        type SetState<TState> = (newState: TState) => unknown;
+        /**
+         * @summary Transition props
+         */
+        type Props<TState> = {
+            state: Transition.SetState<TState>;
+            begin?: TState;
+            end: TState;
+        };
+        /**
+         * @summary Create transition overload
+         */
+        type Overload<TMetaDefaultAction extends Action = Action> = {
+            /**
+             * @summary Create transition
+             * @returns Transition object
+             */
+            <TState, TDefaultAction extends TMetaDefaultAction = TMetaDefaultAction>(state: SetState<TState>, end: TState): Transition<TDefaultAction>;
+            /**
+             * @summary Create transition
+             * @returns Transition object
+             */
+            <TState, TDefaultAction extends TMetaDefaultAction = TMetaDefaultAction>(state: SetState<TState>, begin: TState, end: TState): Transition<TDefaultAction>;
+            /**
+             * @summary Create transition
+             * @returns Transition object
+             */
+            <TState, TDefaultAction extends TMetaDefaultAction = TMetaDefaultAction>(props: Props<TState>): Transition<TDefaultAction>;
+        };
+        /**
+         * @summary Internal definition of transition
+         */
+        type Execute<TDefaultAction extends Action = Action> = {
+            <TAction extends Action = TDefaultAction>(action: TAction): Promise<Perform.Promise.Sync.Result<TAction>>;
+            /**
+             * @summary Nested transition factory
+             */
+            Nest: Overload<TDefaultAction>;
+        };
+    }
+    type Transition<TDefaultAction extends Transition.Action = Transition.Action> = Transition.Execute<TDefaultAction>;
+    interface Code {
+        /**
+         * @summary Transition factory.\
+         * Set `state` to `begin` -> await `action` -> `state` to `end`
+         */
+        Transition: AVStantso.Transition.Overload;
+    }
+    const Transition: Code['Transition'];
+}

package/dist/_global/value-wrap.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @summary Object wrap around value
+ */
+declare class AVStantso_ValueWrap<TValue = unknown> {
+    #private;
+    constructor(value: TValue);
+    protected static Clone<TThis extends typeof AVStantso_ValueWrap>(this: TThis, source: InstanceType<TThis>): InstanceType<TThis>;
+    protected toString(): string;
+    protected valueOf(): TValue;
+    get value(): TValue;
+}
+declare namespace AVStantso_ValueWrap { }

package/dist/_std-ext/abort-controller.d.ts

@@ -0,0 +1,7 @@
+interface AbortSignal {
+    /**
+     * @summary Stub for func/funcs if `aborted`
+     * @returns Stub for func/funcs. This stub prevent func call if `aborted`
+     */
+    Safe: AVStantso.Stub.One & AVStantso.Stub.Multiple;
+}

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

@@ -0,0 +1 @@
+import './abort-controller';

package/dist/export.d.ts

@@ -0,0 +1,16 @@
+import Perform = AVStantso.Perform;
+import Provider = AVStantso.Provider;
+import Compare = AVStantso.Compare;
+import Equality = AVStantso.Equality;
+import Extend = AVStantso.Extend;
+import Switch = AVStantso.Switch;
+import Stub = AVStantso.Stub;
+import Mock = AVStantso.Mock;
+import Mapping = AVStantso.Mapping;
+import Conveyor = AVStantso.Conveyor;
+import Override = AVStantso.Override;
+import Transition = AVStantso.Transition;
+import AsyncTasksManager = AVStantso.AsyncTasksManager;
+import ClassicEnum = AVStantso.ClassicEnum;
+import ValueWrap = AVStantso_ValueWrap;
+export { Perform, Provider, Compare, Equality, Extend, Switch, Stub, Mock, Mapping, Conveyor, Override, Transition, AsyncTasksManager, ClassicEnum, ValueWrap };

package/dist/index.d.ts

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