@isopodlabs/utilities 1.8.0 → 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.js

@@ -73,3 +73,4 @@ function* lazySlice(array, start, end) {
     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

@@ -1323,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

@@ -13,6 +13,7 @@ export declare class Lazy<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 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.8.0",
+	"version": "1.9.0",
 	"description": "Various typescript helpers.",
 	"repository": {
 		"type": "git",
@@ -17,6 +17,7 @@
 	],
 	"scripts": {
 		"build": "tsc",
+		"watch": "tsc -watch -p ./",
 		"lint": "eslint \"src/**/*.ts\""
 	},
 	"keywords": [