@isopodlabs/utilities 1.7.1 → 1.9.0

package/dist/algorithm.js

@@ -52,3 +52,4 @@ function argmax(array, func = object_1.compare) {
 function max(array, func = object_1.compare) {
     return array[argmax(array, func)];
 }
+//# sourceMappingURL=algorithm.js.map

package/dist/array.d.ts

@@ -4,3 +4,4 @@ export declare function equal<T>(arr1: T[], arr2: T[]): boolean;
 export declare function reverse<T>(array: T[], start: number, end: number): void;
 export declare function rotate<T>(array: T[], start: number, end: number, shift: number): void;
 export declare function make<T>(n: number, constructor: new () => T): T[];
+export declare function lazySlice<T>(array: T[], start?: number, end?: number): Generator<T>;

package/dist/array.js

@@ -6,6 +6,7 @@ exports.equal = equal;
 exports.reverse = reverse;
 exports.rotate = rotate;
 exports.make = make;
+exports.lazySlice = lazySlice;
 const object_1 = require("./object");
 //-----------------------------------------------------------------------------
 //	array
@@ -55,3 +56,21 @@ function rotate(array, start, end, shift) {
 function make(n, constructor) {
     return Array.from({ length: n }, () => new constructor);
 }
+function* lazySlice(array, start, end) {
+    const len = array.length;
+    if (start === undefined)
+        start = 0;
+    else if (start < 0)
+        start = Math.max(len + start, 0);
+    else
+        start = Math.min(start, len);
+    if (end === undefined)
+        end = len;
+    else if (end < 0)
+        end = Math.max(len + start, 0);
+    else
+        end = Math.min(end, len);
+    for (let i = start; i < end; i++)
+        yield array[i];
+}
+//# sourceMappingURL=array.js.map

package/dist/async.d.ts

@@ -1,4 +1,5 @@
 export declare function map<T, U>(iterable: Iterable<T> | undefined, func: (v: T, i: number) => Promise<U>): Promise<U[]>;
+export declare function mapObject<T, U>(obj: Record<string, T>, func: (x: [k: string, v: T]) => Promise<[k: string, v: U]>): Promise<Record<string, U>>;
 export declare function mapSerial<T, U>(iterable: Iterable<T> | undefined, func: (v: T, i: number) => Promise<U>): Promise<U[]>;
 export declare function reduce<T, U>(iterable: Iterable<T>, func: (acc: U, v: T, i: number, iterable: Iterable<T>) => Promise<U>, initialValue: U): Promise<U>;
 export declare function filter<T>(iterable: Iterable<T>, func: (v: T) => Promise<unknown>): Promise<T[]>;

package/dist/async.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.map = map;
+exports.mapObject = mapObject;
 exports.mapSerial = mapSerial;
 exports.reduce = reduce;
 exports.filter = filter;
@@ -45,6 +46,9 @@ const iterator = __importStar(require("./iterator"));
 async function map(iterable, func) {
     return Promise.all(iterator.map(iterable, func));
 }
+async function mapObject(obj, func) {
+    return Object.fromEntries(await Promise.all(Object.entries(obj).map(x => func(x))));
+}
 async function mapSerial(iterable, func) {
     const results = [];
     let i = 0;
@@ -63,3 +67,4 @@ async function filter(iterable, func) {
     const filters = await map(iterable, func);
     return iterator.filter(iterable, (_, i) => filters[i]);
 }
+//# sourceMappingURL=async.js.map

package/dist/bits.js

@@ -28,7 +28,7 @@ function highestSet32(x) {
     return x ? 32 - Math.clz32(x) : 0;
 }
 function highestSet1024(x) {
-    let b = Math.floor(Math.log2(x));
+    const b = Math.floor(Math.log2(x));
     return 1n << BigInt(b) <= x ? b + 1 : b;
 }
 // Returns the number of set bits
@@ -42,7 +42,7 @@ function nthSet32(x, i) {
     let b2 = x - ((x >> 1) & 0x55555555);
     let b4 = (b2 & 0x33333333) + ((b2 >> 2) & 0x33333333);
     let b8 = (b4 + (b4 >> 4) & 0xF0F0F0F);
-    let b16 = (b8 + (b8 >> 8)) & 0xff;
+    const b16 = (b8 + (b8 >> 8)) & 0xff;
     let n = 0;
     if (i >= b16) {
         i -= b16;
@@ -744,7 +744,8 @@ function sparseClearMask(bits, i, m, undef = 0) {
         bits[i] = ~m;
 }
 function sparseSetRange(bits, a, b, undef = 0) {
-    let i = a >> 5, j = b >> 5;
+    let i = a >> 5;
+    const j = b >> 5;
     if (i === j) {
         sparseSetMask(bits, i, (1 << (b & 0x1f)) - (1 << (a & 0x1f)), undef);
     }
@@ -762,7 +763,8 @@ function sparseSetRange(bits, a, b, undef = 0) {
     }
 }
 function sparseClearRange(bits, a, b, undef = 0) {
-    let i = a >> 5, j = b >> 5;
+    let i = a >> 5;
+    const j = b >> 5;
     if (i === j) {
         sparseClearMask(bits, i, (1 << (b & 0x1f)) - (1 << (a & 0x1f)), undef);
     }
@@ -821,36 +823,32 @@ function sparseComplement(bits) {
 function sparseIntersect(bits, other) {
     const result = [];
     for (const i in bits) {
-        if (other[i] !== undefined) {
+        if (other[i] !== undefined)
             result[i] = bits[i] & other[i];
-        }
     }
     return result;
 }
 function sparseUnion(bits, other) {
     const result = [];
     for (const i in bits) {
-        if (other[i] !== undefined) {
+        if (other[i] !== undefined)
             result[i] = bits[i] | other[i];
-        }
     }
     return result;
 }
 function sparseXor(bits, other) {
     const result = [];
     for (const i in bits) {
-        if (other[i] !== undefined) {
+        if (other[i] !== undefined)
             result[i] = bits[i] ^ other[i];
-        }
     }
     return result;
 }
 function sparseDifference(bits, other) {
     const result = [];
     for (const i in bits) {
-        if (other[i] !== undefined) {
+        if (other[i] !== undefined)
             result[i] = bits[i] & ~other[i];
-        }
     }
     return result;
 }
@@ -975,7 +973,7 @@ function* sparseWhere(bits, set, from = -1, to, undef = 0) {
 }
 function* sparseRanges(bits, set, undef = 0) {
     let start = -1, end = 0;
-    let other = undef ? set : !set;
+    const other = undef ? set : !set;
     for (const i in bits) {
         let b = bits[i] ^ undef;
         const c0 = +i * 32;
@@ -1325,3 +1323,4 @@ class SparseBits2 extends SparseBits {
 }
 exports.SparseBits2 = SparseBits2;
 ;
+//# sourceMappingURL=bits.js.map

package/dist/glob.d.ts

@@ -1,4 +1,4 @@
-export declare function parseGlob(glob: string): string;
+export declare function parse(glob: string): string;
 export declare function anchoredRe(re: string): RegExp;
-export declare function globToRe(glob: string): RegExp;
-export declare function globToReMulti(globs: string[]): RegExp;
+export declare function toRe(glob: string): RegExp;
+export declare function toReMulti(globs: string[]): RegExp;

package/dist/glob.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseGlob = parseGlob;
+exports.parse = parse;
 exports.anchoredRe = anchoredRe;
-exports.globToRe = globToRe;
-exports.globToReMulti = globToReMulti;
+exports.toRe = toRe;
+exports.toReMulti = toReMulti;
 const posixClasses = {
     alnum: '\\p{L}\\p{Nl}\\p{Nd}',
     alpha: '\\p{L}\\p{Nl}',
@@ -23,7 +23,7 @@ const posixClasses = {
 //-----------------------------------------------------------------------------
 // Glob pattern to regex
 //-----------------------------------------------------------------------------
-function parseGlob(glob) {
+function parse(glob) {
     let result = '';
     let depth = 0;
     for (let i = 0; i < glob.length; ++i) {
@@ -104,9 +104,10 @@ function parseGlob(glob) {
 function anchoredRe(re) {
     return new RegExp(`^${re}$`);
 }
-function globToRe(glob) {
-    return anchoredRe(parseGlob(glob));
+function toRe(glob) {
+    return anchoredRe(parse(glob));
 }
-function globToReMulti(globs) {
-    return anchoredRe(globs.map(parseGlob).join('|'));
+function toReMulti(globs) {
+    return anchoredRe(globs.map(parse).join('|'));
 }
+//# sourceMappingURL=glob.js.map

package/dist/index.d.ts

@@ -2,10 +2,23 @@ export * from './object';
 export * from './iterator';
 export * from './string';
 export * from './algorithm';
-export * from './glob';
+export * as glob from './glob';
 export * as bits from './bits';
 export * as array from './array';
 export * as async from './async';
 export * as insensitive from './insensitive';
 export declare function parallel(...fns: (() => any)[]): Promise<any[]>;
 export declare function serial(...fns: (() => any)[]): Promise<any[]>;
+export declare function regex(strings: TemplateStringsArray, ...args: any[]): RegExp;
+export declare function regex(flags: string): (strings: TemplateStringsArray, ...args: any[]) => RegExp;
+export declare function reDup(re: RegExp): RegExp;
+export declare class DeferredPromise<T> {
+    private promise;
+    private resolver?;
+    private rejecter?;
+    constructor(t?: T);
+    resolve(value: T): void;
+    reset(): void;
+    then<T2 = void>(onfulfilled?: (t: T) => T2 | PromiseLike<T2>): Promise<T2>;
+    reject(error: any): void;
+}

package/dist/index.js

@@ -36,15 +36,17 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.insensitive = exports.async = exports.array = exports.bits = void 0;
+exports.DeferredPromise = exports.insensitive = exports.async = exports.array = exports.bits = exports.glob = void 0;
 exports.parallel = parallel;
 exports.serial = serial;
+exports.regex = regex;
+exports.reDup = reDup;
 const async = __importStar(require("./async"));
 __exportStar(require("./object"), exports);
 __exportStar(require("./iterator"), exports);
 __exportStar(require("./string"), exports);
 __exportStar(require("./algorithm"), exports);
-__exportStar(require("./glob"), exports);
+exports.glob = __importStar(require("./glob"));
 exports.bits = __importStar(require("./bits"));
 exports.array = __importStar(require("./array"));
 exports.async = __importStar(require("./async"));
@@ -55,3 +57,48 @@ async function parallel(...fns) {
 async function serial(...fns) {
     return async.mapSerial(fns, f => f());
 }
+function regex(param, ...args) {
+    const flags = typeof param === 'string' ? param : 'g';
+    if (typeof param === 'string')
+        return inner;
+    return inner(param, ...args);
+    function inner(strings, ...args) {
+        const s = strings.raw.reduce((s, str, i) => s + str + (args[i] || ''), '');
+        const lines = s.split('\n');
+        return new RegExp(lines.map(line => line.split('#')[0].trim()).join(''), flags);
+    }
+    ;
+}
+function reDup(re) { return new RegExp(re.source, re.flags); }
+class DeferredPromise {
+    promise;
+    resolver;
+    rejecter;
+    constructor(t) {
+        this.promise = t === undefined ? new Promise((resolve, reject) => {
+            this.resolver = resolve;
+            this.rejecter = reject;
+        }) : Promise.resolve(t);
+    }
+    resolve(value) {
+        if (this.resolver) {
+            this.resolver(value);
+            this.resolver = undefined;
+        }
+    }
+    reset() {
+        this.promise = new Promise((resolve, reject) => {
+            this.resolver = resolve;
+            this.rejecter = reject;
+        });
+    }
+    then(onfulfilled) {
+        return this.promise.then(onfulfilled);
+    }
+    reject(error) {
+        if (this.rejecter)
+            this.rejecter(error);
+    }
+}
+exports.DeferredPromise = DeferredPromise;
+//# sourceMappingURL=index.js.map

package/dist/insensitive.js

@@ -77,3 +77,4 @@ class Set extends globalThis.Set {
     has(value) { return super.has(value.toUpperCase()); }
 }
 exports.Set = Set;
+//# sourceMappingURL=insensitive.js.map

package/dist/iterator.js

@@ -76,3 +76,4 @@ function filter(iterable, func) {
             array.push(v);
     return array;
 }
+//# sourceMappingURL=iterator.js.map

package/dist/object.d.ts

@@ -11,8 +11,9 @@ export declare class Lazy<T> {
     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>;
+    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 function Memoize<T>(func: () => T): () => T;
 export declare class CallCombiner0 {
     private timeout?;
     combine(delay: number, func: () => void): void;

package/dist/object.js

@@ -9,6 +9,7 @@ exports.clone = clone;
 exports.compare = compare;
 exports.reverse_compare = reverse_compare;
 exports.reverse = reverse;
+exports.Memoize = Memoize;
 exports.makeCache = makeCache;
 exports.union = union;
 exports.difference = difference;
@@ -65,6 +66,10 @@ class Lazy {
     }
 }
 exports.Lazy = Lazy;
+function Memoize(func) {
+    const lazy = new Lazy(func);
+    return () => lazy.value;
+}
 class CallCombiner0 {
     timeout;
     combine(delay, func) {
@@ -117,3 +122,4 @@ function difference(a, b) {
     }
     return [remaining, removed];
 }
+//# sourceMappingURL=object.js.map

package/dist/string.d.ts

@@ -5,6 +5,7 @@ export declare function splitLastOf(value: string, find: string): (string | unde
 export declare function trim0(value: string): string;
 export declare function replace(value: string, re: RegExp, process: (match: RegExpExecArray) => string): string;
 export declare function async_replace(value: string, re: RegExp, process: (match: RegExpExecArray) => Promise<string>): Promise<string>;
+export declare function async_replace_async(value: string, re: RegExp, process: (match: RegExpExecArray) => Promise<string>): Promise<string>;
 export declare function replace_back(value: string, re: RegExp, process: (match: RegExpExecArray, right: string) => string): string;
 export declare function async_replace_back(value: string, re: RegExp, process: (match: RegExpExecArray, right: string) => Promise<string>): Promise<string>;
 export declare function splitEvery(s: string, n: number): string[];

package/dist/string.js

@@ -11,6 +11,7 @@ exports.splitLastOf = splitLastOf;
 exports.trim0 = trim0;
 exports.replace = replace;
 exports.async_replace = async_replace;
+exports.async_replace_async = async_replace_async;
 exports.replace_back = replace_back;
 exports.async_replace_back = async_replace_back;
 exports.splitEvery = splitEvery;
@@ -54,17 +55,29 @@ function replace(value, re, process) {
     return result + value.substring(i);
 }
 /*
-export async function async_replace(value: string, re: RegExp, process: (match: RegExpExecArray)=>Promise<string>): Promise<string> {
+export async function async_replace<T = undefined>(value: string, re: RegExp, process: (match: RegExpExecArray, right: (context?: T)=>Promise<string>, context?: T)=>Promise<string>, context?: T): Promise<string> {
+    const right		= async (context?: T) => async_replace(value, re, process, context);
     let result = "";
-    let i = 0;
+    let i = re.lastIndex;
     for (let m; (m = re.exec(value));) {
-        result += value.substring(i, m.index) + await process(m);
+        result += value.substring(i, m.index) + await process(m, right, context);
         i = re.lastIndex;
     }
+    re.lastIndex = value.length;
     return result + value.substring(i);
 }
 */
 async function async_replace(value, re, process) {
+    let result = "";
+    let i = re.lastIndex;
+    for (let m; (m = re.exec(value));) {
+        result += value.substring(i, m.index) + await process(m);
+        i = re.lastIndex;
+    }
+    re.lastIndex = value.length;
+    return result + value.substring(i);
+}
+async function async_replace_async(value, re, process) {
     const combine = async (m) => value.substring(i, m.index) + await process(m);
     const promises = [];
     let i = 0;
@@ -161,3 +174,4 @@ class StringParser {
     }
 }
 exports.StringParser = StringParser;
+//# sourceMappingURL=string.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@isopodlabs/utilities",
-	"version": "1.7.1",
+	"version": "1.9.0",
 	"description": "Various typescript helpers.",
 	"repository": {
 		"type": "git",
@@ -16,7 +16,9 @@
 		"README.md"
 	],
 	"scripts": {
-		"build": "tsc"
+		"build": "tsc",
+		"watch": "tsc -watch -p ./",
+		"lint": "eslint \"src/**/*.ts\""
 	},
 	"keywords": [
 		"typescript",
@@ -29,7 +31,6 @@
 	"devDependencies": {
 		"@types/node": "^22.13.8",
 		"eslint": "^9.21.0",
-		"typescript": "^5.8.2",
 		"typescript-eslint": "^8.26.0"
 	}
 }