@isopodlabs/utilities 1.4.1

package/README.md

@@ -0,0 +1,24 @@
+# @isopodlabs/utilities
+
+This package provides a set of utilities for TypeScript.
+
+## ☕ Support My Work  
+If you use this package, consider [buying me a tea](https://coff.ee/adrianstephens) to support future updates!  
+
+## Usage
+
+Here is a basic example of how to use the package:
+
+```typescript
+import * as utils from '@isopodlabs/utilities';
+````
+
+**Interfaces**:
+
+
+**Functions**:
+
+
+## License
+
+This project is licensed under the MIT License.

package/dist/CaseInsensitive.d.ts

@@ -0,0 +1,22 @@
+export declare class CaseInsensitiveString {
+    private value;
+    constructor(value: string);
+    get length(): number;
+    toString(): string;
+    includes(searchString: string, position?: number): boolean;
+    startsWith(searchString: string, position?: number): boolean;
+    endsWith(searchString: string, position?: number): boolean;
+    indexOf(searchString: string, position?: number): number;
+    lastIndexOf(searchString: string, position?: number): number;
+    compare(other: string): 1 | -1 | 0;
+}
+export declare class CaseInsensitiveString2 extends CaseInsensitiveString {
+    private orig;
+    constructor(orig: string);
+    toString(): string;
+}
+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 Record<T>(obj: Record<string, T>): Record<string, T>;
+export declare function Record2<T>(obj: Record<string, T>): Record<string, T>;

package/dist/CaseInsensitive.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CaseInsensitiveString2 = exports.CaseInsensitiveString = void 0;
+exports.String = String;
+exports.String2 = String2;
+exports.compare = compare;
+exports.Record = Record;
+exports.Record2 = Record2;
+class CaseInsensitiveString {
+    value;
+    constructor(value) { this.value = value.toLowerCase(); }
+    get length() { return this.value.length; }
+    toString() { return this.value; }
+    includes(searchString, position) { return this.value.includes(searchString.toLowerCase(), position); }
+    startsWith(searchString, position) { return this.value.startsWith(searchString.toLowerCase(), position); }
+    endsWith(searchString, position) { return this.value.endsWith(searchString.toLowerCase(), position); }
+    indexOf(searchString, position) { return this.value.indexOf(searchString.toLowerCase(), position); }
+    lastIndexOf(searchString, position) { return this.value.lastIndexOf(searchString.toLowerCase(), position); }
+    compare(other) { const bi = other.toLowerCase(); return this.value < bi ? -1 : this.value > bi ? 1 : 0; }
+}
+exports.CaseInsensitiveString = CaseInsensitiveString;
+// keeps original string
+class CaseInsensitiveString2 extends CaseInsensitiveString {
+    orig;
+    constructor(orig) {
+        super(orig);
+        this.orig = orig;
+    }
+    toString() { return this.orig; }
+}
+exports.CaseInsensitiveString2 = CaseInsensitiveString2;
+function String(value) {
+    return new CaseInsensitiveString(value);
+}
+function String2(value) {
+    return new CaseInsensitiveString2(value);
+}
+function compare(a, b) {
+    const ai = a.toUpperCase(), bi = b.toUpperCase();
+    return ai < bi ? -1 : ai > bi ? 1 : 0;
+}
+function Record(obj) {
+    return new Proxy(obj, {
+        get: (target, name) => target[name.toUpperCase()],
+        set: (target, name, value) => (target[name.toUpperCase()] = value, true),
+        has: (target, name) => name.toUpperCase() in target,
+    });
+}
+// keeps original record
+function Record2(obj) {
+    return new Proxy(Object.entries(obj).reduce((acc, [key, value]) => ((acc[key.toUpperCase()] = value), acc), {}), {
+        get: (target, name) => target[name.toUpperCase()],
+        set: (target, name, value) => (target[name.toUpperCase()] = value, true),
+        has: (target, name) => name.toUpperCase() in target,
+        ownKeys: (target) => Object.keys(obj),
+        getOwnPropertyDescriptor: (target, name) => Object.getOwnPropertyDescriptor(obj, name)
+    });
+}

package/dist/algorithm.d.ts

@@ -0,0 +1,5 @@
+type PartitionIndex<U> = U extends boolean ? 'true' | 'false' : U;
+export declare function partition<T, U extends keyof any | boolean>(array: Iterable<T>, func: (v: T) => U): Record<PartitionIndex<U>, T[]>;
+export declare function lowerBound<T>(array: T[], value: T, func: (a: T, b: T, i: number) => boolean): number;
+export declare function argmin<T>(array: T[], func?: (i: T) => number): number;
+export {};

package/dist/algorithm.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.partition = partition;
+exports.lowerBound = lowerBound;
+exports.argmin = argmin;
+function partition(array, func) {
+    const partitions = {};
+    for (const i of array)
+        (partitions[func(i)] ??= []).push(i);
+    return partitions;
+}
+function lowerBound(array, value, func) {
+    let i = 0;
+    for (let n = array.length; n; n >>= 1) {
+        const mid = i + (n >> 1);
+        if (func(array[mid], value, mid)) {
+            i = mid + 1;
+            --n;
+        }
+    }
+    return i;
+}
+function argmin(array, func) {
+    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;
+}

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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 });
+__exportStar(require("./utils"), exports);
+__exportStar(require("./iterator"), exports);
+__exportStar(require("./string"), exports);
+__exportStar(require("./algorithm"), exports);

package/dist/iterator.d.ts

@@ -0,0 +1,19 @@
+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 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 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) => boolean): T[];
+export declare function asyncFilter<T>(iterable: Iterable<T>, func: (v: T) => Promise<boolean>): 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

@@ -0,0 +1,120 @@
+"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.asyncMap = asyncMap;
+exports.asyncReduce = asyncReduce;
+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);
+}
+function arrayRemove(array, item) {
+    const index = array.indexOf(item);
+    if (index === -1)
+        return false;
+    array.splice(index, 1);
+    return true;
+}
+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]);
+        if (r)
+            return r;
+    }
+    return arr1.length - arr2.length;
+}
+function arrayEqual(arr1, arr2) {
+    if (arr1.length !== arr2.length)
+        return false;
+    for (let i = 0; i < arr1.length; i++) {
+        if (arr1[i] !== arr2[i])
+            return false;
+    }
+    return true;
+}
+function arrayRotate(array, start, end, shift) {
+    const length = end - start;
+    if (length > 1 && shift % length) {
+        shift = ((shift % length) + length) % length;
+        arrayReverse(array, start, end - 1);
+        arrayReverse(array, start, start + shift - 1);
+        arrayReverse(array, start + shift, end - 1);
+    }
+}
+function arrayReverse(array, start, end) {
+    while (start < end) {
+        [array[start], array[end]] = [array[end], array[start]];
+        start++;
+        end--;
+    }
+}
+function array_make(n, constructor) {
+    return Array.from({ length: n }, () => new constructor);
+}
+function eachIterable(iterable, func) {
+    if (iterable) {
+        let i = 0;
+        for (const v of iterable)
+            func(v, i++);
+    }
+}
+function findIterable(iterable, func) {
+    if (iterable) {
+        for (const v of iterable) {
+            if (func(v))
+                return v;
+        }
+    }
+}
+function mapIterable(iterable, func) {
+    return iterable ? Array.from(iterable, func) : [];
+}
+async function asyncMap(iterable, func) {
+    return Promise.all(mapIterable(iterable, func));
+}
+async function asyncReduce(array, func, initialValue) {
+    return array.reduce(async (promise, v, i, array) => func(await promise, v, i, array), Promise.resolve(initialValue));
+}
+async function parallel(...fns) {
+    return asyncMap(fns, f => f());
+}
+async function serial(...fns) {
+    const results = [];
+    for (const f of fns)
+        results.push(await f());
+    return results;
+}
+function filterIterable(iterable, func) {
+    const array = [];
+    let i = 0;
+    for (const v of iterable)
+        if (func(v, i++))
+            array.push(v);
+    return array;
+}
+async function asyncFilter(iterable, func) {
+    const filters = await Promise.all(mapIterable(iterable, func));
+    return filterIterable(iterable, (_, i) => filters[i]);
+}
+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)));
+}

package/dist/string.d.ts

@@ -0,0 +1,28 @@
+export declare function firstOf(value: string, find: string): number;
+export declare function lastOf(value: string, find: string): number;
+export declare function splitFirstOf(value: string, find: string): (string | undefined)[];
+export declare function splitLastOf(value: string, find: string): (string | undefined)[];
+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 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[];
+export declare function tag(strings: TemplateStringsArray, ...keys: any[]): (...values: any[]) => string;
+export declare function previousChar(str: string, pos: number): string;
+export declare function hasCustomToString(value: any): boolean;
+export declare class StringParser {
+    subject: string;
+    pos: number;
+    constructor(subject: string, pos?: number);
+    remaining(): number;
+    remainder(): string;
+    processed(): string;
+    peek(): string;
+    peekn(n: number): string;
+    get(n: number): string;
+    skip(c: string): boolean;
+    expect(c: string): void;
+    match(re: RegExp): string | undefined;
+    exec(re: RegExp): RegExpExecArray | undefined;
+}

package/dist/string.js

@@ -0,0 +1,153 @@
+"use strict";
+//-----------------------------------------------------------------------------
+//	strings
+//-----------------------------------------------------------------------------
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StringParser = void 0;
+exports.firstOf = firstOf;
+exports.lastOf = lastOf;
+exports.splitFirstOf = splitFirstOf;
+exports.splitLastOf = splitLastOf;
+exports.trim0 = trim0;
+exports.replace = replace;
+exports.async_replace = async_replace;
+exports.replace_back = replace_back;
+exports.async_replace_back = async_replace_back;
+exports.splitEvery = splitEvery;
+exports.tag = tag;
+exports.previousChar = previousChar;
+exports.hasCustomToString = hasCustomToString;
+function firstOf(value, find) {
+    let index = value.length;
+    for (const c of find) {
+        const i = value.indexOf(c);
+        if (i >= 0)
+            index = Math.min(i);
+    }
+    return index;
+}
+function lastOf(value, find) {
+    let index = -1;
+    for (const c of find)
+        index = Math.max(value.indexOf(c));
+    return index;
+}
+function splitFirstOf(value, find) {
+    const index = firstOf(value, find);
+    return index === -1 ? [undefined, value] : [value.substring(0, index), value.substring(index + 1)];
+}
+function splitLastOf(value, find) {
+    const index = lastOf(value, find);
+    return index === -1 ? [value, undefined] : [value.substring(0, index), value.substring(index + 1)];
+}
+function trim0(value) {
+    const index = value.indexOf('\0');
+    return index === -1 ? value : value.substring(0, index);
+}
+function replace(value, re, process) {
+    let m;
+    let result = "";
+    let i = 0;
+    while ((m = re.exec(value))) {
+        result += value.substring(i, m.index) + process(m);
+        i = re.lastIndex;
+    }
+    return result + value.substring(i);
+}
+async function async_replace(value, re, process) {
+    let m;
+    let result = "";
+    let i = 0;
+    while ((m = re.exec(value))) {
+        result += value.substring(i, m.index) + await process(m);
+        i = re.lastIndex;
+    }
+    return result + value.substring(i);
+}
+function replace_back(value, re, process) {
+    const start = re.lastIndex;
+    const m = re.exec(value);
+    if (m) {
+        const right = replace_back(value, re, process);
+        return value.substring(start, m.index) + process(m, right);
+    }
+    re.lastIndex = value.length;
+    return value.substring(start);
+}
+async function async_replace_back(value, re, process) {
+    const start = re.lastIndex;
+    const m = re.exec(value);
+    if (m) {
+        const right = await async_replace_back(value, re, process);
+        return value.substring(start, m.index) + await process(m, right);
+    }
+    re.lastIndex = value.length;
+    return value.substring(start);
+}
+function splitEvery(s, n) {
+    return Array.from({ length: Math.ceil(s.length / n) }, (_, i) => s.slice(i * n, (i + 1) * n));
+}
+function tag(strings, ...keys) {
+    return ((...values) => {
+        const dict = values.at(-1) || {};
+        return keys.map((key, i) => (Number.isInteger(key) ? values[key] : dict[key]) + strings[i + 1]).join('');
+    });
+}
+function previousChar(str, pos) {
+    return pos === 0
+        ? "\n"
+        // check for low surrogate (BMP)
+        : (str.charCodeAt(pos - 1) & 0xfc00) === 0xdc00 && (str.charCodeAt(pos - 2) & 0xfc00) === 0xd800
+            ? str.slice(pos - 2, pos) : str.charAt(pos - 1);
+}
+function hasCustomToString(value) {
+    return value && value.toString !== Object.prototype.toString;
+}
+class StringParser {
+    subject;
+    pos;
+    constructor(subject, pos = 0) {
+        this.subject = subject;
+        this.pos = pos;
+    }
+    remaining() { return this.subject.length - this.pos; }
+    remainder() { return this.subject.slice(this.pos); }
+    processed() { return this.subject.slice(0, this.pos); }
+    peek() {
+        return this.subject[this.pos];
+    }
+    peekn(n) {
+        return this.subject.slice(this.pos, this.pos + n);
+    }
+    get(n) {
+        const pos = this.pos;
+        this.pos = Math.min(pos + n, this.subject.length);
+        return this.subject.slice(pos, this.pos);
+    }
+    skip(c) {
+        if (this.remainder().startsWith(c)) {
+            this.pos += c.length;
+            return true;
+        }
+        return false;
+    }
+    expect(c) {
+        if (!this.skip(c))
+            throw new Error(`Expected '${c}'`);
+    }
+    match(re) {
+        const m = re.exec(this.remainder());
+        if (m) {
+            this.pos += m.index + m[0].length;
+            return m[0];
+        }
+    }
+    exec(re) {
+        const m = re.exec(this.remainder());
+        if (m) {
+            this.pos += m.index + m[0].length;
+            return m;
+        }
+    }
+}
+exports.StringParser = StringParser;

package/dist/utils.d.ts

@@ -0,0 +1,33 @@
+export declare class Lazy<T> {
+    private factory;
+    private _value;
+    constructor(factory: () => T);
+    get value(): T;
+}
+export declare class AsyncLazy<T> {
+    private factory;
+    private _value;
+    constructor(factory: () => Promise<T>);
+    get value(): (T & {}) | null;
+}
+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;
+};
+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 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;

package/dist/utils.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CallCombiner = exports.CallCombiner0 = exports.AsyncLazy = exports.Lazy = void 0;
+exports.makeCache = makeCache;
+exports.compare = compare;
+exports.reverse_compare = reverse_compare;
+exports.reverse = reverse;
+exports.merge = merge;
+exports.isEmpty = isEmpty;
+exports.clone = clone;
+class Lazy {
+    factory;
+    _value;
+    constructor(factory) {
+        this.factory = factory;
+    }
+    get value() {
+        if (this._value === undefined)
+            this._value = this.factory();
+        return this._value;
+    }
+}
+exports.Lazy = Lazy;
+class AsyncLazy {
+    factory;
+    _value;
+    constructor(factory) {
+        this.factory = factory;
+    }
+    get value() {
+        if (this._value === undefined) {
+            this._value = null;
+            this.factory().then(v => this._value = v);
+        }
+        return this._value;
+    }
+}
+exports.AsyncLazy = AsyncLazy;
+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];
+        },
+    };
+}
+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);
+}
+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);
+}

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@isopodlabs/utilities",
+  "version": "1.4.1",
+  "description": "Various typescript helpers.",
+  "main": "dist/index.js",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "echo \"No tests specified\" && exit 0"
+  },
+  "keywords": [
+    "typescript",
+    "string",
+    "iterator",
+    "algorithm"
+  ],
+  "author": "Adrian Stephens",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^22.13.8",
+    "eslint": "^9.21.0",
+    "typescript": "^5.8.2",
+    "typescript-eslint": "^8.26.0"
+  }
+}