@itwin/core-i18n 5.7.0-dev.8 → 5.7.0

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 - will not be removed until after 2027-03-03. 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), () => {
@@ -21491,6 +21519,10 @@ class ObservableSet extends Set {
     onDeleted = new _BeEvent__WEBPACK_IMPORTED_MODULE_0__.BeEvent();
     /** Emitted after this set's contents are cleared. */
     onCleared = new _BeEvent__WEBPACK_IMPORTED_MODULE_0__.BeEvent();
+    /** Emitted after multiple items are added to this set via [[addAll]]. */
+    onBatchAdded = new _BeEvent__WEBPACK_IMPORTED_MODULE_0__.BeEvent();
+    /** Emitted after multiple items are deleted from this set via [[deleteAll]]. */
+    onBatchDeleted = new _BeEvent__WEBPACK_IMPORTED_MODULE_0__.BeEvent();
     /** Construct a new ObservableSet.
      * @param elements Optional elements with which to populate the new set.
      */
@@ -21523,6 +21555,32 @@ class ObservableSet extends Set {
             this.onCleared.raiseEvent();
         }
     }
+    /** Add multiple items to the set, raising [[onBatchAdded]] only once after all items are added.
+     * This is more efficient than calling [[add]] in a loop when listeners need not be notified of each individual addition.
+     * @param items The items to add.
+     * @returns The number of items that were actually added (i.e., were not already present).
+     */
+    addAll(items) {
+        const prevSize = this.size;
+        for (const item of items)
+            super.add(item);
+        if (this.size !== prevSize)
+            this.onBatchAdded.raiseEvent();
+        return this.size - prevSize;
+    }
+    /** Delete multiple items from the set, raising [[onBatchDeleted]] only once after all items are deleted.
+     * This is more efficient than calling [[delete]] in a loop when listeners need not be notified of each individual deletion.
+     * @param items The items to delete.
+     * @returns The number of items that were actually deleted (i.e., were present in the set).
+     */
+    deleteAll(items) {
+        const prevSize = this.size;
+        for (const item of items)
+            super.delete(item);
+        if (this.size !== prevSize)
+            this.onBatchDeleted.raiseEvent();
+        return prevSize - this.size;
+    }
 }
 
 
@@ -21631,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
+            }
         }
     }
 }
@@ -23718,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
@@ -25629,7 +25691,7 @@ describe("ITwinLocalization", () => {
     // For interpolation options, see: https://www.i18next.com/translation-function/interpolation
     describe("#getLocalizedString", () => {
         before(async () => {
-            localization = new ITwinLocalization_1.ITwinLocalization();
+            localization = new ITwinLocalization_1.ITwinLocalization({ initOptions: { lng: "en-US" } });
             await localization.initialize(["Default", "Test"]);
             germanLocalization = new ITwinLocalization_1.ITwinLocalization({ initOptions: { lng: "de" } });
             await germanLocalization.initialize(["Default", "Test"]);
@@ -26202,11 +26264,11 @@ describe("ITwinLocalization", () => {
         // On current Linux CI environment, "@POSIX" is appended as a suffix to the locale,
         // which means that the en-US locales do not get loaded.
         if (!navigator.userAgent.toLowerCase().includes("linux")) {
-            it("english language list includes en and en-US", async () => {
+            it("default list includes en and the user's language", async () => {
                 localization = new ITwinLocalization_1.ITwinLocalization();
                 await localization.initialize([]);
                 languages = localization.getLanguageList();
-                chai_1.assert.isTrue(languages.includes("en-US"));
+                chai_1.assert.isTrue(languages.includes(navigator.language));
                 chai_1.assert.isTrue(languages.includes("en"));
             });
         }