@aglyn/shared-util-logger 1.0.0-beta.143

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,48 @@
+# @aglyn/shared-util-logger
+
+---
+
+# Logger Helper
+
+This library was generated with [Nx](https://nx.dev).
+
+Logger framework and logical flow is inspired by `@firebase/logger`
+
+This package serves as the base of all logging in the JS SDK. Any logging that is intended to be
+visible to Firebase end developers should go through this module.
+
+## Basic Usage
+
+Firebase components should import the `Logger` class and instantiate a new instance by passing a
+component name (
+e.g. `@aglyn/<project-name>`) to the constructor.
+
+_e.g._
+
+```typescript
+import { Logger } from '@aglyn/shared-util-logger'
+
+const logger = new Logger(`@aglyn/<project-name>`)
+```
+
+Each `Logger` instance supports 5 log functions each to be used in a specific instance:
+
+- `debug`: Internal logs; use this to allow developers to send us their debug logs for us to be able
+  to diagnose an issue.
+- `log`: Use to inform your user about things they may need to know.
+- `info`: Use if you have to inform the user about something that they need to take a concrete
+  action on. Once they take that action, the log should go away.
+- `warn`: Use when a product feature may stop functioning correctly; unexpected scenario.
+- `error`: Only use when user App would stop functioning correctly - super rare!
+
+## Log Format
+
+Each log will be formatted in the following manner:
+
+```typescript
+`"[${new Date()}] ${COMPONENT_NAME}: ${...args}"`
+```
+
+## Running unit tests
+
+Run `nx test shared-util-logger` to execute the unit tests via [Jest](https://jestjs.io).

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@aglyn/shared-util-logger",
+  "version": "1.0.0-beta.143",
+  "license": "Apache-2.0",
+  "homepage": "https://aglyn.com",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/aglyn/aglyn.git",
+    "directory": "libs/shared/util/logger"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./src/index.d.ts",
+      "default": "./src/index.js"
+    },
+    "./*": {
+      "types": "./src/lib/*.d.ts",
+      "default": "./src/lib/*.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "@swc/helpers": "0.5.23"
+  },
+  "sideEffects": false,
+  "types": "./src/index.d.ts",
+  "module": "./src/index.js",
+  "main": "./src/index.js"
+}

package/src/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @license
+ * Copyright 2021 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export * from './lib/logger';

package/src/index.js

@@ -0,0 +1,18 @@
+/**
+ * @license
+ * Copyright 2021 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ export * from "./lib/logger.js";
+
+//# sourceMappingURL=index.js.map

package/src/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../libs/shared/util/logger/src/index.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2021 Aglyn LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nexport * from './lib/logger'\n"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;CAeC,GAED,cAAc,kBAAc"}

package/src/lib/logger.d.ts

@@ -0,0 +1,170 @@
+/**
+ * @license
+ * Copyright 2022 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * A container for all of the Logger instances
+ */
+export declare const instances: Logger[];
+/**
+ * The JS SDK supports 5 log levels and also allows a user the ability to
+ * silence the logs altogether.
+ *
+ * The order is a follows:
+ * DEBUG < VERBOSE < INFO < WARN < ERROR
+ *
+ * All of the log types above the current log level will be captured (i.e. if
+ * you set the log level to `INFO`, errors will still be logged, but `DEBUG` and
+ * `VERBOSE` logs will not)
+ */
+export declare enum LogLevel {
+    DEBUG = "debug",
+    ERROR = "error",
+    INFO = "info",
+    SILENT = "silent",
+    VERBOSE = "verbose",
+    WARN = "warn"
+}
+export type LogLevelString = LogLevel | keyof Console;
+/**
+ * We allow users the ability to pass their own log handler. We will pass the
+ * type of log, the current log level, and any other arguments passed (i.e. the
+ * messages that the user wants to log) to this function.
+ */
+export type LogHandler = (loggerInstance: Logger, level: LogLevelString, ...args: unknown[]) => void;
+export interface LogOptions {
+    level: LogLevel | keyof Console;
+}
+export interface LogCallbackParams {
+    level: LogLevel | keyof Console;
+    message: string;
+    args: unknown[];
+    type: string;
+}
+export type LogCallback = (callbackParams: LogCallbackParams) => void;
+/**
+ * By default, `console.debug` is not displayed in the developer console (in
+ * chrome). To avoid forcing users to have to opt-in to these logs twice
+ * (i.e. once for firebase, and once in the console), we are sending `DEBUG`
+ * logs to the `console.log` function.
+ */
+export declare const ConsoleMethodKey: Partial<Record<string, string>>;
+/**
+ * The default log handler will forward DEBUG, VERBOSE, INFO, WARN, and ERROR
+ * messages on to their corresponding console counterparts (if the log method
+ * is supported by the current log level)
+ *
+ * ## The level was decorative (AGL-1151)
+ *
+ * This handler used to test only the level of the CALL — dropping the literal
+ * `'silent'` and forwarding everything else — so `_logLevel` decided nothing
+ * and `logger.debug()` reached `console.log` at every level including the
+ * default INFO. On a published tenant page that is not a stray line: plugin
+ * registration walks every component and preset through `lifecycleEvent`,
+ * which logs a before and an after for each, so a visitor's browser formatted
+ * and retained ~400 `console.log` calls of internal event names and payloads
+ * before the page was interactive — measurably, and on a customer's site.
+ *
+ * The threshold is now the INSTANCE's, which is what the level's own docblock
+ * has always said it means.
+ */
+export declare const defaultLogHandler: LogHandler;
+export declare const FALLBACK_LOG_LEVEL = LogLevel.INFO;
+/**
+ * TODO: INTEGRATE PACKAGE`debug`
+ */
+export declare class Logger {
+    name?: string;
+    /**
+     * The default log level.
+     *
+     * DEBUG outside production, so a developer keeps the running commentary the
+     * handler used to emit unconditionally, and a deployed build does not.
+     * Nothing in the workspace calls `setLogLevel`, so this constant is the only
+     * threshold that applies anywhere until something does.
+     *
+     * `process` is guarded because this library is reachable from a browser
+     * realm that has no bundler substituting `process.env` — a marketplace
+     * plugin bundle. Dot notation is load-bearing: the substitution is textual
+     * and never sees the bracket form.
+     */
+    static defaultLogLevel: LogLevel;
+    _logLevel: LogLevelString;
+    _logHandler: LogHandler;
+    _userLogHandler: LogHandler | null;
+    /**
+     * The log level of the given Logger instance.
+     */
+    get logLevel(): LogLevelString;
+    /**
+     * The log level of the given Logger instance.
+     */
+    set logLevel(val: LogLevelString);
+    /**
+     * The main (internal) log handler for the Logger instance.
+     * Can be set to a new function in internal package code but not by user.
+     */
+    get logHandler(): LogHandler;
+    /**
+     * The main (internal) log handler for the Logger instance.
+     * Can be set to a new function in internal package code but not by user.
+     */
+    set logHandler(val: LogHandler);
+    /**
+     * The optional, additional, user-defined log handler for the Logger instance.
+     */
+    get userLogHandler(): LogHandler | null;
+    /**
+     * The optional, additional, user-defined log handler for the Logger instance.
+     */
+    set userLogHandler(val: LogHandler | null);
+    /**
+     * Gives you an instance of a Logger to capture messages according to
+     * Firebase's logging scheme.
+     *
+     * @param name The name that the logs will be associated with
+     */
+    constructor(name?: string);
+    /**
+     * Workaround for setter/getter having to be the same type
+     */
+    setLogLevel(val?: LogLevelString): this;
+    /**
+     * Set the log level for all logger instances
+     */
+    static setLogLevel(val?: LogLevelString): typeof Logger;
+    /**
+     * The optional, additional, user-defined log handler for the Logger instance.
+     */
+    setUserLogHandler(logCallback: LogCallback | null, options?: LogOptions): void;
+    /**
+     * The optional, additional, user-defined log handler for the Logger instance.
+     */
+    static setUserLogHandler(logCallback: LogCallback | null, options?: LogOptions): void;
+    /**
+     * The functions below are all based on the `console` interface
+     */
+    /** {@inheritDoc Console.debug} */
+    debug(...args: unknown[]): void;
+    /** {@inheritDoc Console.log} */
+    log(...args: unknown[]): void;
+    /** {@inheritDoc Console.info} */
+    info(...args: unknown[]): void;
+    /** {@inheritDoc Console.warn} */
+    warn(...args: unknown[]): void;
+    /** {@inheritDoc Console.error} */
+    error(...args: unknown[]): void;
+}
+export default Logger;

package/src/lib/logger.js

@@ -0,0 +1,274 @@
+/**
+ * @license
+ * Copyright 2022 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ /**
+ * A container for all of the Logger instances
+ */ export const instances = [];
+/**
+ * The JS SDK supports 5 log levels and also allows a user the ability to
+ * silence the logs altogether.
+ *
+ * The order is a follows:
+ * DEBUG < VERBOSE < INFO < WARN < ERROR
+ *
+ * All of the log types above the current log level will be captured (i.e. if
+ * you set the log level to `INFO`, errors will still be logged, but `DEBUG` and
+ * `VERBOSE` logs will not)
+ */ export var LogLevel = /*#__PURE__*/ function(LogLevel) {
+    LogLevel["DEBUG"] = "debug";
+    LogLevel["ERROR"] = "error";
+    LogLevel["INFO"] = "info";
+    LogLevel["SILENT"] = "silent";
+    LogLevel["VERBOSE"] = "verbose";
+    LogLevel["WARN"] = "warn";
+    return LogLevel;
+}({});
+/**
+ * By default, `console.debug` is not displayed in the developer console (in
+ * chrome). To avoid forcing users to have to opt-in to these logs twice
+ * (i.e. once for firebase, and once in the console), we are sending `DEBUG`
+ * logs to the `console.log` function.
+ */ export const ConsoleMethodKey = {
+    ["debug"]: 'log',
+    ["verbose"]: 'log',
+    ["info"]: 'info',
+    ["warn"]: 'warn',
+    ["error"]: 'error'
+};
+/**
+ * Rank of each level, so "at or above the configured level" is comparable.
+ *
+ * The levels are string values, so `level >= instance.logLevel` compares them
+ * alphabetically — under which `'debug' >= 'error'` holds and `'warn' >= 'info'`
+ * does not. A level needs a number to be ordered by.
+ *
+ * SILENT sits above ERROR: it is the level at which nothing qualifies.
+ */ const LOG_LEVEL_RANK = {
+    ["debug"]: 0,
+    ["verbose"]: 1,
+    ["info"]: 2,
+    ["warn"]: 3,
+    ["error"]: 4,
+    ["silent"]: 5
+};
+/**
+ * Whether a message at `level` clears the `configured` threshold.
+ *
+ * `setLogLevel` accepts any `keyof Console`, not just a `LogLevel`, so either
+ * side can be a string this table has no rank for. An unranked THRESHOLD falls
+ * back to the default one rather than admitting everything; an unranked
+ * MESSAGE is passed through to the invalid-logType throw below, which is what
+ * names the mistake.
+ */ function meetsLogLevel(level, configured) {
+    var _LOG_LEVEL_RANK_configured;
+    const messageRank = LOG_LEVEL_RANK[level];
+    if (messageRank === undefined) return true;
+    const threshold = (_LOG_LEVEL_RANK_configured = LOG_LEVEL_RANK[configured]) != null ? _LOG_LEVEL_RANK_configured : LOG_LEVEL_RANK[FALLBACK_LOG_LEVEL];
+    return messageRank >= threshold;
+}
+/**
+ * The default log handler will forward DEBUG, VERBOSE, INFO, WARN, and ERROR
+ * messages on to their corresponding console counterparts (if the log method
+ * is supported by the current log level)
+ *
+ * ## The level was decorative (AGL-1151)
+ *
+ * This handler used to test only the level of the CALL — dropping the literal
+ * `'silent'` and forwarding everything else — so `_logLevel` decided nothing
+ * and `logger.debug()` reached `console.log` at every level including the
+ * default INFO. On a published tenant page that is not a stray line: plugin
+ * registration walks every component and preset through `lifecycleEvent`,
+ * which logs a before and an after for each, so a visitor's browser formatted
+ * and retained ~400 `console.log` calls of internal event names and payloads
+ * before the page was interactive — measurably, and on a customer's site.
+ *
+ * The threshold is now the INSTANCE's, which is what the level's own docblock
+ * has always said it means.
+ */ export const defaultLogHandler = (instance, level, ...args)=>{
+    if (!level || level === 'silent') return;
+    if (!meetsLogLevel(level, instance.logLevel)) return;
+    const now = new Date().toISOString();
+    const method = ConsoleMethodKey[level];
+    if (method) {
+        return console[method](`[${now}]  ${instance.name}`, ...args);
+    }
+    throw new Error(`Attempted to log a message with an invalid logType (value: ${level})`);
+};
+export const FALLBACK_LOG_LEVEL = "info";
+/**
+ * Whether this build is something other than a deployed one.
+ *
+ * Proven, never assumed: the default is the QUIET level, and only a readable
+ * `NODE_ENV` that is positively not `production` raises it. A bundler that
+ * does not substitute the expression, or a realm-plugin bundle with no
+ * `process` at all, leaves this false and the deployed behaviour stands —
+ * which is the direction a wrong answer here has to fail in.
+ *
+ * Dot notation on both reads is load-bearing: the substitution is textual and
+ * matches only this exact form.
+ */ const DEVELOPMENT_RUNTIME = typeof process !== 'undefined' && typeof process.env !== 'undefined' && typeof process.env.NODE_ENV === 'string' && process.env.NODE_ENV !== 'production';
+/**
+ * TODO: INTEGRATE PACKAGE`debug`
+ */ export class Logger {
+    /**
+   * The log level of the given Logger instance.
+   */ get logLevel() {
+        return this._logLevel;
+    }
+    /**
+   * The log level of the given Logger instance.
+   */ set logLevel(val) {
+        if (!(val in LogLevel)) {
+            throw new TypeError(`Invalid value "${val}" assigned to \`logLevel\``);
+        }
+        this._logLevel = val;
+    }
+    /**
+   * The main (internal) log handler for the Logger instance.
+   * Can be set to a new function in internal package code but not by user.
+   */ get logHandler() {
+        return this._logHandler;
+    }
+    /**
+   * The main (internal) log handler for the Logger instance.
+   * Can be set to a new function in internal package code but not by user.
+   */ set logHandler(val) {
+        if (typeof val !== 'function') {
+            throw new TypeError('Value assigned to `logHandler` must be a function');
+        }
+        this._logHandler = val;
+    }
+    /**
+   * The optional, additional, user-defined log handler for the Logger instance.
+   */ get userLogHandler() {
+        return this._userLogHandler;
+    }
+    /**
+   * The optional, additional, user-defined log handler for the Logger instance.
+   */ set userLogHandler(val) {
+        this._userLogHandler = val;
+    }
+    /**
+   * Workaround for setter/getter having to be the same type
+   */ setLogLevel(val) {
+        if (val && LogLevel[LogLevel[val]] || console[val]) this._logLevel = val;
+        else this._logLevel = FALLBACK_LOG_LEVEL;
+        return this;
+    }
+    /**
+   * Set the log level for all logger instances
+   */ static setLogLevel(val) {
+        instances.forEach((inst)=>inst.setLogLevel(val));
+        return this;
+    }
+    /**
+   * The optional, additional, user-defined log handler for the Logger instance.
+   */ setUserLogHandler(logCallback, options) {
+        let customLogLevel = null;
+        if ((options == null ? void 0 : options.level) && (LogLevel[LogLevel[options.level]] || console[options.level])) {
+            customLogLevel = options.level;
+        }
+        if (logCallback === null) {
+            this.userLogHandler = null;
+        } else {
+            this.userLogHandler = (instance, level, ...args)=>{
+                const message = args.map((arg)=>{
+                    if (arg == null) {
+                        return null;
+                    } else if (typeof arg === 'string') {
+                        return arg;
+                    } else if (typeof arg === 'number' || typeof arg === 'boolean') {
+                        return arg.toString();
+                    } else if (arg instanceof Error) {
+                        return arg.message;
+                    } else {
+                        try {
+                            return JSON.stringify(arg);
+                        } catch (ignored) {
+                            return null;
+                        }
+                    }
+                }).filter((arg)=>arg).join(' ');
+                if (level >= (customLogLevel != null ? customLogLevel : instance.logLevel)) {
+                    logCallback({
+                        args,
+                        message,
+                        type: instance.name,
+                        level: (options == null ? void 0 : options.level) && (LogLevel[LogLevel[options.level]] || console[options.level]) || FALLBACK_LOG_LEVEL
+                    });
+                }
+            };
+        }
+    }
+    /**
+   * The optional, additional, user-defined log handler for the Logger instance.
+   */ static setUserLogHandler(logCallback, options) {
+        for (const instance of instances){
+            instance.setUserLogHandler(logCallback, options);
+        }
+    }
+    /**
+   * The functions below are all based on the `console` interface
+   */ /** {@inheritDoc Console.debug} */ debug(...args) {
+        this._logHandler(this, "debug", ...args);
+        this._userLogHandler && this._userLogHandler(this, "debug", ...args);
+    }
+    /** {@inheritDoc Console.log} */ log(...args) {
+        this._logHandler(this, "verbose", ...args);
+        this._userLogHandler && this._userLogHandler(this, "verbose", ...args);
+    }
+    /** {@inheritDoc Console.info} */ info(...args) {
+        this._logHandler(this, "info", ...args);
+        this._userLogHandler && this._userLogHandler(this, "info", ...args);
+    }
+    /** {@inheritDoc Console.warn} */ warn(...args) {
+        this._logHandler(this, "warn", ...args);
+        this._userLogHandler && this._userLogHandler(this, "warn", ...args);
+    }
+    /** {@inheritDoc Console.error} */ error(...args) {
+        this._logHandler(this, "error", ...args);
+        this._userLogHandler && this._userLogHandler(this, "error", ...args);
+    }
+    /**
+   * Gives you an instance of a Logger to capture messages according to
+   * Firebase's logging scheme.
+   *
+   * @param name The name that the logs will be associated with
+   */ constructor(name){
+        this.name = name;
+        this._logLevel = Logger.defaultLogLevel;
+        this._logHandler = defaultLogHandler;
+        this._userLogHandler = null;
+        /**
+     * Capture the current instance for later use
+     */ instances.push(this);
+    }
+}
+/**
+   * The default log level.
+   *
+   * DEBUG outside production, so a developer keeps the running commentary the
+   * handler used to emit unconditionally, and a deployed build does not.
+   * Nothing in the workspace calls `setLogLevel`, so this constant is the only
+   * threshold that applies anywhere until something does.
+   *
+   * `process` is guarded because this library is reachable from a browser
+   * realm that has no bundler substituting `process.env` — a marketplace
+   * plugin bundle. Dot notation is load-bearing: the substitution is textual
+   * and never sees the bracket form.
+   */ Logger.defaultLogLevel = DEVELOPMENT_RUNTIME ? "debug" : "info";
+export default Logger;
+
+//# sourceMappingURL=logger.js.map

package/src/lib/logger.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../libs/shared/util/logger/src/lib/logger.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2022 Aglyn LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * A container for all of the Logger instances\n */\nexport const instances: Logger[] = []\n\n/**\n * The JS SDK supports 5 log levels and also allows a user the ability to\n * silence the logs altogether.\n *\n * The order is a follows:\n * DEBUG < VERBOSE < INFO < WARN < ERROR\n *\n * All of the log types above the current log level will be captured (i.e. if\n * you set the log level to `INFO`, errors will still be logged, but `DEBUG` and\n * `VERBOSE` logs will not)\n */\nexport enum LogLevel {\n  DEBUG = 'debug',\n  ERROR = 'error',\n  INFO = 'info',\n  SILENT = 'silent',\n  VERBOSE = 'verbose',\n  WARN = 'warn',\n}\n\nexport type LogLevelString = LogLevel | keyof Console\n\n/**\n * We allow users the ability to pass their own log handler. We will pass the\n * type of log, the current log level, and any other arguments passed (i.e. the\n * messages that the user wants to log) to this function.\n */\nexport type LogHandler = (\n  loggerInstance: Logger,\n  level: LogLevelString,\n  ...args: unknown[]\n) => void\n\nexport interface LogOptions {\n  level: LogLevel | keyof Console\n}\n\nexport interface LogCallbackParams {\n  level: LogLevel | keyof Console\n  message: string\n  args: unknown[]\n  type: string\n}\n\nexport type LogCallback = (callbackParams: LogCallbackParams) => void\n\n/**\n * By default, `console.debug` is not displayed in the developer console (in\n * chrome). To avoid forcing users to have to opt-in to these logs twice\n * (i.e. once for firebase, and once in the console), we are sending `DEBUG`\n * logs to the `console.log` function.\n */\nexport const ConsoleMethodKey: Partial<Record<string, string>> = {\n  [LogLevel.DEBUG]: 'log',\n  [LogLevel.VERBOSE]: 'log',\n  [LogLevel.INFO]: 'info',\n  [LogLevel.WARN]: 'warn',\n  [LogLevel.ERROR]: 'error',\n}\n\n/**\n * Rank of each level, so \"at or above the configured level\" is comparable.\n *\n * The levels are string values, so `level >= instance.logLevel` compares them\n * alphabetically — under which `'debug' >= 'error'` holds and `'warn' >= 'info'`\n * does not. A level needs a number to be ordered by.\n *\n * SILENT sits above ERROR: it is the level at which nothing qualifies.\n */\nconst LOG_LEVEL_RANK: Record<string, number> = {\n  [LogLevel.DEBUG]: 0,\n  [LogLevel.VERBOSE]: 1,\n  [LogLevel.INFO]: 2,\n  [LogLevel.WARN]: 3,\n  [LogLevel.ERROR]: 4,\n  [LogLevel.SILENT]: 5,\n}\n\n/**\n * Whether a message at `level` clears the `configured` threshold.\n *\n * `setLogLevel` accepts any `keyof Console`, not just a `LogLevel`, so either\n * side can be a string this table has no rank for. An unranked THRESHOLD falls\n * back to the default one rather than admitting everything; an unranked\n * MESSAGE is passed through to the invalid-logType throw below, which is what\n * names the mistake.\n */\nfunction meetsLogLevel(level: LogLevelString, configured: LogLevelString): boolean {\n  const messageRank = LOG_LEVEL_RANK[level as string]\n  if (messageRank === undefined) return true\n  const threshold =\n    LOG_LEVEL_RANK[configured as string] ?? LOG_LEVEL_RANK[FALLBACK_LOG_LEVEL]\n  return messageRank >= threshold\n}\n\n/**\n * The default log handler will forward DEBUG, VERBOSE, INFO, WARN, and ERROR\n * messages on to their corresponding console counterparts (if the log method\n * is supported by the current log level)\n *\n * ## The level was decorative (AGL-1151)\n *\n * This handler used to test only the level of the CALL — dropping the literal\n * `'silent'` and forwarding everything else — so `_logLevel` decided nothing\n * and `logger.debug()` reached `console.log` at every level including the\n * default INFO. On a published tenant page that is not a stray line: plugin\n * registration walks every component and preset through `lifecycleEvent`,\n * which logs a before and an after for each, so a visitor's browser formatted\n * and retained ~400 `console.log` calls of internal event names and payloads\n * before the page was interactive — measurably, and on a customer's site.\n *\n * The threshold is now the INSTANCE's, which is what the level's own docblock\n * has always said it means.\n */\nexport const defaultLogHandler: LogHandler = (\n  instance: Logger,\n  level: LogLevelString,\n  ...args: any[]\n): void => {\n  if (!level || level === 'silent') return\n  if (!meetsLogLevel(level, instance.logLevel)) return\n\n  const now = new Date().toISOString()\n  const method = ConsoleMethodKey[level]\n\n  if (method) {\n    return (console as unknown as Record<string, (...a: any[]) => void>)[method](`[${now}]  ${instance.name}`, ...args)\n  }\n\n  throw new Error(\n    `Attempted to log a message with an invalid logType (value: ${level})`,\n  )\n}\n\nexport const FALLBACK_LOG_LEVEL = LogLevel.INFO\n\n/**\n * Whether this build is something other than a deployed one.\n *\n * Proven, never assumed: the default is the QUIET level, and only a readable\n * `NODE_ENV` that is positively not `production` raises it. A bundler that\n * does not substitute the expression, or a realm-plugin bundle with no\n * `process` at all, leaves this false and the deployed behaviour stands —\n * which is the direction a wrong answer here has to fail in.\n *\n * Dot notation on both reads is load-bearing: the substitution is textual and\n * matches only this exact form.\n */\nconst DEVELOPMENT_RUNTIME: boolean =\n  typeof process !== 'undefined' &&\n  typeof process.env !== 'undefined' &&\n  typeof process.env.NODE_ENV === 'string' &&\n  process.env.NODE_ENV !== 'production'\n\n/**\n * TODO: INTEGRATE PACKAGE`debug`\n */\nexport class Logger {\n  /**\n   * The default log level.\n   *\n   * DEBUG outside production, so a developer keeps the running commentary the\n   * handler used to emit unconditionally, and a deployed build does not.\n   * Nothing in the workspace calls `setLogLevel`, so this constant is the only\n   * threshold that applies anywhere until something does.\n   *\n   * `process` is guarded because this library is reachable from a browser\n   * realm that has no bundler substituting `process.env` — a marketplace\n   * plugin bundle. Dot notation is load-bearing: the substitution is textual\n   * and never sees the bracket form.\n   */\n  public static defaultLogLevel: LogLevel = DEVELOPMENT_RUNTIME\n    ? LogLevel.DEBUG\n    : LogLevel.INFO\n\n  _logLevel: LogLevelString = Logger.defaultLogLevel\n  _logHandler: LogHandler = defaultLogHandler\n  _userLogHandler: LogHandler | null = null\n\n  /**\n   * The log level of the given Logger instance.\n   */\n  public get logLevel(): LogLevelString {\n    return this._logLevel\n  }\n  /**\n   * The log level of the given Logger instance.\n   */\n  public set logLevel(val: LogLevelString) {\n    if (!(val in LogLevel)) {\n      throw new TypeError(`Invalid value \"${val}\" assigned to \\`logLevel\\``)\n    }\n    this._logLevel = val\n  }\n  /**\n   * The main (internal) log handler for the Logger instance.\n   * Can be set to a new function in internal package code but not by user.\n   */\n  public get logHandler(): LogHandler {\n    return this._logHandler\n  }\n  /**\n   * The main (internal) log handler for the Logger instance.\n   * Can be set to a new function in internal package code but not by user.\n   */\n  public set logHandler(val: LogHandler) {\n    if (typeof val !== 'function') {\n      throw new TypeError('Value assigned to `logHandler` must be a function')\n    }\n    this._logHandler = val\n  }\n  /**\n   * The optional, additional, user-defined log handler for the Logger instance.\n   */\n  public get userLogHandler(): LogHandler | null {\n    return this._userLogHandler\n  }\n  /**\n   * The optional, additional, user-defined log handler for the Logger instance.\n   */\n  public set userLogHandler(val: LogHandler | null) {\n    this._userLogHandler = val\n  }\n\n  /**\n   * Gives you an instance of a Logger to capture messages according to\n   * Firebase's logging scheme.\n   *\n   * @param name The name that the logs will be associated with\n   */\n  constructor(public name?: string) {\n    /**\n     * Capture the current instance for later use\n     */\n    instances.push(this)\n  }\n\n  /**\n   * Workaround for setter/getter having to be the same type\n   */\n  public setLogLevel(val?: LogLevelString): this {\n    if ((val && (LogLevel as Record<string, unknown>)[(LogLevel as Record<string, unknown>)[val as string] as string]) || (console as unknown as Record<string, unknown>)[val as string])\n      this._logLevel = val as LogLevel\n    else this._logLevel = FALLBACK_LOG_LEVEL\n    return this\n  }\n  /**\n   * Set the log level for all logger instances\n   */\n  public static setLogLevel(val?: LogLevelString): typeof Logger {\n    instances.forEach((inst) => inst.setLogLevel(val))\n    return this\n  }\n\n  /**\n   * The optional, additional, user-defined log handler for the Logger instance.\n   */\n  public setUserLogHandler(\n    logCallback: LogCallback | null,\n    options?: LogOptions,\n  ): void {\n    let customLogLevel: LogLevelString | null = null\n    if (\n      options?.level &&\n      ((LogLevel as Record<string, unknown>)[(LogLevel as Record<string, unknown>)[options.level as string] as string] || (console as unknown as Record<string, unknown>)[options.level as string])\n    ) {\n      customLogLevel = options.level\n    }\n    if (logCallback === null) {\n      this.userLogHandler = null\n    } else {\n      this.userLogHandler = (\n        instance: Logger,\n        level: LogLevelString,\n        ...args: unknown[]\n      ) => {\n        const message = args\n          .map((arg) => {\n            if (arg == null) {\n              return null\n            } else if (typeof arg === 'string') {\n              return arg\n            } else if (typeof arg === 'number' || typeof arg === 'boolean') {\n              return arg.toString()\n            } else if (arg instanceof Error) {\n              return arg.message\n            } else {\n              try {\n                return JSON.stringify(arg)\n              } catch (ignored) {\n                return null\n              }\n            }\n          })\n          .filter((arg) => arg)\n          .join(' ')\n        if (level >= (customLogLevel ?? instance.logLevel)) {\n          logCallback({\n            args,\n            message,\n            type: instance.name,\n            level:\n              (options?.level &&\n                ((LogLevel as Record<string, unknown>)[(LogLevel as Record<string, unknown>)[options.level as string] as string] ||\n                  (console as unknown as Record<string, unknown>)[options.level as string])) as LogLevel ||\n              FALLBACK_LOG_LEVEL,\n          })\n        }\n      }\n    }\n  }\n  /**\n   * The optional, additional, user-defined log handler for the Logger instance.\n   */\n  public static setUserLogHandler(\n    logCallback: LogCallback | null,\n    options?: LogOptions,\n  ): void {\n    for (const instance of instances) {\n      instance.setUserLogHandler(logCallback, options)\n    }\n  }\n\n  /**\n   * The functions below are all based on the `console` interface\n   */\n\n  /** {@inheritDoc Console.debug} */\n  public debug(...args: unknown[]): void {\n    this._logHandler(this, LogLevel.DEBUG, ...args)\n    this._userLogHandler && this._userLogHandler(this, LogLevel.DEBUG, ...args)\n  }\n  /** {@inheritDoc Console.log} */\n  public log(...args: unknown[]): void {\n    this._logHandler(this, LogLevel.VERBOSE, ...args)\n    this._userLogHandler &&\n      this._userLogHandler(this, LogLevel.VERBOSE, ...args)\n  }\n  /** {@inheritDoc Console.info} */\n  public info(...args: unknown[]): void {\n    this._logHandler(this, LogLevel.INFO, ...args)\n    this._userLogHandler && this._userLogHandler(this, LogLevel.INFO, ...args)\n  }\n  /** {@inheritDoc Console.warn} */\n  public warn(...args: unknown[]): void {\n    this._logHandler(this, LogLevel.WARN, ...args)\n    this._userLogHandler && this._userLogHandler(this, LogLevel.WARN, ...args)\n  }\n  /** {@inheritDoc Console.error} */\n  public error(...args: unknown[]): void {\n    this._logHandler(this, LogLevel.ERROR, ...args)\n    this._userLogHandler && this._userLogHandler(this, LogLevel.ERROR, ...args)\n  }\n}\n\nexport default Logger\n"],"names":["instances","LogLevel","ConsoleMethodKey","LOG_LEVEL_RANK","meetsLogLevel","level","configured","messageRank","undefined","threshold","FALLBACK_LOG_LEVEL","defaultLogHandler","instance","args","logLevel","now","Date","toISOString","method","console","name","Error","DEVELOPMENT_RUNTIME","process","env","NODE_ENV","Logger","_logLevel","val","TypeError","logHandler","_logHandler","userLogHandler","_userLogHandler","setLogLevel","forEach","inst","setUserLogHandler","logCallback","options","customLogLevel","message","map","arg","toString","JSON","stringify","ignored","filter","join","type","debug","log","info","warn","error","defaultLogLevel","push"],"mappings":"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"}