@isopodlabs/utilities 1.5.1 → 1.5.2

package/dist/algorithm.d.ts

@@ -1,5 +1,8 @@
 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 declare function argmin<T>(array: T[], func?: (a: T, b: T) => number): number;
+export declare function min<T>(array: T[], func?: (a: T, b: T) => number): T;
+export declare function argmax<T>(array: T[], func?: (a: T, b: T) => number): number;
+export declare function max<T>(array: T[], func?: (a: T, b: T) => number): T;
 export {};

package/dist/algorithm.js

@@ -3,6 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.partition = partition;
 exports.lowerBound = lowerBound;
 exports.argmin = argmin;
+exports.min = min;
+exports.argmax = argmax;
+exports.max = max;
+const utils_1 = require("./utils");
 function partition(array, func) {
     const partitions = {};
     for (const i of array)
@@ -20,9 +24,10 @@ function lowerBound(array, value, func) {
     }
     return i;
 }
-function argmin(array, func) {
-    let mini = 0;
-    let minv = func ? func(array[0]) : array[0];
+/*
+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) {
@@ -31,4 +36,29 @@ function argmin(array, func) {
         }
     }
     return mini;
+}
+    */
+function argmin(array, func = utils_1.compare) {
+    let mini = 0;
+    for (let i = 1; i < array.length; i++) {
+        const v = func(array[i], array[mini]);
+        if (v < 0)
+            mini = i;
+    }
+    return mini;
+}
+function min(array, func = utils_1.compare) {
+    return array[argmin(array, func)];
+}
+function argmax(array, func = utils_1.compare) {
+    let maxi = 0;
+    for (let i = 1; i < array.length; i++) {
+        const v = func(array[i], array[maxi]);
+        if (v > 0)
+            maxi = i;
+    }
+    return maxi;
+}
+function max(array, func = utils_1.compare) {
+    return array[argmax(array, func)];
 }

package/dist/index.d.ts

@@ -2,3 +2,4 @@ export * from './utils';
 export * from './iterator';
 export * from './string';
 export * from './algorithm';
+export * as insensitive from './insensitive';

package/dist/index.js

@@ -10,11 +10,35 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
     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 __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);
 };
+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.insensitive = void 0;
 __exportStar(require("./utils"), exports);
 __exportStar(require("./iterator"), exports);
 __exportStar(require("./string"), exports);
 __exportStar(require("./algorithm"), exports);
+exports.insensitive = __importStar(require("./insensitive"));

package/dist/insensitive.d.ts

@@ -1,22 +1,38 @@
-export declare class CaseInsensitiveString {
+declare class CaseInsensitiveString {
     private value;
     constructor(value: string);
     get length(): number;
     toString(): string;
+    toUpperCase(): string;
+    toLowerCase(): 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;
+    compare(other: string | CaseInsensitiveString): 1 | -1 | 0;
 }
-export declare class CaseInsensitiveString2 extends CaseInsensitiveString {
+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 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>;
+export declare class Map<T> extends globalThis.Map<string, T> {
+    constructor(entries?: Iterable<[string, T]>);
+    delete(key: string): boolean;
+    get(key: string): T | undefined;
+    has(key: string): boolean;
+    set(key: string, value: T): this;
+}
+export declare class Set extends globalThis.Set<string> {
+    constructor(values?: Iterable<string>);
+    add(value: string): this;
+    delete(value: string): boolean;
+    has(value: string): boolean;
+}
+export {};

package/dist/insensitive.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CaseInsensitiveString2 = exports.CaseInsensitiveString = void 0;
+exports.Set = exports.Map = void 0;
 exports.String = String;
 exports.String2 = String2;
 exports.compare = compare;
@@ -8,17 +8,18 @@ exports.Record = Record;
 exports.Record2 = Record2;
 class CaseInsensitiveString {
     value;
-    constructor(value) { this.value = value.toLowerCase(); }
+    constructor(value) { this.value = value.toUpperCase(); }
     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;
+    toUpperCase() { return this.value; }
+    toLowerCase() { return this.value.toLowerCase(); }
+    includes(searchString, position) { return this.value.includes(searchString.toUpperCase(), position); }
+    startsWith(searchString, position) { return this.value.startsWith(searchString.toUpperCase(), position); }
+    endsWith(searchString, position) { return this.value.endsWith(searchString.toUpperCase(), position); }
+    indexOf(searchString, position) { return this.value.indexOf(searchString.toUpperCase(), position); }
+    lastIndexOf(searchString, position) { return this.value.lastIndexOf(searchString.toUpperCase(), position); }
+    compare(other) { const bi = other.toUpperCase(); return this.value < bi ? -1 : this.value > bi ? 1 : 0; }
+}
 // keeps original string
 class CaseInsensitiveString2 extends CaseInsensitiveString {
     orig;
@@ -28,7 +29,6 @@ class CaseInsensitiveString2 extends CaseInsensitiveString {
     }
     toString() { return this.orig; }
 }
-exports.CaseInsensitiveString2 = CaseInsensitiveString2;
 function String(value) {
     return new CaseInsensitiveString(value);
 }
@@ -44,6 +44,8 @@ function Record(obj) {
         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(target),
+        getOwnPropertyDescriptor: (target, name) => Object.getOwnPropertyDescriptor(target, name),
     });
 }
 // keeps original record
@@ -52,7 +54,34 @@ function Record2(obj) {
         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)
+        ownKeys: (_target) => Object.keys(obj),
+        getOwnPropertyDescriptor: (target, name) => Object.getOwnPropertyDescriptor(target, name)
     });
 }
+class Map extends globalThis.Map {
+    constructor(entries) {
+        super();
+        if (entries) {
+            for (const [key, value] of entries)
+                this.set(key, value);
+        }
+    }
+    delete(key) { return super.delete(key.toUpperCase()); }
+    get(key) { return super.get(key.toUpperCase()); }
+    has(key) { return super.has(key.toUpperCase()); }
+    set(key, value) { return super.set(key.toUpperCase(), value); }
+}
+exports.Map = Map;
+class Set extends globalThis.Set {
+    constructor(values) {
+        super();
+        if (values) {
+            for (const value of values)
+                this.add(value);
+        }
+    }
+    add(value) { return super.add(value.toUpperCase()); }
+    delete(value) { return super.delete(value.toUpperCase()); }
+    has(value) { return super.has(value.toUpperCase()); }
+}
+exports.Set = Set;

package/dist/utils.d.ts

@@ -3,12 +3,14 @@ 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>;
 }
 export declare class AsyncLazy<T> {
     private factory;
     private _value;
     constructor(factory: () => Promise<T>);
     get value(): (T & {}) | null;
+    then(fn: (v: T) => void): void;
 }
 export declare class CallCombiner0 {
     private timeout;

package/dist/utils.js

@@ -19,6 +19,10 @@ class Lazy {
             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 AsyncLazy {
@@ -34,6 +38,18 @@ class AsyncLazy {
         }
         return this._value;
     }
+    then(fn) {
+        if (this._value === undefined) {
+            this._value = null;
+            this.factory().then(v => {
+                this._value = v;
+                fn(v);
+            });
+        }
+        else if (this._value !== null) {
+            fn(this._value);
+        }
+    }
 }
 exports.AsyncLazy = AsyncLazy;
 class CallCombiner0 {

package/package.json

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