@hpcc-js/util 2.42.0 → 2.46.1

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);
+    });
+}

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());
+    }
+}

package/src/dispatch.ts

@@ -1,119 +1,119 @@
-import { IObserverHandle } from "./observer";
-import { root } from "./platform";
-
-export type RquestAnimationFrame = (callback: FrameRequestCallback) => number | undefined;
-export type CancelAnimationFrame = (handle: number) => void | undefined;
-
-let requestAnimationFrame: RquestAnimationFrame;
-// let cancelAnimationFrame: CancelAnimationFrame;
-
-(function () {
-    if (root.requestAnimationFrame) {
-        requestAnimationFrame = root.requestAnimationFrame;
-        // cancelAnimationFrame = root.cancelAnimationFrame;
-    } else {
-        let lastTime = 0;
-        requestAnimationFrame = function (callback: FrameRequestCallback): number {
-            const currTime = new Date().getTime();
-            const timeToCall = Math.max(0, 16 - (currTime - lastTime));
-            const id = setTimeout(() => callback(currTime + timeToCall), timeToCall);
-            lastTime = currTime + timeToCall;
-            return id;
-        };
-        // cancelAnimationFrame = function (handle: number): void {
-        //     clearTimeout(handle);
-        // };
-    }
-})();
-
-export class Message {
-
-    get canConflate(): boolean { return false; }
-    conflate(other: Message): boolean {
-        return false;
-    }
-
-    void(): boolean {
-        return false;
-    }
-}
-type MessageConstructor<T extends Message> = new (...args: any[]) => T;
-
-export type Callback<T extends Message> = (messages: T[]) => void;
-export { IObserverHandle };
-
-type ObserverAdapter<T extends Message = Message> = {
-    id: number;
-    type?: MessageConstructor<T>;
-    callback: Callback<T>;
-};
-
-export class Dispatch<T extends Message = Message> {
-
-    private _observerID: number = 0;
-    private _observers: ObserverAdapter[] = [];
-    private _messageBuffer: T[] = [];
-
-    constructor() {
-    }
-
-    private observers(): ObserverAdapter[] {
-        return this._observers;
-    }
-
-    private messages(): T[] {
-        const retVal: T[] = [];
-        this._messageBuffer.forEach(msg => {
-            if (!retVal.some(msg2 => msg2.canConflate && msg2.conflate(msg))) {
-                retVal.push(msg);
-            }
-        });
-        return retVal;
-    }
-
-    private dispatchAll() {
-        this.dispatch(this.messages());
-        this.flush();
-    }
-
-    private dispatch(messages: T[]) {
-        if (messages.length === 0) return;
-        this.observers().forEach(o => {
-            const msgs = messages.filter(m => !m.void() && (o.type === undefined || m instanceof o.type));
-            if (msgs.length) {
-                o.callback(msgs);
-            }
-        });
-    }
-
-    hasObserver(): boolean {
-        return this._observers.length > 0;
-    }
-
-    flush() {
-        this._messageBuffer = [];
-    }
-
-    send(msg: T) {
-        this.dispatch([msg]);
-    }
-
-    post(msg: T) {
-        this._messageBuffer.push(msg);
-        requestAnimationFrame(() => this.dispatchAll());
-    }
-
-    attach(callback: Callback<T>, type?: MessageConstructor<T>): IObserverHandle {
-        const context = this;
-        const id = ++this._observerID;
-        this._observers.push({ id, type, callback });
-        return {
-            release() {
-                context._observers = context._observers.filter(o => o.id !== id);
-            },
-            unwatch() {
-                this.release();
-            }
-        };
-    }
-}
+import { IObserverHandle } from "./observer";
+import { root } from "./platform";
+
+export type RquestAnimationFrame = (callback: FrameRequestCallback) => number | undefined;
+export type CancelAnimationFrame = (handle: number) => void | undefined;
+
+let requestAnimationFrame: RquestAnimationFrame;
+// let cancelAnimationFrame: CancelAnimationFrame;
+
+(function () {
+    if (root.requestAnimationFrame) {
+        requestAnimationFrame = root.requestAnimationFrame;
+        // cancelAnimationFrame = root.cancelAnimationFrame;
+    } else {
+        let lastTime = 0;
+        requestAnimationFrame = function (callback: FrameRequestCallback): number {
+            const currTime = new Date().getTime();
+            const timeToCall = Math.max(0, 16 - (currTime - lastTime));
+            const id = setTimeout(() => callback(currTime + timeToCall), timeToCall);
+            lastTime = currTime + timeToCall;
+            return id;
+        };
+        // cancelAnimationFrame = function (handle: number): void {
+        //     clearTimeout(handle);
+        // };
+    }
+})();
+
+export class Message {
+
+    get canConflate(): boolean { return false; }
+    conflate(other: Message): boolean {
+        return false;
+    }
+
+    void(): boolean {
+        return false;
+    }
+}
+type MessageConstructor<T extends Message> = new (...args: any[]) => T;
+
+export type Callback<T extends Message> = (messages: T[]) => void;
+export { IObserverHandle };
+
+type ObserverAdapter<T extends Message = Message> = {
+    id: number;
+    type?: MessageConstructor<T>;
+    callback: Callback<T>;
+};
+
+export class Dispatch<T extends Message = Message> {
+
+    private _observerID: number = 0;
+    private _observers: ObserverAdapter[] = [];
+    private _messageBuffer: T[] = [];
+
+    constructor() {
+    }
+
+    private observers(): ObserverAdapter[] {
+        return this._observers;
+    }
+
+    private messages(): T[] {
+        const retVal: T[] = [];
+        this._messageBuffer.forEach(msg => {
+            if (!retVal.some(msg2 => msg2.canConflate && msg2.conflate(msg))) {
+                retVal.push(msg);
+            }
+        });
+        return retVal;
+    }
+
+    private dispatchAll() {
+        this.dispatch(this.messages());
+        this.flush();
+    }
+
+    private dispatch(messages: T[]) {
+        if (messages.length === 0) return;
+        this.observers().forEach(o => {
+            const msgs = messages.filter(m => !m.void() && (o.type === undefined || m instanceof o.type));
+            if (msgs.length) {
+                o.callback(msgs);
+            }
+        });
+    }
+
+    hasObserver(): boolean {
+        return this._observers.length > 0;
+    }
+
+    flush() {
+        this._messageBuffer = [];
+    }
+
+    send(msg: T) {
+        this.dispatch([msg]);
+    }
+
+    post(msg: T) {
+        this._messageBuffer.push(msg);
+        requestAnimationFrame(() => this.dispatchAll());
+    }
+
+    attach(callback: Callback<T>, type?: MessageConstructor<T>): IObserverHandle {
+        const context = this;
+        const id = ++this._observerID;
+        this._observers.push({ id, type, callback });
+        return {
+            release() {
+                context._observers = context._observers.filter(o => o.id !== id);
+            },
+            unwatch() {
+                this.release();
+            }
+        };
+    }
+}

package/src/esp.ts

@@ -1,32 +1,32 @@
-export function espTime2Seconds(duration: string): number {
-    if (!duration) {
-        return 0;
-    } else {
-        if (!isNaN(Number(duration))) {
-            return Number(duration);
-        }
-    }
-    //  GH:  <n>ns or <m>ms or <s>s or [<d> days ][<h>:][<m>:]<s>[.<ms>]
-    const nsIndex = duration.indexOf("ns");
-    if (nsIndex !== -1) {
-        return parseFloat(duration.substr(0, nsIndex)) / 1000000000;
-    }
-    const msIndex = duration.indexOf("ms");
-    if (msIndex !== -1) {
-        return parseFloat(duration.substr(0, msIndex)) / 1000;
-    }
-    const sIndex = duration.indexOf("s");
-    if (sIndex !== -1 && duration.indexOf("days") === -1) {
-        return parseFloat(duration.substr(0, sIndex));
-    }
-
-    const dayTimeParts = duration.split(" days ");
-    const days: number = dayTimeParts.length > 1 ? parseFloat(dayTimeParts[0]) : 0.0;
-    const time: string = dayTimeParts.length > 1 ? dayTimeParts[1] : dayTimeParts[0];
-    let secs = 0.0;
-    const timeParts = time.split(":").reverse();
-    for (let j = 0; j < timeParts.length; ++j) {
-        secs += parseFloat(timeParts[j]) * Math.pow(60, j);
-    }
-    return (days * 24 * 60 * 60) + secs;
-}
+export function espTime2Seconds(duration: string): number {
+    if (!duration) {
+        return 0;
+    } else {
+        if (!isNaN(Number(duration))) {
+            return Number(duration);
+        }
+    }
+    //  GH:  <n>ns or <m>ms or <s>s or [<d> days ][<h>:][<m>:]<s>[.<ms>]
+    const nsIndex = duration.indexOf("ns");
+    if (nsIndex !== -1) {
+        return parseFloat(duration.substr(0, nsIndex)) / 1000000000;
+    }
+    const msIndex = duration.indexOf("ms");
+    if (msIndex !== -1) {
+        return parseFloat(duration.substr(0, msIndex)) / 1000;
+    }
+    const sIndex = duration.indexOf("s");
+    if (sIndex !== -1 && duration.indexOf("days") === -1) {
+        return parseFloat(duration.substr(0, sIndex));
+    }
+
+    const dayTimeParts = duration.split(" days ");
+    const days: number = dayTimeParts.length > 1 ? parseFloat(dayTimeParts[0]) : 0.0;
+    const time: string = dayTimeParts.length > 1 ? dayTimeParts[1] : dayTimeParts[0];
+    let secs = 0.0;
+    const timeParts = time.split(":").reverse();
+    for (let j = 0; j < timeParts.length; ++j) {
+        secs += parseFloat(timeParts[j]) * Math.pow(60, j);
+    }
+    return (days * 24 * 60 * 60) + secs;
+}