@configura/web-utilities 2.1.0-alpha.0 → 2.1.0-alpha.1

package/__tests__/cmMips.test.ts

@@ -1,129 +1,129 @@
-/**
- * @jest-environment node
- *
- * We need to use Node.js since the default "jsdom" environment results in a
- * "ReferenceError: TextDecoder is not defined" error.
- **/
-
-import { readFileSync } from "fs";
-import { CmMip, extractCmMips } from "../dist/cmMips.js";
-import { LogObservable } from "../dist/Observable/LogObservable.js";
-
-const logger = new LogObservable();
-
-let onlyInternal: Uint8Array | undefined = undefined;
-let partlyExternal: Uint8Array | undefined = undefined;
-
-const emptyCmMips = new Uint8Array([
-	0x77, // magic
-	0xee,
-	1, // version
-	0,
-	0,
-	0,
-	1, // suffix length
-	65, // suffix string ("A")
-	3, // format length
-	82, // format string ("RGB")
-	71,
-	66,
-	1, // averageR
-	2, // averageG
-	3, // averageB
-	4, // minWidth
-	0,
-	0,
-	0,
-	5, // minHeight
-	0,
-	0,
-	0,
-	0, // mipLevels
-	0,
-	0,
-	0,
-]);
-
-beforeAll(() => {
-	onlyInternal = new Uint8Array(
-		readFileSync("./packages/web-utilities/__tests__/images/onlyInternal.cmmips")
-	);
-	partlyExternal = new Uint8Array(
-		readFileSync("./packages/web-utilities/__tests__/images/partlyExternal.cmmips")
-	);
-});
-
-afterAll(() => {
-	onlyInternal = undefined;
-	partlyExternal = undefined;
-});
-
-function checkBasics(mip: CmMip) {
-	expect(mip).toBeDefined();
-	expect(mip.name).toBeTruthy();
-	expect(mip.suffix).toBeTruthy();
-	expect(mip.width).toBeGreaterThan(0);
-	expect(mip.height).toBeGreaterThan(0);
-	expect(mip.data?.length).toBeGreaterThan(0);
-}
-
-test("Default Mip from CmMips file with only internal images", () => {
-	checkBasics(extractCmMips(onlyInternal, logger));
-});
-
-test("Default Mip from CmMips file with some external images", () => {
-	checkBasics(extractCmMips(partlyExternal, logger));
-});
-
-test("Requesting exact Mip size", () => {
-	const mip = extractCmMips(onlyInternal, logger, 16);
-	checkBasics(mip);
-	expect(mip.width).toEqual(16);
-	expect(mip.height).toEqual(16);
-});
-
-test("Requesting closest smaller Mip size", () => {
-	const mip = extractCmMips(onlyInternal, logger, 15);
-	checkBasics(mip);
-	expect(mip.width).toEqual(8);
-	expect(mip.height).toEqual(8);
-});
-
-test("Requesting impossible Mip size", () => {
-	// We should always get a Mip back, if there are any internal at all in the file.
-	const mip = extractCmMips(onlyInternal, logger, 0);
-	checkBasics(mip);
-	expect(mip.width).toEqual(1);
-	expect(mip.height).toEqual(1);
-});
-
-test("Undefined array", () => {
-	expect(extractCmMips(undefined, logger, 0)).toBeUndefined();
-});
-
-test("Wrong magic", () => {
-	expect(extractCmMips(new Uint8Array([0x39, 0x30, 0, 0, 0, 0]), logger)).toBeUndefined();
-});
-
-test("Only header", () => {
-	expect(extractCmMips(emptyCmMips, logger)).toBeUndefined();
-});
-
-test("Truncated data", () => {
-	// Slice and Subarray will give internal buffers of different sizes.
-	// Slice is safest and can therefor be considered the reference if the tests differ.
-	const mip = extractCmMips(onlyInternal.subarray(0, 15), logger);
-	expect(mip).toBeUndefined();
-	expect(extractCmMips(onlyInternal.slice(0, 15), logger)).toEqual(mip);
-});
-
-test("Subarray with non-zero offset", () => {
-	// Slice and Subarray will give internal buffers of different sizes and offsets.
-	// Slice is safest and can therefor be considered the reference if the tests differ.
-	const array = new Uint8Array(onlyInternal.length + 1);
-	array.set(onlyInternal, 1);
-	array[0] = 42;
-	const mip = extractCmMips(array.subarray(1, array.length), logger);
-	checkBasics(mip);
-	expect(extractCmMips(array.slice(1, array.length), logger)).toEqual(mip);
-});
+/**
+ * @jest-environment node
+ *
+ * We need to use Node.js since the default "jsdom" environment results in a
+ * "ReferenceError: TextDecoder is not defined" error.
+ **/
+
+import { readFileSync } from "fs";
+import { CmMip, extractCmMips } from "../dist/cmMips.js";
+import { LogObservable } from "../dist/Observable/LogObservable.js";
+
+const logger = new LogObservable();
+
+let onlyInternal: Uint8Array | undefined = undefined;
+let partlyExternal: Uint8Array | undefined = undefined;
+
+const emptyCmMips = new Uint8Array([
+	0x77, // magic
+	0xee,
+	1, // version
+	0,
+	0,
+	0,
+	1, // suffix length
+	65, // suffix string ("A")
+	3, // format length
+	82, // format string ("RGB")
+	71,
+	66,
+	1, // averageR
+	2, // averageG
+	3, // averageB
+	4, // minWidth
+	0,
+	0,
+	0,
+	5, // minHeight
+	0,
+	0,
+	0,
+	0, // mipLevels
+	0,
+	0,
+	0,
+]);
+
+beforeAll(() => {
+	onlyInternal = new Uint8Array(
+		readFileSync("./packages/web-utilities/__tests__/images/onlyInternal.cmmips")
+	);
+	partlyExternal = new Uint8Array(
+		readFileSync("./packages/web-utilities/__tests__/images/partlyExternal.cmmips")
+	);
+});
+
+afterAll(() => {
+	onlyInternal = undefined;
+	partlyExternal = undefined;
+});
+
+function checkBasics(mip: CmMip) {
+	expect(mip).toBeDefined();
+	expect(mip.name).toBeTruthy();
+	expect(mip.suffix).toBeTruthy();
+	expect(mip.width).toBeGreaterThan(0);
+	expect(mip.height).toBeGreaterThan(0);
+	expect(mip.data?.length).toBeGreaterThan(0);
+}
+
+test("Default Mip from CmMips file with only internal images", () => {
+	checkBasics(extractCmMips(onlyInternal, logger));
+});
+
+test("Default Mip from CmMips file with some external images", () => {
+	checkBasics(extractCmMips(partlyExternal, logger));
+});
+
+test("Requesting exact Mip size", () => {
+	const mip = extractCmMips(onlyInternal, logger, 16);
+	checkBasics(mip);
+	expect(mip.width).toEqual(16);
+	expect(mip.height).toEqual(16);
+});
+
+test("Requesting closest smaller Mip size", () => {
+	const mip = extractCmMips(onlyInternal, logger, 15);
+	checkBasics(mip);
+	expect(mip.width).toEqual(8);
+	expect(mip.height).toEqual(8);
+});
+
+test("Requesting impossible Mip size", () => {
+	// We should always get a Mip back, if there are any internal at all in the file.
+	const mip = extractCmMips(onlyInternal, logger, 0);
+	checkBasics(mip);
+	expect(mip.width).toEqual(1);
+	expect(mip.height).toEqual(1);
+});
+
+test("Undefined array", () => {
+	expect(extractCmMips(undefined, logger, 0)).toBeUndefined();
+});
+
+test("Wrong magic", () => {
+	expect(extractCmMips(new Uint8Array([0x39, 0x30, 0, 0, 0, 0]), logger)).toBeUndefined();
+});
+
+test("Only header", () => {
+	expect(extractCmMips(emptyCmMips, logger)).toBeUndefined();
+});
+
+test("Truncated data", () => {
+	// Slice and Subarray will give internal buffers of different sizes.
+	// Slice is safest and can therefor be considered the reference if the tests differ.
+	const mip = extractCmMips(onlyInternal.subarray(0, 15), logger);
+	expect(mip).toBeUndefined();
+	expect(extractCmMips(onlyInternal.slice(0, 15), logger)).toEqual(mip);
+});
+
+test("Subarray with non-zero offset", () => {
+	// Slice and Subarray will give internal buffers of different sizes and offsets.
+	// Slice is safest and can therefor be considered the reference if the tests differ.
+	const array = new Uint8Array(onlyInternal.length + 1);
+	array.set(onlyInternal, 1);
+	array[0] = 42;
+	const mip = extractCmMips(array.subarray(1, array.length), logger);
+	checkBasics(mip);
+	expect(extractCmMips(array.slice(1, array.length), logger)).toEqual(mip);
+});

package/__tests__/convertLength.test.ts

@@ -1,37 +1,37 @@
-import { convertLength, toLengthUnit } from "../dist/utilitiesUnits";
-
-test("to m", () => {
-	expect(toLengthUnit("M")).toBe("m");
-});
-
-test("to in", () => {
-	expect(toLengthUnit("Inch")).toBe("in");
-});
-
-test("ft to ft", () => {
-	expect(convertLength(2, "ft", "ft")).toBe(2);
-});
-
-test("cm to m", () => {
-	expect(convertLength(2, "cm", "m")).toBe(0.02);
-});
-
-test("dm to mm", () => {
-	expect(convertLength(12.34, "dm", "mm")).toBe(1234);
-});
-
-test("ft to mm", () => {
-	expect(convertLength(12.34, "ft", "mm")).toBeCloseTo(3761.232, 3);
-});
-
-test("cm to inch", () => {
-	expect(convertLength(5, "cm", "in")).toBeCloseTo(1.96850394, 3);
-});
-
-test("feet to inch", () => {
-	expect(convertLength(1, "ft", "in")).toBe(12);
-});
-
-test("inch to feet", () => {
-	expect(convertLength(12, "in", "ft")).toBe(1);
-});
+import { convertLength, toLengthUnit } from "../dist/utilitiesUnits";
+
+test("to m", () => {
+	expect(toLengthUnit("M")).toBe("m");
+});
+
+test("to in", () => {
+	expect(toLengthUnit("Inch")).toBe("in");
+});
+
+test("ft to ft", () => {
+	expect(convertLength(2, "ft", "ft")).toBe(2);
+});
+
+test("cm to m", () => {
+	expect(convertLength(2, "cm", "m")).toBe(0.02);
+});
+
+test("dm to mm", () => {
+	expect(convertLength(12.34, "dm", "mm")).toBe(1234);
+});
+
+test("ft to mm", () => {
+	expect(convertLength(12.34, "ft", "mm")).toBeCloseTo(3761.232, 3);
+});
+
+test("cm to inch", () => {
+	expect(convertLength(5, "cm", "in")).toBeCloseTo(1.96850394, 3);
+});
+
+test("feet to inch", () => {
+	expect(convertLength(1, "ft", "in")).toBe(12);
+});
+
+test("inch to feet", () => {
+	expect(convertLength(12, "in", "ft")).toBe(1);
+});

package/__tests__/price.test.ts

@@ -1,21 +1,21 @@
-import { formatPrice } from "../src/utilitiesPrice";
-
-const price = 123456.789012;
-const lang = "en-US";
-const currency = "SEK";
-
-test("price rounding 0", () => {
-	expect(formatPrice(price, 0, lang, currency)).toBe("SEK\u00A0123,457");
-});
-
-test("price rounding 2", () => {
-	expect(formatPrice(price, 2, lang, currency)).toBe("SEK\u00A0123,456.79");
-});
-
-test("price rounding -1", () => {
-	expect(formatPrice(price, -1, lang, currency)).toBe("SEK\u00A0123,460");
-});
-
-test("price rounding -2", () => {
-	expect(formatPrice(price, -2, lang, currency)).toBe("SEK\u00A0123,500");
-});
+import { formatPrice } from "../src/utilitiesPrice";
+
+const price = 123456.789012;
+const lang = "en-US";
+const currency = "SEK";
+
+test("price rounding 0", () => {
+	expect(formatPrice(price, 0, lang, currency)).toBe("SEK\u00A0123,457");
+});
+
+test("price rounding 2", () => {
+	expect(formatPrice(price, 2, lang, currency)).toBe("SEK\u00A0123,456.79");
+});
+
+test("price rounding -1", () => {
+	expect(formatPrice(price, -1, lang, currency)).toBe("SEK\u00A0123,460");
+});
+
+test("price rounding -2", () => {
+	expect(formatPrice(price, -2, lang, currency)).toBe("SEK\u00A0123,500");
+});

package/dist/GenericCache.d.ts

@@ -1,15 +1,15 @@
-export declare class GenericCache<Key, Item> {
-    private _keyLookupFunction?;
-    /** @remarks Using a keyLoopupFunction makes the cache much much slower! */
-    constructor(_keyLookupFunction?: ((key1: Key, key2: Key) => boolean) | undefined);
-    _cache: Map<Key, Item>;
-    get(key: Key, createMissing: () => Item): Item;
-    delete: (key: Key) => boolean;
-    clear: () => void;
-    /**
-     * This might seem unnecessary, but for non-primitive datatypes equality is compared on
-     * reference, not value, so finding the right key is a thing that must be done.
-     */
-    findExistingKeyOrReturnInput(key: Key, keyLookupFunction: (key1: Key, key2: Key) => boolean): Key;
-}
+export declare class GenericCache<Key, Item> {
+    private _keyLookupFunction?;
+    /** @remarks Using a keyLoopupFunction makes the cache much much slower! */
+    constructor(_keyLookupFunction?: ((key1: Key, key2: Key) => boolean) | undefined);
+    _cache: Map<Key, Item>;
+    get(key: Key, createMissing: () => Item): Item;
+    delete: (key: Key) => boolean;
+    clear: () => void;
+    /**
+     * This might seem unnecessary, but for non-primitive datatypes equality is compared on
+     * reference, not value, so finding the right key is a thing that must be done.
+     */
+    findExistingKeyOrReturnInput(key: Key, keyLookupFunction: (key1: Key, key2: Key) => boolean): Key;
+}
 //# sourceMappingURL=GenericCache.d.ts.map

package/dist/GenericCache.js

@@ -1,38 +1,38 @@
-export class GenericCache {
-    /** @remarks Using a keyLoopupFunction makes the cache much much slower! */
-    constructor(_keyLookupFunction) {
-        this._keyLookupFunction = _keyLookupFunction;
-        this._cache = new Map();
-        this.delete = (key) => {
-            return this._cache.delete(key);
-        };
-        this.clear = () => {
-            this._cache.clear();
-        };
-    }
-    get(key, createMissing) {
-        key =
-            this._keyLookupFunction === undefined
-                ? key
-                : this.findExistingKeyOrReturnInput(key, this._keyLookupFunction);
-        let item = this._cache.get(key);
-        if (item !== undefined) {
-            return item;
-        }
-        item = createMissing();
-        this._cache.set(key, item);
-        return item;
-    }
-    /**
-     * This might seem unnecessary, but for non-primitive datatypes equality is compared on
-     * reference, not value, so finding the right key is a thing that must be done.
-     */
-    findExistingKeyOrReturnInput(key, keyLookupFunction) {
-        for (const otherKey of this._cache.keys()) {
-            if (keyLookupFunction(key, otherKey)) {
-                return otherKey;
-            }
-        }
-        return key;
-    }
-}
+export class GenericCache {
+    /** @remarks Using a keyLoopupFunction makes the cache much much slower! */
+    constructor(_keyLookupFunction) {
+        this._keyLookupFunction = _keyLookupFunction;
+        this._cache = new Map();
+        this.delete = (key) => {
+            return this._cache.delete(key);
+        };
+        this.clear = () => {
+            this._cache.clear();
+        };
+    }
+    get(key, createMissing) {
+        key =
+            this._keyLookupFunction === undefined
+                ? key
+                : this.findExistingKeyOrReturnInput(key, this._keyLookupFunction);
+        let item = this._cache.get(key);
+        if (item !== undefined) {
+            return item;
+        }
+        item = createMissing();
+        this._cache.set(key, item);
+        return item;
+    }
+    /**
+     * This might seem unnecessary, but for non-primitive datatypes equality is compared on
+     * reference, not value, so finding the right key is a thing that must be done.
+     */
+    findExistingKeyOrReturnInput(key, keyLookupFunction) {
+        for (const otherKey of this._cache.keys()) {
+            if (keyLookupFunction(key, otherKey)) {
+                return otherKey;
+            }
+        }
+        return key;
+    }
+}

package/dist/Observable/AccumulatingObservable.d.ts

@@ -1,11 +1,11 @@
-import { Observable } from "./Observable.js";
-export declare class AccumulatingObservable<T> extends Observable<T> {
-    constructor();
-    private _accumulated;
-    get accumulated(): T[];
-    private accumulatedObservable;
-    listenForAccumulated: (listener: (v: T[]) => void) => void;
-    stopListenForAccumulated: (listener: (v: T[]) => void) => void;
-    clear: () => void;
-}
+import { Observable } from "./Observable.js";
+export declare class AccumulatingObservable<T> extends Observable<T> {
+    constructor();
+    private _accumulated;
+    get accumulated(): T[];
+    private accumulatedObservable;
+    listenForAccumulated: (listener: (v: T[]) => void) => void;
+    stopListenForAccumulated: (listener: (v: T[]) => void) => void;
+    clear: () => void;
+}
 //# sourceMappingURL=AccumulatingObservable.d.ts.map

package/dist/Observable/AccumulatingObservable.js

@@ -1,25 +1,25 @@
-import { Observable } from "./Observable.js";
-export class AccumulatingObservable extends Observable {
-    constructor() {
-        super();
-        this._accumulated = [];
-        this.accumulatedObservable = new Observable();
-        this.listenForAccumulated = (listener) => {
-            this.accumulatedObservable.listen(listener);
-            listener(this._accumulated);
-        };
-        this.stopListenForAccumulated = (listener) => {
-            this.accumulatedObservable.stopListen(listener);
-        };
-        this.clear = () => {
-            this._accumulated.length = 0;
-        };
-        this.listen((m) => {
-            this._accumulated.push(m);
-            this.accumulatedObservable.notifyAll(this.accumulated);
-        });
-    }
-    get accumulated() {
-        return this._accumulated;
-    }
-}
+import { Observable } from "./Observable.js";
+export class AccumulatingObservable extends Observable {
+    constructor() {
+        super();
+        this._accumulated = [];
+        this.accumulatedObservable = new Observable();
+        this.listenForAccumulated = (listener) => {
+            this.accumulatedObservable.listen(listener);
+            listener(this._accumulated);
+        };
+        this.stopListenForAccumulated = (listener) => {
+            this.accumulatedObservable.stopListen(listener);
+        };
+        this.clear = () => {
+            this._accumulated.length = 0;
+        };
+        this.listen((m) => {
+            this._accumulated.push(m);
+            this.accumulatedObservable.notifyAll(this.accumulated);
+        });
+    }
+    get accumulated() {
+        return this._accumulated;
+    }
+}

package/dist/Observable/AggregatedLoadingObservable.d.ts

@@ -1,11 +1,11 @@
-import { Observable } from "./Observable.js";
-declare type LoadingToken = unknown;
-export declare class AggregatedLoadingObservable extends Observable<boolean> {
-    private currentlyLoadingTokens;
-    startChildLoading: (token?: LoadingToken) => LoadingToken;
-    stopChildLoading: (token: LoadingToken) => void;
-    startStopChildLoading: (token: LoadingToken, on: boolean) => void;
-    private doNotifyAll;
-}
-export {};
+import { Observable } from "./Observable.js";
+declare type LoadingToken = unknown;
+export declare class AggregatedLoadingObservable extends Observable<boolean> {
+    private currentlyLoadingTokens;
+    startChildLoading: (token?: LoadingToken) => LoadingToken;
+    stopChildLoading: (token: LoadingToken) => void;
+    startStopChildLoading: (token: LoadingToken, on: boolean) => void;
+    private doNotifyAll;
+}
+export {};
 //# sourceMappingURL=AggregatedLoadingObservable.d.ts.map

package/dist/Observable/AggregatedLoadingObservable.js

@@ -1,28 +1,28 @@
-import { Observable } from "./Observable.js";
-export class AggregatedLoadingObservable extends Observable {
-    constructor() {
-        super(...arguments);
-        this.currentlyLoadingTokens = new Set();
-        this.startChildLoading = (token) => {
-            if (token === undefined) {
-                token = {};
-            }
-            this.currentlyLoadingTokens.add(token);
-            this.doNotifyAll();
-            return token;
-        };
-        this.stopChildLoading = (token) => {
-            this.currentlyLoadingTokens.delete(token);
-            this.doNotifyAll();
-        };
-        this.startStopChildLoading = (token, on) => {
-            if (on) {
-                this.startChildLoading(token);
-            }
-            else {
-                this.stopChildLoading(token);
-            }
-        };
-        this.doNotifyAll = () => this.notifyAll(0 < this.currentlyLoadingTokens.size);
-    }
-}
+import { Observable } from "./Observable.js";
+export class AggregatedLoadingObservable extends Observable {
+    constructor() {
+        super(...arguments);
+        this.currentlyLoadingTokens = new Set();
+        this.startChildLoading = (token) => {
+            if (token === undefined) {
+                token = {};
+            }
+            this.currentlyLoadingTokens.add(token);
+            this.doNotifyAll();
+            return token;
+        };
+        this.stopChildLoading = (token) => {
+            this.currentlyLoadingTokens.delete(token);
+            this.doNotifyAll();
+        };
+        this.startStopChildLoading = (token, on) => {
+            if (on) {
+                this.startChildLoading(token);
+            }
+            else {
+                this.stopChildLoading(token);
+            }
+        };
+        this.doNotifyAll = () => this.notifyAll(0 < this.currentlyLoadingTokens.size);
+    }
+}