wenay-common2 1.0.45 → 1.0.48

package/lib/Common/async/waitRun.js

@@ -1,51 +1,59 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.enhancedWaitRun = enhancedWaitRun;
+exports.createTaskQueue = exports.enhancedWaitRun = void 0;
+exports.createThrottle = createThrottle;
 exports.createAsyncQueue = createAsyncQueue;
 exports.enhancedQueueRun = enhancedQueueRun;
 exports.waitRun = waitRun;
 exports.queueRun = queueRun;
-exports.createTaskQueue = createTaskQueue;
+exports.createReadyGate = createReadyGate;
 const common_1 = require("../core/common");
-function enhancedWaitRun() {
+function createThrottle() {
     let last = 0, busy = false, pending;
     let chain = Promise.resolve();
+    const throttle = (ms, func) => {
+        if (busy || last + ms >= Date.now())
+            return;
+        busy = true;
+        chain = chain.catch(() => { }).then(async () => {
+            try {
+                return await func();
+            }
+            finally {
+                busy = false;
+                last = Date.now();
+            }
+        }).catch(() => { });
+    };
+    const debounce = (ms, func) => {
+        if (!func)
+            throw new Error("debounceAsync: func is undefined");
+        pending = func;
+        if (busy)
+            return chain;
+        busy = true;
+        return chain = chain.finally(async () => {
+            try {
+                await (0, common_1.sleepAsync)(ms);
+                await pending?.();
+            }
+            finally {
+                busy = false;
+                chain = Promise.resolve();
+            }
+        });
+    };
     return {
-        throttleAsync: (ms, func) => {
-            if (busy || last + ms >= Date.now())
-                return;
-            busy = true;
-            chain = chain.then(async () => {
-                try {
-                    return await func();
-                }
-                finally {
-                    busy = false;
-                    last = Date.now();
-                }
-            });
-        },
-        debounceAsync: (ms, func) => {
-            if (!func)
-                throw new Error("debounceAsync: func is undefined");
-            pending = func;
-            if (busy)
-                return chain;
-            busy = true;
-            return chain = chain.finally(async () => {
-                try {
-                    await (0, common_1.sleepAsync)(ms);
-                    await pending?.();
-                }
-                finally {
-                    busy = false;
-                    chain = Promise.resolve();
-                }
-            });
-        },
+        throttle,
+        debounce,
+        throttleAsync: throttle,
+        debounceAsync: debounce,
     };
 }
+exports.enhancedWaitRun = createThrottle;
 function createAsyncQueue(concurrency = 1) {
+    if (concurrency < 1)
+        throw new Error("createAsyncQueue: concurrency must be >= 1");
     const queue = [];
     let active = 0, resolveIdle = null, idle = null;
     const drain = () => {
@@ -67,19 +75,25 @@ function createAsyncQueue(concurrency = 1) {
     } }); drain(); });
     const onIdle = () => idle ??= new Promise(r => (active === 0 && !queue.length) ? r() : (resolveIdle = r));
     const getQueueSize = () => queue.length;
-    return { enqueue, onIdle, getQueueSize };
+    return {
+        add: enqueue,
+        onIdle,
+        get size() { return queue.length; },
+        enqueue,
+        getQueueSize,
+    };
 }
 function enhancedQueueRun(maxParallelTasks = 5) {
     const q = createAsyncQueue(maxParallelTasks);
     return {
         get queueSize() { return q.getQueueSize(); },
-        enqueue: (task) => { q.enqueue(task); },
-        enqueueAndRun: (task) => { q.enqueue(task); },
+        enqueue: (task) => { q.enqueue(task).catch(() => { }); },
+        enqueueAndRun: (task) => q.enqueue(task),
         runAll: () => q.onIdle(),
     };
 }
 function waitRun() {
-    const w = enhancedWaitRun();
+    const w = (0, exports.enhancedWaitRun)();
     return { refreshAsync: w.throttleAsync, refreshAsync2: w.debounceAsync };
 }
 function queueRun(n = 5) {
@@ -91,14 +105,30 @@ function queueRun(n = 5) {
         run: () => q.runAll(),
     };
 }
-function createTaskQueue() {
-    let ready = false;
+function createReadyGate() {
+    let isReadyFlag = false;
     const tasks = [];
+    const setReady = async () => {
+        isReadyFlag = true;
+        const run = tasks.splice(0);
+        let err;
+        for (const fn of run) {
+            try {
+                await fn();
+            }
+            catch (e) {
+                err ??= e;
+            }
+        }
+        if (err !== undefined)
+            throw err;
+    };
     return {
-        add: (fn) => ready ? void fn() : tasks.push(fn),
-        setReady: async () => { ready = true; for (const fn of tasks)
-            await fn(); tasks.length = 0; },
-        isReady: () => ready,
+        add: (fn) => isReadyFlag ? void fn() : tasks.push(fn),
+        ready: setReady,
+        isReady: () => isReadyFlag,
         tasks: () => [...tasks],
+        setReady,
     };
 }
+exports.createTaskQueue = createReadyGate;

package/lib/Common/core/Decorator.d.ts

@@ -11,6 +11,7 @@ type AsyncExtras<T extends (...args: any[]) => any> = ReturnType<T> extends Prom
 } : {};
 type EnhancedDecoratorOptions<T extends (...args: any[]) => any> = CommonOptions<T> & AsyncExtras<T>;
 export declare function enhancedDecorator<T extends (...args: any[]) => any>(fn: T, opt?: EnhancedDecoratorOptions<T>): (...args: Parameters<T>) => ReturnType<T>;
+export declare const wrap: typeof enhancedDecorator;
 export declare function enhancedTransformer<T extends (...args: any[]) => any, R>(fn: T, transform: (data: [args: Parameters<T>, result: ReturnType<T>]) => R): (...args: Parameters<T>) => R;
 export declare function Decorator<T extends (...args: any[]) => any>(fn: T, opt?: {
     parameters?: (...a: Parameters<T>) => any;
@@ -20,5 +21,6 @@ export declare function Decorator<T extends (...args: any[]) => any>(fn: T, opt?
     resultModifier?: (res: ReturnType<T>) => ReturnType<T>;
 }): (...args: Parameters<T>) => ReturnType<T>;
 export declare function TransformerResult<T extends (...args: any[]) => any, R>(fn: T, transform: (data: [args: Parameters<T>, result: ReturnType<T>]) => R): (...args: Parameters<T>) => R;
-export declare function Transformer<T extends (...args: any[]) => any, R>(fn: T, transform: (data: [args: Parameters<T>, fn: T]) => R): (...args: Parameters<T>) => R;
+export declare function around<T extends (...args: any[]) => any, R>(fn: T, transform: (data: [args: Parameters<T>, fn: T]) => R): (...args: Parameters<T>) => R;
+export declare const Transformer: typeof around;
 export {};

package/lib/Common/core/Decorator.js

@@ -1,10 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.Transformer = exports.wrap = void 0;
 exports.enhancedDecorator = enhancedDecorator;
 exports.enhancedTransformer = enhancedTransformer;
 exports.Decorator = Decorator;
 exports.TransformerResult = TransformerResult;
-exports.Transformer = Transformer;
+exports.around = around;
 function enhancedDecorator(fn, opt) {
     return (...args) => {
         opt?.beforeParams?.(...args);
@@ -20,15 +21,17 @@ function enhancedDecorator(fn, opt) {
             })
                 .catch((err) => {
                 optAsync?.onCatch?.(err);
+                throw err;
             })
                 .finally(() => optAsync?.onFinally?.());
         }
         else {
             opt?.onResult?.(rawResult);
-            return opt?.modifyResult?.(rawResult) || rawResult;
+            return opt?.modifyResult?.(rawResult) ?? rawResult;
         }
     };
 }
+exports.wrap = enhancedDecorator;
 function enhancedTransformer(fn, transform) {
     return (...args) => {
         const result = fn(...args);
@@ -47,6 +50,7 @@ function Decorator(fn, opt) {
 function TransformerResult(fn, transform) {
     return enhancedTransformer(fn, transform);
 }
-function Transformer(fn, transform) {
+function around(fn, transform) {
     return (...args) => transform([args, fn]);
 }
+exports.Transformer = around;

package/lib/Common/core/DeepCompareKeys.js

@@ -24,6 +24,8 @@ function DeepCompareKeys2(obj1, keys, func) {
         return obj1;
     if (CompareKeys2(obj1, keys))
         return func(obj1);
+    if (Array.isArray(obj1))
+        return obj1.map((v) => DeepCompareKeys2(v, keys, func));
     return Object.fromEntries(Object.entries(obj1).map(([k, v]) => [k, DeepCompareKeys2(v, keys, func)]));
 }
 function DeepCompareKeys(obj1, obj2, func) {
@@ -32,5 +34,7 @@ function DeepCompareKeys(obj1, obj2, func) {
     const keys = Object.keys(obj2);
     if (CompareKeys2(obj1, keys))
         return func(obj1);
+    if (Array.isArray(obj1))
+        return obj1.map((v) => DeepCompareKeys2(v, keys, func));
     return Object.fromEntries(Object.entries(obj1).map(([k, v]) => [k, DeepCompareKeys2(v, keys, func)]));
 }

package/lib/Common/core/MemoFunc.js

@@ -16,7 +16,7 @@ function MemoFunc(a) {
         eventUpdate?.();
     }
     function evictOldest(map) {
-        const keep = Math.floor(maxLimits / 2);
+        const keep = Math.max(1, Math.floor(maxLimits / 2));
         const entries = [...map.entries()].sort((a, b) => a[1].time - b[1].time);
         const toRemove = entries.slice(0, entries.length - keep);
         for (const [key] of toRemove) {
@@ -25,7 +25,7 @@ function MemoFunc(a) {
         eventUpdate?.();
     }
     function evictOldestFuncs() {
-        const keep = Math.floor(maxLimits / 2);
+        const keep = Math.max(1, Math.floor(maxLimits / 2));
         const entries = [...memo.entries()].sort((a, b) => {
             const maxTimeA = Math.max(...[...a[1].values()].map(e => e.time ?? 0));
             const maxTimeB = Math.max(...[...b[1].values()].map(e => e.time ?? 0));

package/lib/Common/core/common.d.ts

@@ -7,16 +7,16 @@ type const_Date = Omit<Date, "setTime" | "setFullYear" | "setMonth" | "setDate"
 export declare function isDate<T>(value: T & (Extract<T, const_Date> extends never ? never : T)): value is Extract<typeof value, const_Date>;
 export { Mutable };
 export declare function shallowClone<T>(val: T): Mutable<T>;
-export declare function _deepClone<T>(src: T, map?: Map<object, object>): T;
-export declare function deepClone<T>(object: T): T;
+export declare function _deepClone<T>(src: T, map?: Map<object, object>): any;
+export declare function deepClone<T>(object: T): any;
+export declare const clone: typeof deepClone;
 export declare function deepCloneMutable<T>(value: T): MutableFull<T>;
-export declare function deepCloneObject<T extends object>(object: T): T;
+export declare function deepCloneObject<T extends object>(object: T): any;
 export declare function deepCloneObjectMutable<T extends object>(object: T): MutableFull<T>;
 export declare function toImmutable<T extends object>(object: T): Immutable<T>;
 export declare function readonlyFull<T>(arg: T): ReadonlyFull<T>;
-export declare function deepEqual<T extends {
-    [key: string]: any;
-}>(object1: T, object2: T): boolean;
+export declare function deepEqual(object1: any, object2: any): boolean;
+export declare const isEqual: typeof deepEqual;
 export declare function shallowEqual<T extends {
     [key: string]: unknown;
 } | undefined>(object1: T, object2: T): boolean;
@@ -57,21 +57,28 @@ export declare function BSearchNearest(array: ArrayLike<number>, searchValue: nu
 export declare function BSearchNearest<T>(array: ArrayLike<T>, searchValue: number, arrayGetValue: (element: T) => number, maxDelta?: number): number;
 export declare function _BSearchNearest<T>(array: ArrayLike<T>, searchValue: number, arrayGetValue: (element: T) => number, maxDelta?: number): number;
 export declare function NormalizeDouble(value: number, digits: number): number;
+export declare function round(value: number, digits?: number): number;
 export declare function MaxCommonDivisor(a: number, b: number, digits?: number): number;
 export declare function MaxCommonDivisorOnArray(values: Iterable<number>, precisDigits?: number): number;
+export declare function gcd(a: number, b: number, digits?: number): number;
+export declare function gcd(values: Iterable<number>, digits?: number): number;
 export declare function GetDblPrecision2(value: number, mindigits: number, maxdigits: number): number;
 export declare function GetDblPrecision(value: number, maxdigits?: number): number;
+export declare function decimals(value: number, maxDigits?: number, minDigits?: number): number;
 export declare function DblToStrAuto(value: number, maxprecis?: number): string;
+export declare const formatAuto: typeof DblToStrAuto;
 export declare function NormalizeDoubleAnd(a: number, options?: {
     digitsPoint?: number;
     digitsR?: number;
     type?: "max" | "min";
 }): number;
+export declare const roundSig: typeof NormalizeDoubleAnd;
 export declare function DblToStrAnd(a: number, options?: {
     digitsPoint?: number;
     digitsR?: number;
     type?: "max" | "min";
 }): string;
+export declare const formatSig: typeof DblToStrAnd;
 export declare function ArrayItemHandler<T extends {
     [key: number]: any;
 }>(getter: (target: T, i: number) => T[number], setter?: (target: T, i: number, value: T[number]) => void): ProxyHandler<T>;
@@ -113,17 +120,25 @@ export declare class __MyMap<K extends {
     get sortedKeys(): readonly K[];
     get Values(): readonly V[];
     assign(other: __MyMap<K, V>): void;
+    set(key: K, value: V): void;
+    get(key: K): V | undefined;
+    has(key: K): boolean;
+    delete(key: K): void;
+    clear(): void;
+    get size(): number;
 }
 export declare class MyMap<K extends {
     valueOf(): number;
 }, V> extends __MyMap<K, V> {
     readonly [key: number]: void;
     Clone(): MyMap<K, V>;
+    clone(): MyMap<K, V>;
 }
 export declare class MyNumMap<VAL> extends __MyMap<number, VAL> {
     [key: number]: VAL | undefined;
     constructor();
     Clone(): MyNumMap<VAL>;
+    clone(): MyNumMap<VAL>;
 }
 export declare class StructMap<TKey extends (Required<TKey> & {
     [key: string]: number | string;
@@ -187,9 +202,10 @@ export declare class CancelToken implements ICancelToken {
     private _cancel;
     isCancelled(): boolean;
     cancel(): void;
+    get aborted(): boolean;
+    abort(): void;
 }
 export declare class CancelablePromise<T> extends Promise<T> {
-    private static _rejectTmp;
     private readonly _reject?;
     private readonly _onCancel?;
     constructor(executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => void, onCancel?: () => void);
@@ -209,6 +225,7 @@ export declare class Mutex {
     private mutex;
     lock(): PromiseLike<() => void>;
     dispatch<T>(fn: () => T | PromiseLike<T>): Promise<T>;
+    runExclusive<T>(fn: () => T | PromiseLike<T>): Promise<T>;
     static createLock(): PromiseLike<() => void>;
 }
 export declare function copyToClipboard(textToCopy: string): Promise<any>;
@@ -232,6 +249,7 @@ export declare class MapExt<K, V> extends Map<K, V> {
     private immutArray?;
     set(key: K, value: V): this;
     delete(key: K): boolean;
+    clear(): void;
     valuesArrayImmutable(): readonly V[];
     getOrSetFunc(key: K, val: () => V): V;
     getOrSet(key: K, val: V): V;