@isopodlabs/utilities 1.5.3 → 1.5.5

package/dist/algorithm.js

@@ -6,7 +6,7 @@ exports.argmin = argmin;
 exports.min = min;
 exports.argmax = argmax;
 exports.max = max;
-const utils_1 = require("./utils");
+const object_1 = require("./object");
 function partition(array, func) {
     const partitions = {};
     for (const i of array)
@@ -24,21 +24,7 @@ function lowerBound(array, value, func) {
     }
     return i;
 }
-/*
-export function argmin<T>(array: T[], func?: (i: T) => number) {
-    let mini	= 0;
-    let minv	= func ? func(array[0]) : array[0];
-    for (let i = 1; i < array.length; i++) {
-        const v = func ? func(array[i]) : array[i];
-        if (v < minv) {
-            mini = i;
-            minv = v;
-        }
-    }
-    return mini;
-}
-    */
-function argmin(array, func = utils_1.compare) {
+function argmin(array, func = object_1.compare) {
     let mini = 0;
     for (let i = 1; i < array.length; i++) {
         const v = func(array[i], array[mini]);
@@ -47,10 +33,10 @@ function argmin(array, func = utils_1.compare) {
     }
     return mini;
 }
-function min(array, func = utils_1.compare) {
+function min(array, func = object_1.compare) {
     return array[argmin(array, func)];
 }
-function argmax(array, func = utils_1.compare) {
+function argmax(array, func = object_1.compare) {
     let maxi = 0;
     for (let i = 1; i < array.length; i++) {
         const v = func(array[i], array[maxi]);
@@ -59,6 +45,6 @@ function argmax(array, func = utils_1.compare) {
     }
     return maxi;
 }
-function max(array, func = utils_1.compare) {
+function max(array, func = object_1.compare) {
     return array[argmax(array, func)];
 }

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export * from './utils';
+export * from './object';
 export * from './iterator';
 export * from './string';
 export * from './algorithm';

package/dist/index.js

@@ -37,7 +37,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.insensitive = void 0;
-__exportStar(require("./utils"), exports);
+__exportStar(require("./object"), exports);
 __exportStar(require("./iterator"), exports);
 __exportStar(require("./string"), exports);
 __exportStar(require("./algorithm"), exports);

package/dist/insensitive.d.ts

@@ -10,7 +10,7 @@ declare class CaseInsensitiveString {
     endsWith(searchString: string, position?: number): boolean;
     indexOf(searchString: string, position?: number): number;
     lastIndexOf(searchString: string, position?: number): number;
-    compare(other: string | CaseInsensitiveString): 1 | -1 | 0;
+    compare(other: string | CaseInsensitiveString): 0 | 1 | -1;
 }
 declare class CaseInsensitiveString2 extends CaseInsensitiveString {
     private orig;
@@ -19,7 +19,7 @@ declare class CaseInsensitiveString2 extends CaseInsensitiveString {
 }
 export declare function String(value: string): CaseInsensitiveString;
 export declare function String2(value: string): CaseInsensitiveString2;
-export declare function compare(a: string, b: string): 1 | -1 | 0;
+export declare function compare(a: string, b: string): 0 | 1 | -1;
 export declare function Record<T>(obj: Record<string, T>): Record<string, T>;
 export declare function Record2<T>(obj: Record<string, T>): Record<string, T>;
 export declare class Map<T> extends globalThis.Map<string, T> {

package/dist/iterator.d.ts

@@ -1,19 +1,18 @@
 export type SpreadType<T> = T extends Iterable<infer U> ? U[] : never;
-export declare function arrayAppend<T, U extends Iterable<T>>(array: T[], items: U): void;
 export declare function arrayRemove<T>(array: T[], item: T): boolean;
 export declare function arrayCompare<T>(arr1: T[], arr2: T[]): number;
 export declare function arrayEqual<T>(arr1: T[], arr2: T[]): boolean;
 export declare function arrayRotate<T>(array: T[], start: number, end: number, shift: number): void;
 export declare function arrayReverse<T>(array: T[], start: number, end: number): void;
-export declare function array_make<T>(n: number, constructor: new () => T): T[];
-export declare function eachIterable<T>(iterable: Iterable<T> | undefined, func: (v: T, i: number) => void): void;
-export declare function findIterable<T>(iterable: Iterable<T> | undefined, func: (v: T) => boolean): T | undefined;
-export declare function mapIterable<T, U>(iterable: Iterable<T> | undefined, func: (v: T, i: number) => U): U[];
+export declare function arrayMake<T>(n: number, constructor: new () => T): T[];
+export declare function forEach<T>(iterable: Iterable<T> | undefined, func: (v: T, i: number) => void): void;
+export declare function find<T>(iterable: Iterable<T> | undefined, func: (v: T) => boolean): T | undefined;
+export declare function map<T, U>(iterable: Iterable<T> | undefined, func: (v: T, i: number) => U): U[];
+export declare function reduce<T, U>(iterable: Iterable<T>, func: (acc: U, v: T, i: number, iterable: Iterable<T>) => U, initialValue: U): U;
+export declare function filter<T>(iterable: Iterable<T>, func: (v: T, i: number) => unknown): T[];
 export declare function asyncMap<T, U>(iterable: Iterable<T> | undefined, func: (v: T, i: number) => Promise<U>): Promise<U[]>;
-export declare function asyncReduce<T, U>(array: T[], func: (acc: U, v: T, i: number, array: T[]) => Promise<U>, initialValue: U): Promise<U>;
+export declare function asyncMapSerial<T, U>(iterable: Iterable<T> | undefined, func: (v: T, i: number) => Promise<U>): Promise<U[]>;
+export declare function asyncReduce<T, U>(iterable: Iterable<T>, func: (acc: U, v: T, i: number, iterable: Iterable<T>) => Promise<U>, initialValue: U): Promise<U>;
+export declare function asyncFilter<T>(iterable: Iterable<T>, func: (v: T) => Promise<unknown>): Promise<T[]>;
 export declare function parallel(...fns: (() => any)[]): Promise<any[]>;
 export declare function serial(...fns: (() => any)[]): Promise<any[]>;
-export declare function filterIterable<T>(iterable: Iterable<T>, func: (v: T, i: number) => unknown): T[];
-export declare function asyncFilter<T>(iterable: Iterable<T>, func: (v: T) => Promise<unknown>): Promise<T[]>;
-export declare function mapObject<T, U>(obj: Record<string, T>, func: (x: [k: string, v: T]) => [k: string, v: U]): Record<string, U>;
-export declare function filterObject<T>(obj: Record<string, T>, func: (x: [k: string, v: T]) => boolean): Record<string, T>;

package/dist/iterator.js

@@ -1,28 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.arrayAppend = arrayAppend;
 exports.arrayRemove = arrayRemove;
 exports.arrayCompare = arrayCompare;
 exports.arrayEqual = arrayEqual;
 exports.arrayRotate = arrayRotate;
 exports.arrayReverse = arrayReverse;
-exports.array_make = array_make;
-exports.eachIterable = eachIterable;
-exports.findIterable = findIterable;
-exports.mapIterable = mapIterable;
+exports.arrayMake = arrayMake;
+exports.forEach = forEach;
+exports.find = find;
+exports.map = map;
+exports.reduce = reduce;
+exports.filter = filter;
 exports.asyncMap = asyncMap;
+exports.asyncMapSerial = asyncMapSerial;
 exports.asyncReduce = asyncReduce;
+exports.asyncFilter = asyncFilter;
 exports.parallel = parallel;
 exports.serial = serial;
-exports.filterIterable = filterIterable;
-exports.asyncFilter = asyncFilter;
-exports.mapObject = mapObject;
-exports.filterObject = filterObject;
-const utils_1 = require("./utils");
-function arrayAppend(array, items) {
-    for (const i of items)
-        array.push(i);
-}
+const object_1 = require("./object");
+//remove element of array
 function arrayRemove(array, item) {
     const index = array.indexOf(item);
     if (index === -1)
@@ -33,7 +29,7 @@ function arrayRemove(array, item) {
 function arrayCompare(arr1, arr2) {
     const length = Math.min(arr1.length, arr2.length);
     for (let i = 0; i < length; i++) {
-        const r = (0, utils_1.compare)(arr1[i], arr2[i]);
+        const r = (0, object_1.compare)(arr1[i], arr2[i]);
         if (r)
             return r;
     }
@@ -64,17 +60,17 @@ function arrayReverse(array, start, end) {
         end--;
     }
 }
-function array_make(n, constructor) {
+function arrayMake(n, constructor) {
     return Array.from({ length: n }, () => new constructor);
 }
-function eachIterable(iterable, func) {
+function forEach(iterable, func) {
     if (iterable) {
         let i = 0;
         for (const v of iterable)
             func(v, i++);
     }
 }
-function findIterable(iterable, func) {
+function find(iterable, func) {
     if (iterable) {
         for (const v of iterable) {
             if (func(v))
@@ -82,39 +78,58 @@ function findIterable(iterable, func) {
         }
     }
 }
-function mapIterable(iterable, func) {
+function map(iterable, func) {
     return iterable ? Array.from(iterable, func) : [];
 }
-async function asyncMap(iterable, func) {
-    return Promise.all(mapIterable(iterable, func));
+function reduce(iterable, func, initialValue) {
+    let i = 0;
+    let acc = initialValue;
+    for (const v of iterable)
+        acc = func(acc, v, i++, iterable);
+    return acc;
 }
-async function asyncReduce(array, func, initialValue) {
-    return array.reduce(async (promise, v, i, array) => func(await promise, v, i, array), Promise.resolve(initialValue));
+function filter(iterable, func) {
+    const array = [];
+    let i = 0;
+    for (const v of iterable)
+        if (func(v, i++))
+            array.push(v);
+    return array;
 }
-async function parallel(...fns) {
-    return asyncMap(fns, f => f());
+async function asyncMap(iterable, func) {
+    return Promise.all(map(iterable, func));
 }
-async function serial(...fns) {
+async function asyncMapSerial(iterable, func) {
     const results = [];
-    for (const f of fns)
-        results.push(await f());
+    let i = 0;
+    for (const v of iterable || [])
+        results.push(await func(v, i++));
     return results;
 }
-function filterIterable(iterable, func) {
-    const array = [];
+async function asyncReduce(iterable, func, initialValue) {
     let i = 0;
+    let acc = initialValue;
     for (const v of iterable)
-        if (func(v, i++))
-            array.push(v);
-    return array;
+        acc = await func(acc, v, i++, iterable);
+    return acc;
+    /*
+        return reduce<T, Promise<U>>(
+            iterable,
+            async (promise, v, i, iterable) => func(await promise, v, i, iterable),
+            Promise.resolve(initialValue)
+        );
+        */
 }
 async function asyncFilter(iterable, func) {
-    const filters = await Promise.all(mapIterable(iterable, func));
-    return filterIterable(iterable, (_, i) => filters[i]);
+    const filters = await Promise.all(map(iterable, func));
+    return filter(iterable, (_, i) => filters[i]);
 }
-function mapObject(obj, func) {
-    return Object.fromEntries(Object.entries(obj).map(x => func(x)));
+async function parallel(...fns) {
+    return asyncMap(fns, f => f());
 }
-function filterObject(obj, func) {
-    return Object.fromEntries(Object.entries(obj).filter(x => func(x)));
+async function serial(...fns) {
+    const results = [];
+    for (const f of fns)
+        results.push(await f());
+    return results;
 }

package/dist/object.d.ts

@@ -0,0 +1,30 @@
+export declare function mapObject<T, U>(obj: Record<string, T>, func: (x: [k: string, v: T]) => [k: string, v: U]): Record<string, U>;
+export declare function filterObject<T>(obj: Record<string, T>, func: (x: [k: string, v: T]) => boolean): Record<string, T>;
+export declare function merge(...list: Record<string, any>[]): Record<string, any>;
+export declare function isEmpty(obj: object): boolean;
+export declare function clone<T extends object>(obj: T): T;
+export declare function compare<T>(a: T, b: T): number;
+export declare function reverse_compare<T>(a: T, b: T): number;
+export declare function reverse<T, R>(func: (a: T, b: T) => R): (a: T, b: T) => R;
+export declare class Lazy<T> {
+    private factory;
+    private _value;
+    constructor(factory: () => T);
+    get value(): T;
+    then<U>(this: T extends Promise<infer R> ? Lazy<T> : never, onFulfilled: (value: T extends Promise<infer R> ? R : never) => U): Promise<U>;
+}
+export declare class CallCombiner0 {
+    private timeout;
+    combine(delay: number, func: () => void): void;
+    pending(): boolean;
+}
+export declare class CallCombiner extends CallCombiner0 {
+    private func;
+    private delay;
+    constructor(func: () => void, delay: number);
+    trigger(): void;
+}
+export declare function makeCache<T>(load: (key: string) => T): {
+    get: (fullpath: string) => T;
+    remove: (fullpath: string) => void;
+};

package/dist/object.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CallCombiner = exports.CallCombiner0 = exports.Lazy = void 0;
+exports.mapObject = mapObject;
+exports.filterObject = filterObject;
+exports.merge = merge;
+exports.isEmpty = isEmpty;
+exports.clone = clone;
+exports.compare = compare;
+exports.reverse_compare = reverse_compare;
+exports.reverse = reverse;
+exports.makeCache = makeCache;
+function mapObject(obj, func) {
+    return Object.fromEntries(Object.entries(obj).map(x => func(x)));
+}
+function filterObject(obj, func) {
+    return Object.fromEntries(Object.entries(obj).filter(x => func(x)));
+}
+function merge(...list) {
+    function isObject(value) {
+        return typeof value === 'object' && value !== null;
+    }
+    function recurse(target, source) {
+        for (const key in source) {
+            if (isObject(source[key]) && isObject(target[key]))
+                recurse(target[key], source[key]);
+            else
+                target[key] = source[key];
+        }
+        return target;
+    }
+    return list.reduce((merged, r) => recurse(merged, r), {});
+}
+function isEmpty(obj) {
+    return Object.keys(obj).length === 0;
+}
+function clone(obj) {
+    return Object.assign(Object.create(Object.getPrototypeOf(obj)), obj);
+}
+function compare(a, b) {
+    return a < b ? -1 : a > b ? 1 : 0;
+}
+function reverse_compare(a, b) {
+    return compare(b, a);
+}
+function reverse(func) {
+    return (a, b) => func(b, a);
+}
+class Lazy {
+    factory;
+    _value;
+    constructor(factory) {
+        this.factory = factory;
+    }
+    get value() {
+        if (this._value === undefined)
+            this._value = this.factory();
+        return this._value;
+    }
+    // Add 'then' method only when T is a Promise
+    then(onFulfilled) {
+        return this.value.then(onFulfilled);
+    }
+}
+exports.Lazy = Lazy;
+class CallCombiner0 {
+    timeout = null;
+    combine(delay, func) {
+        if (this.timeout)
+            clearTimeout(this.timeout);
+        this.timeout = setTimeout(() => {
+            this.timeout = null;
+            func();
+        }, delay);
+    }
+    pending() {
+        return !!this.timeout;
+    }
+}
+exports.CallCombiner0 = CallCombiner0;
+class CallCombiner extends CallCombiner0 {
+    func;
+    delay;
+    constructor(func, delay) {
+        super();
+        this.func = func;
+        this.delay = delay;
+    }
+    trigger() {
+        super.combine(this.delay, this.func);
+    }
+}
+exports.CallCombiner = CallCombiner;
+function makeCache(load) {
+    const cache = {};
+    return {
+        get: (fullpath) => {
+            if (!cache[fullpath])
+                cache[fullpath] = load(fullpath);
+            return cache[fullpath];
+        },
+        remove: (fullpath) => {
+            delete cache[fullpath];
+        },
+    };
+}

package/dist/string.d.ts

@@ -26,3 +26,7 @@ export declare class StringParser {
     match(re: RegExp): string | undefined;
     exec(re: RegExp): RegExpExecArray | undefined;
 }
+export declare function parseGlob(glob: string): string;
+export declare function anchoredRe(re: string): RegExp;
+export declare function globToRe(glob: string): RegExp;
+export declare function globToReMulti(globs: string[]): RegExp;

package/dist/string.js

@@ -17,6 +17,10 @@ exports.splitEvery = splitEvery;
 exports.tag = tag;
 exports.previousChar = previousChar;
 exports.hasCustomToString = hasCustomToString;
+exports.parseGlob = parseGlob;
+exports.anchoredRe = anchoredRe;
+exports.globToRe = globToRe;
+exports.globToReMulti = globToReMulti;
 function firstOf(value, find) {
     let index = value.length;
     for (const c of find) {
@@ -161,3 +165,106 @@ class StringParser {
     }
 }
 exports.StringParser = StringParser;
+const posixClasses = {
+    alnum: '\\p{L}\\p{Nl}\\p{Nd}',
+    alpha: '\\p{L}\\p{Nl}',
+    ascii: '\\x00-\\x7f',
+    blank: '\\p{Zs}\\t',
+    cntrl: '\\p{Cc}',
+    digit: '\\p{Nd}',
+    graph: '^\\p{Z}\\p{C}',
+    lower: '\\p{Ll}',
+    print: '\\p{C}',
+    punct: '\\p{P}',
+    space: '\\p{Z}\\t\\r\\n\\v\\f',
+    upper: '\\p{Lu}',
+    word: '\\p{L}\\p{Nl}\\p{Nd}\\p{Pc}',
+    xdigit: 'A-Fa-f0-9',
+};
+function parseGlob(glob) {
+    let result = '';
+    let depth = 0;
+    for (let i = 0; i < glob.length; ++i) {
+        let c = glob[i];
+        switch (c) {
+            case '\\':
+                c = glob[++i];
+                if ('*?+.,^$()|[]a-zA-Z'.includes(c))
+                    result += '\\';
+                break;
+            case '*':
+                if (glob[i + 1] === '*') {
+                    result += '.*';
+                    ++i;
+                }
+                else {
+                    result += '[^/]*';
+                }
+                continue;
+            case '?':
+                c = '.';
+                break;
+            case '+':
+            case '.':
+            case '^':
+            case '$':
+            case '(':
+            case ')':
+            case '|':
+                result += `\\`;
+                break;
+            case '[': {
+                const end = glob.indexOf(']', i + 1);
+                if (end > i) {
+                    const next = glob[i + 1];
+                    if (next === ':' && glob[end - 1] === ':') {
+                        const p = posixClasses[glob.slice(i + 2, end - 1)];
+                        if (p) {
+                            result += `[${p}]`;
+                            i = end;
+                            continue;
+                        }
+                        else {
+                            console.log(`Warning: Unknown POSIX class ${glob.slice(i + 2, end - 1)} in glob pattern ${glob}`);
+                        }
+                    }
+                    const neg = next === '!' || next === '^';
+                    result += `[${neg ? '^' : ''}${glob.slice(neg ? i + 2 : i + 1, end)}]`;
+                    i = end;
+                    continue;
+                }
+                result += '\\';
+                break;
+            }
+            case '{':
+                ++depth;
+                c = '(';
+                break;
+            case '}':
+                if (depth > 0) {
+                    --depth;
+                    c = ')';
+                }
+                break;
+            case ',':
+                if (depth > 0)
+                    c = '|';
+                break;
+        }
+        result += c;
+    }
+    if (depth > 0) {
+        console.log(`Warning: Unmatched { in glob pattern ${glob}`);
+        result += ')'.repeat(depth);
+    }
+    return result;
+}
+function anchoredRe(re) {
+    return new RegExp(`^${re}$`);
+}
+function globToRe(glob) {
+    return anchoredRe(parseGlob(glob));
+}
+function globToReMulti(globs) {
+    return anchoredRe(globs.map(parseGlob).join('|'));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@isopodlabs/utilities",
-	"version": "1.5.3",
+	"version": "1.5.5",
 	"description": "Various typescript helpers.",
 	"repository": {
 		"type": "git",