@isopodlabs/utilities 1.4.1 → 1.5.0

package/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Adrian Stephens
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,24 +1,27 @@
-# @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
-
+# @isopodlabs/utilities
+[![npm version](https://img.shields.io/npm/v/@isopodlabs/utilities.svg)](https://www.npmjs.com/package/@isopodlabs/utilities)
+[![GitHub stars](https://img.shields.io/github/stars/adrianstephens/utilities.svg?style=social)](https://github.com/adrianstephens/utilities)
+[![License](https://img.shields.io/npm/l/@isopodlabs/utilities.svg)](LICENSE.txt)
+
+This package provides a set of utilities for TypeScript.
+
+## ☕ Support My Work  
+If you use this package, consider [buying me a cup of 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/glob.d.ts

@@ -0,0 +1,20 @@
+export interface Patcher {
+    patch(input: string): string;
+}
+export declare function patch<T>(patcher: Patcher, input: T): T;
+export declare class MapPatcher implements Patcher {
+    matches: Record<string, string>;
+    constructor(matches: Record<string, string>);
+    add(key: string, value: string): this;
+    patch(input: string): string;
+}
+export declare function globRe(glob: string): RegExp;
+export declare class Glob {
+    glob: string;
+    re: RegExp;
+    constructor(glob: string);
+    test(match: string): boolean;
+    star(match: string): string;
+}
+export declare function isWild(glob: string): boolean;
+export declare function expandGlobs(patterns: string[], cwd: string): Promise<string[]>;

package/dist/glob.js

@@ -0,0 +1,156 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Glob = exports.MapPatcher = void 0;
+exports.patch = patch;
+exports.globRe = globRe;
+exports.isWild = isWild;
+exports.expandGlobs = expandGlobs;
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+function patch(patcher, input) {
+    if (typeof input === 'string')
+        return patcher.patch(input);
+    if (typeof input === 'object' && input !== null) {
+        if (Array.isArray(input))
+            return input.map(value => patch(patcher, value));
+        return Object.entries(input).reduce((acc, [key, value]) => {
+            acc[key] = patch(patcher, value);
+            return acc;
+        }, Object.create(Object.getPrototypeOf(input)));
+    }
+    return input;
+}
+class MapPatcher {
+    matches;
+    constructor(matches) {
+        this.matches = matches;
+    }
+    add(key, value) {
+        this.matches[key] = value;
+        return this;
+    }
+    patch(input) {
+        for (const [key, value] of Object.entries(this.matches))
+            input = input.replaceAll(key, value);
+        return input;
+    }
+}
+exports.MapPatcher = MapPatcher;
+function globRe(glob) {
+    const regex = glob
+        .replace(/[.+^${}()|[\]\\]/g, '\\$&') // Escape regex chars except * and ?
+        .replace(/\*/g, '[^/]*') // * matches any chars except dir separator
+        .replace(/\*\*/g, '.*') // ** matches any chars
+        .replace(/\?/g, '.'); // ? matches single char
+    return new RegExp(`^${regex}$`);
+}
+class Glob {
+    glob;
+    re;
+    constructor(glob) {
+        this.glob = glob;
+        this.re = globRe(glob);
+    }
+    test(match) {
+        return this.re.test(match);
+    }
+    star(match) {
+        const parts = this.glob.split('*');
+        return match.slice(parts[0].length, match.length - parts[1].length);
+    }
+}
+exports.Glob = Glob;
+function isWild(glob) {
+    return glob.includes('*') || glob.includes('?');
+}
+async function getDirs(dir, glob) {
+    const star = dir.indexOf('*');
+    if (star >= 0) {
+        const startDir = dir.lastIndexOf(path.sep, star);
+        const endDir = dir.indexOf(path.sep, star);
+        const dirDone = dir.substring(0, startDir);
+        const dirWild = dir.substring(startDir + 1, endDir >= 0 ? endDir : undefined);
+        const dirRest = endDir >= 0 ? dir.substring(endDir + 1) : '';
+        const entries = await fs.promises.readdir(dirDone, { withFileTypes: true });
+        if (dirWild === '**') {
+            if (dirRest) {
+                return (await Promise.all(entries.filter(i => i.isDirectory()).map(async (i) => [
+                    ...await getDirs(path.join(i.parentPath, i.name, '**', dirRest), glob),
+                    ...await getDirs(path.join(i.parentPath, i.name, dirRest), glob)
+                ]))).flat();
+            }
+            else {
+                /*
+                return (await Promise.all(entries.filter(i => i.isDirectory()).map(i =>
+                    getDirs(path.join(i.parentPath, i.name, '**'), glob)
+                ))).flat().concat(
+                    entries.filter(i => !i.isDirectory() && glob.test(i.name))
+                    .map(i => path.join(i.parentPath, i.name))
+                );*/
+                return (await Promise.all(entries.map(i => i.isDirectory() ? getDirs(path.join(i.parentPath, i.name, '**'), glob)
+                    : glob.test(i.name) ? path.join(i.parentPath, i.name)
+                        : []))).flat();
+            }
+        }
+        else {
+            const dirGlob = globRe(dirWild);
+            return (await Promise.all(entries
+                .filter(i => i.isDirectory() && dirGlob.test(i.name))
+                .map(i => getDirs(path.join(dirDone, i.name, dirRest), glob)))).flat();
+        }
+    }
+    else {
+        try {
+            const entries = await fs.promises.readdir(dir, { withFileTypes: true });
+            return entries
+                .filter(i => !i.isDirectory() && glob.test(i.name))
+                .map(i => path.join(i.parentPath, i.name));
+        }
+        catch (error) {
+            console.log(`Warning: Cannot read directory ${dir}: ${error}`);
+            return [];
+        }
+    }
+}
+async function expandGlobs(patterns, cwd) {
+    const files = (await Promise.all(patterns.map(async (i) => {
+        const pattern = path.resolve(cwd, i);
+        return isWild(i)
+            ? await getDirs(path.dirname(pattern), globRe(path.basename(pattern)))
+            : pattern;
+    }))).flat();
+    return [...new Set(files)]; // Remove duplicates
+}

package/dist/insensitive.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): 0 | 1 | -1;
+}
+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): 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>;

package/dist/insensitive.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/string.js

@@ -45,25 +45,35 @@ function trim0(value) {
     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))) {
+    for (let m; (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;
+/*
+export async function async_replace(value: string, re: RegExp, process: (match: RegExpExecArray)=>Promise<string>): Promise<string> {
     let result = "";
     let i = 0;
-    while ((m = re.exec(value))) {
+    for (let m; (m = re.exec(value));) {
         result += value.substring(i, m.index) + await process(m);
         i = re.lastIndex;
     }
     return result + value.substring(i);
 }
+*/
+async function async_replace(value, re, process) {
+    const combine = async (m) => value.substring(i, m.index) + await process(m);
+    const promises = [];
+    let i = 0;
+    for (let m; (m = re.exec(value));) {
+        promises.push(combine(m));
+        i = re.lastIndex;
+    }
+    return (await Promise.all(promises)).join('') + value.substring(i);
+}
 function replace_back(value, re, process) {
     const start = re.lastIndex;
     const m = re.exec(value);
@@ -88,10 +98,10 @@ 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) => {
+    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

package/package.json

@@ -1,28 +1,36 @@
-{
-  "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"
-  }
-}
+{
+	"name": "@isopodlabs/utilities",
+	"version": "1.5.0",
+	"description": "Various typescript helpers.",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/adrianstephens/ts-utilities.git"
+	},
+	"main": "dist/index.js",
+	"exports": {
+		".": "./dist/index.js",
+		"./insensitive": "./dist/insensitive.js"
+	},
+	"files": [
+		"dist/**/*.{js,d.ts}",
+		"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"
+	}
+}