@hpcc-js/util 3.4.8 → 3.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@hpcc-js/util",
-    "version": "3.4.8",
+    "version": "3.5.0",
     "description": "hpcc-js - Utilities",
     "type": "module",
     "main": "./dist/index.umd.cjs",
@@ -55,5 +55,5 @@
         "url": "https://github.com/hpcc-systems/Visualization/issues"
     },
     "homepage": "https://github.com/hpcc-systems/Visualization/tree/main/packages/util",
-    "gitHead": "34c404f172efc43a9caf59e8e463d1f07d469578"
+    "gitHead": "ada394f582442d2b23a7ff55b9f87a50a723f45b"
 }

package/src/__package__.ts

@@ -1,3 +1,3 @@
-export const PKG_NAME = "__PACKAGE_NAME__";
-export const PKG_VERSION = "__PACKAGE_VERSION__";
-export const BUILD_VERSION = "__BUILD_VERSION__";
+export const PKG_NAME = "__PACKAGE_NAME__";
+export const PKG_VERSION = "__PACKAGE_VERSION__";
+export const BUILD_VERSION = "__BUILD_VERSION__";

package/src/array.ts

@@ -1,97 +1,97 @@
-// Based on:  https://tc39.github.io/ecma262/#sec-array.prototype.find
-export function find<T>(o: ReadonlyArray<T>, predicate: (value: T, index: number) => boolean) {
-    // 1. Let O be ? ToObject(this value).
-    if (o == null) {
-        throw new TypeError('"o" is null or not defined');
-    }
-
-    // 2. Let len be ? ToLength(? Get(O, "length")).
-    const len = o.length >>> 0;
-
-    // 3. If IsCallable(predicate) is false, throw a TypeError exception.
-    if (typeof predicate !== "function") {
-        throw new TypeError("predicate must be a function");
-    }
-
-    // 4. If thisArg was supplied, let T be thisArg; else let T be undefined.
-    const thisArg = arguments[1];
-
-    // 5. Let k be 0.
-    let k = 0;
-
-    // 6. Repeat, while k < len
-    while (k < len) {
-        // a. Let Pk be ! ToString(k).
-        // b. Let kValue be ? Get(O, Pk).
-        // c. Let testResult be ToBoolean(? Call(predicate, T, « kValue, k, O »)).
-        // d. If testResult is true, return kValue.
-        const kValue = o[k];
-        if (predicate.call(thisArg, kValue, k)) {
-            return kValue;
-        }
-        // e. Increase k by 1.
-        k++;
-    }
-
-    // 7. Return undefined.
-    return undefined;
-}
-export interface IDifferences2<T> {
-    update: T[];
-    exit: T[];
-    enter: T[];
-}
-
-export function compare<T>(before: readonly T[], after: readonly T[]): IDifferences2<T> {
-    const retVal: IDifferences2<T> = {
-        update: [],
-        exit: [],
-        enter: [...after]
-    };
-    for (const row of before) {
-        const otherIdx = retVal.enter.indexOf(row);
-        if (otherIdx >= 0) {
-            retVal.update.push(row);
-            retVal.enter.splice(otherIdx, 1);
-        } else {
-            retVal.exit.push(row);
-        }
-    }
-    return retVal;
-}
-
-export interface IDifferences2<T> {
-    enter: T[];
-    update: T[];
-    exit: T[];
-}
-
-export function compare2<T>(before: readonly T[], after: readonly T[], idFunc: (itme: T) => string | number, updateFunc: (before: T, after: T) => T = (before, after) => after): IDifferences2<T> {
-    const retVal: IDifferences2<T> = {
-        update: [],
-        exit: [],
-        enter: []
-    };
-    if (before === after) {
-        retVal.update = before as T[];
-        return retVal;
-    }
-    const unknownMap: { [key: string]: T } = {};
-    after.forEach(item => {
-        unknownMap[idFunc(item)] = item;
-    });
-    for (const row of before) {
-        const id = idFunc(row);
-        const item = unknownMap[id];
-        if (item !== undefined) {
-            delete unknownMap[id];
-            retVal.update.push(updateFunc(row, item));
-        } else {
-            retVal.exit.push(row);
-        }
-    }
-    for (const key in unknownMap) {
-        retVal.enter.push(unknownMap[key]);
-    }
-    return retVal;
-}
+// Based on:  https://tc39.github.io/ecma262/#sec-array.prototype.find
+export function find<T>(o: ReadonlyArray<T>, predicate: (value: T, index: number) => boolean) {
+    // 1. Let O be ? ToObject(this value).
+    if (o == null) {
+        throw new TypeError('"o" is null or not defined');
+    }
+
+    // 2. Let len be ? ToLength(? Get(O, "length")).
+    const len = o.length >>> 0;
+
+    // 3. If IsCallable(predicate) is false, throw a TypeError exception.
+    if (typeof predicate !== "function") {
+        throw new TypeError("predicate must be a function");
+    }
+
+    // 4. If thisArg was supplied, let T be thisArg; else let T be undefined.
+    const thisArg = arguments[1];
+
+    // 5. Let k be 0.
+    let k = 0;
+
+    // 6. Repeat, while k < len
+    while (k < len) {
+        // a. Let Pk be ! ToString(k).
+        // b. Let kValue be ? Get(O, Pk).
+        // c. Let testResult be ToBoolean(? Call(predicate, T, « kValue, k, O »)).
+        // d. If testResult is true, return kValue.
+        const kValue = o[k];
+        if (predicate.call(thisArg, kValue, k)) {
+            return kValue;
+        }
+        // e. Increase k by 1.
+        k++;
+    }
+
+    // 7. Return undefined.
+    return undefined;
+}
+export interface IDifferences2<T> {
+    update: T[];
+    exit: T[];
+    enter: T[];
+}
+
+export function compare<T>(before: readonly T[], after: readonly T[]): IDifferences2<T> {
+    const retVal: IDifferences2<T> = {
+        update: [],
+        exit: [],
+        enter: [...after]
+    };
+    for (const row of before) {
+        const otherIdx = retVal.enter.indexOf(row);
+        if (otherIdx >= 0) {
+            retVal.update.push(row);
+            retVal.enter.splice(otherIdx, 1);
+        } else {
+            retVal.exit.push(row);
+        }
+    }
+    return retVal;
+}
+
+export interface IDifferences2<T> {
+    enter: T[];
+    update: T[];
+    exit: T[];
+}
+
+export function compare2<T>(before: readonly T[], after: readonly T[], idFunc: (itme: T) => string | number, updateFunc: (before: T, after: T) => T = (before, after) => after): IDifferences2<T> {
+    const retVal: IDifferences2<T> = {
+        update: [],
+        exit: [],
+        enter: []
+    };
+    if (before === after) {
+        retVal.update = before as T[];
+        return retVal;
+    }
+    const unknownMap: { [key: string]: T } = {};
+    after.forEach(item => {
+        unknownMap[idFunc(item)] = item;
+    });
+    for (const row of before) {
+        const id = idFunc(row);
+        const item = unknownMap[id];
+        if (item !== undefined) {
+            delete unknownMap[id];
+            retVal.update.push(updateFunc(row, item));
+        } else {
+            retVal.exit.push(row);
+        }
+    }
+    for (const key in unknownMap) {
+        retVal.enter.push(unknownMap[key]);
+    }
+    return retVal;
+}

package/src/cache.ts

@@ -1,65 +1,65 @@
-import { hashSum } from "./hashSum.ts";
-
-export class Cache<I, C> {
-    private _cache: { [id: string]: C } = {};
-    private _calcID: (espObj: I | C) => string;
-
-    static hash(...args: any[]) {
-        return hashSum({ ...args });
-    }
-
-    constructor(calcID: (espObj: I | C) => string) {
-        this._calcID = calcID;
-    }
-
-    has(espObj: I): boolean {
-        return this._calcID(espObj) in this._cache;
-    }
-
-    set(obj: C): C {
-        this._cache[this._calcID(obj)] = obj;
-        return obj;
-    }
-
-    get(espObj: I): C | null;
-    get(espObj: I, factory: () => C): C;
-    get(espObj: I, factory?: () => C): C | null {
-        const retVal = this._cache[this._calcID(espObj)];
-        if (!retVal) {
-            return factory ? this.set(factory()) : null;
-        }
-        return retVal;
-    }
-}
-
-export class AsyncCache<I, C> {
-    private _cache: { [id: string]: Promise<C> } = {};
-    private _calcID: (espObj: I | C) => string;
-
-    static hash(...args: any[]) {
-        return hashSum({ ...args });
-    }
-
-    constructor(calcID: (espObj: I | C) => string) {
-        this._calcID = calcID;
-    }
-
-    has(espObj: I): boolean {
-        return this._calcID(espObj) in this._cache;
-    }
-
-    set(espObj: I, obj: Promise<C>): Promise<C> {
-        this._cache[this._calcID(espObj)] = obj;
-        return obj;
-    }
-
-    get(espObj: I): Promise<C | null>;
-    get(espObj: I, factory: () => Promise<C>): Promise<C>;
-    get(espObj: I, factory?: () => Promise<C>): Promise<C | null> {
-        const retVal = this._cache[this._calcID(espObj)];
-        if (!retVal) {
-            return factory ? this.set(espObj, factory()) : Promise.resolve(null);
-        }
-        return retVal;
-    }
-}
+import { hashSum } from "./hashSum.ts";
+
+export class Cache<I, C> {
+    private _cache: { [id: string]: C } = {};
+    private _calcID: (espObj: I | C) => string;
+
+    static hash(...args: any[]) {
+        return hashSum({ ...args });
+    }
+
+    constructor(calcID: (espObj: I | C) => string) {
+        this._calcID = calcID;
+    }
+
+    has(espObj: I): boolean {
+        return this._calcID(espObj) in this._cache;
+    }
+
+    set(obj: C): C {
+        this._cache[this._calcID(obj)] = obj;
+        return obj;
+    }
+
+    get(espObj: I): C | null;
+    get(espObj: I, factory: () => C): C;
+    get(espObj: I, factory?: () => C): C | null {
+        const retVal = this._cache[this._calcID(espObj)];
+        if (!retVal) {
+            return factory ? this.set(factory()) : null;
+        }
+        return retVal;
+    }
+}
+
+export class AsyncCache<I, C> {
+    private _cache: { [id: string]: Promise<C> } = {};
+    private _calcID: (espObj: I | C) => string;
+
+    static hash(...args: any[]) {
+        return hashSum({ ...args });
+    }
+
+    constructor(calcID: (espObj: I | C) => string) {
+        this._calcID = calcID;
+    }
+
+    has(espObj: I): boolean {
+        return this._calcID(espObj) in this._cache;
+    }
+
+    set(espObj: I, obj: Promise<C>): Promise<C> {
+        this._cache[this._calcID(espObj)] = obj;
+        return obj;
+    }
+
+    get(espObj: I): Promise<C | null>;
+    get(espObj: I, factory: () => Promise<C>): Promise<C>;
+    get(espObj: I, factory?: () => Promise<C>): Promise<C | null> {
+        const retVal = this._cache[this._calcID(espObj)];
+        if (!retVal) {
+            return factory ? this.set(espObj, factory()) : Promise.resolve(null);
+        }
+        return retVal;
+    }
+}

package/src/debounce.ts

@@ -1,88 +1,88 @@
-import { hashSum } from "./hashSum.ts";
-
-export function debounce<R extends Promise<any>>(fn: () => R, timeout?: number): () => R;
-export function debounce<P1, R extends Promise<any>>(fn: (param1: P1) => R, timeout?: number): (param1: P1) => R;
-export function debounce<P1, P2, R extends Promise<any>>(fn: (param1: P1, param2: P2) => R, timeout?: number): (param1: P1, param2: P2) => R;
-export function debounce<P1, P2, P3, R extends Promise<any>>(fn: (param1: P1, param2: P2, param3: P3) => R, timeout?: number): (param1: P1, param2: P2, param3: P3) => R;
-export function debounce<P1, P2, P3, P4, R extends Promise<any>>(fn: (param1: P1, param2: P2, param3: P3, param4: P4) => R, timeout?: number): (param1: P1, param2: P2, param3: P3, param4: P4) => R;
-export function debounce<TParam, R extends Promise<any>>(fn: (...params: TParam[]) => R, timeout?: number): (...params: TParam[]) => R {
-    const promises: { [key: string]: { promise: R, clockStart: number } | null } = {};
-
-    return (...params) => {
-        const hash = hashSum(params);
-        if (!promises[hash]) {
-            promises[hash] = {
-                clockStart: Date.now(),
-                promise: fn(...params).then(response => {
-                    if (timeout === undefined) {
-                        promises[hash] = null;
-                    } else {
-                        setTimeout(() => {
-                            promises[hash] = null;
-                        }, Math.max(timeout - (Date.now() - promises[hash]!.clockStart), 0));
-                    }
-                    return response;
-                }).catch(e => {
-                    promises[hash] = null;
-                    throw e;
-                }) as R
-            };
-        }
-        return promises[hash]!.promise;
-    };
-}
-
-export function promiseTimeout<T>(ms: number, promise: Promise<T>): Promise<T> {
-    let id: any;
-    const timeout = new Promise((resolve, reject) => {
-        id = setTimeout(() => {
-            clearTimeout(id);
-            reject("Timed out in " + ms + "ms.");
-        }, ms);
-    });
-
-    return Promise.race([
-        promise,
-        timeout
-    ]).then((response: unknown) => {
-        clearTimeout(id);
-        return response as T;
-    }).catch(e => {
-        clearTimeout(id);
-        throw e;
-    });
-}
-
-export class AsyncOrderedQueue {
-    private _q: Array<Promise<any>> = [];
-
-    private isTop(p: Promise<any>): boolean {
-        return this._q[0] === p;
-    }
-
-    push<T>(p: Promise<T>): Promise<T> {
-        const retVal = p.then(response => {
-            if (this.isTop(retVal)) {
-                this._q.shift();
-                return response;
-            }
-            return new Promise<T>((resolve, reject) => {
-                const intervalHandler = setInterval(() => {
-                    if (this.isTop(retVal)) {
-                        clearInterval(intervalHandler);
-                        this._q.shift();
-                        resolve(response);
-                    }
-                }, 20);
-            });
-        });
-        this._q.push(retVal);
-        return retVal;
-    }
-}
-
-export function sleep(ms: number): Promise<void> {
-    return new Promise(resolve => {
-        setTimeout(() => resolve(), ms);
-    });
-}
+import { hashSum } from "./hashSum.ts";
+
+export function debounce<R extends Promise<any>>(fn: () => R, timeout?: number): () => R;
+export function debounce<P1, R extends Promise<any>>(fn: (param1: P1) => R, timeout?: number): (param1: P1) => R;
+export function debounce<P1, P2, R extends Promise<any>>(fn: (param1: P1, param2: P2) => R, timeout?: number): (param1: P1, param2: P2) => R;
+export function debounce<P1, P2, P3, R extends Promise<any>>(fn: (param1: P1, param2: P2, param3: P3) => R, timeout?: number): (param1: P1, param2: P2, param3: P3) => R;
+export function debounce<P1, P2, P3, P4, R extends Promise<any>>(fn: (param1: P1, param2: P2, param3: P3, param4: P4) => R, timeout?: number): (param1: P1, param2: P2, param3: P3, param4: P4) => R;
+export function debounce<TParam, R extends Promise<any>>(fn: (...params: TParam[]) => R, timeout?: number): (...params: TParam[]) => R {
+    const promises: { [key: string]: { promise: R, clockStart: number } | null } = {};
+
+    return (...params) => {
+        const hash = hashSum(params);
+        if (!promises[hash]) {
+            promises[hash] = {
+                clockStart: Date.now(),
+                promise: fn(...params).then(response => {
+                    if (timeout === undefined) {
+                        promises[hash] = null;
+                    } else {
+                        setTimeout(() => {
+                            promises[hash] = null;
+                        }, Math.max(timeout - (Date.now() - promises[hash]!.clockStart), 0));
+                    }
+                    return response;
+                }).catch(e => {
+                    promises[hash] = null;
+                    throw e;
+                }) as R
+            };
+        }
+        return promises[hash]!.promise;
+    };
+}
+
+export function promiseTimeout<T>(ms: number, promise: Promise<T>): Promise<T> {
+    let id: any;
+    const timeout = new Promise((resolve, reject) => {
+        id = setTimeout(() => {
+            clearTimeout(id);
+            reject("Timed out in " + ms + "ms.");
+        }, ms);
+    });
+
+    return Promise.race([
+        promise,
+        timeout
+    ]).then((response: unknown) => {
+        clearTimeout(id);
+        return response as T;
+    }).catch(e => {
+        clearTimeout(id);
+        throw e;
+    });
+}
+
+export class AsyncOrderedQueue {
+    private _q: Array<Promise<any>> = [];
+
+    private isTop(p: Promise<any>): boolean {
+        return this._q[0] === p;
+    }
+
+    push<T>(p: Promise<T>): Promise<T> {
+        const retVal = p.then(response => {
+            if (this.isTop(retVal)) {
+                this._q.shift();
+                return response;
+            }
+            return new Promise<T>((resolve, reject) => {
+                const intervalHandler = setInterval(() => {
+                    if (this.isTop(retVal)) {
+                        clearInterval(intervalHandler);
+                        this._q.shift();
+                        resolve(response);
+                    }
+                }, 20);
+            });
+        });
+        this._q.push(retVal);
+        return retVal;
+    }
+}
+
+export function sleep(ms: number): Promise<void> {
+    return new Promise(resolve => {
+        setTimeout(() => resolve(), ms);
+    });
+}

package/src/dictionary.ts

@@ -1,69 +1,69 @@
-export type StringAnyMap = { [key: string]: any };
-
-export class Dictionary<T> {
-    private store: { [key: string]: T } = {};
-
-    constructor(attrs?: StringAnyMap) {
-        if (attrs) {
-            for (const key in attrs) {
-                this.set(key, attrs[key]);
-            }
-        }
-    }
-
-    set(key: string, value: T): T {
-        const retVal: T = this.store[key];
-        this.store[key] = value;
-        return retVal;
-    }
-
-    get(key: string): T {
-        return this.store[key];
-    }
-
-    has(key: string) {
-        return this.store[key] !== undefined;
-    }
-
-    remove(key: string) {
-        delete this.store[key];
-    }
-
-    keys(): string[] {
-        const retVal: string[] = [];
-        for (const key in this.store) {
-            retVal.push(key);
-        }
-        return retVal;
-    }
-
-    values(): T[] {
-        const retVal: T[] = [];
-        for (const key in this.store) {
-            retVal.push(this.store[key]);
-        }
-        return retVal;
-    }
-}
-
-export class DictionaryNoCase<T> extends Dictionary<T> {
-    constructor(attrs?: StringAnyMap) {
-        super(attrs);
-    }
-
-    set(key: string, value: T): T {
-        return super.set(key.toLowerCase(), value);
-    }
-
-    get(key: string): T {
-        return super.get(key.toLowerCase());
-    }
-
-    has(key: string) {
-        return super.has(key.toLowerCase());
-    }
-
-    remove(key: string) {
-        return super.remove(key.toLowerCase());
-    }
-}
+export type StringAnyMap = { [key: string]: any };
+
+export class Dictionary<T> {
+    private store: { [key: string]: T } = {};
+
+    constructor(attrs?: StringAnyMap) {
+        if (attrs) {
+            for (const key in attrs) {
+                this.set(key, attrs[key]);
+            }
+        }
+    }
+
+    set(key: string, value: T): T {
+        const retVal: T = this.store[key];
+        this.store[key] = value;
+        return retVal;
+    }
+
+    get(key: string): T {
+        return this.store[key];
+    }
+
+    has(key: string) {
+        return this.store[key] !== undefined;
+    }
+
+    remove(key: string) {
+        delete this.store[key];
+    }
+
+    keys(): string[] {
+        const retVal: string[] = [];
+        for (const key in this.store) {
+            retVal.push(key);
+        }
+        return retVal;
+    }
+
+    values(): T[] {
+        const retVal: T[] = [];
+        for (const key in this.store) {
+            retVal.push(this.store[key]);
+        }
+        return retVal;
+    }
+}
+
+export class DictionaryNoCase<T> extends Dictionary<T> {
+    constructor(attrs?: StringAnyMap) {
+        super(attrs);
+    }
+
+    set(key: string, value: T): T {
+        return super.set(key.toLowerCase(), value);
+    }
+
+    get(key: string): T {
+        return super.get(key.toLowerCase());
+    }
+
+    has(key: string) {
+        return super.has(key.toLowerCase());
+    }
+
+    remove(key: string) {
+        return super.remove(key.toLowerCase());
+    }
+}