@hpcc-js/util 2.42.0 → 2.46.1

package/src/object.ts

@@ -1,117 +1,117 @@
-/**
- * inner - return inner property of Object
- * Usage:  inner("some.prop.to.locate", obj);
- *
- * @param prop - property to locate
- * @param obj - object to locate property in
- */
-export function inner(prop: string, obj: any): any {
-    if (prop === void 0 || obj === void 0) return void 0;
-    for (const item of prop.split(".")) {
-        if (!obj.hasOwnProperty(item)) {
-            return undefined;
-        }
-        obj = obj[item];
-    }
-    return obj;
-}
-
-/**
- * exists - return true if inner property of Object exists
- * Usage:  exists("some.prop.to.locate", obj);
- *
- * @param prop - property to locate
- * @param obj - object to locate property in
- */
-export function exists(prop: string, obj: any): boolean {
-    return inner(prop, obj) !== undefined;
-}
-
-function _mixin(dest: any, source: any): any {
-    const empty: any = {};
-    for (const key in source) {
-        if (!source.hasOwnProperty(key)) continue;
-        if (key === "__proto__" || key === "constructor") continue;
-        let s: any = source[key];
-        if (s instanceof Array) {
-            //  TODO:  Do we need to support arrays?
-        } else if (typeof s === "object") {
-            s = deepMixin(dest[key], s);
-        }
-        if (!(key in dest) || (dest[key] !== s && (!(key in empty) || empty[key] !== s))) {
-            dest[key] = s;
-        }
-    }
-    return dest;
-}
-
-/**
- * deepMixin - combine several objects from right to left
- * Usage:  deepMixin({a: "a"}, {b: "b"});
- *
- * @param dest - target object to mix into.
- * @param sources - objects to mix in
- */
-export function deepMixin(dest: any = {}, ...sources: any[]): any {
-    if (typeof dest !== "object") throw new Error(`Destination "${dest}" must be an object.`);
-    for (const source of sources) {
-        _mixin(dest, source);
-    }
-    return dest;
-}
-
-/**
- * deepMixinT - combine several objects of Partial<T> from right to left
- * Usage:  deepMixinT<MyInterface>({a: "a"}, {b: "b"});
- *
- * Note:  Only provided as a convenience, so user gets auto completion based on destination type.
- *
- * @param dest - target object to mix into.
- * @param sources - objects to mix in
- */
-export function deepMixinT<T>(dest: Partial<T> = {}, ...sources: Array<Partial<T>>): T {
-    return deepMixin(dest, ...sources);
-}
-
-/**
- * safeStingify - JSONsimilar to .stringify, except ignores circular references.
- * Usage:  safeStingify(object);
- *
- * @param obj - any object.
- */
-export function safeStringify(obj: object) {
-    const cache: any[] = [];
-    return JSON.stringify(obj, function (key, value) {
-        if (typeof value === "object" && value !== null) {
-            if (cache.indexOf(value) !== -1) {
-                return;
-            }
-
-            cache.push(value);
-        }
-        return value;
-    });
-}
-
-export function isArray(arg: any): arg is any[] {
-    if (Array.isArray !== undefined) {
-        return Array.isArray(arg);
-    }
-    return Object.prototype.toString.call(arg) === "[object Array]";
-}
-
-export interface ClassMeta {
-    module: string;
-    file: string;
-    class: string;
-}
-
-export function classID2Meta(classID: string): ClassMeta {
-    const info = classID.split("_");
-    const classInfo = info[1].split(".");
-    return {
-        module: `@hpcc-js/${info[0]}`,
-        file: classInfo[0],
-        class: classInfo[1] || classInfo[0]
-    };
-}
+/**
+ * inner - return inner property of Object
+ * Usage:  inner("some.prop.to.locate", obj);
+ *
+ * @param prop - property to locate
+ * @param obj - object to locate property in
+ */
+export function inner(prop: string, obj: any): any {
+    if (prop === void 0 || obj === void 0) return void 0;
+    for (const item of prop.split(".")) {
+        if (!obj.hasOwnProperty(item)) {
+            return undefined;
+        }
+        obj = obj[item];
+    }
+    return obj;
+}
+
+/**
+ * exists - return true if inner property of Object exists
+ * Usage:  exists("some.prop.to.locate", obj);
+ *
+ * @param prop - property to locate
+ * @param obj - object to locate property in
+ */
+export function exists(prop: string, obj: any): boolean {
+    return inner(prop, obj) !== undefined;
+}
+
+function _mixin(dest: any, source: any): any {
+    const empty: any = {};
+    for (const key in source) {
+        if (!source.hasOwnProperty(key)) continue;
+        if (key === "__proto__" || key === "constructor") continue;
+        let s: any = source[key];
+        if (s instanceof Array) {
+            //  TODO:  Do we need to support arrays?
+        } else if (typeof s === "object") {
+            s = deepMixin(dest[key], s);
+        }
+        if (!(key in dest) || (dest[key] !== s && (!(key in empty) || empty[key] !== s))) {
+            dest[key] = s;
+        }
+    }
+    return dest;
+}
+
+/**
+ * deepMixin - combine several objects from right to left
+ * Usage:  deepMixin({a: "a"}, {b: "b"});
+ *
+ * @param dest - target object to mix into.
+ * @param sources - objects to mix in
+ */
+export function deepMixin(dest: any = {}, ...sources: any[]): any {
+    if (typeof dest !== "object") throw new Error(`Destination "${dest}" must be an object.`);
+    for (const source of sources) {
+        _mixin(dest, source);
+    }
+    return dest;
+}
+
+/**
+ * deepMixinT - combine several objects of Partial<T> from right to left
+ * Usage:  deepMixinT<MyInterface>({a: "a"}, {b: "b"});
+ *
+ * Note:  Only provided as a convenience, so user gets auto completion based on destination type.
+ *
+ * @param dest - target object to mix into.
+ * @param sources - objects to mix in
+ */
+export function deepMixinT<T>(dest: Partial<T> = {}, ...sources: Array<Partial<T>>): T {
+    return deepMixin(dest, ...sources);
+}
+
+/**
+ * safeStingify - JSONsimilar to .stringify, except ignores circular references.
+ * Usage:  safeStingify(object);
+ *
+ * @param obj - any object.
+ */
+export function safeStringify(obj: object) {
+    const cache: any[] = [];
+    return JSON.stringify(obj, function (key, value) {
+        if (typeof value === "object" && value !== null) {
+            if (cache.indexOf(value) !== -1) {
+                return;
+            }
+
+            cache.push(value);
+        }
+        return value;
+    });
+}
+
+export function isArray(arg: any): arg is any[] {
+    if (Array.isArray !== undefined) {
+        return Array.isArray(arg);
+    }
+    return Object.prototype.toString.call(arg) === "[object Array]";
+}
+
+export interface ClassMeta {
+    module: string;
+    file: string;
+    class: string;
+}
+
+export function classID2Meta(classID: string): ClassMeta {
+    const info = classID.split("_");
+    const classInfo = info[1].split(".");
+    return {
+        module: `@hpcc-js/${info[0]}`,
+        file: classInfo[0],
+        class: classInfo[1] || classInfo[0]
+    };
+}

package/src/observer.ts

@@ -1,91 +1,91 @@
-/**
- * IObserverHandle - Reference to an observing instance
- */
-export interface IObserverHandle {
-    release(): void;
-    unwatch(): void;
-}
-
-export type CallbackFunction = (...args: any[]) => void;
-
-class ObserverHandle<T extends string> implements IObserverHandle {
-    private eventTarget: Observable<T>;
-    private eventID: T;
-    private callback: CallbackFunction;
-
-    constructor(eventTarget: Observable<T>, eventID: T, callback: CallbackFunction) {
-        this.eventTarget = eventTarget;
-        this.eventID = eventID;
-        this.callback = callback;
-    }
-
-    release() {
-        this.eventTarget.removeObserver(this.eventID, this.callback);
-    }
-
-    unwatch() {
-        this.release();
-    }
-}
-
-export type EventID = string;
-export class Observable<T extends EventID> {
-    private _eventObservers: { [eventID: string]: CallbackFunction[] } = {};
-
-    constructor(...events: T[]) {
-    }
-
-    addObserver(eventID: T, callback: CallbackFunction): IObserverHandle {
-        let eventObservers: CallbackFunction[] = this._eventObservers[eventID];
-        if (!eventObservers) {
-            eventObservers = [];
-            this._eventObservers[eventID] = eventObservers;
-        }
-        eventObservers.push(callback);
-        return new ObserverHandle<T>(this, eventID, callback);
-    }
-
-    removeObserver(eventID: T, callback: CallbackFunction): this {
-        const eventObservers = this._eventObservers[eventID];
-        if (eventObservers) {
-            for (let i = eventObservers.length - 1; i >= 0; --i) {
-                if (eventObservers[i] === callback) {
-                    eventObservers.splice(i, 1);
-                }
-            }
-        }
-        return this;
-    }
-
-    dispatchEvent(eventID: T, ...args: any[]): this {
-        const eventObservers = this._eventObservers[eventID];
-        if (eventObservers) {
-            for (const observer of eventObservers) {
-                observer(...args);
-            }
-        }
-        return this;
-    }
-
-    private _hasObserver(eventID: string): boolean {
-        const eventObservers = this._eventObservers[eventID];
-        for (const observer in eventObservers) {
-            if (eventObservers[observer]) {
-                return true;
-            }
-        }
-        return false;
-    }
-
-    hasObserver(_eventID?: T): boolean {
-        if (_eventID !== void 0) {
-            return this._hasObserver(_eventID);
-        }
-        for (const eventID in this._eventObservers) {
-            if (this._hasObserver(eventID)) {
-                return true;
-            }
-        }
-        return false;
-    }
-}
+/**
+ * IObserverHandle - Reference to an observing instance
+ */
+export interface IObserverHandle {
+    release(): void;
+    unwatch(): void;
+}
+
+export type CallbackFunction = (...args: any[]) => void;
+
+class ObserverHandle<T extends string> implements IObserverHandle {
+    private eventTarget: Observable<T>;
+    private eventID: T;
+    private callback: CallbackFunction;
+
+    constructor(eventTarget: Observable<T>, eventID: T, callback: CallbackFunction) {
+        this.eventTarget = eventTarget;
+        this.eventID = eventID;
+        this.callback = callback;
+    }
+
+    release() {
+        this.eventTarget.removeObserver(this.eventID, this.callback);
+    }
+
+    unwatch() {
+        this.release();
+    }
+}
+
+export type EventID = string;
+export class Observable<T extends EventID> {
+    private _eventObservers: { [eventID: string]: CallbackFunction[] } = {};
+
+    constructor(...events: T[]) {
+    }
+
+    addObserver(eventID: T, callback: CallbackFunction): IObserverHandle {
+        let eventObservers: CallbackFunction[] = this._eventObservers[eventID];
+        if (!eventObservers) {
+            eventObservers = [];
+            this._eventObservers[eventID] = eventObservers;
+        }
+        eventObservers.push(callback);
+        return new ObserverHandle<T>(this, eventID, callback);
+    }
+
+    removeObserver(eventID: T, callback: CallbackFunction): this {
+        const eventObservers = this._eventObservers[eventID];
+        if (eventObservers) {
+            for (let i = eventObservers.length - 1; i >= 0; --i) {
+                if (eventObservers[i] === callback) {
+                    eventObservers.splice(i, 1);
+                }
+            }
+        }
+        return this;
+    }
+
+    dispatchEvent(eventID: T, ...args: any[]): this {
+        const eventObservers = this._eventObservers[eventID];
+        if (eventObservers) {
+            for (const observer of eventObservers) {
+                observer(...args);
+            }
+        }
+        return this;
+    }
+
+    private _hasObserver(eventID: string): boolean {
+        const eventObservers = this._eventObservers[eventID];
+        for (const observer in eventObservers) {
+            if (eventObservers[observer]) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    hasObserver(_eventID?: T): boolean {
+        if (_eventID !== void 0) {
+            return this._hasObserver(_eventID);
+        }
+        for (const eventID in this._eventObservers) {
+            if (this._hasObserver(eventID)) {
+                return true;
+            }
+        }
+        return false;
+    }
+}

package/src/platform.ts

@@ -1,20 +1,20 @@
-declare const process: any;
-
-export const root: any = typeof globalThis !== "undefined" ? globalThis : window;
-export const isBrowser: boolean = typeof window !== "undefined" && root === window;
-export const isNode: boolean = typeof process !== "undefined" && process.versions != null && process.versions.node != null;
-export const isCI: boolean = isNode && process.env != null && (process.env.TRAVIS != null || process.env.GITHUB_ACTIONS != null);
-
-export function getScriptSrc(partial: string) {
-    const scripts = document.scripts || [];
-    for (let i = document.scripts.length - 1; i >= 0; --i) {
-        const script = scripts[i];
-        if (script.src) {
-            const idx = script.src.indexOf(partial);
-            if (idx >= 0) {
-                return script.src.substring(0, idx);
-            }
-        }
-    }
-    return "";
-}
+declare const process: any;
+
+export const root: any = typeof globalThis !== "undefined" ? globalThis : window;
+export const isBrowser: boolean = typeof window !== "undefined" && root === window;
+export const isNode: boolean = typeof process !== "undefined" && process.versions != null && process.versions.node != null;
+export const isCI: boolean = isNode && process.env != null && (process.env.TRAVIS != null || process.env.GITHUB_ACTIONS != null);
+
+export function getScriptSrc(partial: string) {
+    const scripts = document.scripts || [];
+    for (let i = document.scripts.length - 1; i >= 0; --i) {
+        const script = scripts[i];
+        if (script.src) {
+            const idx = script.src.indexOf(partial);
+            if (idx >= 0) {
+                return script.src.substring(0, idx);
+            }
+        }
+    }
+    return "";
+}