@configura/web-utilities 2.1.0-alpha.2 → 2.1.0-alpha.3

package/dist/Observable/LogObservable.d.ts

@@ -1,43 +1,43 @@
-import { AccumulatingObservable } from "./AccumulatingObservable.js";
-export declare enum LogLevel {
-    Log = "Log",
-    Info = "Info",
-    Warn = "Warn",
-    Error = "Error"
-}
-export declare class LogMessage {
-    level: LogLevel;
-    message: unknown;
-    optionalParams: unknown[];
-    constructor(level: LogLevel, message: unknown, optionalParams?: unknown[]);
-    get key(): string;
-    get levelMessageHash(): number;
-    equals(other: LogMessage): boolean;
-}
-export interface Logger {
-    addPrebaked(logMessage: LogMessage, toConsoleLog?: boolean): void;
-    info(message: unknown, ...optionalParams: unknown[]): void;
-    warn(message: unknown, ...optionalParams: unknown[]): void;
-    warnFromCaught(error: unknown): void;
-    error(message: unknown, ...optionalParams: unknown[]): void;
-    errorFromCaught(error: unknown): void;
-    errorAsObject(message: unknown, ...optionalParams: unknown[]): Error;
-}
-export declare class LogObservable extends AccumulatingObservable<LogMessage> implements Logger {
-    private static _allObservables;
-    private static _accumulate;
-    static get accumulate(): boolean;
-    static set accumulate(v: boolean);
-    static get allMessages(): LogMessage[];
-    static clear(): void;
-    constructor();
-    addPrebaked: (m: LogMessage, toConsoleLog?: boolean) => void;
-    private someLog;
-    info(message: unknown, ...optionalParams: unknown[]): void;
-    warn(message: unknown, ...optionalParams: unknown[]): void;
-    warnFromCaught(e: unknown): void;
-    error(message: unknown, ...optionalParams: unknown[]): void;
-    errorFromCaught(e: unknown): void;
-    errorAsObject(message: unknown, ...optionalParams: unknown[]): Error;
-}
+import { AccumulatingObservable } from "./AccumulatingObservable.js";
+export declare enum LogLevel {
+    Log = "Log",
+    Info = "Info",
+    Warn = "Warn",
+    Error = "Error"
+}
+export declare class LogMessage {
+    level: LogLevel;
+    message: unknown;
+    optionalParams: unknown[];
+    constructor(level: LogLevel, message: unknown, optionalParams?: unknown[]);
+    get key(): string;
+    get levelMessageHash(): number;
+    equals(other: LogMessage): boolean;
+}
+export interface Logger {
+    addPrebaked(logMessage: LogMessage, toConsoleLog?: boolean): void;
+    info(message: unknown, ...optionalParams: unknown[]): void;
+    warn(message: unknown, ...optionalParams: unknown[]): void;
+    warnFromCaught(error: unknown): void;
+    error(message: unknown, ...optionalParams: unknown[]): void;
+    errorFromCaught(error: unknown): void;
+    errorAsObject(message: unknown, ...optionalParams: unknown[]): Error;
+}
+export declare class LogObservable extends AccumulatingObservable<LogMessage> implements Logger {
+    private static _allObservables;
+    private static _accumulate;
+    static get accumulate(): boolean;
+    static set accumulate(v: boolean);
+    static get allMessages(): LogMessage[];
+    static clear(): void;
+    constructor();
+    addPrebaked: (m: LogMessage, toConsoleLog?: boolean) => void;
+    private someLog;
+    info(message: unknown, ...optionalParams: unknown[]): void;
+    warn(message: unknown, ...optionalParams: unknown[]): void;
+    warnFromCaught(e: unknown): void;
+    error(message: unknown, ...optionalParams: unknown[]): void;
+    errorFromCaught(e: unknown): void;
+    errorAsObject(message: unknown, ...optionalParams: unknown[]): Error;
+}
 //# sourceMappingURL=LogObservable.d.ts.map

package/dist/Observable/LogObservable.js

@@ -1,104 +1,104 @@
-import { hashCode } from "../index.js";
-import { AccumulatingObservable } from "./AccumulatingObservable.js";
-export var LogLevel;
-(function (LogLevel) {
-    LogLevel["Log"] = "Log";
-    LogLevel["Info"] = "Info";
-    LogLevel["Warn"] = "Warn";
-    LogLevel["Error"] = "Error";
-})(LogLevel || (LogLevel = {}));
-export class LogMessage {
-    constructor(level, message, optionalParams = []) {
-        this.level = level;
-        this.message = message;
-        this.optionalParams = optionalParams;
-    }
-    get key() {
-        return `${this.level}_${this.message}_${this.optionalParams.join("_")}`;
-    }
-    get levelMessageHash() {
-        return hashCode(`${this.level}_${this.message}`);
-    }
-    equals(other) {
-        return this.key === other.key;
-    }
-}
-function notInArray(target, m) {
-    return target.every((a) => !a.equals(m));
-}
-export class LogObservable extends AccumulatingObservable {
-    constructor() {
-        super();
-        this.addPrebaked = (m, toConsoleLog = false) => {
-            if (notInArray(this.accumulated, m)) {
-                this.notifyAll(m);
-            }
-            if (toConsoleLog) {
-                const message = m.message;
-                const optionalParams = m.optionalParams;
-                switch (m.level) {
-                    case LogLevel.Info:
-                        console.info(message, ...optionalParams);
-                        break;
-                    case LogLevel.Warn:
-                        console.warn(message, ...optionalParams);
-                        break;
-                    case LogLevel.Error:
-                        console.error(message, ...optionalParams);
-                        break;
-                    default:
-                        console.log(message, ...optionalParams);
-                }
-            }
-        };
-        this.someLog = (level, message, ...optionalParams) => {
-            this.addPrebaked(new LogMessage(level, message, optionalParams), true);
-        };
-        LogObservable._allObservables.push(this);
-    }
-    static get accumulate() {
-        return this._accumulate;
-    }
-    static set accumulate(v) {
-        this._accumulate = v;
-        if (!v) {
-            this.clear();
-        }
-    }
-    static get allMessages() {
-        return this._allObservables.reduce((a, o) => {
-            o.accumulated.forEach((m) => {
-                if (notInArray(a, m)) {
-                    a.push(m);
-                }
-            });
-            return a;
-        }, []);
-    }
-    static clear() {
-        for (const o of this._allObservables) {
-            o.clear();
-        }
-    }
-    info(message, ...optionalParams) {
-        this.someLog(LogLevel.Info, message, ...optionalParams);
-    }
-    warn(message, ...optionalParams) {
-        this.someLog(LogLevel.Warn, message, ...optionalParams);
-    }
-    warnFromCaught(e) {
-        this.warn(`${e}`);
-    }
-    error(message, ...optionalParams) {
-        this.someLog(LogLevel.Error, message, ...optionalParams);
-    }
-    errorFromCaught(e) {
-        this.error(`${e}`);
-    }
-    errorAsObject(message, ...optionalParams) {
-        this.someLog(LogLevel.Error, message, ...optionalParams);
-        return new Error(message + "\n " + optionalParams.join("a"));
-    }
-}
-LogObservable._allObservables = [];
-LogObservable._accumulate = true;
+import { hashCode } from "../index.js";
+import { AccumulatingObservable } from "./AccumulatingObservable.js";
+export var LogLevel;
+(function (LogLevel) {
+    LogLevel["Log"] = "Log";
+    LogLevel["Info"] = "Info";
+    LogLevel["Warn"] = "Warn";
+    LogLevel["Error"] = "Error";
+})(LogLevel || (LogLevel = {}));
+export class LogMessage {
+    constructor(level, message, optionalParams = []) {
+        this.level = level;
+        this.message = message;
+        this.optionalParams = optionalParams;
+    }
+    get key() {
+        return `${this.level}_${this.message}_${this.optionalParams.join("_")}`;
+    }
+    get levelMessageHash() {
+        return hashCode(`${this.level}_${this.message}`);
+    }
+    equals(other) {
+        return this.key === other.key;
+    }
+}
+function notInArray(target, m) {
+    return target.every((a) => !a.equals(m));
+}
+export class LogObservable extends AccumulatingObservable {
+    constructor() {
+        super();
+        this.addPrebaked = (m, toConsoleLog = false) => {
+            if (notInArray(this.accumulated, m)) {
+                this.notifyAll(m);
+            }
+            if (toConsoleLog) {
+                const message = m.message;
+                const optionalParams = m.optionalParams;
+                switch (m.level) {
+                    case LogLevel.Info:
+                        console.info(message, ...optionalParams);
+                        break;
+                    case LogLevel.Warn:
+                        console.warn(message, ...optionalParams);
+                        break;
+                    case LogLevel.Error:
+                        console.error(message, ...optionalParams);
+                        break;
+                    default:
+                        console.log(message, ...optionalParams);
+                }
+            }
+        };
+        this.someLog = (level, message, ...optionalParams) => {
+            this.addPrebaked(new LogMessage(level, message, optionalParams), true);
+        };
+        LogObservable._allObservables.push(this);
+    }
+    static get accumulate() {
+        return this._accumulate;
+    }
+    static set accumulate(v) {
+        this._accumulate = v;
+        if (!v) {
+            this.clear();
+        }
+    }
+    static get allMessages() {
+        return this._allObservables.reduce((a, o) => {
+            o.accumulated.forEach((m) => {
+                if (notInArray(a, m)) {
+                    a.push(m);
+                }
+            });
+            return a;
+        }, []);
+    }
+    static clear() {
+        for (const o of this._allObservables) {
+            o.clear();
+        }
+    }
+    info(message, ...optionalParams) {
+        this.someLog(LogLevel.Info, message, ...optionalParams);
+    }
+    warn(message, ...optionalParams) {
+        this.someLog(LogLevel.Warn, message, ...optionalParams);
+    }
+    warnFromCaught(e) {
+        this.warn(`${e}`);
+    }
+    error(message, ...optionalParams) {
+        this.someLog(LogLevel.Error, message, ...optionalParams);
+    }
+    errorFromCaught(e) {
+        this.error(`${e}`);
+    }
+    errorAsObject(message, ...optionalParams) {
+        this.someLog(LogLevel.Error, message, ...optionalParams);
+        return new Error(message + "\n " + optionalParams.join("a"));
+    }
+}
+LogObservable._allObservables = [];
+LogObservable._accumulate = true;

package/dist/Observable/LogProducer.d.ts

@@ -1,6 +1,6 @@
-import { LogObservable } from "./LogObservable.js";
-export interface LogProducer {
-    logger: LogObservable;
-}
-export declare function isLogProducer(object: unknown): object is LogProducer;
+import { LogObservable } from "./LogObservable.js";
+export interface LogProducer {
+    logger: LogObservable;
+}
+export declare function isLogProducer(object: unknown): object is LogProducer;
 //# sourceMappingURL=LogProducer.d.ts.map

package/dist/Observable/LogProducer.js

@@ -1,9 +1,9 @@
-import { LogObservable } from "./LogObservable.js";
-function hasLoggerProperty(object) {
-    return typeof object === "object" && object !== null && "logger" in object;
-}
-// This has to be possible to do without the helper function and the HasLoggerProperty
-// but can't figure out how right now
-export function isLogProducer(object) {
-    return hasLoggerProperty(object) && object.logger instanceof LogObservable;
-}
+import { LogObservable } from "./LogObservable.js";
+function hasLoggerProperty(object) {
+    return typeof object === "object" && object !== null && "logger" in object;
+}
+// This has to be possible to do without the helper function and the HasLoggerProperty
+// but can't figure out how right now
+export function isLogProducer(object) {
+    return hasLoggerProperty(object) && object.logger instanceof LogObservable;
+}

package/dist/Observable/Observable.d.ts

@@ -1,13 +1,13 @@
-export declare class Observable<T> {
-    listeners: {
-        l: (v: T) => void;
-        c: unknown | undefined;
-    }[];
-    listen: (listener: (v: T) => void, context?: unknown) => void;
-    stopListen: (listener: (v: T) => void) => void;
-    stopAllListen: () => void;
-    notifyAll: (v: T, context?: unknown) => void;
-    link: (other: Observable<T>) => void;
-    unlink: (other: Observable<T>) => void;
-}
+export declare class Observable<T> {
+    listeners: {
+        l: (v: T) => void;
+        c: unknown | undefined;
+    }[];
+    listen: (listener: (v: T) => void, context?: unknown) => void;
+    stopListen: (listener: (v: T) => void) => void;
+    stopAllListen: () => void;
+    notifyAll: (v: T, context?: unknown) => void;
+    link: (other: Observable<T>) => void;
+    unlink: (other: Observable<T>) => void;
+}
 //# sourceMappingURL=Observable.d.ts.map

package/dist/Observable/Observable.js

@@ -1,33 +1,33 @@
-export class Observable {
-    constructor() {
-        this.listeners = [];
-        this.listen = (listener, context) => {
-            this.listeners.push({ l: listener, c: context });
-        };
-        this.stopListen = (listener) => {
-            const index = this.listeners.findIndex((l) => l.l === listener);
-            if (index !== -1) {
-                this.listeners.splice(index, 1);
-            }
-        };
-        this.stopAllListen = () => {
-            this.listeners.length = 0;
-        };
-        this.notifyAll = (v, context) => {
-            this.listeners.forEach((l) => {
-                if (context && l.c === context) {
-                    return;
-                }
-                l.l(v);
-            });
-        };
-        this.link = (other) => {
-            this.listen((v) => other.notifyAll(v, this), other);
-            other.listen((v) => this.notifyAll(v, other), this);
-        };
-        this.unlink = (other) => {
-            this.stopListen(other.notifyAll);
-            other.stopListen(this.notifyAll);
-        };
-    }
-}
+export class Observable {
+    constructor() {
+        this.listeners = [];
+        this.listen = (listener, context) => {
+            this.listeners.push({ l: listener, c: context });
+        };
+        this.stopListen = (listener) => {
+            const index = this.listeners.findIndex((l) => l.l === listener);
+            if (index !== -1) {
+                this.listeners.splice(index, 1);
+            }
+        };
+        this.stopAllListen = () => {
+            this.listeners.length = 0;
+        };
+        this.notifyAll = (v, context) => {
+            this.listeners.forEach((l) => {
+                if (context && l.c === context) {
+                    return;
+                }
+                l.l(v);
+            });
+        };
+        this.link = (other) => {
+            this.listen((v) => other.notifyAll(v, this), other);
+            other.listen((v) => this.notifyAll(v, other), this);
+        };
+        this.unlink = (other) => {
+            this.stopListen(other.notifyAll);
+            other.stopListen(this.notifyAll);
+        };
+    }
+}

package/dist/PromiseCache.d.ts

@@ -1,5 +1,5 @@
-import { GenericCache } from "./GenericCache.js";
-export declare class PromiseCache<Key, Item> extends GenericCache<Key, Promise<Item>> {
-    get(key: Key, createMissing: () => Promise<Item>): Promise<Item>;
-}
+import { GenericCache } from "./GenericCache.js";
+export declare class PromiseCache<Key, Item> extends GenericCache<Key, Promise<Item>> {
+    get(key: Key, createMissing: () => Promise<Item>): Promise<Item>;
+}
 //# sourceMappingURL=PromiseCache.d.ts.map

package/dist/PromiseCache.js

@@ -1,28 +1,28 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { GenericCache } from "./GenericCache.js";
-export class PromiseCache extends GenericCache {
-    get(key, createMissing) {
-        const _super = Object.create(null, {
-            get: { get: () => super.get }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            return _super.get.call(this, key, () => {
-                const item = createMissing();
-                if (item !== undefined) {
-                    item.catch(() => {
-                        this.delete(key);
-                    });
-                }
-                return item;
-            });
-        });
-    }
-}
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { GenericCache } from "./GenericCache.js";
+export class PromiseCache extends GenericCache {
+    get(key, createMissing) {
+        const _super = Object.create(null, {
+            get: { get: () => super.get }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return _super.get.call(this, key, () => {
+                const item = createMissing();
+                if (item !== undefined) {
+                    item.catch(() => {
+                        this.delete(key);
+                    });
+                }
+                return item;
+            });
+        });
+    }
+}

package/dist/assert.d.ts

@@ -1,13 +1,13 @@
-/**
- * @throws error with the supplied message, if the condition is not true.
- *
- * Can for example be used like a type guard in TypeScript.
- */
-export declare function assert(condition: unknown, msg?: string): asserts condition;
-/**
- * @throws error with the supplied message, if the value === undefined.
- *
- * Can be used like a type guard in TypeScript.
- */
-export declare function assertDefined<T>(value: T, msg?: string): asserts value is Exclude<T, undefined>;
+/**
+ * @throws error with the supplied message, if the condition is not true.
+ *
+ * Can for example be used like a type guard in TypeScript.
+ */
+export declare function assert(condition: unknown, msg?: string): asserts condition;
+/**
+ * @throws error with the supplied message, if the value === undefined.
+ *
+ * Can be used like a type guard in TypeScript.
+ */
+export declare function assertDefined<T>(value: T, msg?: string): asserts value is Exclude<T, undefined>;
 //# sourceMappingURL=assert.d.ts.map

package/dist/assert.js

@@ -1,20 +1,20 @@
-/**
- * @throws error with the supplied message, if the condition is not true.
- *
- * Can for example be used like a type guard in TypeScript.
- */
-export function assert(condition, msg) {
-    if (!condition) {
-        throw new Error(msg);
-    }
-}
-/**
- * @throws error with the supplied message, if the value === undefined.
- *
- * Can be used like a type guard in TypeScript.
- */
-export function assertDefined(value, msg) {
-    if (value === undefined) {
-        throw new Error(msg);
-    }
-}
+/**
+ * @throws error with the supplied message, if the condition is not true.
+ *
+ * Can for example be used like a type guard in TypeScript.
+ */
+export function assert(condition, msg) {
+    if (!condition) {
+        throw new Error(msg);
+    }
+}
+/**
+ * @throws error with the supplied message, if the value === undefined.
+ *
+ * Can be used like a type guard in TypeScript.
+ */
+export function assertDefined(value, msg) {
+    if (value === undefined) {
+        throw new Error(msg);
+    }
+}

package/dist/cmMips.d.ts

@@ -1,27 +1,27 @@
-import { LogObservable } from "./Observable/LogObservable.js";
-/** The mime type (or media type) is only used internally, so using the "x." sub type is OK. */
-export declare const CMMIPS_MIMETYPE = "image/x.cmmips";
-/**
- * Extracts the specified MIP level image data from the CmMips container.
- *
- * By default the highest quality MIP level is loaded. The optional maxResolution setting will
- * instead load the highest quality MIP level where BOTH width and height is < maxResolution, or
- * the lowest quality if none fulfill the requirement.
- *
- * Returns a filled in CmMips class with meta data as well as the byte array with the image data.
- * Returns undefined if there was an error
- *
- * @warning: For efficacy and maximum flexibility, the returned Uint8Array is only a new View into
- * the supplied bytes typed array. It is up to the caller to call slice() on it to create a copy of
- * the data if needed.
- */
-export declare function extractCmMips(bytes: Uint8Array, logger: LogObservable, maxRes?: number): CmMip | undefined;
-export declare class CmMip {
-    readonly name: string;
-    readonly suffix: string;
-    readonly width: number;
-    readonly height: number;
-    readonly data?: Uint8Array | undefined;
-    constructor(name: string, suffix: string, width: number, height: number, data?: Uint8Array | undefined);
-}
+import { LogObservable } from "./Observable/LogObservable.js";
+/** The mime type (or media type) is only used internally, so using the "x." sub type is OK. */
+export declare const CMMIPS_MIMETYPE = "image/x.cmmips";
+/**
+ * Extracts the specified MIP level image data from the CmMips container.
+ *
+ * By default the highest quality MIP level is loaded. The optional maxResolution setting will
+ * instead load the highest quality MIP level where BOTH width and height is < maxResolution, or
+ * the lowest quality if none fulfill the requirement.
+ *
+ * Returns a filled in CmMips class with meta data as well as the byte array with the image data.
+ * Returns undefined if there was an error
+ *
+ * @warning: For efficacy and maximum flexibility, the returned Uint8Array is only a new View into
+ * the supplied bytes typed array. It is up to the caller to call slice() on it to create a copy of
+ * the data if needed.
+ */
+export declare function extractCmMips(bytes: Uint8Array, logger: LogObservable, maxRes?: number): CmMip | undefined;
+export declare class CmMip {
+    readonly name: string;
+    readonly suffix: string;
+    readonly width: number;
+    readonly height: number;
+    readonly data?: Uint8Array | undefined;
+    constructor(name: string, suffix: string, width: number, height: number, data?: Uint8Array | undefined);
+}
 //# sourceMappingURL=cmMips.d.ts.map