@matter/general 0.11.0-alpha.0-20241005-e3e4e4a7a

package/src/util/Bytes.ts

@@ -0,0 +1,73 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { UnexpectedDataError } from "../MatterError.js";
+
+export enum Endian {
+    Little,
+    Big,
+}
+
+/**
+ * Utility functions for manipulating Uint8Array.
+ */
+export namespace Bytes {
+    export function toHex(array: Uint8Array) {
+        const hexArray = new Array<string>();
+        hexArray.length = array.length;
+        array.forEach(byte => hexArray.push(byte.toString(16).padStart(2, "0")));
+        return hexArray.join("");
+    }
+
+    export function toBase64(array: Uint8Array) {
+        let result = "";
+        array.forEach(byte => (result += String.fromCharCode(byte)));
+        return btoa(result);
+    }
+
+    export function dataViewOf(array: Uint8Array) {
+        return new DataView(array.buffer, array.byteOffset, array.byteLength);
+    }
+
+    export function areEqual(array1: Uint8Array, array2: Uint8Array) {
+        if (array1.length !== array2.length) return false;
+        return array1.every((value, index) => array2[index] === value);
+    }
+
+    export function fromHex(hexString: string) {
+        if (hexString.length === 0) return new Uint8Array(0);
+        if (hexString.length % 2 !== 0) throw new UnexpectedDataError("Hex string should have an even length.");
+        const bytes = hexString.match(/.{1,2}/g)?.map(byteHex => parseInt(byteHex, 16));
+        if (bytes === undefined) throw new UnexpectedDataError("Failed to parse the hex string.");
+        return Uint8Array.from(bytes);
+    }
+
+    export function fromBase64(base64String: string) {
+        const raw = atob(base64String);
+        let result = "";
+        for (let i = 0; i < raw.length; i++) {
+            const hex = raw.charCodeAt(i).toString(16);
+            result += hex.length === 2 ? hex : "0" + hex;
+        }
+        return fromHex(result);
+    }
+
+    export function fromString(string: string) {
+        return new TextEncoder().encode(string);
+    }
+
+    export function concat(...arrays: Uint8Array[]): Uint8Array {
+        let length = 0;
+        arrays.forEach(array => (length += array.length));
+        const result = new Uint8Array(length);
+        let offset = 0;
+        arrays.forEach(array => {
+            result.set(array, offset);
+            offset += array.length;
+        });
+        return result;
+    }
+}

package/src/util/Cache.ts

@@ -0,0 +1,111 @@
+/**
+ * Cache computed values or resources for a specified duration to improve performances.
+ *
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { Diagnostic } from "../log/Diagnostic.js";
+import { Time, Timer } from "../time/Time.js";
+
+class GenericCache<T> {
+    protected readonly knownKeys = new Set<string>();
+    protected readonly values = new Map<string, T>();
+    protected readonly timestamps = new Map<string, number>();
+    private readonly periodicTimer: Timer;
+
+    constructor(
+        name: string,
+        private readonly expirationMs: number,
+        private readonly expireCallback?: (key: string, value: T) => Promise<void>,
+    ) {
+        this.periodicTimer = Time.getPeriodicTimer(
+            Diagnostic.upgrade(`${name} cache expiration`, [Diagnostic.strong(name), "cache expiration"]),
+            expirationMs,
+            () => this.expire(),
+        ).start();
+        this.periodicTimer.utility = true;
+    }
+
+    keys() {
+        return Array.from(this.knownKeys.values());
+    }
+
+    private async deleteEntry(key: string) {
+        const value = this.values.get(key);
+        if (this.expireCallback !== undefined && value !== undefined) {
+            await this.expireCallback(key, value);
+        }
+        this.values.delete(key);
+        this.timestamps.delete(key);
+    }
+
+    async clear() {
+        for (const key of this.values.keys()) {
+            await this.deleteEntry(key);
+        }
+        this.values.clear();
+        this.timestamps.clear();
+    }
+
+    async close() {
+        await this.clear();
+        this.knownKeys.clear();
+        this.periodicTimer.stop();
+    }
+
+    private async expire() {
+        const now = Time.nowMs();
+        for (const [key, timestamp] of this.timestamps.entries()) {
+            if (now - timestamp < this.expirationMs) continue;
+            await this.deleteEntry(key);
+        }
+    }
+}
+
+export class Cache<T> extends GenericCache<T> {
+    constructor(
+        name: string,
+        private readonly generator: (...params: any[]) => T,
+        expirationMs: number,
+        expireCallback?: (key: string, value: T) => Promise<void>,
+    ) {
+        super(name, expirationMs, expireCallback);
+    }
+
+    get(...params: any[]) {
+        const key = params.join(",");
+        let value = this.values.get(key);
+        if (value === undefined) {
+            value = this.generator(...params);
+            this.values.set(key, value);
+            this.knownKeys.add(key);
+        }
+        this.timestamps.set(key, Time.nowMs());
+        return value;
+    }
+}
+
+export class AsyncCache<T> extends GenericCache<T> {
+    constructor(
+        name: string,
+        private readonly generator: (...params: any[]) => Promise<T>,
+        expirationMs: number,
+        expireCallback?: (key: string, value: T) => Promise<void>,
+    ) {
+        super(name, expirationMs, expireCallback);
+    }
+
+    async get(...params: any[]) {
+        const key = params.join(",");
+        let value = this.values.get(key);
+        if (value === undefined) {
+            value = await this.generator(...params);
+            this.values.set(key, value);
+            this.knownKeys.add(key);
+        }
+        this.timestamps.set(key, Time.nowMs());
+        return value;
+    }
+}