@itwin/core-bentley 4.0.0-dev.8 → 4.0.0-dev.81

package/lib/esm/Assert.d.ts

@@ -1,26 +1,26 @@
-/** @packageDocumentation
- * @module Utils
- */
-/** Asserts that a condition is `true` and - when enabled - throws an error if it is not.
- * Assertions are enabled only if the build configuration defines `process.env.NODE_ENV` as `development` at build time.
- *
- * Assertions exist solely to assist programmers during development, in the following ways:
- *  1 They allow the programmer to declare conditions that they believe cannot possibly occur. If such conditions occur, they indicate
- *    a serious flaw in the programmer's logic.
- *  2 They allow the programmer to assure the TypeScript compiler of the truth of some condition that the compiler cannot itself infer.
- *  3 They allow the author of an API to indicate to consumers of the API a serious misuse that should be corrected during development.
- *
- * Assertions should **never** be used to test for conditions - however unlikely - that could be expected to occur at run-time,
- * such as failing to write to a file or load a resource over the network. If the condition asserted ever fails in a production environment,
- * the programmer has made a serious mistake.
- *
- * Note that even when assertions are disabled, calls to `assert` remain in the code and their arguments will be evaluated at run-time.
- * Therefore, if your condition or message requires computation, prefer to pass it as a function to prevent it from being evaluated when assertions are disabled.
- *
- * @param condition The condition that is asserted to be `true`. If the condition is more complex than a simple `boolean` variable, pass it as a function to prevent it from being evaluated when assertions are disabled.
- * @param message An optional description of the condition being asserted, to be included in the exception if `condition` is `false`. If the message must be computed, pass it as a function to prevent it from being evaluated when assertions are disabled. Defaults to "Programmer Error".
- * @throws Error containing the specified `message` if `condition` is `false`.
- * @public
- */
-export declare function assert(condition: boolean | (() => boolean), message?: string | (() => string)): asserts condition;
+/** @packageDocumentation
+ * @module Utils
+ */
+/** Asserts that a condition is `true` and - when enabled - throws an error if it is not.
+ * Assertions are enabled only if the build configuration defines `process.env.NODE_ENV` as `development` at build time.
+ *
+ * Assertions exist solely to assist programmers during development, in the following ways:
+ *  1 They allow the programmer to declare conditions that they believe cannot possibly occur. If such conditions occur, they indicate
+ *    a serious flaw in the programmer's logic.
+ *  2 They allow the programmer to assure the TypeScript compiler of the truth of some condition that the compiler cannot itself infer.
+ *  3 They allow the author of an API to indicate to consumers of the API a serious misuse that should be corrected during development.
+ *
+ * Assertions should **never** be used to test for conditions - however unlikely - that could be expected to occur at run-time,
+ * such as failing to write to a file or load a resource over the network. If the condition asserted ever fails in a production environment,
+ * the programmer has made a serious mistake.
+ *
+ * Note that even when assertions are disabled, calls to `assert` remain in the code and their arguments will be evaluated at run-time.
+ * Therefore, if your condition or message requires computation, prefer to pass it as a function to prevent it from being evaluated when assertions are disabled.
+ *
+ * @param condition The condition that is asserted to be `true`. If the condition is more complex than a simple `boolean` variable, pass it as a function to prevent it from being evaluated when assertions are disabled.
+ * @param message An optional description of the condition being asserted, to be included in the exception if `condition` is `false`. If the message must be computed, pass it as a function to prevent it from being evaluated when assertions are disabled. Defaults to "Programmer Error".
+ * @throws Error containing the specified `message` if `condition` is `false`.
+ * @public
+ */
+export declare function assert(condition: boolean | (() => boolean), message?: string | (() => string)): asserts condition;
 //# sourceMappingURL=Assert.d.ts.map

package/lib/esm/Assert.js

@@ -1,42 +1,42 @@
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-/** @packageDocumentation
- * @module Utils
- */
-const assertionsEnabled = process.env.NODE_ENV === "development";
-/** Asserts that a condition is `true` and - when enabled - throws an error if it is not.
- * Assertions are enabled only if the build configuration defines `process.env.NODE_ENV` as `development` at build time.
- *
- * Assertions exist solely to assist programmers during development, in the following ways:
- *  1 They allow the programmer to declare conditions that they believe cannot possibly occur. If such conditions occur, they indicate
- *    a serious flaw in the programmer's logic.
- *  2 They allow the programmer to assure the TypeScript compiler of the truth of some condition that the compiler cannot itself infer.
- *  3 They allow the author of an API to indicate to consumers of the API a serious misuse that should be corrected during development.
- *
- * Assertions should **never** be used to test for conditions - however unlikely - that could be expected to occur at run-time,
- * such as failing to write to a file or load a resource over the network. If the condition asserted ever fails in a production environment,
- * the programmer has made a serious mistake.
- *
- * Note that even when assertions are disabled, calls to `assert` remain in the code and their arguments will be evaluated at run-time.
- * Therefore, if your condition or message requires computation, prefer to pass it as a function to prevent it from being evaluated when assertions are disabled.
- *
- * @param condition The condition that is asserted to be `true`. If the condition is more complex than a simple `boolean` variable, pass it as a function to prevent it from being evaluated when assertions are disabled.
- * @param message An optional description of the condition being asserted, to be included in the exception if `condition` is `false`. If the message must be computed, pass it as a function to prevent it from being evaluated when assertions are disabled. Defaults to "Programmer Error".
- * @throws Error containing the specified `message` if `condition` is `false`.
- * @public
- */
-export function assert(condition, message) {
-    if (!assertionsEnabled)
-        return;
-    if ("boolean" !== typeof condition)
-        condition = condition();
-    if (condition)
-        return;
-    message = message !== null && message !== void 0 ? message : "Programmer Error";
-    if ("string" !== typeof message)
-        message = message();
-    throw new Error(`Assert: ${message}`);
-}
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module Utils
+ */
+const assertionsEnabled = process.env.NODE_ENV === "development";
+/** Asserts that a condition is `true` and - when enabled - throws an error if it is not.
+ * Assertions are enabled only if the build configuration defines `process.env.NODE_ENV` as `development` at build time.
+ *
+ * Assertions exist solely to assist programmers during development, in the following ways:
+ *  1 They allow the programmer to declare conditions that they believe cannot possibly occur. If such conditions occur, they indicate
+ *    a serious flaw in the programmer's logic.
+ *  2 They allow the programmer to assure the TypeScript compiler of the truth of some condition that the compiler cannot itself infer.
+ *  3 They allow the author of an API to indicate to consumers of the API a serious misuse that should be corrected during development.
+ *
+ * Assertions should **never** be used to test for conditions - however unlikely - that could be expected to occur at run-time,
+ * such as failing to write to a file or load a resource over the network. If the condition asserted ever fails in a production environment,
+ * the programmer has made a serious mistake.
+ *
+ * Note that even when assertions are disabled, calls to `assert` remain in the code and their arguments will be evaluated at run-time.
+ * Therefore, if your condition or message requires computation, prefer to pass it as a function to prevent it from being evaluated when assertions are disabled.
+ *
+ * @param condition The condition that is asserted to be `true`. If the condition is more complex than a simple `boolean` variable, pass it as a function to prevent it from being evaluated when assertions are disabled.
+ * @param message An optional description of the condition being asserted, to be included in the exception if `condition` is `false`. If the message must be computed, pass it as a function to prevent it from being evaluated when assertions are disabled. Defaults to "Programmer Error".
+ * @throws Error containing the specified `message` if `condition` is `false`.
+ * @public
+ */
+export function assert(condition, message) {
+    if (!assertionsEnabled)
+        return;
+    if ("boolean" !== typeof condition)
+        condition = condition();
+    if (condition)
+        return;
+    message = message ?? "Programmer Error";
+    if ("string" !== typeof message)
+        message = message();
+    throw new Error(`Assert: ${message}`);
+}
 //# sourceMappingURL=Assert.js.map

package/lib/esm/Assert.js.map

@@ -1 +1 @@
-{"version":3,"file":"Assert.js","sourceRoot":"","sources":["../../src/Assert.ts"],"names":[],"mappings":"AAAA;;;+FAG+F;AAC/F;;GAEG;AAEH,MAAM,iBAAiB,GAAG,OAAO,CAAC,GAAG,CAAC,QAAQ,KAAK,aAAa,CAAC;AAEjE;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,UAAU,MAAM,CAAC,SAAoC,EAAE,OAAiC;IAC5F,IAAI,CAAC,iBAAiB;QACpB,OAAO;IAET,IAAI,SAAS,KAAK,OAAO,SAAS;QAChC,SAAS,GAAG,SAAS,EAAE,CAAC;IAE1B,IAAI,SAAS;QACX,OAAO;IAET,OAAO,GAAG,OAAO,aAAP,OAAO,cAAP,OAAO,GAAI,kBAAkB,CAAC;IACxC,IAAI,QAAQ,KAAK,OAAO,OAAO;QAC7B,OAAO,GAAG,OAAO,EAAE,CAAC;IAEtB,MAAM,IAAI,KAAK,CAAC,WAAW,OAAO,EAAE,CAAC,CAAC;AACxC,CAAC","sourcesContent":["/*---------------------------------------------------------------------------------------------\r\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\r\n* See LICENSE.md in the project root for license terms and full copyright notice.\r\n*--------------------------------------------------------------------------------------------*/\r\n/** @packageDocumentation\r\n * @module Utils\r\n */\r\n\r\nconst assertionsEnabled = process.env.NODE_ENV === \"development\";\r\n\r\n/** Asserts that a condition is `true` and - when enabled - throws an error if it is not.\r\n * Assertions are enabled only if the build configuration defines `process.env.NODE_ENV` as `development` at build time.\r\n *\r\n * Assertions exist solely to assist programmers during development, in the following ways:\r\n *  1 They allow the programmer to declare conditions that they believe cannot possibly occur. If such conditions occur, they indicate\r\n *    a serious flaw in the programmer's logic.\r\n *  2 They allow the programmer to assure the TypeScript compiler of the truth of some condition that the compiler cannot itself infer.\r\n *  3 They allow the author of an API to indicate to consumers of the API a serious misuse that should be corrected during development.\r\n *\r\n * Assertions should **never** be used to test for conditions - however unlikely - that could be expected to occur at run-time,\r\n * such as failing to write to a file or load a resource over the network. If the condition asserted ever fails in a production environment,\r\n * the programmer has made a serious mistake.\r\n *\r\n * Note that even when assertions are disabled, calls to `assert` remain in the code and their arguments will be evaluated at run-time.\r\n * Therefore, if your condition or message requires computation, prefer to pass it as a function to prevent it from being evaluated when assertions are disabled.\r\n *\r\n * @param condition The condition that is asserted to be `true`. If the condition is more complex than a simple `boolean` variable, pass it as a function to prevent it from being evaluated when assertions are disabled.\r\n * @param message An optional description of the condition being asserted, to be included in the exception if `condition` is `false`. If the message must be computed, pass it as a function to prevent it from being evaluated when assertions are disabled. Defaults to \"Programmer Error\".\r\n * @throws Error containing the specified `message` if `condition` is `false`.\r\n * @public\r\n */\r\nexport function assert(condition: boolean | (() => boolean), message?: string | (() => string)): asserts condition {\r\n  if (!assertionsEnabled)\r\n    return;\r\n\r\n  if (\"boolean\" !== typeof condition)\r\n    condition = condition();\r\n\r\n  if (condition)\r\n    return;\r\n\r\n  message = message ?? \"Programmer Error\";\r\n  if (\"string\" !== typeof message)\r\n    message = message();\r\n\r\n  throw new Error(`Assert: ${message}`);\r\n}\r\n"]}
+{"version":3,"file":"Assert.js","sourceRoot":"","sources":["../../src/Assert.ts"],"names":[],"mappings":"AAAA;;;+FAG+F;AAC/F;;GAEG;AAEH,MAAM,iBAAiB,GAAG,OAAO,CAAC,GAAG,CAAC,QAAQ,KAAK,aAAa,CAAC;AAEjE;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,UAAU,MAAM,CAAC,SAAoC,EAAE,OAAiC;IAC5F,IAAI,CAAC,iBAAiB;QACpB,OAAO;IAET,IAAI,SAAS,KAAK,OAAO,SAAS;QAChC,SAAS,GAAG,SAAS,EAAE,CAAC;IAE1B,IAAI,SAAS;QACX,OAAO;IAET,OAAO,GAAG,OAAO,IAAI,kBAAkB,CAAC;IACxC,IAAI,QAAQ,KAAK,OAAO,OAAO;QAC7B,OAAO,GAAG,OAAO,EAAE,CAAC;IAEtB,MAAM,IAAI,KAAK,CAAC,WAAW,OAAO,EAAE,CAAC,CAAC;AACxC,CAAC","sourcesContent":["/*---------------------------------------------------------------------------------------------\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\n* See LICENSE.md in the project root for license terms and full copyright notice.\n*--------------------------------------------------------------------------------------------*/\n/** @packageDocumentation\n * @module Utils\n */\n\nconst assertionsEnabled = process.env.NODE_ENV === \"development\";\n\n/** Asserts that a condition is `true` and - when enabled - throws an error if it is not.\n * Assertions are enabled only if the build configuration defines `process.env.NODE_ENV` as `development` at build time.\n *\n * Assertions exist solely to assist programmers during development, in the following ways:\n *  1 They allow the programmer to declare conditions that they believe cannot possibly occur. If such conditions occur, they indicate\n *    a serious flaw in the programmer's logic.\n *  2 They allow the programmer to assure the TypeScript compiler of the truth of some condition that the compiler cannot itself infer.\n *  3 They allow the author of an API to indicate to consumers of the API a serious misuse that should be corrected during development.\n *\n * Assertions should **never** be used to test for conditions - however unlikely - that could be expected to occur at run-time,\n * such as failing to write to a file or load a resource over the network. If the condition asserted ever fails in a production environment,\n * the programmer has made a serious mistake.\n *\n * Note that even when assertions are disabled, calls to `assert` remain in the code and their arguments will be evaluated at run-time.\n * Therefore, if your condition or message requires computation, prefer to pass it as a function to prevent it from being evaluated when assertions are disabled.\n *\n * @param condition The condition that is asserted to be `true`. If the condition is more complex than a simple `boolean` variable, pass it as a function to prevent it from being evaluated when assertions are disabled.\n * @param message An optional description of the condition being asserted, to be included in the exception if `condition` is `false`. If the message must be computed, pass it as a function to prevent it from being evaluated when assertions are disabled. Defaults to \"Programmer Error\".\n * @throws Error containing the specified `message` if `condition` is `false`.\n * @public\n */\nexport function assert(condition: boolean | (() => boolean), message?: string | (() => string)): asserts condition {\n  if (!assertionsEnabled)\n    return;\n\n  if (\"boolean\" !== typeof condition)\n    condition = condition();\n\n  if (condition)\n    return;\n\n  message = message ?? \"Programmer Error\";\n  if (\"string\" !== typeof message)\n    message = message();\n\n  throw new Error(`Assert: ${message}`);\n}\n"]}

package/lib/esm/BeEvent.d.ts

@@ -1,82 +1,82 @@
-/** @packageDocumentation
- * @module Events
- */
-/** A function invoked when a BeEvent is raised.
- * @public
- */
-export declare type Listener = (...arg: any[]) => void;
-/**
- * Manages a set of *listeners* for a particular event and notifies them when the event is raised.
- * This class is usually instantiated inside of a container class and
- * exposed as a property for others to *subscribe* via [[BeEvent.addListener]].
- * @public
- */
-export declare class BeEvent<T extends Listener> {
-    private _listeners;
-    private _insideRaiseEvent;
-    /** The number of listeners currently subscribed to the event. */
-    get numberOfListeners(): number;
-    /**
-     * 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.
-     * @see [[BeEvent.raiseEvent]], [[BeEvent.removeListener]]
-     */
-    addListener(listener: T, scope?: any): () => void;
-    /**
-     * 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.
-     * @see [[BeEvent.raiseEvent]], [[BeEvent.removeListener]]
-     */
-    addOnce(listener: T, scope?: any): () => void;
-    /**
-     * Un-register a previously registered listener.
-     * @param listener The listener to be unregistered.
-     * @param  scope The scope that was originally passed to addListener.
-     * @returns 'true' if the listener was removed; 'false' if the listener and scope are not registered with the event.
-     * @see [[BeEvent.raiseEvent]], [[BeEvent.addListener]]
-     */
-    removeListener(listener: T, scope?: any): boolean;
-    /**
-     * 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.
-     * @see [[BeEvent.removeListener]], [[BeEvent.addListener]]
-     */
-    raiseEvent(...args: Parameters<T>): void;
-    /** Determine whether this BeEvent has a specified listener registered.
-     * @param listener The listener to check.
-     * @param scope optional scope argument to match call to addListener
-     */
-    has(listener: T, scope?: any): boolean;
-    /** Clear all Listeners from this BeEvent. */
-    clear(): void;
-}
-/** Specialization of BeEvent for events that take a single strongly typed argument, primarily used for UI events.
- * @public
- */
-export declare class BeUiEvent<TEventArgs> extends BeEvent<(args: TEventArgs) => void> {
-    /** Raises event with single strongly typed argument. */
-    emit(args: TEventArgs): void;
-}
-/**
- * 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.
- * @public
- */
-export declare class BeEventList<T extends Listener> {
-    private _events;
-    /**
-     * Gets the event associated with the specified name, creating the event if it does not already exist.
-     * @param name The name of the event.
-     */
-    get(name: string): BeEvent<T>;
-    /**
-     * Removes the event associated with a name.
-     * @param name The name of the event.
-     */
-    remove(name: string): void;
-}
+/** @packageDocumentation
+ * @module Events
+ */
+/** A function invoked when a BeEvent is raised.
+ * @public
+ */
+export type Listener = (...arg: any[]) => void;
+/**
+ * Manages a set of *listeners* for a particular event and notifies them when the event is raised.
+ * This class is usually instantiated inside of a container class and
+ * exposed as a property for others to *subscribe* via [[BeEvent.addListener]].
+ * @public
+ */
+export declare class BeEvent<T extends Listener> {
+    private _listeners;
+    private _insideRaiseEvent;
+    /** The number of listeners currently subscribed to the event. */
+    get numberOfListeners(): number;
+    /**
+     * 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.
+     * @see [[BeEvent.raiseEvent]], [[BeEvent.removeListener]]
+     */
+    addListener(listener: T, scope?: any): () => void;
+    /**
+     * 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.
+     * @see [[BeEvent.raiseEvent]], [[BeEvent.removeListener]]
+     */
+    addOnce(listener: T, scope?: any): () => void;
+    /**
+     * Un-register a previously registered listener.
+     * @param listener The listener to be unregistered.
+     * @param  scope The scope that was originally passed to addListener.
+     * @returns 'true' if the listener was removed; 'false' if the listener and scope are not registered with the event.
+     * @see [[BeEvent.raiseEvent]], [[BeEvent.addListener]]
+     */
+    removeListener(listener: T, scope?: any): boolean;
+    /**
+     * 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.
+     * @see [[BeEvent.removeListener]], [[BeEvent.addListener]]
+     */
+    raiseEvent(...args: Parameters<T>): void;
+    /** Determine whether this BeEvent has a specified listener registered.
+     * @param listener The listener to check.
+     * @param scope optional scope argument to match call to addListener
+     */
+    has(listener: T, scope?: any): boolean;
+    /** Clear all Listeners from this BeEvent. */
+    clear(): void;
+}
+/** Specialization of BeEvent for events that take a single strongly typed argument, primarily used for UI events.
+ * @public
+ */
+export declare class BeUiEvent<TEventArgs> extends BeEvent<(args: TEventArgs) => void> {
+    /** Raises event with single strongly typed argument. */
+    emit(args: TEventArgs): void;
+}
+/**
+ * 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.
+ * @public
+ */
+export declare class BeEventList<T extends Listener> {
+    private _events;
+    /**
+     * Gets the event associated with the specified name, creating the event if it does not already exist.
+     * @param name The name of the event.
+     */
+    get(name: string): BeEvent<T>;
+    /**
+     * Removes the event associated with a name.
+     * @param name The name of the event.
+     */
+    remove(name: string): void;
+}
 //# sourceMappingURL=BeEvent.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"BeEvent.d.ts","sourceRoot":"","sources":["../../src/BeEvent.ts"],"names":[],"mappings":"AAIA;;GAEG;AAIH;;GAEG;AACH,oBAAY,QAAQ,GAAG,CAAC,GAAG,GAAG,EAAE,GAAG,EAAE,KAAK,IAAI,CAAC;AAQ/C;;;;;GAKG;AACH,qBAAa,OAAO,CAAC,CAAC,SAAS,QAAQ;IACrC,OAAO,CAAC,UAAU,CAAsB;IACxC,OAAO,CAAC,iBAAiB,CAAkB;IAE3C,iEAAiE;IACjE,IAAW,iBAAiB,WAAqC;IAEjE;;;;;;OAMG;IACI,WAAW,CAAC,QAAQ,EAAE,CAAC,EAAE,KAAK,CAAC,EAAE,GAAG,GAAG,MAAM,IAAI;IAKxD;;;;;;OAMG;IACI,OAAO,CAAC,QAAQ,EAAE,CAAC,EAAE,KAAK,CAAC,EAAE,GAAG,GAAG,MAAM,IAAI;IAKpD;;;;;;OAMG;IACI,cAAc,CAAC,QAAQ,EAAE,CAAC,EAAE,KAAK,CAAC,EAAE,GAAG,GAAG,OAAO;IAiBxD;;;;OAIG;IACI,UAAU,CAAC,GAAG,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC;IA+BxC;;;OAGG;IACI,GAAG,CAAC,QAAQ,EAAE,CAAC,EAAE,KAAK,CAAC,EAAE,GAAG,GAAG,OAAO;IAS7C,6CAA6C;IACtC,KAAK,IAAI,IAAI;CACrB;AAED;;GAEG;AACH,qBAAa,SAAS,CAAC,UAAU,CAAE,SAAQ,OAAO,CAAC,CAAC,IAAI,EAAE,UAAU,KAAK,IAAI,CAAC;IAC5E,wDAAwD;IACjD,IAAI,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI;CACpC;AAED;;;;GAIG;AACH,qBAAa,WAAW,CAAC,CAAC,SAAS,QAAQ;IACzC,OAAO,CAAC,OAAO,CAAkD;IAEjE;;;OAGG;IACI,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC;IAUpC;;;OAGG;IACI,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;CAGlC"}
+{"version":3,"file":"BeEvent.d.ts","sourceRoot":"","sources":["../../src/BeEvent.ts"],"names":[],"mappings":"AAIA;;GAEG;AAIH;;GAEG;AACH,MAAM,MAAM,QAAQ,GAAG,CAAC,GAAG,GAAG,EAAE,GAAG,EAAE,KAAK,IAAI,CAAC;AAQ/C;;;;;GAKG;AACH,qBAAa,OAAO,CAAC,CAAC,SAAS,QAAQ;IACrC,OAAO,CAAC,UAAU,CAAsB;IACxC,OAAO,CAAC,iBAAiB,CAAkB;IAE3C,iEAAiE;IACjE,IAAW,iBAAiB,WAAqC;IAEjE;;;;;;OAMG;IACI,WAAW,CAAC,QAAQ,EAAE,CAAC,EAAE,KAAK,CAAC,EAAE,GAAG,GAAG,MAAM,IAAI;IAKxD;;;;;;OAMG;IACI,OAAO,CAAC,QAAQ,EAAE,CAAC,EAAE,KAAK,CAAC,EAAE,GAAG,GAAG,MAAM,IAAI;IAKpD;;;;;;OAMG;IACI,cAAc,CAAC,QAAQ,EAAE,CAAC,EAAE,KAAK,CAAC,EAAE,GAAG,GAAG,OAAO;IAiBxD;;;;OAIG;IACI,UAAU,CAAC,GAAG,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC;IA+BxC;;;OAGG;IACI,GAAG,CAAC,QAAQ,EAAE,CAAC,EAAE,KAAK,CAAC,EAAE,GAAG,GAAG,OAAO;IAS7C,6CAA6C;IACtC,KAAK,IAAI,IAAI;CACrB;AAED;;GAEG;AACH,qBAAa,SAAS,CAAC,UAAU,CAAE,SAAQ,OAAO,CAAC,CAAC,IAAI,EAAE,UAAU,KAAK,IAAI,CAAC;IAC5E,wDAAwD;IACjD,IAAI,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI;CACpC;AAED;;;;GAIG;AACH,qBAAa,WAAW,CAAC,CAAC,SAAS,QAAQ;IACzC,OAAO,CAAC,OAAO,CAAkD;IAEjE;;;OAGG;IACI,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC;IAUpC;;;OAGG;IACI,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;CAGlC"}

package/lib/esm/BeEvent.js

@@ -1,151 +1,151 @@
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-/** @packageDocumentation
- * @module Events
- */
-import { UnexpectedErrors } from "./UnexpectedErrors";
-/**
- * Manages a set of *listeners* for a particular event and notifies them when the event is raised.
- * This class is usually instantiated inside of a container class and
- * exposed as a property for others to *subscribe* via [[BeEvent.addListener]].
- * @public
- */
-export class BeEvent {
-    constructor() {
-        this._listeners = [];
-        this._insideRaiseEvent = false;
-    }
-    /** The number of listeners currently subscribed to the event. */
-    get numberOfListeners() { return this._listeners.length; }
-    /**
-     * 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.
-     * @see [[BeEvent.raiseEvent]], [[BeEvent.removeListener]]
-     */
-    addListener(listener, scope) {
-        this._listeners.push({ listener, scope, once: false });
-        return () => this.removeListener(listener, scope);
-    }
-    /**
-     * 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.
-     * @see [[BeEvent.raiseEvent]], [[BeEvent.removeListener]]
-     */
-    addOnce(listener, scope) {
-        this._listeners.push({ listener, scope, once: true });
-        return () => this.removeListener(listener, scope);
-    }
-    /**
-     * Un-register a previously registered listener.
-     * @param listener The listener to be unregistered.
-     * @param  scope The scope that was originally passed to addListener.
-     * @returns 'true' if the listener was removed; 'false' if the listener and scope are not registered with the event.
-     * @see [[BeEvent.raiseEvent]], [[BeEvent.addListener]]
-     */
-    removeListener(listener, scope) {
-        const listeners = this._listeners;
-        for (let i = 0; i < listeners.length; ++i) {
-            const context = listeners[i];
-            if (context.listener === listener && context.scope === scope) {
-                if (this._insideRaiseEvent) {
-                    context.listener = undefined;
-                }
-                else {
-                    listeners.splice(i, 1);
-                }
-                return true;
-            }
-        }
-        return false;
-    }
-    /**
-     * 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.
-     * @see [[BeEvent.removeListener]], [[BeEvent.addListener]]
-     */
-    raiseEvent(...args) {
-        this._insideRaiseEvent = true;
-        const listeners = this._listeners;
-        const length = listeners.length;
-        let dropped = false;
-        for (let i = 0; i < length; ++i) {
-            const context = listeners[i];
-            if (!context.listener) {
-                dropped = true;
-            }
-            else {
-                try {
-                    context.listener.apply(context.scope, args);
-                }
-                catch (e) {
-                    UnexpectedErrors.handle(e);
-                }
-                if (context.once) {
-                    context.listener = undefined;
-                    dropped = true;
-                }
-            }
-        }
-        // if we had dropped listeners, remove them now
-        if (dropped)
-            this._listeners = this._listeners.filter((ctx) => ctx.listener !== undefined);
-        this._insideRaiseEvent = false;
-    }
-    /** Determine whether this BeEvent has a specified listener registered.
-     * @param listener The listener to check.
-     * @param scope optional scope argument to match call to addListener
-     */
-    has(listener, scope) {
-        for (const ctx of this._listeners) {
-            if (ctx.listener === listener && ctx.scope === scope) {
-                return true;
-            }
-        }
-        return false;
-    }
-    /** Clear all Listeners from this BeEvent. */
-    clear() { this._listeners.length = 0; }
-}
-/** Specialization of BeEvent for events that take a single strongly typed argument, primarily used for UI events.
- * @public
- */
-export class BeUiEvent extends BeEvent {
-    /** Raises event with single strongly typed argument. */
-    emit(args) { this.raiseEvent(args); }
-}
-/**
- * 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.
- * @public
- */
-export class BeEventList {
-    constructor() {
-        this._events = {};
-    }
-    /**
-     * Gets the event associated with the specified name, creating the event if it does not already exist.
-     * @param name The name of the event.
-     */
-    get(name) {
-        let event = this._events[name];
-        if (event)
-            return event;
-        event = new BeEvent();
-        this._events[name] = event;
-        return event;
-    }
-    /**
-     * Removes the event associated with a name.
-     * @param name The name of the event.
-     */
-    remove(name) {
-        this._events[name] = undefined;
-    }
-}
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module Events
+ */
+import { UnexpectedErrors } from "./UnexpectedErrors";
+/**
+ * Manages a set of *listeners* for a particular event and notifies them when the event is raised.
+ * This class is usually instantiated inside of a container class and
+ * exposed as a property for others to *subscribe* via [[BeEvent.addListener]].
+ * @public
+ */
+export class BeEvent {
+    constructor() {
+        this._listeners = [];
+        this._insideRaiseEvent = false;
+    }
+    /** The number of listeners currently subscribed to the event. */
+    get numberOfListeners() { return this._listeners.length; }
+    /**
+     * 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.
+     * @see [[BeEvent.raiseEvent]], [[BeEvent.removeListener]]
+     */
+    addListener(listener, scope) {
+        this._listeners.push({ listener, scope, once: false });
+        return () => this.removeListener(listener, scope);
+    }
+    /**
+     * 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.
+     * @see [[BeEvent.raiseEvent]], [[BeEvent.removeListener]]
+     */
+    addOnce(listener, scope) {
+        this._listeners.push({ listener, scope, once: true });
+        return () => this.removeListener(listener, scope);
+    }
+    /**
+     * Un-register a previously registered listener.
+     * @param listener The listener to be unregistered.
+     * @param  scope The scope that was originally passed to addListener.
+     * @returns 'true' if the listener was removed; 'false' if the listener and scope are not registered with the event.
+     * @see [[BeEvent.raiseEvent]], [[BeEvent.addListener]]
+     */
+    removeListener(listener, scope) {
+        const listeners = this._listeners;
+        for (let i = 0; i < listeners.length; ++i) {
+            const context = listeners[i];
+            if (context.listener === listener && context.scope === scope) {
+                if (this._insideRaiseEvent) {
+                    context.listener = undefined;
+                }
+                else {
+                    listeners.splice(i, 1);
+                }
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * 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.
+     * @see [[BeEvent.removeListener]], [[BeEvent.addListener]]
+     */
+    raiseEvent(...args) {
+        this._insideRaiseEvent = true;
+        const listeners = this._listeners;
+        const length = listeners.length;
+        let dropped = false;
+        for (let i = 0; i < length; ++i) {
+            const context = listeners[i];
+            if (!context.listener) {
+                dropped = true;
+            }
+            else {
+                try {
+                    context.listener.apply(context.scope, args);
+                }
+                catch (e) {
+                    UnexpectedErrors.handle(e);
+                }
+                if (context.once) {
+                    context.listener = undefined;
+                    dropped = true;
+                }
+            }
+        }
+        // if we had dropped listeners, remove them now
+        if (dropped)
+            this._listeners = this._listeners.filter((ctx) => ctx.listener !== undefined);
+        this._insideRaiseEvent = false;
+    }
+    /** Determine whether this BeEvent has a specified listener registered.
+     * @param listener The listener to check.
+     * @param scope optional scope argument to match call to addListener
+     */
+    has(listener, scope) {
+        for (const ctx of this._listeners) {
+            if (ctx.listener === listener && ctx.scope === scope) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /** Clear all Listeners from this BeEvent. */
+    clear() { this._listeners.length = 0; }
+}
+/** Specialization of BeEvent for events that take a single strongly typed argument, primarily used for UI events.
+ * @public
+ */
+export class BeUiEvent extends BeEvent {
+    /** Raises event with single strongly typed argument. */
+    emit(args) { this.raiseEvent(args); }
+}
+/**
+ * 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.
+ * @public
+ */
+export class BeEventList {
+    constructor() {
+        this._events = {};
+    }
+    /**
+     * Gets the event associated with the specified name, creating the event if it does not already exist.
+     * @param name The name of the event.
+     */
+    get(name) {
+        let event = this._events[name];
+        if (event)
+            return event;
+        event = new BeEvent();
+        this._events[name] = event;
+        return event;
+    }
+    /**
+     * Removes the event associated with a name.
+     * @param name The name of the event.
+     */
+    remove(name) {
+        this._events[name] = undefined;
+    }
+}
 //# sourceMappingURL=BeEvent.js.map