@itwin/core-i18n 5.7.0-dev.14 → 5.7.0-dev.16

package/lib/cjs/test/webpack/bundled-tests.instrumented.js

@@ -21352,30 +21352,58 @@ class Logger {
         const minLevel = Logger.getLevel(category);
         return (minLevel !== undefined) && (level >= minLevel);
     }
-    /** Log the specified message to the **error** stream.
-     * @param category  The category of the message.
-     * @param message  The message.
-     * @param metaData  Optional data for the message
-     */
-    static logError(category, message, metaData) {
-        if (Logger._logError && Logger.isEnabled(category, LogLevel.Error))
-            Logger._logError(category, message, metaData);
+    // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
+    static logError(category, messageOrError, metaData) {
+        if (Logger._logError && Logger.isEnabled(category, LogLevel.Error)) {
+            if (typeof messageOrError === "string") {
+                Logger._logError(category, messageOrError, metaData);
+            }
+            else if (_BentleyError__WEBPACK_IMPORTED_MODULE_1__.BentleyError.isError(messageOrError)) {
+                // For backwards compatibility, log BentleyError old way
+                Logger._logError(category, Logger.getExceptionMessage(messageOrError), () => ({ ..._BentleyError__WEBPACK_IMPORTED_MODULE_1__.BentleyError.getErrorMetadata(messageOrError), exceptionType: messageOrError?.constructor?.name ?? "<Unknown>", ..._BentleyError__WEBPACK_IMPORTED_MODULE_1__.BentleyError.getMetaData(metaData) }));
+            }
+            else {
+                // Else, return a copy of the error, with non-enumerable members `message` and `stack` removed, as "metadata" for log.
+                Logger._logError(category, Logger.getExceptionMessage(messageOrError), Logger.getExceptionMetaData(messageOrError, metaData));
+            }
+        }
     }
-    static getExceptionMessage(err) {
-        if (err === undefined) {
-            return "Error: err is undefined.";
+    /**
+     * Get a sting message for a given error.
+     * For legacy [[BentleyError]] exceptions, this will include the error message and, optionally, the call stack.
+     * For other exceptions, this will include the stringified version of the error.
+     * @param error The error to get the message for
+     * @returns A string message for the error
+     */
+    static getExceptionMessage(error) {
+        if (error === undefined) {
+            return "Error: error is undefined.";
+        }
+        if (error === null) {
+            return "Error: error is null.";
         }
-        if (err === null) {
-            return "Error: err is null.";
+        const stack = Logger.logExceptionCallstacks ? `\n${_BentleyError__WEBPACK_IMPORTED_MODULE_1__.BentleyError.getErrorStack(error)}` : "";
+        return _BentleyError__WEBPACK_IMPORTED_MODULE_1__.BentleyError.getErrorMessage(error) + stack;
+    }
+    /**
+     * Merged passed metaData with error properties into one LoggingMetaData, with the passed metaData taking precedence in case of conflict.
+     * @param error The error to be logged as metadata
+     * @param metaData Optional metadata to be merged with the error
+     * @returns A function returning the merged metadata
+     */
+    static getExceptionMetaData(error, metaData) {
+        const exceptionType = error?.constructor?.name ?? "<Unknown>";
+        if (metaData === undefined) {
+            return () => ({ exceptionType, ...error });
         }
-        const stack = Logger.logExceptionCallstacks ? `\n${_BentleyError__WEBPACK_IMPORTED_MODULE_1__.BentleyError.getErrorStack(err)}` : "";
-        return _BentleyError__WEBPACK_IMPORTED_MODULE_1__.BentleyError.getErrorMessage(err) + stack;
+        return () => ({ exceptionType, ...error, ..._BentleyError__WEBPACK_IMPORTED_MODULE_1__.BentleyError.getMetaData(metaData) });
     }
     /** Log the specified exception.
      * For legacy [[BentleyError]] exceptions, the special "exceptionType" property will be added as metadata. Otherwise, all enumerable members of the exception are logged as metadata.
      * @param category  The category of the message.
      * @param err  The exception object.
      * @param log The logger output function to use - defaults to Logger.logError
+     * @deprecated in 5.6. Use logError(category, error, metaData) instead, which will log exceptions in the same way but is more flexible and easier to use.
      */
     static logException(category, err, log = (_category, message, metaData) => Logger.logError(_category, message, metaData)) {
         log(category, Logger.getExceptionMessage(err), () => {
@@ -21661,11 +21689,15 @@ class OneAtATimeAction {
             return await promise;
         }
         finally {
-            // do all of this whether promise was fulfilled or rejected
-            this._active = this._pending; // see if there's a pending request waiting
-            this._pending = undefined; // clear pending
-            if (this._active)
-                this._active.start(); // eslint-disable-line @typescript-eslint/no-floating-promises
+            // A replaced pending request can be abandoned before it ever becomes active.
+            // Only the currently active entry is allowed to promote/start the next pending request.
+            if (this._active === entry) {
+                // do all of this whether promise was fulfilled or rejected
+                this._active = this._pending; // see if there's a pending request waiting
+                this._pending = undefined; // clear pending
+                if (this._active)
+                    this._active.start(); // eslint-disable-line @typescript-eslint/no-floating-promises
+            }
         }
     }
 }
@@ -23748,7 +23780,7 @@ class UnexpectedErrors {
     /** handler for logging exception to console */
     static consoleLog = (e) => console.error(e); // eslint-disable-line no-console
     /** handler for logging exception with [[Logger]] */
-    static errorLog = (e) => _Logger__WEBPACK_IMPORTED_MODULE_0__.Logger.logException("unhandled", e);
+    static errorLog = (e) => _Logger__WEBPACK_IMPORTED_MODULE_0__.Logger.logError("unhandled", e);
     static _telemetry = [];
     static _handler = this.errorLog; // default to error logging
     constructor() { } // this is a singleton