@hpcc-js/util 2.46.1 → 2.47.1

package/lib-es6/string.js

@@ -1,23 +1,23 @@
-export function trim(str, char) {
-    if (typeof char !== "string")
-        return str;
-    if (char.length === 0)
-        return str;
-    while (str.indexOf(char) === 0) {
-        str = str.substring(1);
-    }
-    while (endsWith(str, char)) {
-        str = str.substring(0, str.length - 1);
-    }
-    return str;
-}
-export function endsWith(origString, searchString, position) {
-    var subjectString = origString.toString();
-    if (typeof position !== "number" || !isFinite(position) || Math.floor(position) !== position || position > subjectString.length) {
-        position = subjectString.length;
-    }
-    position -= searchString.length;
-    var lastIndex = subjectString.lastIndexOf(searchString, position);
-    return lastIndex !== -1 && lastIndex === position;
-}
+export function trim(str, char) {
+    if (typeof char !== "string")
+        return str;
+    if (char.length === 0)
+        return str;
+    while (str.indexOf(char) === 0) {
+        str = str.substring(1);
+    }
+    while (endsWith(str, char)) {
+        str = str.substring(0, str.length - 1);
+    }
+    return str;
+}
+export function endsWith(origString, searchString, position) {
+    var subjectString = origString.toString();
+    if (typeof position !== "number" || !isFinite(position) || Math.floor(position) !== position || position > subjectString.length) {
+        position = subjectString.length;
+    }
+    position -= searchString.length;
+    var lastIndex = subjectString.lastIndexOf(searchString, position);
+    return lastIndex !== -1 && lastIndex === position;
+}
 //# sourceMappingURL=string.js.map

package/lib-es6/url.js

@@ -1,33 +1,33 @@
-import { __spreadArray } from "tslib";
-export function join() {
-    var segments = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        segments[_i] = arguments[_i];
-    }
-    var parts = segments.reduce(function (parts, segment) {
-        // Remove leading slashes from non-first part.
-        if (parts.length > 0) {
-            segment = segment.replace(/^\//, "");
-        }
-        // Remove trailing slashes.
-        segment = segment.replace(/\/$/, "");
-        return __spreadArray(__spreadArray([], parts, true), segment.split("/"), true);
-    }, []);
-    var resultParts = [];
-    for (var _a = 0, parts_1 = parts; _a < parts_1.length; _a++) {
-        var part = parts_1[_a];
-        if (part === ".") {
-            continue;
-        }
-        if (part === "..") {
-            resultParts.pop();
-            continue;
-        }
-        resultParts.push(part);
-    }
-    return resultParts.join("/");
-}
-export function dirname(path) {
-    return join(path, "..");
-}
+import { __spreadArray } from "tslib";
+export function join() {
+    var segments = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        segments[_i] = arguments[_i];
+    }
+    var parts = segments.reduce(function (parts, segment) {
+        // Remove leading slashes from non-first part.
+        if (parts.length > 0) {
+            segment = segment.replace(/^\//, "");
+        }
+        // Remove trailing slashes.
+        segment = segment.replace(/\/$/, "");
+        return __spreadArray(__spreadArray([], parts, true), segment.split("/"), true);
+    }, []);
+    var resultParts = [];
+    for (var _a = 0, parts_1 = parts; _a < parts_1.length; _a++) {
+        var part = parts_1[_a];
+        if (part === ".") {
+            continue;
+        }
+        if (part === "..") {
+            resultParts.pop();
+            continue;
+        }
+        resultParts.push(part);
+    }
+    return resultParts.join("/");
+}
+export function dirname(path) {
+    return join(path, "..");
+}
 //# sourceMappingURL=url.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@hpcc-js/util",
-    "version": "2.46.1",
+    "version": "2.47.1",
     "description": "hpcc-js - Utilities",
     "main": "dist/index.js",
     "module": "lib-es6/index",
@@ -34,7 +34,7 @@
         "build": "npm run compile-es6 && npm run bundle",
         "watch": "npm-run-all compile-es6 -p compile-es6-watch bundle-watch",
         "stamp": "node ../../node_modules/@hpcc-js/bundle/src/stamp.js",
-        "lint": "eslint src/**/*.ts",
+        "lint": "eslint ./src",
         "docs": "typedoc --options tdoptions.json .",
         "update": "npx npm-check-updates -u -t minor"
     },
@@ -56,5 +56,5 @@
         "url": "https://github.com/hpcc-systems/Visualization/issues"
     },
     "homepage": "https://github.com/hpcc-systems/Visualization",
-    "gitHead": "bc245d3dccc358e21bc1b2103f6d88bb75b9f999"
+    "gitHead": "b7c5d9a853196b53078d665df4368629a1a87903"
 }

package/src/__package__.ts

@@ -1,3 +1,3 @@
 export const PKG_NAME = "@hpcc-js/util";
-export const PKG_VERSION = "2.46.1";
-export const BUILD_VERSION = "2.102.1";
+export const PKG_VERSION = "2.47.1";
+export const BUILD_VERSION = "2.103.1";

package/src/array.ts

@@ -1,98 +1,98 @@
-// 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, o)) {
-            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, o)) {
+            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";
-
-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";
+
+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";
-
-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: number;
-    const timeout = new Promise((resolve, reject) => {
-        id = setTimeout(() => {
-            clearTimeout(id);
-            reject("Timed out in " + ms + "ms.");
-        }, ms);
-    });
-
-    return Promise.race([
-        promise,
-        timeout
-    ]).then((response: T) => {
-        clearTimeout(id);
-        return response;
-    }).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";
+
+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: number;
+    const timeout = new Promise((resolve, reject) => {
+        id = setTimeout(() => {
+            clearTimeout(id);
+            reject("Timed out in " + ms + "ms.");
+        }, ms);
+    });
+
+    return Promise.race([
+        promise,
+        timeout
+    ]).then((response: T) => {
+        clearTimeout(id);
+        return response;
+    }).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);
+    });
+}