@itwin/core-i18n 5.15.0-dev.12 → 5.15.0-dev.14

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

@@ -17339,6 +17339,7 @@ function assert(condition, message) {
 "use strict";
 __webpack_require__.r(__webpack_exports__);
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   BeAsyncEvent: () => (/* binding */ BeAsyncEvent),
 /* harmony export */   BeEvent: () => (/* binding */ BeEvent),
 /* harmony export */   BeEventList: () => (/* binding */ BeEventList),
 /* harmony export */   BeUiEvent: () => (/* binding */ BeUiEvent),
@@ -17426,8 +17427,13 @@ class BeEvent {
                 dropped = true;
             }
             else {
+                const listener = context.listener;
+                if (context.once) {
+                    context.listener = undefined;
+                    dropped = true;
+                }
                 try {
-                    context.listener.apply(context.scope, args);
+                    listener.apply(context.scope, args);
                 }
                 catch (e) {
                     _UnexpectedErrors__WEBPACK_IMPORTED_MODULE_0__.UnexpectedErrors.handle(e);
@@ -17436,10 +17442,6 @@ class BeEvent {
                     // listener was removed during its own callback
                     dropped = true;
                 }
-                else if (context.once) {
-                    context.listener = undefined;
-                    dropped = true;
-                }
             }
         }
         this._emitDepth--;
@@ -17483,8 +17485,6 @@ class BeUiEvent extends BeEvent {
  */
 class BeUnorderedEvent {
     _listeners = new Set();
-    _emitDepth = 0;
-    _hasTombstones = false;
     /** The number of listeners currently subscribed to the event.
      * @note During `raiseEvent()`, this may include listeners that have been removed or are one-shot
      * but are awaiting deferred cleanup. The count is accurate outside of `raiseEvent()`.
@@ -17514,43 +17514,26 @@ class BeUnorderedEvent {
     }
     /** Remove a specific context entry, deferring during emit. */
     _removeCtx(ctx) {
-        if (this._emitDepth > 0) {
-            ctx.listener = undefined; // tombstone for deferred cleanup
-            this._hasTombstones = true;
-        }
-        else {
-            this._listeners.delete(ctx);
-        }
+        this._listeners.delete(ctx);
     }
     /**
      * Raises the event by calling each registered listener with the supplied arguments.
      * @param args This method takes any number of parameters and passes them through to the listeners.
      */
     raiseEvent(...args) {
-        this._emitDepth++;
         for (const ctx of this._listeners) {
             if (!ctx.listener) {
                 continue;
             }
+            if (ctx.once) {
+                this._listeners.delete(ctx);
+            }
             try {
                 ctx.listener.apply(ctx.scope, args);
             }
             catch (e) {
                 _UnexpectedErrors__WEBPACK_IMPORTED_MODULE_0__.UnexpectedErrors.handle(e);
             }
-            if (ctx.listener && ctx.once) {
-                ctx.listener = undefined;
-                this._hasTombstones = true;
-            }
-        }
-        this._emitDepth--;
-        // Only clean up tombstoned entries when we're back at the outermost emit
-        if (this._hasTombstones && this._emitDepth === 0) {
-            this._hasTombstones = false;
-            for (const ctx of this._listeners) {
-                if (ctx.listener === undefined)
-                    this._listeners.delete(ctx);
-            }
         }
     }
     /** Clear all listeners from this BeUnorderedEvent.
@@ -17566,6 +17549,108 @@ class BeUnorderedUiEvent extends BeUnorderedEvent {
     /** Raises event with single strongly typed argument. */
     emit(args) { this.raiseEvent(args); }
 }
+/**
+ * Manages a set of *listeners* for a particular event and notifies them when the event is raised.
+ * Each listener is async (return a Promise<void>). The listeners may be invoked in series
+ * or concurrently depending on the configuration of the instance.
+ *
+ * Like [[BeUnorderedEvent]], this class uses a `Set` internally to support more performant removal
+ * of old listeners. When a listener is removed during emit, it is marked for deferred removal instead
+ * of mutating the set immediately. Despite the "unordered" implication, items in a `Set` are enumerated
+ * in insertion order, which means that this class invokes the listeners in insertion order.
+ *
+ * Listeners are managed exclusively through the disposal closure returned by [[addListener]] and
+ * [[addOnce]]. There is no `removeListener` or `has` method — callers must capture the returned
+ * closure to unsubscribe.
+ * @beta
+ */
+class BeAsyncEvent {
+    _listeners = new Set();
+    _concurrent = false;
+    _promiseRejectionIsUnexpected = false;
+    constructor(options) {
+        if (options?.concurrent)
+            this._concurrent = true;
+        if (options?.promiseRejectionIsUnexpected)
+            this._promiseRejectionIsUnexpected = true;
+    }
+    /** The number of listeners currently subscribed to the event.
+     * @note During `raiseEvent()`, this may include listeners that have been removed or are one-shot
+     * but are awaiting deferred cleanup. The count is accurate outside of `raiseEvent()`.
+     */
+    get numberOfListeners() { return this._listeners.size; }
+    /**
+     * Registers a Listener to be executed whenever this event is raised.
+     * @param listener The function to be executed when the event is raised.
+     * @param scope An optional object scope to serve as the 'this' pointer when listener is invoked.
+     * @returns A function that will remove this event listener in O(1).
+     */
+    addListener(listener, scope) {
+        const ctx = { listener, scope, once: false };
+        this._listeners.add(ctx);
+        return () => this._removeCtx(ctx);
+    }
+    /**
+     * Registers a callback function to be executed *only once* when the event is raised.
+     * @param listener The function to be executed once when the event is raised.
+     * @param scope An optional object scope to serve as the `this` pointer in which the listener function will execute.
+     * @returns A function that will remove this event listener in O(1).
+     */
+    addOnce(listener, scope) {
+        const ctx = { listener, scope, once: true };
+        this._listeners.add(ctx);
+        return () => this._removeCtx(ctx);
+    }
+    /** Remove a specific context entry, deferring during emit. */
+    _removeCtx(ctx) {
+        this._listeners.delete(ctx);
+    }
+    /**
+     * Raises the event by calling each registered listener with the supplied arguments.
+     *
+     * See [[BeAsyncEventOptions]] for options that control the behavior of this method.
+     *
+     * @param args This method takes any number of parameters and passes them through to the listeners.
+     * @returns A Promise that settles when the event invocation is complete.
+     */
+    async raiseEvent(...args) {
+        const promises = [];
+        // Wrapper to ensure that an exception thrown immediately by a listener is captured as a rejected promise rather than
+        // allowed to propagate as an exception. A well-behaved Promise-returning function should never throw, but
+        // this defends against the poorly-behaved ones. In Node 23+ we could use `Promise.try` instead.
+        const invoke = async (ctx, args) => {
+            if (!ctx.listener)
+                return;
+            await ctx.listener.apply(ctx.scope, args);
+        };
+        for (const ctx of this._listeners) {
+            if (!ctx.listener)
+                continue;
+            if (ctx.once) {
+                // Set guarantees this is safe during iteration.
+                this._listeners.delete(ctx);
+            }
+            let promise = invoke(ctx, args);
+            if (this._promiseRejectionIsUnexpected)
+                promise = promise.catch(reason => _UnexpectedErrors__WEBPACK_IMPORTED_MODULE_0__.UnexpectedErrors.handle(reason));
+            if (this._concurrent)
+                promises.push(promise);
+            else
+                await promise;
+        }
+        if (this._concurrent) {
+            const result = await Promise.allSettled(promises);
+            const firstRejection = result.find(r => r.status === "rejected");
+            if (firstRejection)
+                throw firstRejection.reason;
+        }
+    }
+    /** Clear all listeners from this BeAsyncEvent.
+     * @note If called during `raiseEvent`, remaining listeners in the current iteration are skipped
+     * immediately rather than being tombstoned.
+     */
+    clear() { this._listeners.clear(); }
+}
 /**
  * A list of BeEvent objects, accessible by an event name.
  * This class may be used instead of explicitly declaring each BeEvent as a member of a containing class.
@@ -20122,16 +20207,18 @@ var Id64;
     Id64.getFirst = getFirst;
     /** Return the number of [[Id64String]]s represented by an [[Id64Arg]]. */
     function sizeOf(arg) {
-        return typeof arg === "string" ? 1 : (Array.isArray(arg) ? arg.length : arg.size);
+        return typeof arg === "string" ? 1 : "size" in arg ? arg.size : arg.length;
     }
     Id64.sizeOf = sizeOf;
     /** Returns true if the [[Id64Arg]] contains the specified Id. */
     function has(arg, id) {
-        if (typeof arg === "string")
+        if (typeof arg === "string") {
             return arg === id;
-        if (Array.isArray(arg))
-            return -1 !== arg.indexOf(id);
-        return arg.has(id);
+        }
+        if ("has" in arg) {
+            return arg.has(id);
+        }
+        return -1 !== arg.indexOf(id);
     }
     Id64.has = has;
     /** The string representation of an invalid Id. */
@@ -24201,6 +24288,7 @@ class YieldManager {
 __webpack_require__.r(__webpack_exports__);
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   AbandonedError: () => (/* reexport safe */ _OneAtATimeAction__WEBPACK_IMPORTED_MODULE_22__.AbandonedError),
+/* harmony export */   BeAsyncEvent: () => (/* reexport safe */ _BeEvent__WEBPACK_IMPORTED_MODULE_2__.BeAsyncEvent),
 /* harmony export */   BeDuration: () => (/* reexport safe */ _Time__WEBPACK_IMPORTED_MODULE_30__.BeDuration),
 /* harmony export */   BeEvent: () => (/* reexport safe */ _BeEvent__WEBPACK_IMPORTED_MODULE_2__.BeEvent),
 /* harmony export */   BeEventList: () => (/* reexport safe */ _BeEvent__WEBPACK_IMPORTED_MODULE_2__.BeEventList),