@itwin/core-bentley 3.5.0-dev.5 → 3.5.0-dev.8

package/lib/cjs/AccessToken.d.ts

@@ -1,9 +1,9 @@
-/** @packageDocumentation
- * @module Utils
- */
-/**
- * A string that contains an access token.
- * @beta
- */
-export declare type AccessToken = string;
+/** @packageDocumentation
+ * @module Utils
+ */
+/**
+ * A string that contains an access token.
+ * @beta
+ */
+export declare type AccessToken = string;
 //# sourceMappingURL=AccessToken.d.ts.map

package/lib/cjs/AccessToken.js

@@ -1,10 +1,10 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
-* 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
- */
-Object.defineProperty(exports, "__esModule", { value: true });
+"use strict";
+/*---------------------------------------------------------------------------------------------
+* 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
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
 //# sourceMappingURL=AccessToken.js.map

package/lib/cjs/AccessToken.js.map

@@ -1 +1 @@
-{"version":3,"file":"AccessToken.js","sourceRoot":"","sources":["../../src/AccessToken.ts"],"names":[],"mappings":";AACA;;;+FAG+F;AAC/F;;GAEG","sourcesContent":["\n/*---------------------------------------------------------------------------------------------\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\n/**\n * A string that contains an access token.\n * @beta\n */\nexport type AccessToken = string;\n"]}
+{"version":3,"file":"AccessToken.js","sourceRoot":"","sources":["../../src/AccessToken.ts"],"names":[],"mappings":";AACA;;;+FAG+F;AAC/F;;GAEG","sourcesContent":["\r\n/*---------------------------------------------------------------------------------------------\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\n/**\r\n * A string that contains an access token.\r\n * @beta\r\n */\r\nexport type AccessToken = string;\r\n"]}

package/lib/cjs/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/cjs/Assert.js

@@ -1,46 +1,46 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
-* 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
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.assert = void 0;
-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
- */
-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}`);
-}
-exports.assert = assert;
+"use strict";
+/*---------------------------------------------------------------------------------------------
+* 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
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assert = void 0;
+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
+ */
+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}`);
+}
+exports.assert = assert;
 //# sourceMappingURL=Assert.js.map

package/lib/cjs/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,SAAgB,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;AAfD,wBAeC","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"]}
+{"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,SAAgB,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;AAfD,wBAeC","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"]}

package/lib/cjs/AsyncMutex.d.ts

@@ -1,27 +1,27 @@
-/** @packageDocumentation
- * @module Utils
- */
-/**
- * Type of method to unlock the held mutex
- * @see [[AsyncMutex]]
- * @alpha
- */
-export declare type AsyncMutexUnlockFnType = () => void;
-/**
- * Utility to ensure a block of async code executes atomically.
- * Even if JavaScript precludes the possibility of race conditions between threads, there is potential for
- * race conditions with async code. This utility is needed in cases where a block of async code needs to run
- * to completion before another block is started.
- * This utility was based on this article: https://spin.atomicobject.com/2018/09/10/javascript-concurrency/
- * @alpha
- */
-export declare class AsyncMutex {
-    private _mutex;
-    /**
-     * Await the return value to setup a lock. The return value
-     * is also the unlock function that can be called to unlock
-     * the mutex.
-     */
-    lock(): Promise<AsyncMutexUnlockFnType>;
-}
+/** @packageDocumentation
+ * @module Utils
+ */
+/**
+ * Type of method to unlock the held mutex
+ * @see [[AsyncMutex]]
+ * @alpha
+ */
+export declare type AsyncMutexUnlockFnType = () => void;
+/**
+ * Utility to ensure a block of async code executes atomically.
+ * Even if JavaScript precludes the possibility of race conditions between threads, there is potential for
+ * race conditions with async code. This utility is needed in cases where a block of async code needs to run
+ * to completion before another block is started.
+ * This utility was based on this article: https://spin.atomicobject.com/2018/09/10/javascript-concurrency/
+ * @alpha
+ */
+export declare class AsyncMutex {
+    private _mutex;
+    /**
+     * Await the return value to setup a lock. The return value
+     * is also the unlock function that can be called to unlock
+     * the mutex.
+     */
+    lock(): Promise<AsyncMutexUnlockFnType>;
+}
 //# sourceMappingURL=AsyncMutex.d.ts.map

package/lib/cjs/AsyncMutex.js

@@ -1,44 +1,44 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
-* 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
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AsyncMutex = void 0;
-/**
- * Utility to ensure a block of async code executes atomically.
- * Even if JavaScript precludes the possibility of race conditions between threads, there is potential for
- * race conditions with async code. This utility is needed in cases where a block of async code needs to run
- * to completion before another block is started.
- * This utility was based on this article: https://spin.atomicobject.com/2018/09/10/javascript-concurrency/
- * @alpha
- */
-class AsyncMutex {
-    constructor() {
-        this._mutex = Promise.resolve();
-    }
-    /**
-     * Await the return value to setup a lock. The return value
-     * is also the unlock function that can be called to unlock
-     * the mutex.
-     */
-    async lock() {
-        /**
-         * Note: The promise returned by this method will resolve (with the unlock function, which is actually the
-         * mutex’s then’s resolve function) once any previous mutexes have finished and called their
-         * respective unlock function that was yielded over their promise.
-         */
-        let begin = (_unlock) => { };
-        this._mutex = this._mutex.then(async () => {
-            return new Promise(begin);
-        });
-        return new Promise((res) => {
-            begin = res;
-        });
-    }
-}
-exports.AsyncMutex = AsyncMutex;
+"use strict";
+/*---------------------------------------------------------------------------------------------
+* 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
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsyncMutex = void 0;
+/**
+ * Utility to ensure a block of async code executes atomically.
+ * Even if JavaScript precludes the possibility of race conditions between threads, there is potential for
+ * race conditions with async code. This utility is needed in cases where a block of async code needs to run
+ * to completion before another block is started.
+ * This utility was based on this article: https://spin.atomicobject.com/2018/09/10/javascript-concurrency/
+ * @alpha
+ */
+class AsyncMutex {
+    constructor() {
+        this._mutex = Promise.resolve();
+    }
+    /**
+     * Await the return value to setup a lock. The return value
+     * is also the unlock function that can be called to unlock
+     * the mutex.
+     */
+    async lock() {
+        /**
+         * Note: The promise returned by this method will resolve (with the unlock function, which is actually the
+         * mutex’s then’s resolve function) once any previous mutexes have finished and called their
+         * respective unlock function that was yielded over their promise.
+         */
+        let begin = (_unlock) => { };
+        this._mutex = this._mutex.then(async () => {
+            return new Promise(begin);
+        });
+        return new Promise((res) => {
+            begin = res;
+        });
+    }
+}
+exports.AsyncMutex = AsyncMutex;
 //# sourceMappingURL=AsyncMutex.js.map

package/lib/cjs/AsyncMutex.js.map

@@ -1 +1 @@
-{"version":3,"file":"AsyncMutex.js","sourceRoot":"","sources":["../../src/AsyncMutex.ts"],"names":[],"mappings":";AAAA;;;+FAG+F;AAC/F;;GAEG;;;AASH;;;;;;;GAOG;AACH,MAAa,UAAU;IAAvB;QACU,WAAM,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC;IAuBrC,CAAC;IArBC;;;;OAIG;IACI,KAAK,CAAC,IAAI;QACf;;;;WAIG;QACH,IAAI,KAAK,GAA6C,CAAC,OAAO,EAAE,EAAE,GAAG,CAAC,CAAC;QAEvE,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,IAAmB,EAAE;YACvD,OAAO,IAAI,OAAO,CAAC,KAAK,CAAC,CAAC;QAC5B,CAAC,CAAC,CAAC;QAEH,OAAO,IAAI,OAAO,CAAC,CAAC,GAAG,EAAE,EAAE;YACzB,KAAK,GAAG,GAAG,CAAC;QACd,CAAC,CAAC,CAAC;IACL,CAAC;CACF;AAxBD,gCAwBC","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\n/**\n * Type of method to unlock the held mutex\n * @see [[AsyncMutex]]\n * @alpha\n */\nexport type AsyncMutexUnlockFnType = () => void;\n\n/**\n * Utility to ensure a block of async code executes atomically.\n * Even if JavaScript precludes the possibility of race conditions between threads, there is potential for\n * race conditions with async code. This utility is needed in cases where a block of async code needs to run\n * to completion before another block is started.\n * This utility was based on this article: https://spin.atomicobject.com/2018/09/10/javascript-concurrency/\n * @alpha\n */\nexport class AsyncMutex {\n  private _mutex = Promise.resolve();\n\n  /**\n   * Await the return value to setup a lock. The return value\n   * is also the unlock function that can be called to unlock\n   * the mutex.\n   */\n  public async lock(): Promise<AsyncMutexUnlockFnType> {\n    /**\n     * Note: The promise returned by this method will resolve (with the unlock function, which is actually the\n     * mutex’s then’s resolve function) once any previous mutexes have finished and called their\n     * respective unlock function that was yielded over their promise.\n     */\n    let begin: (unlock: AsyncMutexUnlockFnType) => void = (_unlock) => { };\n\n    this._mutex = this._mutex.then(async (): Promise<void> => {\n      return new Promise(begin);\n    });\n\n    return new Promise((res) => {\n      begin = res;\n    });\n  }\n}\n"]}
+{"version":3,"file":"AsyncMutex.js","sourceRoot":"","sources":["../../src/AsyncMutex.ts"],"names":[],"mappings":";AAAA;;;+FAG+F;AAC/F;;GAEG;;;AASH;;;;;;;GAOG;AACH,MAAa,UAAU;IAAvB;QACU,WAAM,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC;IAuBrC,CAAC;IArBC;;;;OAIG;IACI,KAAK,CAAC,IAAI;QACf;;;;WAIG;QACH,IAAI,KAAK,GAA6C,CAAC,OAAO,EAAE,EAAE,GAAG,CAAC,CAAC;QAEvE,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,IAAmB,EAAE;YACvD,OAAO,IAAI,OAAO,CAAC,KAAK,CAAC,CAAC;QAC5B,CAAC,CAAC,CAAC;QAEH,OAAO,IAAI,OAAO,CAAC,CAAC,GAAG,EAAE,EAAE;YACzB,KAAK,GAAG,GAAG,CAAC;QACd,CAAC,CAAC,CAAC;IACL,CAAC;CACF;AAxBD,gCAwBC","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\n/**\r\n * Type of method to unlock the held mutex\r\n * @see [[AsyncMutex]]\r\n * @alpha\r\n */\r\nexport type AsyncMutexUnlockFnType = () => void;\r\n\r\n/**\r\n * Utility to ensure a block of async code executes atomically.\r\n * Even if JavaScript precludes the possibility of race conditions between threads, there is potential for\r\n * race conditions with async code. This utility is needed in cases where a block of async code needs to run\r\n * to completion before another block is started.\r\n * This utility was based on this article: https://spin.atomicobject.com/2018/09/10/javascript-concurrency/\r\n * @alpha\r\n */\r\nexport class AsyncMutex {\r\n  private _mutex = Promise.resolve();\r\n\r\n  /**\r\n   * Await the return value to setup a lock. The return value\r\n   * is also the unlock function that can be called to unlock\r\n   * the mutex.\r\n   */\r\n  public async lock(): Promise<AsyncMutexUnlockFnType> {\r\n    /**\r\n     * Note: The promise returned by this method will resolve (with the unlock function, which is actually the\r\n     * mutex’s then’s resolve function) once any previous mutexes have finished and called their\r\n     * respective unlock function that was yielded over their promise.\r\n     */\r\n    let begin: (unlock: AsyncMutexUnlockFnType) => void = (_unlock) => { };\r\n\r\n    this._mutex = this._mutex.then(async (): Promise<void> => {\r\n      return new Promise(begin);\r\n    });\r\n\r\n    return new Promise((res) => {\r\n      begin = res;\r\n    });\r\n  }\r\n}\r\n"]}

package/lib/cjs/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 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;
+}
 //# sourceMappingURL=BeEvent.d.ts.map