@wireio/shared 1.0.17 → 1.0.19

package/lib/esm/helpers/Deferred.js

@@ -0,0 +1,111 @@
+import { isDefined, isPromise } from "../guards/index.js";
+export var DeferredStatus;
+(function (DeferredStatus) {
+    DeferredStatus["PENDING"] = "PENDING";
+    DeferredStatus["FULFILLED"] = "FULFILLED";
+    DeferredStatus["REJECTED"] = "REJECTED";
+    DeferredStatus["CANCELED"] = "CANCELED";
+})(DeferredStatus || (DeferredStatus = {}));
+/**
+ * A deferred promise that can be resolved or rejected
+ * externally, ideal for functions like a promise timeout
+ */
+export class Deferred {
+    static async delay(millis) {
+        const deferred = new Deferred();
+        setTimeout(() => deferred.resolve(), millis);
+        await deferred.promise;
+    }
+    static resolve(value) {
+        const deferred = new Deferred();
+        deferred.resolve(value);
+        return deferred;
+    }
+    state;
+    promise;
+    constructor(promise) {
+        this.state = {
+            resolve: null,
+            reject: null,
+            isSettled: false,
+            isCancelled: false,
+            isRejected: false,
+            isFulfilled: false,
+            result: null,
+            err: null
+        };
+        this.promise = new Promise((resolve, reject) => {
+            Object.assign(this.state, {
+                resolve,
+                reject
+            });
+        });
+        if (isDefined(promise)) {
+            if (promise instanceof Promise || isPromise(promise)) {
+                promise
+                    .then(this.state.resolve)
+                    .catch(this.state.reject);
+            }
+            else {
+                throw Error(`An existing promise was provided to Deferred constructor, but it wasn't a valid promise`);
+            }
+        }
+    }
+    isFulfilled() {
+        return this.state.isFulfilled;
+    }
+    isRejected() {
+        return this.state.isRejected;
+    }
+    isSettled() {
+        return this.state.isSettled;
+    }
+    isCancelled() {
+        return this.state.isCancelled;
+    }
+    status() {
+        return this.isCancelled() ? DeferredStatus.CANCELED : this.isSettled() ? this.isFulfilled() ? DeferredStatus.FULFILLED : DeferredStatus.REJECTED : DeferredStatus.PENDING;
+    }
+    cancel() {
+        this.state.isSettled = true;
+        this.state.isCancelled = true;
+    }
+    resolve(result) {
+        if (!this.state.isSettled && !this.state.isCancelled) {
+            Object.assign(this.state, {
+                result: result,
+                isSettled: true,
+                isFulfilled: true
+            });
+            this.state.resolve(result);
+        }
+    }
+    reject(err) {
+        if (!this.state.isSettled && !this.state.isCancelled) {
+            Object.assign(this.state, {
+                isSettled: true,
+                isRejected: true,
+                err
+            });
+            this.state.reject(err);
+        }
+    }
+    get error() {
+        return this.getError();
+    }
+    get value() {
+        return this.getResult();
+    }
+    getError() {
+        if (!this.isSettled())
+            throw Error("Deferred promise is not settled, result is not available");
+        return this.state.err;
+    }
+    getResult() {
+        if (!this.isSettled())
+            throw Error("Deferred promise is not settled, result is not available");
+        return this.state.result;
+    }
+}
+export default Deferred;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Deferred.js","sourceRoot":"","sources":["../../../src/helpers/Deferred.ts"],"names":[],"mappings":"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","sourcesContent":["import { isDefined, isPromise } from \"../guards/index.js\"\n\nexport enum DeferredStatus {\n  PENDING = \"PENDING\",\n  FULFILLED = \"FULFILLED\",\n  REJECTED = \"REJECTED\",\n  CANCELED = \"CANCELED\"\n}\n\n/**\n * Internal deferred state\n */\ninterface DeferredState<T> {\n  resolve: (result?:T) => void\n  reject: (err:any) => void\n  isSettled: boolean\n  isCancelled: boolean\n  isRejected: boolean\n  isFulfilled: boolean\n  result:T | null\n  err: Error | null\n}\n\n/**\n * A deferred promise that can be resolved or rejected\n * externally, ideal for functions like a promise timeout\n */\nexport class Deferred<T> {\n  \n\n  static async delay(millis:number) {\n    const deferred = new Deferred<void>()\n    setTimeout(() => deferred.resolve(),millis)\n    await deferred.promise\n  }\n  \n  static resolve<T>(value?:T): Deferred<T> {\n    const deferred = new Deferred<T>()\n    deferred.resolve(value)\n    return deferred\n  }\n  \n  private readonly state:DeferredState<T>\n  \n  readonly promise:Promise<T>\n\n  \n  constructor(promise?:Promise<T> | undefined) {\n    this.state = {\n      resolve: null,\n      reject: null,\n      isSettled: false,\n      isCancelled: false,\n      isRejected: false,\n      isFulfilled: false,\n      result: null,\n      err: null\n    }\n    \n    this.promise = new Promise<T>((resolve, reject) => {\n      Object.assign(this.state, {\n        resolve,\n        reject\n      })\n    })\n    \n    if (isDefined(promise)) {\n      if (promise instanceof Promise || isPromise(promise)) {\n        promise\n          .then(this.state.resolve)\n          .catch(this.state.reject)\n      } else {\n        throw Error(`An existing promise was provided to Deferred constructor, but it wasn't a valid promise`)\n      }\n    }\n  }\n  \n  isFulfilled(): boolean {\n    return this.state.isFulfilled\n  }\n  \n  isRejected(): boolean {\n    return this.state.isRejected\n  }\n  \n  isSettled(): boolean {\n    return this.state.isSettled\n  }\n  \n  isCancelled(): boolean {\n    return this.state.isCancelled\n  }\n  \n  status(): DeferredStatus {\n    return this.isCancelled() ? DeferredStatus.CANCELED : this.isSettled() ? this.isFulfilled() ? DeferredStatus.FULFILLED : DeferredStatus.REJECTED : DeferredStatus.PENDING\n  }\n  \n  cancel(): void {\n    this.state.isSettled = true\n    this.state.isCancelled = true\n  }\n  \n  resolve(result?:T): void {\n    if (!this.state.isSettled && !this.state.isCancelled) {\n      Object.assign(this.state, {\n        result: result,\n        isSettled: true,\n        isFulfilled: true\n      })\n      this.state.resolve(result)\n    }\n  }\n  \n  reject(err:any): void {\n    if (!this.state.isSettled && !this.state.isCancelled) {\n      Object.assign(this.state, {\n        isSettled: true,\n        isRejected: true,\n        err\n      })\n      \n      \n      \n      this.state.reject(err)\n    }\n  }\n  \n  get error() {\n    return this.getError()\n  }\n  \n  get value() {\n    return this.getResult()\n  }\n  \n  getError(): Error | undefined {\n    if(!this.isSettled())\n      throw Error(\"Deferred promise is not settled, result is not available\")\n    return this.state.err\n  }\n  \n  getResult():T {\n    if(!this.isSettled())\n      throw Error(\"Deferred promise is not settled, result is not available\")\n    return this.state.result\n  }\n}\n\nexport default Deferred\n"]}

package/lib/esm/helpers/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./Deferred.js";
+//# sourceMappingURL=index.d.ts.map

package/lib/esm/helpers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/helpers/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAA"}

package/lib/esm/helpers/index.js

@@ -0,0 +1,2 @@
+export * from "./Deferred.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvaGVscGVycy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGVBQWUsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCIuL0RlZmVycmVkLmpzXCJcbiJdfQ==

package/lib/esm/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./guards/index.js";
+export * from "./helpers/index.js";
+export * from "./logging/index.js";
+//# sourceMappingURL=index.d.ts.map

package/lib/esm/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAA;AACjC,cAAc,oBAAoB,CAAA;AAClC,cAAc,oBAAoB,CAAA"}

package/lib/esm/index.js

@@ -0,0 +1,4 @@
+export * from "./guards/index.js";
+export * from "./helpers/index.js";
+export * from "./logging/index.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxtQkFBbUIsQ0FBQTtBQUNqQyxjQUFjLG9CQUFvQixDQUFBO0FBQ2xDLGNBQWMsb0JBQW9CLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tIFwiLi9ndWFyZHMvaW5kZXguanNcIlxuZXhwb3J0ICogZnJvbSBcIi4vaGVscGVycy9pbmRleC5qc1wiXG5leHBvcnQgKiBmcm9tIFwiLi9sb2dnaW5nL2luZGV4LmpzXCJcbiJdfQ==

package/lib/esm/logging/Appender.d.ts

@@ -0,0 +1,5 @@
+import { LogRecord } from "./LogRecord.js";
+export interface Appender<Record extends LogRecord = any> {
+    append(record: Record): void;
+}
+//# sourceMappingURL=Appender.d.ts.map

package/lib/esm/logging/Appender.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Appender.d.ts","sourceRoot":"","sources":["../../../src/logging/Appender.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAE1C,MAAM,WAAW,QAAQ,CAAC,MAAM,SAAS,SAAS,GAAG,GAAG;IACtD,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;CAC7B"}

package/lib/esm/logging/Appender.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQXBwZW5kZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbG9nZ2luZy9BcHBlbmRlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTG9nUmVjb3JkIH0gZnJvbSBcIi4vTG9nUmVjb3JkLmpzXCJcblxuZXhwb3J0IGludGVyZmFjZSBBcHBlbmRlcjxSZWNvcmQgZXh0ZW5kcyBMb2dSZWNvcmQgPSBhbnk+IHtcbiAgYXBwZW5kKHJlY29yZDogUmVjb3JkKTogdm9pZFxufVxuIl19

package/lib/esm/logging/Formatter.d.ts

@@ -0,0 +1,3 @@
+import type { LogRecord } from "./LogRecord";
+export type Formatter<Output, Context extends {} = {}, Data = any, Record extends LogRecord<Data> = LogRecord<Data>> = (record: Record, options?: Context) => Output;
+//# sourceMappingURL=Formatter.d.ts.map

package/lib/esm/logging/Formatter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Formatter.d.ts","sourceRoot":"","sources":["../../../src/logging/Formatter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAE5C,MAAM,MAAM,SAAS,CACnB,MAAM,EACN,OAAO,SAAS,EAAE,GAAG,EAAE,EACvB,IAAI,GAAG,GAAG,EACV,MAAM,SAAS,SAAS,CAAC,IAAI,CAAC,GAAG,SAAS,CAAC,IAAI,CAAC,IAC9C,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,KAAK,MAAM,CAAA"}

package/lib/esm/logging/Formatter.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiRm9ybWF0dGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2xvZ2dpbmcvRm9ybWF0dGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IExvZ1JlY29yZCB9IGZyb20gXCIuL0xvZ1JlY29yZFwiXG5cbmV4cG9ydCB0eXBlIEZvcm1hdHRlcjxcbiAgT3V0cHV0LFxuICBDb250ZXh0IGV4dGVuZHMge30gPSB7fSxcbiAgRGF0YSA9IGFueSxcbiAgUmVjb3JkIGV4dGVuZHMgTG9nUmVjb3JkPERhdGE+ID0gTG9nUmVjb3JkPERhdGE+XG4+ID0gKHJlY29yZDogUmVjb3JkLCBvcHRpb25zPzogQ29udGV4dCkgPT4gT3V0cHV0XG4iXX0=

package/lib/esm/logging/InternalLogger.d.ts

@@ -0,0 +1,5 @@
+import { LevelKind } from "./Level.js";
+import type { Logger } from "./Logger.js";
+export declare function getInternalLogger(): Logger;
+export declare function setInternalLoggerThresholdLevel(level: LevelKind): void;
+//# sourceMappingURL=InternalLogger.d.ts.map

package/lib/esm/logging/InternalLogger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InternalLogger.d.ts","sourceRoot":"","sources":["../../../src/logging/InternalLogger.ts"],"names":[],"mappings":"AACA,OAAO,EAAS,SAAS,EAAE,MAAM,YAAY,CAAA;AAC7C,OAAO,KAAK,EAAE,MAAM,EAAiB,MAAM,aAAa,CAAA;AAOxD,wBAAgB,iBAAiB,IAAI,MAAM,CAY1C;AAED,wBAAgB,+BAA+B,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI,CAEtE"}

package/lib/esm/logging/InternalLogger.js

@@ -0,0 +1,23 @@
+import { ConsoleAppender } from "./appenders/ConsoleAppender.js";
+import { Level } from "./Level.js";
+import { getLoggingManager } from "./LoggingManager.js";
+const INTERNAL_CATEGORY = "INTERNAL";
+let internalLogger = null;
+export function getInternalLogger() {
+    if (!internalLogger) {
+        internalLogger = getLoggingManager().getLogger(INTERNAL_CATEGORY, {
+            categoryInterpolator: (inCategory, options) => INTERNAL_CATEGORY,
+            overrideAppenders: [new ConsoleAppender()]
+        });
+        internalLogger.setOverrideLevel(Level.fatal);
+    }
+    return internalLogger;
+}
+export function setInternalLoggerThresholdLevel(level) {
+    getInternalLogger().setOverrideLevel(level);
+}
+if (typeof window !== "undefined") {
+    ;
+    window.setInternalLoggerThresholdLevel = setInternalLoggerThresholdLevel;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/logging/Level.d.ts

@@ -0,0 +1,14 @@
+export declare enum Level {
+    trace = "trace",
+    debug = "debug",
+    info = "info",
+    warn = "warn",
+    error = "error",
+    fatal = "fatal"
+}
+export type LevelName = `${Level}`;
+export type LevelKind = LevelName | Level;
+export declare const LevelNames: Array<LevelName>;
+export declare const LevelThresholds: Record<LevelKind, number>;
+export type LevelEnableFnName = `is${Capitalize<LevelName>}Enabled`;
+//# sourceMappingURL=Level.d.ts.map

package/lib/esm/logging/Level.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Level.d.ts","sourceRoot":"","sources":["../../../src/logging/Level.ts"],"names":[],"mappings":"AAEA,oBAAY,KAAK;IACf,KAAK,UAAU;IACf,KAAK,UAAU;IACf,IAAI,SAAS;IACb,IAAI,SAAS;IACb,KAAK,UAAU;IACf,KAAK,UAAU;CAChB;AAED,MAAM,MAAM,SAAS,GAAG,GAAG,KAAK,EAAE,CAAA;AAClC,MAAM,MAAM,SAAS,GAAG,SAAS,GAAG,KAAK,CAAA;AAEzC,eAAO,MAAM,UAAU,EAAE,KAAK,CAAC,SAAS,CAA8B,CAAA;AACtE,eAAO,MAAM,eAAe,EAEvB,MAAM,CAAC,SAAS,EAAE,MAAM,CAAC,CAAA;AAC9B,MAAM,MAAM,iBAAiB,GAAG,KAAK,UAAU,CAAC,SAAS,CAAC,SAAS,CAAA"}

package/lib/esm/logging/Level.js

@@ -0,0 +1,13 @@
+import { fromPairs, uniq } from "lodash";
+export var Level;
+(function (Level) {
+    Level["trace"] = "trace";
+    Level["debug"] = "debug";
+    Level["info"] = "info";
+    Level["warn"] = "warn";
+    Level["error"] = "error";
+    Level["fatal"] = "fatal";
+})(Level || (Level = {}));
+export const LevelNames = uniq(Object.values(Level));
+export const LevelThresholds = fromPairs(LevelNames.map((level, i) => [level, i]));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiTGV2ZWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbG9nZ2luZy9MZXZlbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLElBQUksRUFBRSxNQUFNLFFBQVEsQ0FBQTtBQUV4QyxNQUFNLENBQU4sSUFBWSxLQU9YO0FBUEQsV0FBWSxLQUFLO0lBQ2Ysd0JBQWUsQ0FBQTtJQUNmLHdCQUFlLENBQUE7SUFDZixzQkFBYSxDQUFBO0lBQ2Isc0JBQWEsQ0FBQTtJQUNiLHdCQUFlLENBQUE7SUFDZix3QkFBZSxDQUFBO0FBQ2pCLENBQUMsRUFQVyxLQUFLLEtBQUwsS0FBSyxRQU9oQjtBQUtELE1BQU0sQ0FBQyxNQUFNLFVBQVUsR0FBcUIsSUFBSSxDQUFDLE1BQU0sQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQTtBQUN0RSxNQUFNLENBQUMsTUFBTSxlQUFlLEdBQUcsU0FBUyxDQUN0QyxVQUFVLENBQUMsR0FBRyxDQUFDLENBQUMsS0FBSyxFQUFFLENBQUMsRUFBRSxFQUFFLENBQUMsQ0FBQyxLQUFLLEVBQUUsQ0FBQyxDQUFDLENBQUMsQ0FDWixDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgZnJvbVBhaXJzLCB1bmlxIH0gZnJvbSBcImxvZGFzaFwiXG5cbmV4cG9ydCBlbnVtIExldmVsIHtcbiAgdHJhY2UgPSBcInRyYWNlXCIsXG4gIGRlYnVnID0gXCJkZWJ1Z1wiLFxuICBpbmZvID0gXCJpbmZvXCIsXG4gIHdhcm4gPSBcIndhcm5cIixcbiAgZXJyb3IgPSBcImVycm9yXCIsXG4gIGZhdGFsID0gXCJmYXRhbFwiLCBcbn1cblxuZXhwb3J0IHR5cGUgTGV2ZWxOYW1lID0gYCR7TGV2ZWx9YFxuZXhwb3J0IHR5cGUgTGV2ZWxLaW5kID0gTGV2ZWxOYW1lIHwgTGV2ZWxcblxuZXhwb3J0IGNvbnN0IExldmVsTmFtZXM6IEFycmF5PExldmVsTmFtZT4gPSB1bmlxKE9iamVjdC52YWx1ZXMoTGV2ZWwpKVxuZXhwb3J0IGNvbnN0IExldmVsVGhyZXNob2xkcyA9IGZyb21QYWlycyhcbiAgTGV2ZWxOYW1lcy5tYXAoKGxldmVsLCBpKSA9PiBbbGV2ZWwsIGldKVxuKSBhcyBSZWNvcmQ8TGV2ZWxLaW5kLCBudW1iZXI+XG5leHBvcnQgdHlwZSBMZXZlbEVuYWJsZUZuTmFtZSA9IGBpcyR7Q2FwaXRhbGl6ZTxMZXZlbE5hbWU+fUVuYWJsZWRgXG4iXX0=

package/lib/esm/logging/LogRecord.d.ts

@@ -0,0 +1,19 @@
+import type { LevelKind } from "./Level.js";
+export interface LogMetadata<Data extends {} = any> {
+    url?: string;
+    env?: string;
+    app?: string;
+    data?: Data;
+}
+export interface LogRecord<Data extends {} = any> extends LogMetadata<Data> {
+    timestamp: number;
+    category: string;
+    level: LevelKind;
+    message: string;
+    args?: any[];
+    tags?: string[];
+    event?: string;
+    errorMessage?: string;
+    errorStack?: string;
+}
+//# sourceMappingURL=LogRecord.d.ts.map

package/lib/esm/logging/LogRecord.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LogRecord.d.ts","sourceRoot":"","sources":["../../../src/logging/LogRecord.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA;AAG3C,MAAM,WAAW,WAAW,CAAC,IAAI,SAAS,EAAE,GAAG,GAAG;IAChD,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,IAAI,CAAC,EAAE,IAAI,CAAA;CACZ;AAED,MAAM,WAAW,SAAS,CAAC,IAAI,SAAS,EAAE,GAAG,GAAG,CAAE,SAAQ,WAAW,CAAC,IAAI,CAAC;IACzE,SAAS,EAAE,MAAM,CAAA;IACjB,QAAQ,EAAE,MAAM,CAAA;IAChB,KAAK,EAAE,SAAS,CAAA;IAChB,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,CAAC,EAAE,GAAG,EAAE,CAAA;IACZ,IAAI,CAAC,EAAE,MAAM,EAAE,CAAA;IACf,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB"}

package/lib/esm/logging/LogRecord.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiTG9nUmVjb3JkLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2xvZ2dpbmcvTG9nUmVjb3JkLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IExldmVsS2luZCB9IGZyb20gXCIuL0xldmVsLmpzXCJcblxuXG5leHBvcnQgaW50ZXJmYWNlIExvZ01ldGFkYXRhPERhdGEgZXh0ZW5kcyB7fSA9IGFueT4ge1xuICB1cmw/OiBzdHJpbmdcbiAgZW52Pzogc3RyaW5nXG4gIGFwcD86IHN0cmluZ1xuICBkYXRhPzogRGF0YVxufVxuXG5leHBvcnQgaW50ZXJmYWNlIExvZ1JlY29yZDxEYXRhIGV4dGVuZHMge30gPSBhbnk+IGV4dGVuZHMgTG9nTWV0YWRhdGE8RGF0YT4ge1xuICB0aW1lc3RhbXA6IG51bWJlclxuICBjYXRlZ29yeTogc3RyaW5nXG4gIGxldmVsOiBMZXZlbEtpbmRcbiAgbWVzc2FnZTogc3RyaW5nXG4gIGFyZ3M/OiBhbnlbXVxuICB0YWdzPzogc3RyaW5nW11cbiAgZXZlbnQ/OiBzdHJpbmdcbiAgZXJyb3JNZXNzYWdlPzogc3RyaW5nXG4gIGVycm9yU3RhY2s/OiBzdHJpbmdcbn1cblxuIl19

package/lib/esm/logging/Logger.d.ts

@@ -0,0 +1,81 @@
+import { LevelKind } from "./Level.js";
+import type { LoggingManager } from "./LoggingManager.js";
+import type { LogMetadata, LogRecord } from "./LogRecord.js";
+import type { Appender } from "./Appender.js";
+export interface LoggerOptions {
+    categoryInterpolator: CategoryInterpolator;
+    overrideAppenders: Array<Appender<LogRecord>>;
+}
+export type CategoryInterpolator = (inCategory: string, options?: LoggerOptions) => string;
+export declare const filenameCategoryInterpolator: CategoryInterpolator;
+export declare const defaultLoggerOptions: LoggerOptions;
+export declare function toLogRecord(logger: Logger, levelOrRecord: LevelKind | LogRecord, args: any[]): {
+    timestamp: number;
+    url?: string;
+    env?: string;
+    app?: string;
+    data?: any;
+    category: string;
+    level: LevelKind;
+    message: string;
+    args?: any[];
+    tags?: string[];
+    event?: string;
+    errorMessage?: string;
+    errorStack?: string;
+};
+export interface LoggerState {
+    overrideLevel?: LevelKind;
+}
+export declare class Logger {
+    readonly manager: LoggingManager;
+    readonly category: string;
+    readonly options: LoggerOptions;
+    readonly state: LoggerState;
+    get overrideLevel(): LevelKind;
+    get overrideThreshold(): number;
+    setOverrideLevel(inOverrideLevel: LevelKind): this;
+    /**
+     * Base logging function
+     *
+     * @param record
+     */
+    log(record: LogRecord): void;
+    log(level: LevelKind, message: string, ...args: any[]): void;
+    log(level: LevelKind, metadata: LogMetadata, message: string, ...args: any[]): void;
+    /**
+     * Factory for the log
+     * level functions
+     *
+     * @param {LevelKind} level
+     * @returns {(message: string, ...args: any[]) => void}
+     * @private
+     */
+    private createLevelLogger;
+    /**
+     * Factory for is<Level>Enabled
+     *
+     * @param {LevelKind} level
+     * @returns {() => boolean}
+     * @private
+     */
+    private createLevelEnabled;
+    readonly trace: (message: string, ...args: any[]) => void;
+    readonly debug: (message: string, ...args: any[]) => void;
+    readonly info: (message: string, ...args: any[]) => void;
+    readonly warn: (message: string, ...args: any[]) => void;
+    readonly error: (message: string, ...args: any[]) => void;
+    readonly fatal: (message: string, ...args: any[]) => void;
+    readonly isTraceEnabled: () => boolean;
+    readonly isDebugEnabled: () => boolean;
+    readonly isInfoEnabled: () => boolean;
+    readonly isWarnEnabled: () => boolean;
+    readonly isErrorEnabled: () => boolean;
+    readonly isFatalEnabled: () => boolean;
+    assert(test: boolean | (() => boolean), message: string, ...args: any[]): void;
+    assertFatal(test: boolean | (() => boolean), message: string, exitCode?: number): void;
+    constructor(manager: LoggingManager, category: string, options: LoggerOptions);
+    static hydrateOptions(options?: Partial<LoggerOptions>): LoggerOptions;
+    static interoplateCategory(category: string, options: LoggerOptions): string;
+}
+//# sourceMappingURL=Logger.d.ts.map

package/lib/esm/logging/Logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Logger.d.ts","sourceRoot":"","sources":["../../../src/logging/Logger.ts"],"names":[],"mappings":"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"}

package/lib/esm/logging/Logger.js

@@ -0,0 +1,184 @@
+import { assert, getValue, isString, isDefined, isFunction, isNumber } from "../guards/index.js";
+import { Option } from "@3fv/prelude-ts";
+import { isObject, pick } from "lodash";
+import { LevelThresholds } from "./Level.js";
+import { isLogLevelKind } from "./util.js";
+export const filenameCategoryInterpolator = (filename) => {
+    const allParts = filename.replaceAll("\\", "/").split("/");
+    const rootIndex = Math.max(...["src", "lib"].map(name => allParts.indexOf(name)));
+    const parts = rootIndex === -1 ? [allParts.pop()] : allParts.slice(rootIndex + 1);
+    const category = Option.of(parts.join(":"))
+        .flatMap(cat => Option.of(cat.lastIndexOf(".")).map(index => index === -1 ? cat : cat.slice(0, index)))
+        .getOrElse("unknown");
+    return category;
+};
+export const defaultLoggerOptions = {
+    categoryInterpolator: filenameCategoryInterpolator,
+    overrideAppenders: []
+};
+export function toLogRecord(logger, levelOrRecord, args) {
+    const globalMetadata = logger.manager.globalMetadata;
+    let metadata = {
+        ...globalMetadata
+    };
+    if (isString(levelOrRecord) && isObject(args[0])) {
+        metadata = { ...metadata, ...args.shift() };
+    }
+    if (globalMetadata?.data)
+        metadata.data = {
+            ...globalMetadata.data,
+            ...metadata.data
+        };
+    const errRecord = Option.ofNullable(args.find(arg => (isString(arg?.message) && !!arg.stack) || arg instanceof Error)).match({
+        Some: err => ({
+            errorMessage: getValue(() => err.message),
+            errorStack: getValue(() => err.stack)
+        }),
+        None: () => ({})
+    });
+    const recordBase = isString(levelOrRecord)
+        ? {
+            ...pick(logger, ["category"]),
+            timestamp: Date.now(),
+            message: args[0],
+            level: levelOrRecord,
+            args: args.slice(1)
+        }
+        : levelOrRecord;
+    const record = {
+        ...recordBase,
+        ...errRecord,
+        ...metadata,
+        timestamp: isNumber(recordBase.timestamp) && recordBase.timestamp > 0
+            ? recordBase.timestamp
+            : Date.now()
+    };
+    if (metadata.data) {
+        record.data = {
+            ...metadata.data,
+            ...(recordBase.data ?? {})
+        };
+    }
+    return record;
+}
+export class Logger {
+    manager;
+    category;
+    options;
+    state = {
+        overrideLevel: null
+    };
+    get overrideLevel() {
+        return Option.ofNullable(this.state.overrideLevel)
+            .filter(isLogLevelKind) //Predicate.of<LevelKind>(isString).and(isLogLevelKind))
+            .getOrNull();
+    }
+    get overrideThreshold() {
+        return Option.ofNullable(this.overrideLevel)
+            .map(level => LevelThresholds[level])
+            .getOrNull();
+    }
+    setOverrideLevel(inOverrideLevel) {
+        const overrideLevel = (!inOverrideLevel ? null : inOverrideLevel.toLocaleLowerCase());
+        assert(!isDefined(overrideLevel) || isLogLevelKind(overrideLevel), `Invalid override level, must be a log level, all lower case`);
+        Object.assign(this.state, {
+            overrideLevel
+        });
+        return this;
+    }
+    log(levelOrRecord, ...args) {
+        const record = toLogRecord(this, levelOrRecord, args);
+        if (this.options.overrideAppenders.length) {
+            this.options.overrideAppenders.forEach(appender => appender.append(record));
+        }
+        else {
+            this.manager.fire(record);
+        }
+    }
+    /**
+     * Factory for the log
+     * level functions
+     *
+     * @param {LevelKind} level
+     * @returns {(message: string, ...args: any[]) => void}
+     * @private
+     */
+    createLevelLogger(level) {
+        const isEnabled = this.createLevelEnabled(level);
+        return (message, ...args) => {
+            if (isEnabled()) {
+                this.log(level, message, ...args);
+            }
+        };
+    }
+    /**
+     * Factory for is<Level>Enabled
+     *
+     * @param {LevelKind} level
+     * @returns {() => boolean}
+     * @private
+     */
+    createLevelEnabled(level) {
+        return () => {
+            const { rootThreshold } = this.manager;
+            const globalOverrideThreshold = this.manager.determineThresholdOverride(this.category);
+            const categoryThresholds = isNumber(this.overrideThreshold)
+                ? [this.overrideThreshold]
+                : [globalOverrideThreshold, rootThreshold].filter(isNumber);
+            const categoryThreshold = Math.min(...categoryThresholds);
+            const recordThreshold = LevelThresholds[level];
+            return recordThreshold >= categoryThreshold;
+        };
+    }
+    trace = this.createLevelLogger("trace");
+    debug = this.createLevelLogger("debug");
+    info = this.createLevelLogger("info");
+    warn = this.createLevelLogger("warn");
+    error = this.createLevelLogger("error");
+    fatal = this.createLevelLogger("fatal");
+    isTraceEnabled = this.createLevelEnabled("trace");
+    isDebugEnabled = this.createLevelEnabled("debug");
+    isInfoEnabled = this.createLevelEnabled("info");
+    isWarnEnabled = this.createLevelEnabled("warn");
+    isErrorEnabled = this.createLevelEnabled("error");
+    isFatalEnabled = this.createLevelEnabled("fatal");
+    assert(test, message, ...args) {
+        const isTruthy = isFunction(test) ? test() : test;
+        if (isTruthy) {
+            return;
+        }
+        this.error(message, ...args);
+    }
+    assertFatal(test, message, exitCode = 1) {
+        const isTruthy = isFunction(test) ? test() : test;
+        if (isTruthy) {
+            return;
+        }
+        this.fatal("FATAL ASSERTION: ", message);
+        if (typeof process !== "undefined") {
+            process.exit(exitCode);
+        }
+        else {
+            console.error("FATAL ASSERTION: `process` is not defined, probably in a web browser");
+        }
+    }
+    constructor(manager, category, options) {
+        this.manager = manager;
+        this.category = category;
+        this.options = options;
+    }
+    static hydrateOptions(options = {}) {
+        return {
+            ...defaultLoggerOptions,
+            ...options
+        };
+    }
+    static interoplateCategory(category, options) {
+        options = {
+            ...defaultLoggerOptions,
+            ...options
+        };
+        return options.categoryInterpolator(category, options);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Logger.js","sourceRoot":"","sources":["../../../src/logging/Logger.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  assert,\n  getValue,\n  isString,\n  isDefined,\n  isFunction,\n  isNumber\n} from \"../guards/index.js\"\nimport { Option } from \"@3fv/prelude-ts\"\nimport { cloneDeep, isObject, pick } from \"lodash\"\nimport { LevelKind, LevelThresholds } from \"./Level.js\"\nimport type { LoggingManager } from \"./LoggingManager.js\"\nimport type { LogMetadata, LogRecord } from \"./LogRecord.js\"\nimport { isLogLevelKind } from \"./util.js\"\nimport type { Appender } from \"./Appender.js\"\n\nexport interface LoggerOptions {\n  categoryInterpolator: CategoryInterpolator\n  overrideAppenders: Array<Appender<LogRecord>>\n}\n\nexport type CategoryInterpolator = (\n  inCategory: string,\n  options?: LoggerOptions\n) => string\n\nexport const filenameCategoryInterpolator: CategoryInterpolator = (\n  filename: string\n) => {\n  const allParts = filename.replaceAll(\"\\\\\", \"/\").split(\"/\")\n  const rootIndex = Math.max(\n    ...[\"src\", \"lib\"].map(name => allParts.indexOf(name))\n  )\n  const parts =\n    rootIndex === -1 ? [allParts.pop()] : allParts.slice(rootIndex + 1)\n  const category = Option.of(parts.join(\":\"))\n    .flatMap(cat =>\n      Option.of(cat.lastIndexOf(\".\")).map(index =>\n        index === -1 ? cat : cat.slice(0, index)\n      )\n    )\n    .getOrElse(\"unknown\")\n  return category\n}\n\nexport const defaultLoggerOptions: LoggerOptions = {\n  categoryInterpolator: filenameCategoryInterpolator,\n  overrideAppenders: []\n}\n\nexport function toLogRecord(\n  logger: Logger,\n  levelOrRecord: LevelKind | LogRecord,\n  args: any[]\n) {\n  const globalMetadata = logger.manager.globalMetadata\n  let metadata: LogMetadata = {\n    ...globalMetadata\n  }\n  if (isString(levelOrRecord) && isObject(args[0])) {\n    metadata = { ...metadata, ...args.shift() }\n  }\n\n  if (globalMetadata?.data)\n    metadata.data = {\n      ...globalMetadata.data,\n      ...metadata.data\n    }\n\n  const errRecord = Option.ofNullable(\n    args.find(\n      arg => (isString(arg?.message) && !!arg.stack) || arg instanceof Error\n    )\n  ).match({\n    Some: err => ({\n      errorMessage: getValue(() => err.message),\n      errorStack: getValue(() => err.stack)\n    }),\n    None: () => ({})\n  })\n\n  const recordBase = isString(levelOrRecord)\n    ? ({\n        ...pick(logger, [\"category\"]),\n        timestamp: Date.now(),\n        message: args[0],\n        level: levelOrRecord,\n        args: args.slice(1)\n      } as LogRecord)\n    : levelOrRecord\n\n  const record = {\n    ...recordBase,\n    ...errRecord,\n    ...metadata,\n    timestamp:\n      isNumber(recordBase.timestamp) && recordBase.timestamp > 0\n        ? recordBase.timestamp\n        : Date.now()\n  }\n\n  if (metadata.data) {\n    record.data = {\n      ...metadata.data,\n      ...(recordBase.data ?? {})\n    }\n  }\n\n  return record\n}\n\nexport interface LoggerState {\n  overrideLevel?: LevelKind\n}\n\nexport class Logger {\n  readonly state: LoggerState = {\n    overrideLevel: null\n  }\n\n  get overrideLevel(): LevelKind {\n    return Option.ofNullable(this.state.overrideLevel)\n      .filter(isLogLevelKind) //Predicate.of<LevelKind>(isString).and(isLogLevelKind))\n      .getOrNull()\n  }\n\n  get overrideThreshold() {\n    return Option.ofNullable(this.overrideLevel)\n      .map(level => LevelThresholds[level])\n      .getOrNull()\n  }\n\n  setOverrideLevel(inOverrideLevel: LevelKind) {\n    const overrideLevel = (\n      !inOverrideLevel ? null : inOverrideLevel.toLocaleLowerCase()\n    ) as LevelKind\n\n    assert(\n      !isDefined(overrideLevel) || isLogLevelKind(overrideLevel),\n      `Invalid override level, must be a log level, all lower case`\n    )\n\n    Object.assign(this.state, {\n      overrideLevel\n    })\n\n    return this\n  }\n\n  /**\n   * Base logging function\n   *\n   * @param record\n   */\n  log(record: LogRecord): void\n  log(level: LevelKind, message: string, ...args: any[]): void\n  log(\n    level: LevelKind,\n    metadata: LogMetadata,\n    message: string,\n    ...args: any[]\n  ): void\n  log(levelOrRecord: LevelKind | LogRecord, ...args: any[]) {\n    const record = toLogRecord(this, levelOrRecord, args)\n    if (this.options.overrideAppenders.length) {\n      this.options.overrideAppenders.forEach(appender =>\n        appender.append(record)\n      )\n    } else {\n      this.manager.fire(record)\n    }\n  }\n\n  /**\n   * Factory for the log\n   * level functions\n   *\n   * @param {LevelKind} level\n   * @returns {(message: string, ...args: any[]) => void}\n   * @private\n   */\n  private createLevelLogger(\n    level: LevelKind\n  ): (message: string, ...args: any[]) => void {\n    const isEnabled = this.createLevelEnabled(level)\n    return (message: string, ...args: any[]) => {\n      if (isEnabled()) {\n        this.log(level, message, ...args)\n      }\n    }\n  }\n\n  /**\n   * Factory for is<Level>Enabled\n   *\n   * @param {LevelKind} level\n   * @returns {() => boolean}\n   * @private\n   */\n  private createLevelEnabled(level: LevelKind): () => boolean {\n    return () => {\n      const { rootThreshold } = this.manager\n\n      const globalOverrideThreshold = this.manager.determineThresholdOverride(\n        this.category\n      )\n      const categoryThresholds = isNumber(this.overrideThreshold)\n        ? [this.overrideThreshold]\n        : [globalOverrideThreshold, rootThreshold].filter(isNumber)\n\n      const categoryThreshold = Math.min(...categoryThresholds)\n\n      const recordThreshold = LevelThresholds[level]\n\n      return recordThreshold >= categoryThreshold\n    }\n  }\n\n  readonly trace = this.createLevelLogger(\"trace\")\n  readonly debug = this.createLevelLogger(\"debug\")\n  readonly info = this.createLevelLogger(\"info\")\n  readonly warn = this.createLevelLogger(\"warn\")\n  readonly error = this.createLevelLogger(\"error\")\n  readonly fatal = this.createLevelLogger(\"fatal\")\n\n  readonly isTraceEnabled = this.createLevelEnabled(\"trace\")\n  readonly isDebugEnabled = this.createLevelEnabled(\"debug\")\n  readonly isInfoEnabled = this.createLevelEnabled(\"info\")\n  readonly isWarnEnabled = this.createLevelEnabled(\"warn\")\n  readonly isErrorEnabled = this.createLevelEnabled(\"error\")\n  readonly isFatalEnabled = this.createLevelEnabled(\"fatal\")\n\n  assert(test: boolean | (() => boolean), message: string, ...args: any[]) {\n    const isTruthy = isFunction(test) ? test() : test\n    if (isTruthy) {\n      return\n    }\n\n    this.error(message, ...args)\n  }\n\n  assertFatal(\n    test: boolean | (() => boolean),\n    message: string,\n    exitCode: number = 1\n  ) {\n    const isTruthy = isFunction(test) ? test() : test\n    if (isTruthy) {\n      return\n    }\n\n    this.fatal(\"FATAL ASSERTION: \", message)\n    if (typeof process !== \"undefined\") {\n      process.exit(exitCode)\n    } else {\n      console.error(\n        \"FATAL ASSERTION: `process` is not defined, probably in a web browser\"\n      )\n    }\n  }\n\n  constructor(\n    readonly manager: LoggingManager,\n    readonly category: string,\n    readonly options: LoggerOptions\n  ) {}\n\n  static hydrateOptions(options: Partial<LoggerOptions> = {}): LoggerOptions {\n    return {\n      ...defaultLoggerOptions,\n      ...options\n    }\n  }\n\n  static interoplateCategory(category: string, options: LoggerOptions) {\n    options = {\n      ...defaultLoggerOptions,\n      ...options\n    }\n    return options.categoryInterpolator(category, options)\n  }\n}\n"]}