@hpcc-js/util 3.5.1 → 3.5.4

package/src/stateful.ts

@@ -1,178 +1,178 @@
-import { Dispatch, IObserverHandle, Message } from "./dispatch.ts";
-import { deepEquals } from "./immutable.ts";
-
-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<PropChangedMessage>();
-    private _monitorHandle?: any;
-    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._monitorTimeoutDuration());
-    }
-
-    protected _monitorTimeoutDuration(): 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.ts";
+import { deepEquals } from "./immutable.ts";
+
+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<PropChangedMessage>();
+    private _monitorHandle?: any;
+    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._monitorTimeoutDuration());
+    }
+
+    protected _monitorTimeoutDuration(): 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: string[], 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: string[], 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/src/utf8ToBase64.ts

@@ -1,47 +1,47 @@
-const BASE64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-
-function toUTF8Bytes(value: string): Uint8Array {
-    if (typeof TextEncoder !== "undefined") {
-        return new TextEncoder().encode(value);
-    }
-
-    const encoded = encodeURIComponent(value);
-    const bytes: number[] = [];
-    for (let i = 0; i < encoded.length; ++i) {
-        if (encoded[i] === "%") {
-            bytes.push(parseInt(encoded.substring(i + 1, i + 3), 16));
-            i += 2;
-        } else {
-            bytes.push(encoded.charCodeAt(i));
-        }
-    }
-    return Uint8Array.from(bytes);
-}
-
-function bytesToBase64(bytes: Uint8Array): string {
-    let output = "";
-    for (let i = 0; i < bytes.length; i += 3) {
-        const byte1 = bytes[i];
-        const hasByte2 = i + 1 < bytes.length;
-        const hasByte3 = i + 2 < bytes.length;
-        const byte2 = hasByte2 ? bytes[i + 1] : 0;
-        const byte3 = hasByte3 ? bytes[i + 2] : 0;
-
-        output += BASE64_ALPHABET[byte1 >> 2];
-        output += BASE64_ALPHABET[((byte1 & 0x03) << 4) | (byte2 >> 4)];
-        output += hasByte2 ? BASE64_ALPHABET[((byte2 & 0x0f) << 2) | (byte3 >> 6)] : "=";
-        output += hasByte3 ? BASE64_ALPHABET[byte3 & 0x3f] : "=";
-    }
-    return output;
-}
-
-export function utf8ToBase64(value: string = ""): string {
-    const normalized = value == null ? "" : String(value);
-
-    const maybeBuffer = (globalThis as any)?.Buffer;
-    if (maybeBuffer?.from) {
-        return maybeBuffer.from(normalized, "utf8").toString("base64");
-    }
-
-    return bytesToBase64(toUTF8Bytes(normalized));
-}
+const BASE64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+function toUTF8Bytes(value: string): Uint8Array {
+    if (typeof TextEncoder !== "undefined") {
+        return new TextEncoder().encode(value);
+    }
+
+    const encoded = encodeURIComponent(value);
+    const bytes: number[] = [];
+    for (let i = 0; i < encoded.length; ++i) {
+        if (encoded[i] === "%") {
+            bytes.push(parseInt(encoded.substring(i + 1, i + 3), 16));
+            i += 2;
+        } else {
+            bytes.push(encoded.charCodeAt(i));
+        }
+    }
+    return Uint8Array.from(bytes);
+}
+
+function bytesToBase64(bytes: Uint8Array): string {
+    let output = "";
+    for (let i = 0; i < bytes.length; i += 3) {
+        const byte1 = bytes[i];
+        const hasByte2 = i + 1 < bytes.length;
+        const hasByte3 = i + 2 < bytes.length;
+        const byte2 = hasByte2 ? bytes[i + 1] : 0;
+        const byte3 = hasByte3 ? bytes[i + 2] : 0;
+
+        output += BASE64_ALPHABET[byte1 >> 2];
+        output += BASE64_ALPHABET[((byte1 & 0x03) << 4) | (byte2 >> 4)];
+        output += hasByte2 ? BASE64_ALPHABET[((byte2 & 0x0f) << 2) | (byte3 >> 6)] : "=";
+        output += hasByte3 ? BASE64_ALPHABET[byte3 & 0x3f] : "=";
+    }
+    return output;
+}
+
+export function utf8ToBase64(value: string = ""): string {
+    const normalized = value == null ? "" : String(value);
+
+    const maybeBuffer = (globalThis as any)?.Buffer;
+    if (maybeBuffer?.from) {
+        return maybeBuffer.from(normalized, "utf8").toString("base64");
+    }
+
+    return bytesToBase64(toUTF8Bytes(normalized));
+}