@hpcc-js/util 2.46.1 → 2.47.1

package/src/stateful.ts

@@ -1,178 +1,178 @@
-import { Dispatch, IObserverHandle, Message } from "./dispatch";
-import { deepEquals } from "./immutable";
-
-class PropChangedMessage extends Message {
-
-    constructor(readonly property: string, public newValue: any, public oldValue?: any) {
-        super();
-    }
-
-    get canConflate(): boolean { return true; }
-    conflate(other: PropChangedMessage) {
-        if (this.property === other.property) {
-            this.newValue = other.newValue;
-            return true;
-        }
-        return false;
-    }
-
-    void(): boolean {
-        return deepEquals(this.newValue, this.oldValue);
-    }
-}
-
-export interface IEvent {
-    id: string;
-    oldValue: any;
-    newValue: any;
-}
-
-export type StatePropCallback = (changes: IEvent) => void;
-export type StateCallback = (changes: IEvent[]) => void;
-export type StateEvents = "propChanged" | "changed";
-export class StateObject<U, I> {
-    private _espState: Partial<U> = {} as U;
-    private _dispatch = new Dispatch();
-    private _monitorHandle?: number;
-    protected _monitorTickCount: number = 0;
-
-    protected clear(newVals?: Partial<I>) {
-        this._espState = {} as U;
-        if (newVals !== void 0) {
-            this.set(newVals as I);
-        }
-        this._monitorTickCount = 0;
-    }
-
-    protected get(): U;
-    protected get<K extends keyof U>(key: K, defValue?: U[K]): U[K];
-    protected get<K extends keyof U>(key?: K, defValue?: U[K]): Partial<U> | U[K] | undefined {
-        if (key === void 0) {
-            return this._espState;
-        }
-        return this.has(key) ? this._espState[key] : defValue;
-    }
-
-    protected set(newVals: I): void;
-    protected set<K extends keyof U>(key: K, newVal: U[K], batchMode?: boolean): void;
-    protected set<K extends keyof U>(keyOrNewVals: K | U, newVal?: U[K]): void {
-        if (typeof keyOrNewVals === "string") {
-            return this.setSingle(keyOrNewVals as any, newVal as U[K]);  //  TODO:  "as any" should not be needed (TS >= 3.1.x)
-        }
-        this.setAll(keyOrNewVals as Partial<U>);
-    }
-
-    private setSingle<K extends keyof U>(key: K, newVal: U[K] | undefined): void {
-        const oldVal = this._espState[key];
-        this._espState[key] = newVal;
-        this._dispatch.post(new PropChangedMessage(key as string, newVal, oldVal));
-    }
-
-    private setAll(_: Partial<U>): void {
-        for (const key in _) {
-            if (_.hasOwnProperty(key)) {
-                this.setSingle(key, _[key]);
-            }
-        }
-    }
-
-    protected has<K extends keyof U>(key: K): boolean {
-        return this._espState[key] !== void 0;
-    }
-
-    addObserver(eventID: StateEvents, callback: StateCallback): IObserverHandle;
-    addObserver(eventID: StateEvents, propID: keyof U, callback: StatePropCallback): IObserverHandle;
-    addObserver(eventID: StateEvents, propIDOrCallback: StateCallback | keyof U, callback?: StatePropCallback): IObserverHandle {
-        if (this.isCallback(propIDOrCallback)) {
-            if (eventID !== "changed") throw new Error("Invalid eventID:  " + eventID);
-            return this._dispatch.attach((messages: PropChangedMessage[]) => {
-                propIDOrCallback(messages.map(m => ({
-                    id: m.property,
-                    oldValue: m.oldValue,
-                    newValue: m.newValue
-                })));
-            });
-        } else {
-            if (eventID !== "propChanged") throw new Error("Invalid eventID:  " + eventID);
-            return this._dispatch.attach((messages: PropChangedMessage[]) => {
-                const filteredMessages = messages.filter(m => m.property === propIDOrCallback);
-                if (filteredMessages.length) {
-                    if (filteredMessages.length > 1) {
-                        console.warn("Should only be 1 message?");
-                    }
-                    const event = filteredMessages[filteredMessages.length - 1];
-                    callback!({
-                        id: event.property,
-                        oldValue: event.oldValue,
-                        newValue: event.newValue
-                    });
-                }
-            });
-        }
-    }
-
-    on(eventID: StateEvents, callback: StateCallback): this;
-    on(eventID: StateEvents, propID: keyof U, callback: StatePropCallback): this;
-    on(eventID: StateEvents, propIDOrCallback: StateCallback | keyof U, callback?: StatePropCallback): this {
-        this.addObserver(eventID, propIDOrCallback as any, callback as any);
-        return this;
-    }
-
-    protected isCallback(propIDOrCallback: StateCallback | keyof U): propIDOrCallback is StateCallback {
-        return (typeof propIDOrCallback === "function");
-    }
-
-    protected hasEventListener(): boolean {
-        return this._dispatch.hasObserver();
-    }
-
-    //  Monitoring  ---
-    protected async refresh(full: boolean = false): Promise<this> {
-        await Promise.resolve();
-        return this;
-    }
-
-    protected _monitor(): void {
-        if (this._monitorHandle) {
-            this._monitorTickCount = 0;
-            return;
-        }
-
-        this._monitorHandle = setTimeout(() => {
-            const refreshPromise: Promise<any> = this.hasEventListener() ? this.refresh() : Promise.resolve();
-            refreshPromise.then(() => {
-                this._monitor();
-            });
-            delete this._monitorHandle;
-        }, this._monitorTimeoutDuraction());
-    }
-
-    protected _monitorTimeoutDuraction(): number {
-        ++this._monitorTickCount;
-        if (this._monitorTickCount <= 1) {          //  Once
-            return 0;
-        }
-        return 30000;
-    }
-
-    watch(callback: StateCallback, triggerChange: boolean = true): IObserverHandle {
-        if (typeof callback !== "function") {
-            throw new Error("Invalid Callback");
-        }
-        if (triggerChange) {
-            setTimeout(() => {
-                const props: any = this.get();
-                const changes: IEvent[] = [];
-                for (const key in props) {
-                    if (props.hasOwnProperty(props)) {
-                        changes.push({ id: key, newValue: props[key], oldValue: undefined });
-                    }
-                }
-                callback(changes);
-            }, 0);
-        }
-        const retVal = this.addObserver("changed", callback);
-        this._monitor();
-        return retVal;
-    }
-}
+import { Dispatch, IObserverHandle, Message } from "./dispatch";
+import { deepEquals } from "./immutable";
+
+class PropChangedMessage extends Message {
+
+    constructor(readonly property: string, public newValue: any, public oldValue?: any) {
+        super();
+    }
+
+    get canConflate(): boolean { return true; }
+    conflate(other: PropChangedMessage) {
+        if (this.property === other.property) {
+            this.newValue = other.newValue;
+            return true;
+        }
+        return false;
+    }
+
+    void(): boolean {
+        return deepEquals(this.newValue, this.oldValue);
+    }
+}
+
+export interface IEvent {
+    id: string;
+    oldValue: any;
+    newValue: any;
+}
+
+export type StatePropCallback = (changes: IEvent) => void;
+export type StateCallback = (changes: IEvent[]) => void;
+export type StateEvents = "propChanged" | "changed";
+export class StateObject<U, I> {
+    private _espState: Partial<U> = {} as U;
+    private _dispatch = new Dispatch();
+    private _monitorHandle?: number;
+    protected _monitorTickCount: number = 0;
+
+    protected clear(newVals?: Partial<I>) {
+        this._espState = {} as U;
+        if (newVals !== void 0) {
+            this.set(newVals as I);
+        }
+        this._monitorTickCount = 0;
+    }
+
+    protected get(): U;
+    protected get<K extends keyof U>(key: K, defValue?: U[K]): U[K];
+    protected get<K extends keyof U>(key?: K, defValue?: U[K]): Partial<U> | U[K] | undefined {
+        if (key === void 0) {
+            return this._espState;
+        }
+        return this.has(key) ? this._espState[key] : defValue;
+    }
+
+    protected set(newVals: I): void;
+    protected set<K extends keyof U>(key: K, newVal: U[K], batchMode?: boolean): void;
+    protected set<K extends keyof U>(keyOrNewVals: K | U, newVal?: U[K]): void {
+        if (typeof keyOrNewVals === "string") {
+            return this.setSingle(keyOrNewVals as any, newVal as U[K]);  //  TODO:  "as any" should not be needed (TS >= 3.1.x)
+        }
+        this.setAll(keyOrNewVals as Partial<U>);
+    }
+
+    private setSingle<K extends keyof U>(key: K, newVal: U[K] | undefined): void {
+        const oldVal = this._espState[key];
+        this._espState[key] = newVal;
+        this._dispatch.post(new PropChangedMessage(key as string, newVal, oldVal));
+    }
+
+    private setAll(_: Partial<U>): void {
+        for (const key in _) {
+            if (_.hasOwnProperty(key)) {
+                this.setSingle(key, _[key]);
+            }
+        }
+    }
+
+    protected has<K extends keyof U>(key: K): boolean {
+        return this._espState[key] !== void 0;
+    }
+
+    addObserver(eventID: StateEvents, callback: StateCallback): IObserverHandle;
+    addObserver(eventID: StateEvents, propID: keyof U, callback: StatePropCallback): IObserverHandle;
+    addObserver(eventID: StateEvents, propIDOrCallback: StateCallback | keyof U, callback?: StatePropCallback): IObserverHandle {
+        if (this.isCallback(propIDOrCallback)) {
+            if (eventID !== "changed") throw new Error("Invalid eventID:  " + eventID);
+            return this._dispatch.attach((messages: PropChangedMessage[]) => {
+                propIDOrCallback(messages.map(m => ({
+                    id: m.property,
+                    oldValue: m.oldValue,
+                    newValue: m.newValue
+                })));
+            });
+        } else {
+            if (eventID !== "propChanged") throw new Error("Invalid eventID:  " + eventID);
+            return this._dispatch.attach((messages: PropChangedMessage[]) => {
+                const filteredMessages = messages.filter(m => m.property === propIDOrCallback);
+                if (filteredMessages.length) {
+                    if (filteredMessages.length > 1) {
+                        console.warn("Should only be 1 message?");
+                    }
+                    const event = filteredMessages[filteredMessages.length - 1];
+                    callback!({
+                        id: event.property,
+                        oldValue: event.oldValue,
+                        newValue: event.newValue
+                    });
+                }
+            });
+        }
+    }
+
+    on(eventID: StateEvents, callback: StateCallback): this;
+    on(eventID: StateEvents, propID: keyof U, callback: StatePropCallback): this;
+    on(eventID: StateEvents, propIDOrCallback: StateCallback | keyof U, callback?: StatePropCallback): this {
+        this.addObserver(eventID, propIDOrCallback as any, callback as any);
+        return this;
+    }
+
+    protected isCallback(propIDOrCallback: StateCallback | keyof U): propIDOrCallback is StateCallback {
+        return (typeof propIDOrCallback === "function");
+    }
+
+    protected hasEventListener(): boolean {
+        return this._dispatch.hasObserver();
+    }
+
+    //  Monitoring  ---
+    protected async refresh(full: boolean = false): Promise<this> {
+        await Promise.resolve();
+        return this;
+    }
+
+    protected _monitor(): void {
+        if (this._monitorHandle) {
+            this._monitorTickCount = 0;
+            return;
+        }
+
+        this._monitorHandle = setTimeout(() => {
+            const refreshPromise: Promise<any> = this.hasEventListener() ? this.refresh() : Promise.resolve();
+            refreshPromise.then(() => {
+                this._monitor();
+            });
+            delete this._monitorHandle;
+        }, this._monitorTimeoutDuraction());
+    }
+
+    protected _monitorTimeoutDuraction(): number {
+        ++this._monitorTickCount;
+        if (this._monitorTickCount <= 1) {          //  Once
+            return 0;
+        }
+        return 30000;
+    }
+
+    watch(callback: StateCallback, triggerChange: boolean = true): IObserverHandle {
+        if (typeof callback !== "function") {
+            throw new Error("Invalid Callback");
+        }
+        if (triggerChange) {
+            setTimeout(() => {
+                const props: any = this.get();
+                const changes: IEvent[] = [];
+                for (const key in props) {
+                    if (props.hasOwnProperty(props)) {
+                        changes.push({ id: key, newValue: props[key], oldValue: undefined });
+                    }
+                }
+                callback(changes);
+            }, 0);
+        }
+        const retVal = this.addObserver("changed", callback);
+        this._monitor();
+        return retVal;
+    }
+}

package/src/string.ts

@@ -1,21 +1,21 @@
-export function trim(str: string, char: string): string {
-    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: string, searchString: string, position?: number) {
-    const subjectString = origString.toString();
-    if (typeof position !== "number" || !isFinite(position) || Math.floor(position) !== position || position > subjectString.length) {
-        position = subjectString.length;
-    }
-    position -= searchString.length;
-    const lastIndex = subjectString.lastIndexOf(searchString, position);
-    return lastIndex !== -1 && lastIndex === position;
-}
+export function trim(str: string, char: string): string {
+    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: string, searchString: string, position?: number) {
+    const subjectString = origString.toString();
+    if (typeof position !== "number" || !isFinite(position) || Math.floor(position) !== position || position > subjectString.length) {
+        position = subjectString.length;
+    }
+    position -= searchString.length;
+    const lastIndex = subjectString.lastIndexOf(searchString, position);
+    return lastIndex !== -1 && lastIndex === position;
+}

package/src/url.ts

@@ -1,27 +1,27 @@
-export function join(...segments: string[]) {
-    const parts: string[] = segments.reduce((parts, segment) => {
-        // Remove leading slashes from non-first part.
-        if (parts.length > 0) {
-            segment = segment.replace(/^\//, "");
-        }
-        // Remove trailing slashes.
-        segment = segment.replace(/\/$/, "");
-        return [...parts, ...segment.split("/")];
-    }, []);
-    const resultParts = [];
-    for (const part of parts) {
-        if (part === ".") {
-            continue;
-        }
-        if (part === "..") {
-            resultParts.pop();
-            continue;
-        }
-        resultParts.push(part);
-    }
-    return resultParts.join("/");
-}
-
-export function dirname(path: string) {
-    return join(path, "..");
-}
+export function join(...segments: string[]) {
+    const parts: string[] = segments.reduce((parts, segment) => {
+        // Remove leading slashes from non-first part.
+        if (parts.length > 0) {
+            segment = segment.replace(/^\//, "");
+        }
+        // Remove trailing slashes.
+        segment = segment.replace(/\/$/, "");
+        return [...parts, ...segment.split("/")];
+    }, []);
+    const resultParts = [];
+    for (const part of parts) {
+        if (part === ".") {
+            continue;
+        }
+        if (part === "..") {
+            resultParts.pop();
+            continue;
+        }
+        resultParts.push(part);
+    }
+    return resultParts.join("/");
+}
+
+export function dirname(path: string) {
+    return join(path, "..");
+}

package/types/__package__.d.ts

@@ -1,4 +1,4 @@
-export declare const PKG_NAME = "@hpcc-js/util";
-export declare const PKG_VERSION = "2.46.1";
-export declare const BUILD_VERSION = "2.102.1";
+export declare const PKG_NAME = "@hpcc-js/util";
+export declare const PKG_VERSION = "2.47.1";
+export declare const BUILD_VERSION = "2.103.1";
 //# sourceMappingURL=__package__.d.ts.map

package/types/array.d.ts

@@ -1,14 +1,14 @@
-export declare function find<T>(o: ReadonlyArray<T>, predicate: (value: T, index: number) => boolean): T | undefined;
-export interface IDifferences2<T> {
-    update: T[];
-    exit: T[];
-    enter: T[];
-}
-export declare function compare<T>(before: readonly T[], after: readonly T[]): IDifferences2<T>;
-export interface IDifferences2<T> {
-    enter: T[];
-    update: T[];
-    exit: T[];
-}
-export declare function compare2<T>(before: readonly T[], after: readonly T[], idFunc: (itme: T) => string | number, updateFunc?: (before: T, after: T) => T): IDifferences2<T>;
+export declare function find<T>(o: ReadonlyArray<T>, predicate: (value: T, index: number) => boolean): T | undefined;
+export interface IDifferences2<T> {
+    update: T[];
+    exit: T[];
+    enter: T[];
+}
+export declare function compare<T>(before: readonly T[], after: readonly T[]): IDifferences2<T>;
+export interface IDifferences2<T> {
+    enter: T[];
+    update: T[];
+    exit: T[];
+}
+export declare function compare2<T>(before: readonly T[], after: readonly T[], idFunc: (itme: T) => string | number, updateFunc?: (before: T, after: T) => T): IDifferences2<T>;
 //# sourceMappingURL=array.d.ts.map

package/types/cache.d.ts

@@ -1,21 +1,21 @@
-export declare class Cache<I, C> {
-    private _cache;
-    private _calcID;
-    static hash(...args: any[]): string;
-    constructor(calcID: (espObj: I | C) => string);
-    has(espObj: I): boolean;
-    set(obj: C): C;
-    get(espObj: I): C | null;
-    get(espObj: I, factory: () => C): C;
-}
-export declare class AsyncCache<I, C> {
-    private _cache;
-    private _calcID;
-    static hash(...args: any[]): string;
-    constructor(calcID: (espObj: I | C) => string);
-    has(espObj: I): boolean;
-    set(espObj: I, obj: Promise<C>): Promise<C>;
-    get(espObj: I): Promise<C | null>;
-    get(espObj: I, factory: () => Promise<C>): Promise<C>;
-}
+export declare class Cache<I, C> {
+    private _cache;
+    private _calcID;
+    static hash(...args: any[]): string;
+    constructor(calcID: (espObj: I | C) => string);
+    has(espObj: I): boolean;
+    set(obj: C): C;
+    get(espObj: I): C | null;
+    get(espObj: I, factory: () => C): C;
+}
+export declare class AsyncCache<I, C> {
+    private _cache;
+    private _calcID;
+    static hash(...args: any[]): string;
+    constructor(calcID: (espObj: I | C) => string);
+    has(espObj: I): boolean;
+    set(espObj: I, obj: Promise<C>): Promise<C>;
+    get(espObj: I): Promise<C | null>;
+    get(espObj: I, factory: () => Promise<C>): Promise<C>;
+}
 //# sourceMappingURL=cache.d.ts.map

package/types/debounce.d.ts

@@ -1,13 +1,13 @@
-export declare function debounce<R extends Promise<any>>(fn: () => R, timeout?: number): () => R;
-export declare function debounce<P1, R extends Promise<any>>(fn: (param1: P1) => R, timeout?: number): (param1: P1) => R;
-export declare function debounce<P1, P2, R extends Promise<any>>(fn: (param1: P1, param2: P2) => R, timeout?: number): (param1: P1, param2: P2) => R;
-export declare 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 declare 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 declare function promiseTimeout<T>(ms: number, promise: Promise<T>): Promise<T>;
-export declare class AsyncOrderedQueue {
-    private _q;
-    private isTop;
-    push<T>(p: Promise<T>): Promise<T>;
-}
-export declare function sleep(ms: number): Promise<void>;
+export declare function debounce<R extends Promise<any>>(fn: () => R, timeout?: number): () => R;
+export declare function debounce<P1, R extends Promise<any>>(fn: (param1: P1) => R, timeout?: number): (param1: P1) => R;
+export declare function debounce<P1, P2, R extends Promise<any>>(fn: (param1: P1, param2: P2) => R, timeout?: number): (param1: P1, param2: P2) => R;
+export declare 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 declare 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 declare function promiseTimeout<T>(ms: number, promise: Promise<T>): Promise<T>;
+export declare class AsyncOrderedQueue {
+    private _q;
+    private isTop;
+    push<T>(p: Promise<T>): Promise<T>;
+}
+export declare function sleep(ms: number): Promise<void>;
 //# sourceMappingURL=debounce.d.ts.map

package/types/dictionary.d.ts

@@ -1,21 +1,21 @@
-export declare type StringAnyMap = {
-    [key: string]: any;
-};
-export declare class Dictionary<T> {
-    private store;
-    constructor(attrs?: StringAnyMap);
-    set(key: string, value: T): T;
-    get(key: string): T;
-    has(key: string): boolean;
-    remove(key: string): void;
-    keys(): string[];
-    values(): T[];
-}
-export declare class DictionaryNoCase<T> extends Dictionary<T> {
-    constructor(attrs?: StringAnyMap);
-    set(key: string, value: T): T;
-    get(key: string): T;
-    has(key: string): boolean;
-    remove(key: string): void;
-}
+export declare type StringAnyMap = {
+    [key: string]: any;
+};
+export declare class Dictionary<T> {
+    private store;
+    constructor(attrs?: StringAnyMap);
+    set(key: string, value: T): T;
+    get(key: string): T;
+    has(key: string): boolean;
+    remove(key: string): void;
+    keys(): string[];
+    values(): T[];
+}
+export declare class DictionaryNoCase<T> extends Dictionary<T> {
+    constructor(attrs?: StringAnyMap);
+    set(key: string, value: T): T;
+    get(key: string): T;
+    has(key: string): boolean;
+    remove(key: string): void;
+}
 //# sourceMappingURL=dictionary.d.ts.map

package/types/dispatch.d.ts

@@ -1,27 +1,27 @@
-import { IObserverHandle } from "./observer";
-export declare type RquestAnimationFrame = (callback: FrameRequestCallback) => number | undefined;
-export declare type CancelAnimationFrame = (handle: number) => void | undefined;
-export declare class Message {
-    get canConflate(): boolean;
-    conflate(other: Message): boolean;
-    void(): boolean;
-}
-declare type MessageConstructor<T extends Message> = new (...args: any[]) => T;
-export declare type Callback<T extends Message> = (messages: T[]) => void;
-export { IObserverHandle };
-export declare class Dispatch<T extends Message = Message> {
-    private _observerID;
-    private _observers;
-    private _messageBuffer;
-    constructor();
-    private observers;
-    private messages;
-    private dispatchAll;
-    private dispatch;
-    hasObserver(): boolean;
-    flush(): void;
-    send(msg: T): void;
-    post(msg: T): void;
-    attach(callback: Callback<T>, type?: MessageConstructor<T>): IObserverHandle;
-}
+import type { IObserverHandle } from "./observer";
+export declare type RquestAnimationFrame = (callback: FrameRequestCallback) => number | undefined;
+export declare type CancelAnimationFrame = (handle: number) => void | undefined;
+export declare class Message {
+    get canConflate(): boolean;
+    conflate(other: Message): boolean;
+    void(): boolean;
+}
+declare type MessageConstructor<T extends Message> = new (...args: any[]) => T;
+export declare type Callback<T extends Message> = (messages: T[]) => void;
+export { IObserverHandle };
+export declare class Dispatch<T extends Message = Message> {
+    private _observerID;
+    private _observers;
+    private _messageBuffer;
+    constructor();
+    private observers;
+    private messages;
+    private dispatchAll;
+    private dispatch;
+    hasObserver(): boolean;
+    flush(): void;
+    send(msg: T): void;
+    post(msg: T): void;
+    attach(callback: Callback<T>, type?: MessageConstructor<T>): IObserverHandle;
+}
 //# sourceMappingURL=dispatch.d.ts.map