@hpcc-js/util 3.5.4 → 3.5.6

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,125 +1,125 @@
-import type { IObserverHandle } from "./observer.ts";
-import { root } from "./platform.ts";
-
-export type RequestAnimationFrame = (callback: FrameRequestCallback) => number | undefined;
-export type CancelAnimationFrame = (handle: number) => void | undefined;
-
-let requestAnimationFrame: RequestAnimationFrame;
-// let cancelAnimationFrame: CancelAnimationFrame;
-
-(function () {
-    if (root.requestAnimationFrame) {
-        requestAnimationFrame = root.requestAnimationFrame;
-        // cancelAnimationFrame = root.cancelAnimationFrame;
-    } else {
-        let lastTime = 0;
-        requestAnimationFrame = function (callback: FrameRequestCallback): any {
-            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<T>[] = [];
-    private _messageBuffer: T[] = [];
-    private _rafHandle: number | undefined = undefined;
-
-    constructor() {
-    }
-
-    private observers(): ObserverAdapter<T>[] {
-        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._rafHandle = undefined;
-        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) {
-        if (!this.hasObserver()) return;
-        this.dispatch([msg]);
-    }
-
-    post(msg: T) {
-        if (!this.hasObserver()) return;
-        this._messageBuffer.push(msg);
-        if (this._rafHandle === undefined) {
-            this._rafHandle = 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 type { IObserverHandle } from "./observer.ts";
+import { root } from "./platform.ts";
+
+export type RequestAnimationFrame = (callback: FrameRequestCallback) => number | undefined;
+export type CancelAnimationFrame = (handle: number) => void | undefined;
+
+let requestAnimationFrame: RequestAnimationFrame;
+// let cancelAnimationFrame: CancelAnimationFrame;
+
+(function () {
+    if (root.requestAnimationFrame) {
+        requestAnimationFrame = root.requestAnimationFrame;
+        // cancelAnimationFrame = root.cancelAnimationFrame;
+    } else {
+        let lastTime = 0;
+        requestAnimationFrame = function (callback: FrameRequestCallback): any {
+            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<T>[] = [];
+    private _messageBuffer: T[] = [];
+    private _rafHandle: number | undefined = undefined;
+
+    constructor() {
+    }
+
+    private observers(): ObserverAdapter<T>[] {
+        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._rafHandle = undefined;
+        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) {
+        if (!this.hasObserver()) return;
+        this.dispatch([msg]);
+    }
+
+    post(msg: T) {
+        if (!this.hasObserver()) return;
+        this._messageBuffer.push(msg);
+        if (this._rafHandle === undefined) {
+            this._rafHandle = 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;
+}