@avstantso/concepts 1.1.0 → 1.2.1

package/dist/index.js

@@ -0,0 +1,699 @@
+'use strict';
+
+require('@avstantso/errors');
+require('@avstantso/js');
+
+var AVStantso$e;
+(function (AVStantso) {
+    AVStantso.Perform = avstantso._reg.Perform(({ JS }) => {
+        function isOptions(candidate) {
+            return null !== candidate
+                && JS.is.object(candidate)
+                && ('afterCallback' in candidate || 'params' in candidate);
+        }
+        function parseSimpleOptions(inParams) {
+            return (isOptions(inParams[0])
+                ? { params: [], ...inParams[0] }
+                : { params: inParams });
+        }
+        function perform(p, ...inParams) {
+            const { afterCallback, params } = parseSimpleOptions(inParams);
+            const r = JS.is.function(p) ? p(...params) : p;
+            if (afterCallback)
+                afterCallback(r);
+            return r;
+        }
+        async function performPromise(p, ...inParams) {
+            const pR = await Promise.resolve(p);
+            const pP = perform(pR, ...inParams);
+            return Promise.resolve(pP);
+        }
+        function parseListOptions(inParams) {
+            const options = isOptions(inParams[0])
+                ? inParams.shift()
+                : undefined;
+            const params = Array.isArray(inParams[0])
+                ? inParams[0]
+                : inParams;
+            return [options, ...params];
+        }
+        function performList(...inParams) {
+            const [options, ...items] = parseListOptions(inParams);
+            const r = [];
+            for (let i = 0; i < items.length; i++) {
+                const item = perform(items[i], options);
+                if (Array.isArray(item))
+                    r.push(...item);
+                else
+                    r.push(item);
+            }
+            return r;
+        }
+        async function performPromiseList(...inParams) {
+            const [options, ...items] = parseListOptions(inParams);
+            const r = [];
+            for (let i = 0; i < items.length; i++) {
+                const item = await performPromise(items[i], options);
+                if (Array.isArray(item))
+                    r.push(...item);
+                else
+                    r.push(item);
+            }
+            return r;
+        }
+        const Perform = Object.assign(perform, {
+            Options: { is: isOptions },
+            List: performList,
+            Promise: Object.assign(performPromise, { List: performPromiseList })
+        });
+        return Perform;
+    });
+})(AVStantso$e || (AVStantso$e = {}));
+
+var AVStantso$d;
+(function (AVStantso) {
+    AVStantso.Compare = avstantso._reg.Compare(({ Perform }) => {
+        function Extend(compareFunc) {
+            return Object.defineProperties(compareFunc, {
+                as: { value: () => compareFunc },
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                desc: { value: (a, b) => compareFunc(b, a) }
+            });
+        }
+        function ToNulls(allowNaN, nullsFirst) {
+            return (x) => undefined === x
+                ? -3
+                : null === x
+                    ? -2
+                    : allowNaN && isNaN(x)
+                        ? -1
+                        : nullsFirst
+                            ? 0
+                            : -4;
+        }
+        function Select(...comparisons) {
+            for (const c of comparisons) {
+                const r = Perform(c);
+                if (r !== 0)
+                    return r;
+            }
+            return 0;
+        }
+        return { Extend, ToNulls, Select };
+    });
+})(AVStantso$d || (AVStantso$d = {}));
+
+(function (AVStantso) {
+    avstantso._reg.Compare.Combine(({ JS, Compare: { Extend } }) => {
+        function Combine(...compares) {
+            function combined(a, b) {
+                for (const cRaw of compares) {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    const c = JS.is.function(cRaw) ? cRaw : cRaw.Compare;
+                    const r = c(a, b);
+                    if (0 !== r)
+                        return r;
+                }
+                return 0;
+            }
+            return Extend(combined);
+        }
+        return Combine;
+    });
+})();
+
+(function (AVStantso) {
+    avstantso._reg.Compare.Structures(({ AtomicObjects: SimpleObjects, JS, Compare: { ToNulls, Extend } }) => {
+        const fo = [JS.function, JS.object];
+        const st = [JS.string, JS.symbol];
+        const nm = [JS.number, JS.bigint];
+        // eslint-disable-next-line  @typescript-eslint/no-explicit-any
+        function compareStructures(a, b) {
+            const t = { a: typeof a, b: typeof b };
+            let r = ToNulls(nm.includes(t.a))(a) - ToNulls(nm.includes(t.b))(b);
+            if (r !== 0)
+                return r;
+            function cmbBools({ a, b }) {
+                return (a ? 1 : 0) - (b ? 1 : 0);
+            }
+            const io = {
+                a: fo.includes(t.a),
+                b: fo.includes(t.b)
+            };
+            if (io.a !== io.b)
+                return cmbBools(io);
+            // Object/Function
+            if (io.a) {
+                const ia = { a: Array.isArray(a), b: Array.isArray(a) };
+                if (ia.a !== ia.b)
+                    return cmbBools(ia);
+                // Array
+                if (ia.a) {
+                    for (let la = a.length, lb = b.length, l = Math.max(la, lb), i = 0; i < l; i++) {
+                        if (i >= la)
+                            return -1;
+                        if (i >= lb)
+                            return 1;
+                        r = compareStructures(a[i], b[i]);
+                        if (r !== 0)
+                            return r;
+                    }
+                }
+                // not Array
+                else {
+                    const isSmp = { a: SimpleObjects.is(a), b: SimpleObjects.is(b) };
+                    if (isSmp.a !== isSmp.b)
+                        return cmbBools(isSmp);
+                    if (isSmp.a)
+                        return +a - +b;
+                    for (let aa = Object.entries(a), ab = Object.entries(b), la = aa.length, lb = ab.length, l = Math.max(la, lb), i = 0; i < l; i++) {
+                        if (i >= la)
+                            return -1;
+                        if (i >= lb)
+                            return 1;
+                        const [ka, va] = aa[i];
+                        const [kb, vb] = ab[i];
+                        r = compareStructures(ka, kb);
+                        if (r !== 0)
+                            return r;
+                        r = compareStructures(va, vb);
+                        if (r !== 0)
+                            return r;
+                    }
+                }
+                return 0;
+            }
+            // Simple type
+            else {
+                if (st.includes(t.a) && st.includes(t.b))
+                    return String(a).localeCompare(String(b));
+                if (nm.includes(t.a) && nm.includes(t.b))
+                    return +a - +b;
+                if (t.a !== t.b)
+                    return t.a.localeCompare(t.b);
+                return +a - +b;
+            }
+        }
+        return Extend(compareStructures);
+    });
+})();
+
+var AVStantso$c;
+(function (AVStantso) {
+    AVStantso.Provider = avstantso._reg.Provider({});
+})(AVStantso$c || (AVStantso$c = {}));
+
+(function (AVStantso) {
+    avstantso._reg.Provider.Is(({ TS, JS }) => {
+        function ProviderIs(...params) {
+            const [key, type] = TS.Type.KLD.Parse(params);
+            function is(candidate) {
+                if (null === candidate || !JS.is.object(candidate) || !(key in candidate))
+                    return false;
+                const value = candidate[key];
+                return !type || TS.Literal.IsValue(type, value);
+            }
+            return is;
+        }
+        return ProviderIs;
+    });
+})();
+
+(function (AVStantso) {
+    avstantso._reg.Provider.Extract(({ TS, JS }) => {
+        function ProviderExtract(...params) {
+            const [key, type] = TS.Type.KLD.Parse(params);
+            function extract(union) {
+                return undefined === union || null === union || TS.Literal.IsValue(type, union)
+                    ? union
+                    : JS.is.object(union)
+                        ? union[key]
+                        : undefined;
+            }
+            return extract;
+        }
+        return ProviderExtract;
+    });
+})();
+
+(function (AVStantso) {
+    avstantso._reg.Provider.Compare(({ TS, Compare: { Extend, ToNulls }, Provider: { Extract } }) => {
+        function Compare(...params) {
+            const L = TS.Literal;
+            const [key, type] = TS.Type.KLD.Parse(params);
+            const { extract } = (params[Array.isArray(params[0]) ? 1 : 2] || {
+                extract: Extract(key, type)
+            });
+            /* eslint-disable @typescript-eslint/no-explicit-any */
+            function compare(a, b) {
+                const ea = extract(a);
+                const eb = extract(b);
+                const toNulls = ToNulls(type === L.number);
+                {
+                    const nr = toNulls(ea) - toNulls(eb);
+                    if (nr)
+                        return nr;
+                }
+                if (L.Buffer === type && a instanceof Buffer && b instanceof Buffer)
+                    return a.toString('hex').localeCompare(b.toString('hex'));
+                if (L.string !== type && L.symbol !== type)
+                    return +ea - +eb;
+                const sa = String(ea || '');
+                const sb = String(eb || '');
+                return sa.localeCompare(sb);
+            }
+            return Extend(compare);
+        }
+        return Compare;
+    });
+})();
+
+(function (AVStantso) {
+    avstantso._reg.Provider.Force(({ Generic }) => (function Force() {
+        return Generic.Cast;
+    }));
+})();
+
+var AVStantso$b;
+(function (AVStantso) {
+    AVStantso.Equality = avstantso._reg.Equality(() => {
+        const PredicateFactory = (equality) => (a, notEquals) => (b) => {
+            const r = equality(a, b);
+            return notEquals ? !r : !!r;
+        };
+        const From = (compare) => {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            function equality(a, b) {
+                return !compare(a, b);
+            }
+            equality.as = () => equality;
+            return equality;
+        };
+        return { Predicate: { Factory: PredicateFactory }, From };
+    });
+})(AVStantso$b || (AVStantso$b = {}));
+
+var AVStantso$a;
+(function (AVStantso) {
+    /* eslint-disable @typescript-eslint/no-unsafe-function-type, @typescript-eslint/no-explicit-any */
+    /**
+     * @summary Cast object or function for add extended fields
+     * @param from as TFrom
+     * @returns from as TTo
+     */
+    AVStantso.Extend = avstantso._reg.Extend(({ JS }) => {
+        function extendByRecord(keys, getValue) {
+            function MKM(transformKey) {
+                function MK(isStatic) {
+                    const f0 = (original, extender) => {
+                        (JS.is.function(keys) ? keys() : keys).forEach((key) => {
+                            if (transformKey && !JS.is.string(key))
+                                throw new AVStantso_SystemError(`Extend.ByRecord.Capitalized/Uncapitalized not support "${typeof key}" keys ("${String(key)}")`);
+                            const customKey = (transformKey ? transformKey(key) : key);
+                            function _extender() {
+                                return extender.call(this, getValue ? getValue(key) : key, original, key);
+                            }
+                            if (isStatic)
+                                Object.assign(original, { [customKey]: _extender() });
+                            else
+                                Object.defineProperty(original, customKey, {
+                                    get: _extender
+                                });
+                        });
+                        return original;
+                    };
+                    return f0;
+                }
+                const f1 = MK();
+                f1.static = MK(true);
+                return f1;
+            }
+            const f2 = MKM();
+            f2.Capitalized = MKM((key) => String(key).toCapitalized());
+            f2.Uncapitalized = MKM((key) => String(key).toUncapitalized());
+            return f2;
+        }
+        function extendArbitrary(original, extention) {
+            const e = JS.is.function(extention) ? extention() : extention;
+            return Object.assign(original, e);
+        }
+        return {
+            ByRecord: extendByRecord,
+            Arbitrary: extendArbitrary
+        };
+    });
+})(AVStantso$a || (AVStantso$a = {}));
+
+var AVStantso$9;
+(function (AVStantso) {
+    /* eslint-disable @typescript-eslint/no-empty-object-type */
+    AVStantso.Switch = avstantso._reg.Switch(() => {
+        return (getKey) => {
+            function _switch(value, cases) {
+                /* eslint-disable no-fallthrough */
+                switch (value) {
+                    case undefined:
+                        if ('undefined' in cases)
+                            return cases.undefined;
+                    case null:
+                        if ('null' in cases)
+                            return cases.null;
+                    default: {
+                        const key = String(getKey(value));
+                        return key in cases ? cases[key] : cases.default;
+                    }
+                }
+            }
+            return Object.assign(_switch, {
+                reversed(cases, value) {
+                    return _switch(value, cases);
+                }
+            });
+        };
+    });
+})(AVStantso$9 || (AVStantso$9 = {}));
+
+var AVStantso$8;
+(function (AVStantso) {
+    /* eslint-disable @typescript-eslint/no-unsafe-function-type, @typescript-eslint/no-explicit-any */
+    AVStantso.Stub = avstantso._reg.Stub(({ X }) => {
+        function customStub(stub) {
+            return ((...params) => 1 === params.length ? stub(params[0]) : params.map(stub));
+        }
+        return Object.assign(customStub((func) => func || X), {
+            Custom: customStub
+        });
+    });
+})(AVStantso$8 || (AVStantso$8 = {}));
+
+var AVStantso$7;
+(function (AVStantso) {
+    AVStantso.Mock = avstantso._reg.Mock(({ JS, X }) => {
+        function Mock(source, doNotUseMocking) {
+            return new Proxy(source, {
+                get: (target, p) => {
+                    const src = Reflect.get(target, p);
+                    return doNotUseMocking
+                        ? src
+                        : JS.is.function(src)
+                            ? X
+                            : undefined;
+                }
+            });
+        }
+        return Mock;
+    });
+})(AVStantso$7 || (AVStantso$7 = {}));
+
+var AVStantso$6;
+(function (AVStantso) {
+    AVStantso.Mapping = avstantso._reg.Mapping(({ TS, JS }) => ((...params) => {
+        const subSwitch = (i) => ({
+            object: () => ({ map: params[i] }),
+            function: () => ({ keyFromValue: params[i], map: params[i + 1] }),
+            default: () => {
+                throw new AVStantso_InvalidArgumentTypeError('AVStantso', 'Mapping', [!i && JS.string, JS.object, JS.function].pack().join('|'), { [`param${i}`]: params[i] });
+            }
+        });
+        /* eslint-disable @typescript-eslint/no-explicit-any */
+        const { field, keyFromValue, map } = JS.switch(params[0], {
+            ...subSwitch(0),
+            string: () => ({
+                field: params[0],
+                ...JS.switch(params[1], subSwitch(1))
+            }),
+            undefined: () => JS.switch(params[1], subSwitch(1))
+        });
+        const kfv = keyFromValue || TS.Structure.keyByValue.bind(null, field, map);
+        return (template) => (value) => template[kfv(value)];
+    }));
+})(AVStantso$6 || (AVStantso$6 = {}));
+
+var AVStantso$5;
+(function (AVStantso) {
+    AVStantso.Conveyor = avstantso._reg.Conveyor(({ JS }) => function Conveyor(original, ...transformers) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        let r = original;
+        if (r && JS.is.object(r))
+            r = Array.isArray(r) ? [...r] : { ...r };
+        for (const t of transformers)
+            if (t)
+                r = t.call(r, r);
+        return r;
+    });
+})(AVStantso$5 || (AVStantso$5 = {}));
+
+var AVStantso$4;
+(function (AVStantso) {
+    /* eslint-disable @typescript-eslint/no-empty-object-type, @typescript-eslint/no-explicit-any */
+    AVStantso.Override = avstantso._reg.Override(({ JS, Perform }) => {
+        function isContext(candidate) {
+            return (null !== candidate && JS.is.object(candidate) && 'original' in candidate);
+        }
+        function Calculator(context) {
+            const c = isContext(context) ? context : { original: context };
+            return function override(override) {
+                const r = undefined === override ? c.original : Perform(override, c);
+                return r;
+            };
+        }
+        return {
+            isContext,
+            Calculator
+        };
+    });
+})(AVStantso$4 || (AVStantso$4 = {}));
+
+var AVStantso$3;
+(function (AVStantso) {
+    /* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-function-type */
+    AVStantso.Transition = avstantso._reg.Transition(({ JS, Perform }) => {
+        function Transition(parent, ...params) {
+            const isProps = JS.is.object(params[0]);
+            const state = isProps ? params[0].state : params[0];
+            const begin = isProps ? params[0].begin : params[params.length <= 2 ? undefined : 1];
+            const end = isProps ? params[0].end : params[params.length <= 2 ? 1 : 2];
+            const hasBegin = isProps ? 'begin' in params[0] : params.length > 2;
+            function transition(action) {
+                return Promise.resolve()
+                    .then(() => hasBegin && state(begin))
+                    .then(() => Perform.Promise(action))
+                    .finally(() => state(end));
+            }
+            const curTransition = parent
+                ? function transitionNested(action) {
+                    return parent(() => transition(action));
+                }
+                : transition;
+            function Nest(...params) {
+                return Transition(curTransition, ...params);
+            }
+            return Object.assign(curTransition, { Nest });
+        }
+        return Transition.bind(null, null);
+    });
+})(AVStantso$3 || (AVStantso$3 = {}));
+
+/**
+ * @summary Object wrap around value
+ */
+let AVStantso_ValueWrap$1 = class AVStantso_ValueWrap {
+    #value;
+    constructor(value) {
+        this.#value = value;
+    }
+    static Clone(source) {
+        return Object.assign(new this(source.value), source);
+    }
+    toString() {
+        return this.#value.toString();
+    }
+    valueOf() {
+        return this.#value;
+    }
+    get value() {
+        return this.#value;
+    }
+};
+if (!('AVStantso_ValueWrap' in globalThis))
+    Object.defineProperties(globalThis, {
+        AVStantso_ValueWrap: {
+            value: AVStantso_ValueWrap$1,
+            writable: false,
+            configurable: false
+        }
+    });
+avstantso.AtomicObjects.register(AVStantso_ValueWrap$1, {
+    empty: () => new AVStantso_ValueWrap$1(null),
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    clone: (instance) => instance.constructor.Clone(instance)
+});
+
+var AVStantso$2;
+(function (AVStantso) {
+    AVStantso.AsyncTasksManager = avstantso._reg.AsyncTasksManager(({ symbolFreeze, JS }) => {
+        const symbolATM = Symbol('AsyncTasksManager');
+        function isAsyncTasksManager(candidate) {
+            return candidate && JS.is.structure(candidate) && (symbolATM in candidate);
+        }
+        const onCreateExtenders = [];
+        function AsyncTasksManagerCreate() {
+            const intervals = new Map();
+            const timeouts = new Map();
+            const tasks = new Set();
+            const MAPS = [
+                { intervals, clearInterval, setInterval },
+                { timeouts, clearTimeout, setTimeout }
+            ];
+            const errors = [];
+            let isFinalizig = false;
+            function throwIfFinal() {
+                if (isFinalizig)
+                    throw new AVStantso_InvalidStateError('AsyncTasksManager', 'finalizig', "Can't interact with %C on %S");
+            }
+            async function final(options) {
+                const { quiet } = options || {};
+                isFinalizig = true;
+                const promises = [...tasks];
+                for (const mapInfo of MAPS) {
+                    const [map, clear] = Object.values(mapInfo);
+                    for (const [t, [c, { callOnFinal } = {}]] of map) {
+                        if (callOnFinal)
+                            promises.push(Promise.resolve(0)
+                                .then(() => c(true))
+                                .catch((e) => errors.push(e)));
+                        clear(t);
+                    }
+                }
+                await Promise.all(promises);
+                if (!quiet)
+                    for (const e of errors)
+                        console.error(e);
+            }
+            function regTask(task) {
+                throwIfFinal();
+                const p = task
+                    .catch((e) => {
+                    if (isFinalizig)
+                        errors.push(e);
+                    else
+                        throw e;
+                })
+                    .finally(() => tasks.delete(p));
+                tasks.add(p);
+                return p;
+            }
+            const instance = {
+                final,
+                regTask,
+                get errors() {
+                    return isFinalizig ? errors : undefined;
+                }
+            };
+            for (const MAP of MAPS) {
+                const [[, map], [kClear, vClear], [kSet, vSet]] = Object.entries(MAP);
+                Object.assign(instance, {
+                    [kSet](callback, delay, options) {
+                        throwIfFinal();
+                        const t = vSet(callback, delay);
+                        map.set(t, [callback, options]);
+                        return t;
+                    },
+                    [kClear](timeout) {
+                        vClear(timeout);
+                        map.delete(timeout);
+                    }
+                });
+            }
+            for (const cb of onCreateExtenders)
+                cb(instance);
+            return instance;
+        }
+        function AsyncTasksManagerFactory(target) {
+            let instance;
+            return new Proxy(target, {
+                has(target, p) {
+                    return symbolATM === p ? true : Reflect.has(target, p);
+                },
+                get(target, p) {
+                    const r = Reflect.get(target, p);
+                    if (undefined !== r)
+                        return r;
+                    if (!instance)
+                        instance = AsyncTasksManagerCreate();
+                    return Reflect.get(instance, p);
+                }
+            });
+        }
+        const globalATM = ({
+            _RegOnCreate(extenderCallback) {
+                onCreateExtenders.push(extenderCallback);
+            },
+            Factory: AsyncTasksManagerFactory.bind(null, {}),
+            is: isAsyncTasksManager,
+            [symbolFreeze]() {
+                delete this._RegOnCreate;
+            }
+        });
+        return AsyncTasksManagerFactory(globalATM);
+    });
+})(AVStantso$2 || (AVStantso$2 = {}));
+
+var AVStantso$1;
+(function (AVStantso) {
+    AVStantso.ClassicEnum = avstantso._reg.ClassicEnum(({ JS }) => {
+        function entries(enumType) {
+            if (!enumType || !JS.is.object(enumType))
+                return [];
+            const entries = [];
+            for (const [k, v] of Object.entries(enumType))
+                if (!/^\d+$/.test(k))
+                    entries.push([k, v]);
+            return entries;
+        }
+        return { entries };
+    });
+})(AVStantso$1 || (AVStantso$1 = {}));
+
+Object.definePropertiesOnce(AbortSignal.prototype, {
+    Safe: {
+        get() {
+            return avstantso.Stub.Custom((func) => ((...params) => this.aborted || !func ? undefined : func(...params)
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            ));
+        }
+    }
+});
+
+var Perform = AVStantso.Perform;
+var Provider = AVStantso.Provider;
+var Compare = AVStantso.Compare;
+var Equality = AVStantso.Equality;
+var Extend = AVStantso.Extend;
+var Switch = AVStantso.Switch;
+var Stub = AVStantso.Stub;
+var Mock = AVStantso.Mock;
+var Mapping = AVStantso.Mapping;
+var Conveyor = AVStantso.Conveyor;
+var Override = AVStantso.Override;
+var Transition = AVStantso.Transition;
+var AsyncTasksManager = AVStantso.AsyncTasksManager;
+var ClassicEnum = AVStantso.ClassicEnum;
+var ValueWrap = AVStantso_ValueWrap;
+
+exports.AsyncTasksManager = AsyncTasksManager;
+exports.ClassicEnum = ClassicEnum;
+exports.Compare = Compare;
+exports.Conveyor = Conveyor;
+exports.Equality = Equality;
+exports.Extend = Extend;
+exports.Mapping = Mapping;
+exports.Mock = Mock;
+exports.Override = Override;
+exports.Perform = Perform;
+exports.Provider = Provider;
+exports.Stub = Stub;
+exports.Switch = Switch;
+exports.Transition = Transition;
+exports.ValueWrap = ValueWrap;
+//# sourceMappingURL=index.js.map