@actdim/utico 0.9.0

package/dist/typeUtils.es.js

@@ -0,0 +1,227 @@
+function a(t) {
+  return Object.keys(t);
+}
+function R(t, e, n = !0) {
+  if (!t || !e)
+    return;
+  let o = String(e).trim();
+  const f = a(t);
+  let u;
+  return n ? (o = o.toLowerCase(), u = f.find((r) => String(r).toLowerCase().trim() === o)) : u = f.find((r) => String(r).trim() === o), [u, u == null ? void 0 : t[u]];
+}
+function b() {
+  return (t) => t;
+}
+const h = (t, e) => t;
+function g(t) {
+  const e = new Proxy(
+    {},
+    {
+      get: (n, o) => o
+    }
+  );
+  return t(e);
+}
+function v(t) {
+  return new Proxy(
+    {},
+    {
+      get: (e, n) => n
+    }
+  );
+}
+function E(t) {
+  return {
+    nameOf: (e) => g(e)
+  };
+}
+function C(t) {
+  return d(t);
+}
+function d(t, e) {
+  e == null && (e = []);
+  let n;
+  return n = () => new Proxy(
+    {},
+    {
+      get: (o, f) => (e.push(f), n())
+    }
+  ), t(n()), e;
+}
+function I(t) {
+  const e = [];
+  for (const n of t)
+    e.push(`["${n.toString()}"]`);
+  return e.join("");
+}
+const O = [String, Number];
+function P(t) {
+  return O.indexOf(t) >= 0;
+}
+function $(t) {
+  if (P(t))
+    return t;
+  {
+    let e = function(...n) {
+      return new t(...n);
+    };
+    return e.prototype = t.prototype, e;
+  }
+}
+function j(t) {
+  const e = [];
+  let n;
+  for (; n = Object.getPrototypeOf(n || t), !!n; )
+    e.push(n);
+  return e;
+}
+function J(t) {
+  return new Proxy(
+    {},
+    {
+      get: (e, n) => Reflect.get(t(), n),
+      set: (e, n, o) => Reflect.set(t(), n, o)
+    }
+  );
+}
+function M(t, e, n) {
+  let o = e ? t[e] : n;
+  return o == null && (o = n), o;
+}
+function L(t) {
+  return w(t).map((e) => t[e]);
+}
+function w(t) {
+  return Object.keys(t).filter((e) => Number.isNaN(Number(e))).map((e) => e);
+}
+function m(t, e, n) {
+  const o = t;
+  if (e)
+    for (const f in e) {
+      let u = e[f];
+      n && n(f, u, (i) => {
+        Reflect.set(o, f, i);
+      });
+    }
+  return o;
+}
+function x(t, e, n) {
+  const o = new Set(n);
+  return m(t, e, (f, u, r) => {
+    (!o.size || o.has(f)) && r(u);
+  });
+}
+function W(t, e, n) {
+  return x(e, t, n);
+}
+function S(t) {
+  if (Object.prototype.toString.call(t) !== "[object Object]") return !1;
+  const e = Object.getPrototypeOf(t);
+  return e === null || e === Object.prototype;
+}
+const k = /* @__PURE__ */ (() => {
+  const t = [];
+  function e(n, o) {
+    const f = n ? Object.keys(n) : t;
+    o && (o = (i, c) => c.localeCompare(i));
+    const u = f.sort(o), r = {};
+    for (const i of u)
+      r[i] = S(n[i]) ? e(n[i]) : n[i];
+    return r;
+  }
+  return e;
+})(), l = (t, e, n, o) => JSON.stringify(k(t, e), n, o);
+function _(t, e) {
+  return l(t) === l(e);
+}
+function q(t) {
+  const e = typeof t;
+  if (e !== "object")
+    throw new Error(`Unsupported object type: ${e}`);
+  return t && JSON.parse(JSON.stringify(t));
+}
+const N = Symbol("__lock");
+function z(t, e = !1) {
+  return y(t, e);
+}
+function y(t, e = !1, n) {
+  if (typeof t != "object" || !t)
+    return t;
+  let o = !0;
+  n || (n = () => o);
+  const f = new Proxy(t, {
+    get: (u, r, i) => {
+      if (Reflect.has(u, r))
+        return y(u[r], e, n);
+    },
+    set: (u, r, i, c) => {
+      if (n()) {
+        if (e)
+          throw new Error("Cannot set the value of read-only property");
+        return !0;
+      } else
+        return Reflect.set(u, r, i);
+    }
+  });
+  return f[N] = (u) => {
+    o = u;
+  }, f;
+}
+function D(t, e) {
+  const n = /* @__PURE__ */ new WeakMap();
+  function o(r) {
+    return {
+      set(i, c, s, p) {
+        return typeof s == "object" && (s = u(s, [...r, c])), i[c] = s, e.set && e.set(i, [...r, c], s, p), !0;
+      },
+      deleteProperty(i, c) {
+        if (Reflect.has(i, c)) {
+          f(i, c);
+          let s = Reflect.deleteProperty(i, c);
+          return s && e.deleteProperty && e.deleteProperty(i, [...r, c]), s;
+        }
+        return !1;
+      }
+    };
+  }
+  function f(r, i) {
+    n.has(r[i]) && (r[i] = n.get(r[i]), n.delete(r[i]));
+    for (let c of Object.keys(r[i]))
+      typeof r[i][c] == "object" && f(r[i], c);
+  }
+  function u(r, i) {
+    for (let s of Object.keys(r))
+      typeof r[s] == "object" && (r[s] = u(r[s], [...i, s]));
+    let c = new Proxy(r, o(i));
+    return n.set(c, r), c;
+  }
+  return u(t, []);
+}
+export {
+  v as $keyMap,
+  E as $nh,
+  m as assignWith,
+  I as combinePropertyPath,
+  W as copy,
+  $ as createConstructor,
+  D as createDeepProxy,
+  R as entry,
+  w as getEnumKeys,
+  M as getEnumValue,
+  L as getEnumValues,
+  C as getPropertyPath,
+  j as getPrototypes,
+  S as isPlainObject,
+  q as jsonClone,
+  _ as jsonEquals,
+  h as keyOf,
+  a as keysOf,
+  N as lock,
+  g as nameOf,
+  l as orderedStringify,
+  J as proxify,
+  b as satisfies,
+  z as toReadOnly,
+  x as update
+};
+//# sourceMappingURL=typeUtils.es.js.map

package/dist/typeUtils.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeUtils.es.js","sources":["../src/typeUtils.ts"],"sourcesContent":["import { CallableConstructor, Constructor, ConstructorClass } from \"./typeCore\";\r\n\r\n// @filename: typeUtils.ts\r\n\r\n// typed version of Object.keys\r\nexport function keysOf<T extends object>(obj: T) {\r\n    return Object.keys(obj) as Array<keyof T>;\r\n}\r\n\r\nexport function entry<T extends object, TKey extends keyof T>(obj: T, name: TKey, caseInsensitive = true) {\r\n    if (!obj || !name) {\r\n        return undefined;\r\n    }\r\n    // name.toString()\r\n    let nameStr = String(name).trim();\r\n    const keys = keysOf(obj);\r\n    let key: keyof T;\r\n    if (caseInsensitive) {\r\n        nameStr = nameStr.toLowerCase();\r\n        key = keys.find((k) => String(k).toLowerCase().trim() === nameStr);\r\n    } else {\r\n        key = keys.find((k) => String(k).trim() === nameStr);\r\n    }\r\n    return [key, key == undefined ? undefined : (obj[key] as T[TKey])] as [TKey, T[TKey]];\r\n}\r\n\r\nexport function satisfies<TShape>() {\r\n    return <T extends TShape>(obj: T) => obj;\r\n}\r\n\r\n// $keyOf\r\nexport const keyOf = <T extends object, TKey extends keyof T = keyof T>(key: TKey, obj?: T) => key;\r\n\r\n// $nameOf/$n\r\nexport function nameOf<T extends object>(f: (x: T) => T[keyof T]): keyof T;\r\nexport function nameOf(f: (x: any) => any): keyof any {\r\n    const p = new Proxy(\r\n        {},\r\n        {\r\n            get: (target, key) => key\r\n        }\r\n    );\r\n    return f(p);\r\n}\r\n\r\ntype $KeyMap<T extends object> = {\r\n    [K in keyof T]: K;\r\n};\r\n\r\nexport function $keyMap<T extends object>(obj?: T) {\r\n    return new Proxy(\r\n        {},\r\n        {\r\n            get: (target, key) => key\r\n        }\r\n    ) as $KeyMap<T>;\r\n}\r\n\r\n// $NU\r\ntype $NH<T> = {\r\n    nameOf(f: (x: T) => T[keyof T]): keyof T;\r\n};\r\n\r\n// $nu\r\n// usage: $nh(obj).nameOf(x => x.prop) or $NH<ClassName>().nameOf(x => x.prop)\r\nexport function $nh<T>(obj?: T) {\r\n    return {\r\n        nameOf: (f: (x: any) => any) => {\r\n            return nameOf(f);\r\n        }\r\n    } as $NH<T>;\r\n}\r\n\r\nexport function getPropertyPath<T>(expr: (x: T) => any) {\r\n    return getPropertyPathInternal(expr);\r\n}\r\n\r\nfunction getPropertyPathInternal<T>(expr: (x: T) => any, path?: (string | number | symbol)[]) {\r\n    if (path == undefined) {\r\n        path = [];\r\n    }\r\n    let createProxy: () => any;\r\n    createProxy = () => {\r\n        return new Proxy(\r\n            {},\r\n            {\r\n                get: (target, key) => {\r\n                    path.push(key);\r\n                    return createProxy();\r\n                }\r\n            }\r\n        );\r\n    };\r\n    expr(createProxy());\r\n    return path;\r\n}\r\n\r\nexport function combinePropertyPath(path?: (string | number | symbol)[]) {\r\n    const builder: string[] = [];\r\n    for (const key of path) {\r\n        builder.push(`[\"${key.toString()}\"]`);\r\n    }\r\n    return builder.join(\"\");\r\n}\r\n\r\nconst nonObjectTypes: Constructor[] = [String, Number];\r\n\r\n// isNonObjectCtor\r\nfunction isNonObjectType<TConstructor extends Constructor>(type: TConstructor) {\r\n    return nonObjectTypes.indexOf(type) >= 0;\r\n}\r\n\r\n// getConstructor\r\nexport function createConstructor<TConstructor extends Constructor>(\r\n    type: TConstructor // ctor\r\n): CallableConstructor<TConstructor> {\r\n    if (isNonObjectType(type)) {\r\n        return type as CallableConstructor<TConstructor>;\r\n    } else {\r\n        function createInstance(...args: ConstructorParameters<TConstructor>): ConstructorClass<TConstructor> {\r\n            // return Reflect.construct(type, args); // works too\r\n            return new type(...args);\r\n        }\r\n\r\n        createInstance.prototype = type.prototype;\r\n        return createInstance as CallableConstructor<TConstructor>;\r\n    }\r\n}\r\n\r\nexport function getPrototypes(obj: any) {\r\n    const result = [];\r\n    let prototype;\r\n    while (true) {\r\n        prototype = Object.getPrototypeOf(prototype || obj);\r\n        if (!prototype) {\r\n            break;\r\n        }\r\n        result.push(prototype);\r\n    }\r\n    return result;\r\n}\r\n\r\nexport function proxify<T extends object>(source: () => T): T {\r\n    return new Proxy(\r\n        {},\r\n        {\r\n            get: (target, key) => {\r\n                return Reflect.get(source(), key);\r\n                // return source()[key];\r\n            },\r\n            set: (target, key, value) => {\r\n                return Reflect.set(source(), key, value);\r\n                // source()[key] = value;\r\n                // return true;\r\n            }\r\n        }\r\n    ) as T;\r\n}\r\n\r\nexport function getEnumValue<T>(enumType: T, name: string, defaultValue: T[keyof T]): T[keyof T] {\r\n    let value = name ? enumType[name as keyof T] : defaultValue;\r\n    if (value == undefined) {\r\n        value = defaultValue;\r\n    }\r\n    return value;\r\n}\r\n\r\nexport function getEnumValues<T extends object, K extends keyof T>(enumType: T): Array<T[K]> {\r\n    return getEnumKeys<T, K>(enumType).map((x) => enumType[x]);\r\n}\r\n\r\nexport function getEnumKeys<T extends object, K extends keyof T>(enumType: T): Array<K> {\r\n    return Object.keys(enumType)\r\n        .filter((x) => Number.isNaN(Number(x)))\r\n        .map((x) => x as K);\r\n}\r\n\r\n// conditional assign with value factory\r\nexport function assignWith<T extends object, U extends object>(\r\n    dst: T,\r\n    src: U,\r\n    callback?: (key: keyof U, value: U[keyof U], set: (value: U[keyof U]) => void) => any\r\n): T & Partial<U> {\r\n    const result: T & Partial<U> = dst;\r\n    if (src) {\r\n        for (const key in src) {\r\n            let value = src[key];\r\n            const set = (v: U[keyof U]) => {\r\n                // result[key as PropertyKey] = value;\r\n                Reflect.set(result, key, v);\r\n            };\r\n            if (callback) {\r\n                callback(key, value, set);\r\n            }\r\n        }\r\n    }\r\n    return result;\r\n}\r\n\r\n// constrained and typed assign\r\nexport function update<T extends object, U extends Partial<T>>(dst: T, src: U, props?: [keyof U]): T & Partial<U> {\r\n    const propSet = new Set(props);\r\n\r\n    return assignWith(dst, src, (key, value, set) => {\r\n        if (!propSet.size || propSet.has(key)) {\r\n            set(value);\r\n        }\r\n    });\r\n\r\n    // for (const prop of props) {\r\n    //     // dst[prop as PropertyKey] = src[prop];\r\n    //     Reflect.set(dst, prop, src[prop]);\r\n    // }\r\n    // return dst;\r\n}\r\n\r\nexport function copy<T extends object, U extends object>(src: T, dst: U, props?: [keyof T]): U & Partial<T> {\r\n    return update(dst, src, props);\r\n}\r\n\r\nexport function isPlainObject(value) {\r\n  if (Object.prototype.toString.call(value) !== '[object Object]') return false;\r\n  const proto = Object.getPrototypeOf(value);\r\n  return proto === null || proto === Object.prototype;\r\n}\r\n\r\nconst sort = (() => {\r\n    // It relies on Chrome's and Node's behaviour that the first key assigned to an object is outputted first by JSON.stringify.\r\n    const noKeys = []; // emptyKeys\r\n    function sortImpl(obj: any, keyCompareFn?: (a: string, b: string) => number) {\r\n        const keys = obj ? Object.keys(obj) : noKeys;\r\n        // const orderedKeys = desc ? keys.orderByDesc(k => k) : keys.orderBy(k => k);\r\n        if (keyCompareFn) {\r\n            // array sort method without compare function produces ascending but alphabetical, lexicographic (dictionary) order\r\n            keyCompareFn = (a, b) => b.localeCompare(a);\r\n        }\r\n        const orderedKeys = keys.sort(keyCompareFn);\r\n        // result\r\n        const container = {}; // sortedObj\r\n        for (const key of orderedKeys) {\r\n            container[key] = isPlainObject(obj[key]) ? sortImpl(obj[key]) : obj[key];\r\n        }\r\n        return container;\r\n    }\r\n    return sortImpl;\r\n})();\r\n\r\n// stableStringify\r\nexport const orderedStringify = (() => {\r\n    // https://www.gangofcoders.net/solution/sort-object-properties-and-json-stringify/\r\n    // see also: https://www.npmjs.com/package/json-stable-stringify\r\n    return (\r\n        obj: any,\r\n        keyCompareFn?: (a: string, b: string) => number,\r\n        replacer?: (this: any, key: string, value: any) => any,\r\n        // replacer?: (number | string)[] | null,\r\n        space?: string | number\r\n    ) => {\r\n        return JSON.stringify(sort(obj, keyCompareFn), replacer, space);\r\n    };\r\n})();\r\n\r\n// structural comparison helper\r\nexport function jsonEquals<T>(obj1: T, obj2: T) {\r\n    // contentEquals\r\n    return orderedStringify(obj1) === orderedStringify(obj2);\r\n}\r\n\r\n/** structuredClone alternative */\r\nexport function jsonClone<T extends object>(obj: T): T {\r\n    const type = typeof obj;\r\n    if (type !== \"object\") {\r\n        throw new Error(`Unsupported object type: ${type}`);\r\n    }\r\n    if (!obj) {\r\n        return obj;\r\n    }\r\n    return JSON.parse(JSON.stringify(obj));\r\n}\r\n\r\n// freeze\r\nexport const lock = Symbol(\"__lock\");\r\n\r\n// IFreezable\r\nexport type ILockable<T = any> = Readonly<T> & { [lock]?: (locked: boolean) => void };\r\n\r\n// deepFreeze/lock\r\nexport function toReadOnly<T extends object>(obj: T, throwOnSet: boolean = false): ILockable<T> {\r\n    return toReadOnlyInternal(obj, throwOnSet);\r\n}\r\n\r\nfunction toReadOnlyInternal<T extends object>(obj: T, throwOnSet: boolean = false, lockTest?: () => boolean): ILockable<T> {\r\n    if (typeof obj !== \"object\" || !obj) {\r\n        return obj;\r\n    }\r\n\r\n    let locked = true;\r\n    if (!lockTest) {\r\n        lockTest = () => locked;\r\n    }\r\n\r\n    const result = new Proxy(obj, {\r\n        get: (target, property, receiver) => {\r\n            // property in target\r\n            if (Reflect.has(target, property)) {\r\n                // Reflect.get(target, property)\r\n                return toReadOnlyInternal(target[property], throwOnSet, lockTest);\r\n            }\r\n            return undefined;\r\n        },\r\n        set: (target, property, value, receiver) => {\r\n            if (lockTest()) {\r\n                if (throwOnSet) {\r\n                    throw new Error(\"Cannot set the value of read-only property\"); // read-only object\r\n                }\r\n                // return false; // will throw a TypeError exception in strict mode\r\n                return true;\r\n            } else {\r\n                // target[property] = value;\r\n                return Reflect.set(target, property, value);\r\n            }\r\n        }\r\n    });\r\n\r\n    result[lock] = (l: boolean) => {\r\n        locked = l;\r\n    };\r\n    return result as Readonly<T> & { [lock]: (locked: boolean) => void };\r\n}\r\n\r\nexport type DeepPropertyKey = PropertyKey[];\r\n\r\nexport interface DeepProxyHandler<T extends object> {\r\n    // getPrototypeOf?(target: T): object | null;\r\n    // setPrototypeOf?(target: T, v: any): boolean;\r\n    // isExtensible?(target: T): boolean;\r\n    // preventExtensions?(target: T): boolean;\r\n    // getOwnPropertyDescriptor?(target: T, p: DeepPropertyKey): PropertyDescriptor | undefined;\r\n    // has?(target: T, p: DeepPropertyKey): boolean;\r\n    // get?(target: T, p: DeepPropertyKey, receiver: any): any;\r\n    set?(target: T, p: DeepPropertyKey, value: any, receiver: any): boolean;\r\n\r\n    deleteProperty?(target: T, p: DeepPropertyKey): boolean;\r\n\r\n    // defineProperty?(target: T, p: DeepPropertyKey, attributes: PropertyDescriptor): boolean;\r\n    // enumerate?(target: T): DeepPropertyKey[];\r\n    // ownKeys?(target: T): DeepPropertyKey[];\r\n    // apply?(target: T, thisArg: any, argArray?: any): any; // assign\r\n    // construct?(target: T, argArray: any, newTarget?: any): object;\r\n}\r\n\r\nexport function createDeepProxy<T extends object>(target: T, handler: DeepProxyHandler<T>) {\r\n    const proxyMap = new WeakMap();\r\n\r\n    function makeHandler(path: DeepPropertyKey) {\r\n        return {\r\n            set(target: any, propertyKey: PropertyKey, value: any, receiver) {\r\n                if (typeof value === \"object\") {\r\n                    value = proxify(value, [...path, propertyKey]);\r\n                }\r\n                target[propertyKey] = value;\r\n\r\n                if (handler.set) {\r\n                    handler.set(target, [...path, propertyKey], value, receiver);\r\n                }\r\n                return true;\r\n            },\r\n\r\n            deleteProperty(target: any, propertyKey: PropertyKey) {\r\n                if (Reflect.has(target, propertyKey)) {\r\n                    unproxy(target, propertyKey);\r\n                    let deleted = Reflect.deleteProperty(target, propertyKey);\r\n                    if (deleted && handler.deleteProperty) {\r\n                        handler.deleteProperty(target, [...path, propertyKey]);\r\n                    }\r\n                    return deleted;\r\n                }\r\n                return false;\r\n            }\r\n        };\r\n    }\r\n\r\n    function unproxy(obj: any, key: PropertyKey) {\r\n        if (proxyMap.has(obj[key])) {\r\n            // console.log('unproxy',key);\r\n            obj[key] = proxyMap.get(obj[key]);\r\n            proxyMap.delete(obj[key]);\r\n        }\r\n\r\n        for (let k of Object.keys(obj[key])) {\r\n            if (typeof obj[key][k] === \"object\") {\r\n                unproxy(obj[key], k);\r\n            }\r\n        }\r\n    }\r\n\r\n    function proxify(obj: any, path: DeepPropertyKey) {\r\n        for (let key of Object.keys(obj)) {\r\n            if (typeof obj[key] === \"object\") {\r\n                obj[key] = proxify(obj[key], [...path, key]);\r\n            }\r\n        }\r\n        let p = new Proxy(obj, makeHandler(path));\r\n        proxyMap.set(p, obj);\r\n        return p;\r\n    }\r\n\r\n    return proxify(target, []);\r\n}\r\n"],"names":["keysOf","obj","entry","name","caseInsensitive","nameStr","keys","key","k","satisfies","keyOf","nameOf","f","p","target","$keyMap","$nh","getPropertyPath","expr","getPropertyPathInternal","path","createProxy","combinePropertyPath","builder","nonObjectTypes","isNonObjectType","type","createConstructor","createInstance","args","getPrototypes","result","prototype","proxify","source","value","getEnumValue","enumType","defaultValue","getEnumValues","getEnumKeys","x","assignWith","dst","src","callback","v","update","props","propSet","set","copy","isPlainObject","proto","sort","noKeys","sortImpl","keyCompareFn","a","b","orderedKeys","container","orderedStringify","replacer","space","jsonEquals","obj1","obj2","jsonClone","lock","toReadOnly","throwOnSet","toReadOnlyInternal","lockTest","locked","property","receiver","l","createDeepProxy","handler","proxyMap","makeHandler","propertyKey","unproxy","deleted"],"mappings":"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"}

package/dist/utils.d.ts

@@ -0,0 +1,12 @@
+export declare const normalize: (v: number) => number;
+export declare function numericOr(...values: number[]): number;
+export declare const buildFuncArgCacheKey: (...args: any[]) => string;
+export declare const delayAsync: (ms: number) => Promise<void>;
+export declare const delayErrorAsync: (ms: number, err?: Error) => Promise<never>;
+export declare function withTimeoutAsync<T>(promise: Promise<T>, ms: number): Promise<T>;
+export declare function searchTree<T>(treeNodes: T[], predicate: (item: T) => boolean, childSelector: (item: T) => T[]): any;
+export declare const suppressConsole: (action: () => void) => {
+    method: keyof Console;
+    args: any[];
+}[];
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAaA,eAAO,MAAM,SAAS,GAAI,GAAG,MAAM,WAAiC,CAAC;AAGrE,wBAAgB,SAAS,CAAC,GAAG,MAAM,EAAE,MAAM,EAAE,UAO5C;AAGD,eAAO,MAAM,oBAAoB,YAEZ,GAAG,EAAE,WAiBtB,CAAC;AAEL,eAAO,MAAM,UAAU,GAAI,IAAI,MAAM,kBAEpC,CAAC;AAGF,eAAO,MAAM,eAAe,GAAI,IAAI,MAAM,EAAE,MAAM,KAAK,mBActD,CAAC;AAEF,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,CAS/E;AAQD,wBAAgB,UAAU,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,EAAE,SAAS,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,EAAE,aAAa,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,EAAE,OAc7G;AAED,eAAO,MAAM,eAAe,GAAI,QAAQ,MAAM,IAAI;YAGlC,MAAM,OAAO;UACf,GAAG,EAAE;GAoBlB,CAAC"}

package/dist/utils.es.js

@@ -0,0 +1,71 @@
+import { v4 as i } from "uuid";
+const y = (o) => !o || !isFinite(o) ? 0 : o;
+function l(...o) {
+  for (const e of o)
+    if (e != null)
+      return e;
+}
+const a = /* @__PURE__ */ (() => {
+  const o = /* @__PURE__ */ new WeakMap();
+  return (...e) => {
+    const r = [];
+    for (const t of e) {
+      let n;
+      typeof t == "number" || typeof t == "string" || typeof t == "boolean" || t == null ? n = "" + t : (n = o.get(t), n || (n = i(), o.set(t, n))), r.push(n);
+    }
+    return `"${r.join("/")}"`;
+  };
+})(), m = (o) => new Promise((e) => setTimeout(e, o)), c = (o, e) => (e || (e = new Error("Timeout exceeded")), new Promise(
+  (r, t) => setTimeout(
+    () => t(e),
+    // Don't do this (!):
+    // () => {
+    //     throw err;
+    // },
+    o
+  )
+));
+function d(o, e) {
+  return Promise.race([c(e), o]);
+}
+function u(o, e, r) {
+  if (o)
+    for (const t of o) {
+      if (e(t))
+        return t;
+      const n = u(r(t), e, r);
+      if (n)
+        return n;
+    }
+}
+const p = (o) => {
+  const e = {}, r = [], t = [
+    "log"
+    /*, "debug", "warn", "info"*/
+  ];
+  for (const n of t)
+    e[n] = console[n], console[n] = function(...s) {
+      r.push({
+        method: n,
+        args: s
+      });
+    };
+  try {
+    o();
+  } finally {
+    for (const n of t)
+      console[n] = e[n];
+  }
+  return r;
+};
+export {
+  a as buildFuncArgCacheKey,
+  m as delayAsync,
+  c as delayErrorAsync,
+  y as normalize,
+  l as numericOr,
+  u as searchTree,
+  p as suppressConsole,
+  d as withTimeoutAsync
+};
+//# sourceMappingURL=utils.es.js.map

package/dist/utils.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.es.js","sources":["../src/utils.ts"],"sourcesContent":["import { v4 as uuid } from \"uuid\";\r\n\r\n// @filename: util.ts\r\n\r\n// export function guid() {\r\n//     function s4() {\r\n//         return Math.floor((1 + Math.random()) * 0x10000)\r\n//             .toString(16)\r\n//             .substring(1);\r\n//     }\r\n//     return s4() + s4() + '-' + s4() + '-' + s4() + '-' + s4() + '-' + s4() + s4() + s4();\r\n// }\r\n\r\nexport const normalize = (v: number) => (!v || !isFinite(v) ? 0 : v);\r\n\r\n// numericalOr\r\nexport function numericOr(...values: number[]) {\r\n    for (const value of values) {\r\n        if (value != undefined) {\r\n            return value;\r\n        }\r\n    }\r\n    return undefined;\r\n}\r\n\r\n// funcArgCacheKeyResolver(Provider/Builder)\r\nexport const buildFuncArgCacheKey = (() => {\r\n    const weakMap = new WeakMap<any, string>();\r\n    return (...args: any[]) => {\r\n        const keys: string[] = [];\r\n        for (const arg of args) {\r\n            let key: string = undefined;\r\n            if (typeof arg === \"number\" || typeof arg === \"string\" || typeof arg === \"boolean\" || arg == undefined) {\r\n                key = \"\" + arg;\r\n            } else {\r\n                key = weakMap.get(arg);\r\n                if (!key) {\r\n                    key = uuid();\r\n                    weakMap.set(arg, key);\r\n                }\r\n            }\r\n            keys.push(key);\r\n        }\r\n        return `\"${keys.join(\"/\")}\"`;\r\n    };\r\n})();\r\n\r\nexport const delayAsync = (ms: number) => {\r\n    return new Promise<void>((resolve) => setTimeout(resolve, ms));\r\n};\r\n\r\n// scheduleErrorAsync\r\nexport const delayErrorAsync = (ms: number, err?: Error) => {\r\n    if (!err) {\r\n        err = new Error(\"Timeout exceeded\");\r\n    }\r\n    return new Promise<never>((_, reject) =>\r\n        setTimeout(\r\n            () => reject(err),\r\n            // Don't do this (!):\r\n            // () => {\r\n            //     throw err;\r\n            // },\r\n            ms\r\n        )\r\n    );\r\n};\r\n\r\nexport function withTimeoutAsync<T>(promise: Promise<T>, ms: number): Promise<T> {\r\n    // return new Promise((resolve, reject) => {\r\n    //   const timer = setTimeout(() => reject(new Error('Timeout exceeded')), ms);\r\n    //   promise.then((value) => {\r\n    //     clearTimeout(timer);\r\n    //     resolve(value);\r\n    //   }, reject);\r\n    // });\r\n    return Promise.race([delayErrorAsync(ms), promise]);\r\n}\r\n\r\n/**\r\n * Search node in a tree\r\n * @param predicate filter\r\n * @param childSelector\r\n * @param treeNodes\r\n */\r\nexport function searchTree<T>(treeNodes: T[], predicate: (item: T) => boolean, childSelector: (item: T) => T[]) {\r\n    if (!treeNodes) {\r\n        return undefined;\r\n    }\r\n    for (const treeNode of treeNodes) {\r\n        if (predicate(treeNode)) {\r\n            return treeNode;\r\n        }\r\n        const node = searchTree(childSelector(treeNode), predicate, childSelector);\r\n        if (node) {\r\n            return node;\r\n        }\r\n    }\r\n    return undefined;\r\n}\r\n\r\nexport const suppressConsole = (action: () => void) => {\r\n    const origConsole: any = {};\r\n    const result: {\r\n        method: keyof Console;\r\n        args: any[];\r\n    }[] = [];\r\n    const keys: (keyof Console)[] = [\"log\" /*, \"debug\", \"warn\", \"info\"*/];\r\n    for (const key of keys) {\r\n        origConsole[key] = console[key];\r\n        console[key] = function (...args: any[]) {\r\n            result.push({\r\n                method: key,\r\n                args: args\r\n            });\r\n        } as any;\r\n    }\r\n    try {\r\n        action();\r\n    } finally {\r\n        for (const key of keys) {\r\n            console[key] = origConsole[key];\r\n        }\r\n    }\r\n    return result;\r\n};\r\n\r\n\r\n\r\n/*\r\nexport function memoizeThrottle<T extends Func>(\r\n    func: T,\r\n    wait = 0,\r\n    options?: Parameters<typeof _.throttle<T>>[2],\r\n    resolver?: Parameters<typeof _.memoize<(...args: Parameters<T>) => ReturnType<typeof _.throttle<T>>>>[1]\r\n) {\r\n    const mem = _.memoize<(...args: Parameters<T>) => ReturnType<typeof _.throttle<T>>>(() => {\r\n        return _.throttle<T>(func, wait, options);\r\n    }, resolver);\r\n\r\n    return (...args: Parameters<T>) => {\r\n        return mem(...args)(...args);\r\n    };\r\n}\r\n\r\nexport function memoizeDebounce<T extends Func>(\r\n    func: T,\r\n    wait = 0,\r\n    options?: Parameters<typeof _.debounce<T>>[2],\r\n    resolver?: Parameters<typeof _.memoize<(...args: Parameters<T>) => ReturnType<typeof _.debounce<T>>>>[1]\r\n) {\r\n    const mem = _.memoize<(...args: Parameters<T>) => ReturnType<typeof _.debounce<T>>>(() => {\r\n        return _.debounce<T>(func, wait, options);\r\n    }, resolver);\r\n\r\n    return (...args: Parameters<T>) => {\r\n        return mem(...args)(...args);\r\n    };\r\n}\r\n*/\r\n"],"names":["normalize","v","numericOr","values","value","buildFuncArgCacheKey","weakMap","args","keys","arg","key","uuid","delayAsync","ms","resolve","delayErrorAsync","err","_","reject","withTimeoutAsync","promise","searchTree","treeNodes","predicate","childSelector","treeNode","node","suppressConsole","action","origConsole","result"],"mappings":";AAaa,MAAAA,IAAY,CAACC,MAAe,CAACA,KAAK,CAAC,SAASA,CAAC,IAAI,IAAIA;AAG3D,SAASC,KAAaC,GAAkB;AAC3C,aAAWC,KAASD;AAChB,QAAIC,KAAS;AACF,aAAAA;AAInB;AAGO,MAAMC,IAA8B,uBAAA;AACjC,QAAAC,wBAAc;AACpB,SAAO,IAAIC,MAAgB;AACvB,UAAMC,IAAiB,CAAA;AACvB,eAAWC,KAAOF,GAAM;AACpB,UAAIG;AACA,MAAA,OAAOD,KAAQ,YAAY,OAAOA,KAAQ,YAAY,OAAOA,KAAQ,aAAaA,KAAO,OACzFC,IAAM,KAAKD,KAELC,IAAAJ,EAAQ,IAAIG,CAAG,GAChBC,MACDA,IAAMC,EAAK,GACHL,EAAA,IAAIG,GAAKC,CAAG,KAG5BF,EAAK,KAAKE,CAAG;AAAA,IACjB;AACA,WAAO,IAAIF,EAAK,KAAK,GAAG,CAAC;AAAA,EAAA;AAEjC,GAAG,GAEUI,IAAa,CAACC,MAChB,IAAI,QAAc,CAACC,MAAY,WAAWA,GAASD,CAAE,CAAC,GAIpDE,IAAkB,CAACF,GAAYG,OACnCA,MACKA,IAAA,IAAI,MAAM,kBAAkB,IAE/B,IAAI;AAAA,EAAe,CAACC,GAAGC,MAC1B;AAAA,IACI,MAAMA,EAAOF,CAAG;AAAA;AAAA;AAAA;AAAA;AAAA,IAKhBH;AAAA,EACJ;AAAA;AAIQ,SAAAM,EAAoBC,GAAqBP,GAAwB;AAQ7E,SAAO,QAAQ,KAAK,CAACE,EAAgBF,CAAE,GAAGO,CAAO,CAAC;AACtD;AAQgB,SAAAC,EAAcC,GAAgBC,GAAiCC,GAAiC;AAC5G,MAAKF;AAGL,eAAWG,KAAYH,GAAW;AAC1B,UAAAC,EAAUE,CAAQ;AACX,eAAAA;AAEX,YAAMC,IAAOL,EAAWG,EAAcC,CAAQ,GAAGF,GAAWC,CAAa;AACzE,UAAIE;AACO,eAAAA;AAAA,IAEf;AAEJ;AAEa,MAAAC,IAAkB,CAACC,MAAuB;AACnD,QAAMC,IAAmB,CAAA,GACnBC,IAGA,CAAA,GACAtB,IAA0B;AAAA,IAAC;AAAA;AAAA,EAAA;AACjC,aAAWE,KAAOF;AACF,IAAAqB,EAAAnB,CAAG,IAAI,QAAQA,CAAG,GACtB,QAAAA,CAAG,IAAI,YAAaH,GAAa;AACrC,MAAAuB,EAAO,KAAK;AAAA,QACR,QAAQpB;AAAA,QACR,MAAAH;AAAA,MAAA,CACH;AAAA,IAAA;AAGL,MAAA;AACO,IAAAqB;EAAA,UACT;AACE,eAAWlB,KAAOF;AACN,cAAAE,CAAG,IAAImB,EAAYnB,CAAG;AAAA,EAEtC;AACO,SAAAoB;AACX;"}

package/dist/watchable.d.ts

@@ -0,0 +1,13 @@
+import { Executor, Func } from './typeCore';
+export type PromiseStatus = "pending" | "fulfilled" | "rejected";
+export type WatchablePromise<T = void> = PromiseLike<T> & {
+    readonly status?: PromiseStatus;
+    readonly settled?: boolean;
+    readonly result?: T;
+};
+export type WatchableFunc<TArgs extends any[] = any[], T = any> = Func<TArgs, T> & {
+    executing?: boolean;
+};
+export declare function watch<T = void>(fn: Executor<T>): WatchablePromise<Awaited<T>>;
+export declare function toWatchable<TArgs extends any[] = any[], T = void>(fn: Func<TArgs, T>): WatchableFunc<TArgs, T>;
+//# sourceMappingURL=watchable.d.ts.map

package/dist/watchable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"watchable.d.ts","sourceRoot":"","sources":["../src/watchable.ts"],"names":[],"mappings":"AAAA,OAAO,EAAW,QAAQ,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAGrD,MAAM,MAAM,aAAa,GAAG,SAAS,GAAG,WAAW,GAAG,UAAU,CAAC;AAGjE,MAAM,MAAM,gBAAgB,CAAC,CAAC,GAAG,IAAI,IAAI,WAAW,CAAC,CAAC,CAAC,GAAG;IACtD,QAAQ,CAAC,MAAM,CAAC,EAAE,aAAa,CAAC;IAChC,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;CACvB,CAAC;AAGF,MAAM,MAAM,aAAa,CAAC,KAAK,SAAS,GAAG,EAAE,GAAG,GAAG,EAAE,EAAE,CAAC,GAAG,GAAG,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC,GAAG;IAC/E,SAAS,CAAC,EAAE,OAAO,CAAC;CACvB,CAAC;AAIF,wBAAgB,KAAK,CAAC,CAAC,GAAG,IAAI,EAAE,EAAE,EAAE,QAAQ,CAAC,CAAC,CAAC,GA+BzB,gBAAgB,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CACjD;AAMD,wBAAgB,WAAW,CAAC,KAAK,SAAS,GAAG,EAAE,GAAG,GAAG,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,EAAE,EAAE,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC,GAAG,aAAa,CAAC,KAAK,EAAE,CAAC,CAAC,CA+B9G"}

package/dist/watchable.es.js

@@ -0,0 +1,38 @@
+function l(c) {
+  let s, n;
+  const e = new Promise((t, r) => {
+    s = t, n = r;
+  });
+  return e.status = "pending", Object.defineProperty(e, "settled", {
+    get: () => e.status !== "pending"
+  }), (async () => {
+    try {
+      const t = await Promise.resolve(c());
+      s(t), e.result = t, e.status = "fulfilled";
+    } catch (t) {
+      n(t), e.result = void 0, e.status = "rejected";
+    }
+  })(), e;
+}
+function i(c) {
+  let s;
+  const n = (e) => {
+    if (s.executing = !1, e)
+      throw e;
+  };
+  return s = (...e) => {
+    s.executing = !0;
+    let t = !1;
+    try {
+      const r = c(...e);
+      return r instanceof Promise && (t = !0, r.catch(n), r.then(n)), r;
+    } finally {
+      t || n();
+    }
+  }, s;
+}
+export {
+  i as toWatchable,
+  l as watch
+};
+//# sourceMappingURL=watchable.es.js.map

package/dist/watchable.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"watchable.es.js","sources":["../src/watchable.ts"],"sourcesContent":["import { Mutable, Executor, Func } from \"./typeCore\";\r\n\r\n// PromiseState\r\nexport type PromiseStatus = \"pending\" | \"fulfilled\" | \"rejected\";\r\n\r\n// TrackablePromise\r\nexport type WatchablePromise<T = void> = PromiseLike<T> & {\r\n    readonly status?: PromiseStatus;\r\n    readonly settled?: boolean;\r\n    readonly result?: T;\r\n};\r\n\r\n// WatchableFn\r\nexport type WatchableFunc<TArgs extends any[] = any[], T = any> = Func<TArgs, T> & {\r\n    executing?: boolean; // running/inProgress/pending\r\n};\r\n\r\n// we need promise wrapper because Promise [[PromiseState]] and [[PromiseResult]] symbols are not accessible\r\n// exec and watch/track\r\nexport function watch<T = void>(fn: Executor<T>) {\r\n    // type PromiseExecutorType = ConstructorParameters<typeof Promise<Awaited<T>>>[0];\r\n    let resolve!: (value: Awaited<T>) => void;\r\n    // let resolve: Parameters<PromiseExecutorType>[0];\r\n    let reject!: (reason: any) => void;\r\n    // let reject: Parameters<PromiseExecutorType>[1];\r\n\r\n    const promise: Mutable<WatchablePromise<Awaited<T>>> = new Promise<Awaited<T>>((res, rej) => {\r\n        resolve = res;\r\n        reject = rej;\r\n    });\r\n\r\n    promise.status = \"pending\";\r\n    // TODO: create type-safe defineProperty utility method\r\n    Object.defineProperty(promise, \"settled\" satisfies keyof typeof promise, {\r\n        get: () => promise.status !== \"pending\"\r\n    });\r\n\r\n    (async () => {\r\n        try {\r\n            const retValue = (await Promise.resolve(fn())) as Awaited<T>;\r\n            resolve(retValue);\r\n            promise.result = retValue;\r\n            promise.status = \"fulfilled\";\r\n        } catch (err) {\r\n            reject(err);\r\n            promise.result = undefined;\r\n            promise.status = \"rejected\";\r\n        }\r\n    })();\r\n\r\n    return promise as WatchablePromise<Awaited<T>>;\r\n}\r\n\r\n// TODO: add Promise.prototype.finally support\r\n\r\n// toTrackable\r\n/** wrap to watchable func */\r\nexport function toWatchable<TArgs extends any[] = any[], T = void>(fn: Func<TArgs, T>): WatchableFunc<TArgs, T> {\r\n    // result\r\n    let watchable: Func<TArgs, T> & {\r\n        executing?: boolean; // running/inProgress/pending\r\n    };\r\n    const complete = (err?: any) => {\r\n        watchable.executing = false;\r\n        // watchable result.executing;\r\n        if (err) {\r\n            // err instanceof Error\r\n            throw err; // need to rethrow!\r\n        }\r\n    };\r\n    watchable = (...args) => {\r\n        watchable.executing = true;\r\n        let isAsyncFn = false;\r\n        try {\r\n            const fnResult = fn(...args);\r\n            if (fnResult instanceof Promise) {\r\n                isAsyncFn = true;\r\n                fnResult.catch(complete);\r\n                fnResult.then(complete);\r\n            }\r\n            return fnResult;\r\n        } finally {\r\n            if (!isAsyncFn) {\r\n                complete();\r\n            }\r\n        }\r\n    };\r\n    return watchable;\r\n}\r\n"],"names":["watch","fn","resolve","reject","promise","res","rej","retValue","err","toWatchable","watchable","complete","args","isAsyncFn","fnResult"],"mappings":"AAmBO,SAASA,EAAgBC,GAAiB;AAEzC,MAAAC,GAEAC;AAGJ,QAAMC,IAAiD,IAAI,QAAoB,CAACC,GAAKC,MAAQ;AAC/E,IAAAJ,IAAAG,GACDF,IAAAG;AAAA,EAAA,CACZ;AAED,SAAAF,EAAQ,SAAS,WAEV,OAAA,eAAeA,GAAS,WAA0C;AAAA,IACrE,KAAK,MAAMA,EAAQ,WAAW;AAAA,EAAA,CACjC,IAEA,YAAY;AACL,QAAA;AACA,YAAMG,IAAY,MAAM,QAAQ,QAAQN,EAAI,CAAA;AAC5C,MAAAC,EAAQK,CAAQ,GAChBH,EAAQ,SAASG,GACjBH,EAAQ,SAAS;AAAA,aACZI,GAAK;AACV,MAAAL,EAAOK,CAAG,GACVJ,EAAQ,SAAS,QACjBA,EAAQ,SAAS;AAAA,IACrB;AAAA,EAAA,MAGGA;AACX;AAMO,SAASK,EAAmDR,GAA6C;AAExG,MAAAS;AAGE,QAAAC,IAAW,CAACH,MAAc;AAG5B,QAFAE,EAAU,YAAY,IAElBF;AAEM,YAAAA;AAAA,EACV;AAEJ,SAAAE,IAAY,IAAIE,MAAS;AACrB,IAAAF,EAAU,YAAY;AACtB,QAAIG,IAAY;AACZ,QAAA;AACM,YAAAC,IAAWb,EAAG,GAAGW,CAAI;AAC3B,aAAIE,aAAoB,YACRD,IAAA,IACZC,EAAS,MAAMH,CAAQ,GACvBG,EAAS,KAAKH,CAAQ,IAEnBG;AAAA,IAAA,UACT;AACE,MAAKD,KACQF;IAEjB;AAAA,EAAA,GAEGD;AACX;"}

package/package.json

@@ -0,0 +1,78 @@
+{
+    "name": "@actdim/utico",
+    "version": "0.9.0",
+    "description": "@actdim/utico",
+    "author": "Pavel Borodaev",
+    "license": "Proprietary",
+    "type": "module",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/actdim/utico.git"
+    },
+    "bugs": {
+        "url": "https://github.com/actdim/utico/issues"
+    },
+    "homepage": "https://github.com/actdim/utico/#readme",
+    "keywords": [
+        "core",
+        "common",
+        "typescript",
+        "utility",
+        "utils"
+    ],
+    "files": [
+        "dist",
+        "docs",
+        "README.md",
+        "LICENSE"
+    ],
+    "files(src)": [
+        "src",
+        "docs",
+        "README.md",
+        "LICENSE"
+    ],
+    "exports": {
+        "./*": {
+            "import": "./dist/*.es.js",
+            "types": "./dist/*.d.ts"
+        }
+    },
+    "typesVersions": {
+        "*": {
+            "*": [
+                "dist/*.d.ts"
+            ]
+        }
+    },
+    "sideEffects": false,
+    "sideEffects?": [],
+    "scripts": {
+        "build": "tsc && vite build",
+        "test": "npx vitest",
+        "wtest": "npx vitest --watch",
+        "dtest": "node --inspect-brk node_modules/vitest/vitest.mjs run --poolOptions.threads.singleThread",
+        "lint": "eslint . --ext ts,tsx --report-unused-disable-directives --max-warnings 0"
+    },
+    "peerDependencies": {
+        "dexie": "^4.0.8",
+        "moment": "^2.30.1",
+        "uuid": "^9.0.1"
+    },
+    "devDependencies": {
+        "@types/node": "^20.11.30",
+        "@types/uuid": "^9.0.7",
+        "@typescript-eslint/eslint-plugin": "^6.10.0",
+        "@typescript-eslint/parser": "^6.10.0",
+        "@vitejs/plugin-react-swc": "^3.5.0",
+        "eslint": "^8.53.0",
+        "eslint-import-resolver-typescript": "^4.3.4",
+        "path": "^0.12.7",
+        "tslib": "^2.8.1",
+        "typescript": "^5.8.3",
+        "vite": "^5.4.18",
+        "vite-plugin-dts": "^4.5.3",
+        "vite-tsconfig-paths": "^5.1.4",
+        "vitest": "^3.1.2"
+    }
+}