@itwin/core-bentley 3.6.0-dev.65 → 3.6.0-dev.66

package/lib/esm/UnexpectedErrors.js

@@ -1,65 +1,65 @@
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-/** @packageDocumentation
- * @module Errors
- */
-var _a;
-import { Logger } from "./Logger";
-/**
- * Utility for handling/reporting unexpected runtime errors. This class establishes a global handler for
- * unexpected errors, and programmers should use its `handle` method when they occur. Generally, unexpected
- * errors should not cause program termination, and should instead be logged and swallowed. However, for
- * development/debugging, it can be helpful to re-throw exceptions so they are not missed.
- * @public
- */
-export class UnexpectedErrors {
-    constructor() { } // this is a singleton
-    /** Add a "telemetry tracker" for unexpected errors. Useful for tracking/reporting errors without changing handler.
-     * @returns a method to remove the tracker
-     */
-    static addTelemetry(tracker) {
-        this._telemetry.push(tracker);
-        return () => this._telemetry.splice(this._telemetry.indexOf(tracker), 1);
-    }
-    /** call this method when an unexpected error happens so the global handler can process it.
-     * @param error the unexpected error
-     * @param notifyTelemetry if false, don't notify telemetry trackers. Use this for exceptions from third-party code, for example.
-     */
-    static handle(error, notifyTelemetry = true) {
-        this._handler(error);
-        if (notifyTelemetry) {
-            this._telemetry.forEach((telemetry) => {
-                try {
-                    telemetry(error);
-                }
-                catch (_) {
-                    // ignore errors from telemetry trackers
-                }
-            });
-        }
-    }
-    /** establish a new global *unexpected error* handler.
-     * @param handler the new global handler. You may provide your own function or use one of the static members of this class.
-     * The default is [[errorLog]].
-     * @returns the previous handler. Useful to temporarily change the handler.
-     */
-    static setHandler(handler) {
-        const oldHandler = this._handler;
-        this._handler = handler;
-        return oldHandler;
-    }
-}
-_a = UnexpectedErrors;
-/** handler for re-throwing exceptions directly */
-UnexpectedErrors.reThrowImmediate = (e) => { throw e; };
-/** handler for re-throwing exceptions from an asynchronous interval (so the current call stack is not aborted) */
-UnexpectedErrors.reThrowDeferred = (e) => setTimeout(() => { throw e; }, 0);
-/** handler for logging exception to console */
-UnexpectedErrors.consoleLog = (e) => console.error(e); // eslint-disable-line no-console
-/** handler for logging exception with [[Logger]] */
-UnexpectedErrors.errorLog = (e) => Logger.logException("unhandled", e);
-UnexpectedErrors._telemetry = [];
-UnexpectedErrors._handler = _a.errorLog; // default to error logging
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module Errors
+ */
+var _a;
+import { Logger } from "./Logger";
+/**
+ * Utility for handling/reporting unexpected runtime errors. This class establishes a global handler for
+ * unexpected errors, and programmers should use its `handle` method when they occur. Generally, unexpected
+ * errors should not cause program termination, and should instead be logged and swallowed. However, for
+ * development/debugging, it can be helpful to re-throw exceptions so they are not missed.
+ * @public
+ */
+export class UnexpectedErrors {
+    constructor() { } // this is a singleton
+    /** Add a "telemetry tracker" for unexpected errors. Useful for tracking/reporting errors without changing handler.
+     * @returns a method to remove the tracker
+     */
+    static addTelemetry(tracker) {
+        this._telemetry.push(tracker);
+        return () => this._telemetry.splice(this._telemetry.indexOf(tracker), 1);
+    }
+    /** call this method when an unexpected error happens so the global handler can process it.
+     * @param error the unexpected error
+     * @param notifyTelemetry if false, don't notify telemetry trackers. Use this for exceptions from third-party code, for example.
+     */
+    static handle(error, notifyTelemetry = true) {
+        this._handler(error);
+        if (notifyTelemetry) {
+            this._telemetry.forEach((telemetry) => {
+                try {
+                    telemetry(error);
+                }
+                catch (_) {
+                    // ignore errors from telemetry trackers
+                }
+            });
+        }
+    }
+    /** establish a new global *unexpected error* handler.
+     * @param handler the new global handler. You may provide your own function or use one of the static members of this class.
+     * The default is [[errorLog]].
+     * @returns the previous handler. Useful to temporarily change the handler.
+     */
+    static setHandler(handler) {
+        const oldHandler = this._handler;
+        this._handler = handler;
+        return oldHandler;
+    }
+}
+_a = UnexpectedErrors;
+/** handler for re-throwing exceptions directly */
+UnexpectedErrors.reThrowImmediate = (e) => { throw e; };
+/** handler for re-throwing exceptions from an asynchronous interval (so the current call stack is not aborted) */
+UnexpectedErrors.reThrowDeferred = (e) => setTimeout(() => { throw e; }, 0);
+/** handler for logging exception to console */
+UnexpectedErrors.consoleLog = (e) => console.error(e); // eslint-disable-line no-console
+/** handler for logging exception with [[Logger]] */
+UnexpectedErrors.errorLog = (e) => Logger.logException("unhandled", e);
+UnexpectedErrors._telemetry = [];
+UnexpectedErrors._handler = _a.errorLog; // default to error logging
 //# sourceMappingURL=UnexpectedErrors.js.map

package/lib/esm/UnexpectedErrors.js.map

@@ -1 +1 @@
-{"version":3,"file":"UnexpectedErrors.js","sourceRoot":"","sources":["../../src/UnexpectedErrors.ts"],"names":[],"mappings":"AAAA;;;+FAG+F;AAC/F;;GAEG;;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAOlC;;;;;;GAMG;AACH,MAAM,OAAO,gBAAgB;IAY3B,gBAAwB,CAAC,CAAC,sBAAsB;IAEhD;;OAEG;IACI,MAAM,CAAC,YAAY,CAAC,OAA0B;QACnD,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAC9B,OAAO,GAAG,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC,CAAC;IAC3E,CAAC;IAED;;;OAGG;IACI,MAAM,CAAC,MAAM,CAAC,KAAU,EAAE,eAAe,GAAG,IAAI;QACrD,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;QACrB,IAAI,eAAe,EAAE;YACnB,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,SAAS,EAAE,EAAE;gBACpC,IAAI;oBACF,SAAS,CAAC,KAAK,CAAC,CAAC;iBAClB;gBAAC,OAAO,CAAC,EAAE;oBACV,wCAAwC;iBACzC;YACH,CAAC,CAAC,CAAC;SACJ;IACH,CAAC;IAED;;;;OAIG;IACI,MAAM,CAAC,UAAU,CAAC,OAA0B;QACjD,MAAM,UAAU,GAAG,IAAI,CAAC,QAAQ,CAAC;QACjC,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAC;QACxB,OAAO,UAAU,CAAC;IACpB,CAAC;;;AA/CD,kDAAkD;AAC3B,iCAAgB,GAAG,CAAC,CAAM,EAAE,EAAE,GAAG,MAAM,CAAC,CAAC,CAAC,CAAE,CAAA;AACnE,kHAAkH;AAC3F,gCAAe,GAAG,CAAC,CAAM,EAAE,EAAE,CAAC,UAAU,CAAC,GAAG,EAAE,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAE,CAAA;AACvF,+CAA+C;AACxB,2BAAU,GAAG,CAAC,CAAM,EAAE,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAE,CAAA,CAAC,iCAAiC;AACnG,oDAAoD;AAC7B,yBAAQ,GAAG,CAAC,CAAM,EAAE,EAAE,CAAC,MAAM,CAAC,YAAY,CAAC,WAAW,EAAE,CAAC,CAAE,CAAA;AAEnE,2BAAU,GAAwB,EAAG,CAAA;AACrC,yBAAQ,GAAG,EAAI,CAAC,QAAS,CAAA,CAAC,2BAA2B","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 Errors\n */\n\nimport { Logger } from \"./Logger\";\n\n/** A function to be notified when an unexpected error happens\n * @public\n */\nexport type OnUnexpectedError = (error: any) => void;\n\n/**\n * Utility for handling/reporting unexpected runtime errors. This class establishes a global handler for\n * unexpected errors, and programmers should use its `handle` method when they occur. Generally, unexpected\n * errors should not cause program termination, and should instead be logged and swallowed. However, for\n * development/debugging, it can be helpful to re-throw exceptions so they are not missed.\n * @public\n */\nexport class UnexpectedErrors {\n  /** handler for re-throwing exceptions directly */\n  public static readonly reThrowImmediate = (e: any) => { throw e; };\n  /** handler for re-throwing exceptions from an asynchronous interval (so the current call stack is not aborted) */\n  public static readonly reThrowDeferred = (e: any) => setTimeout(() => { throw e; }, 0);\n  /** handler for logging exception to console */\n  public static readonly consoleLog = (e: any) => console.error(e); // eslint-disable-line no-console\n  /** handler for logging exception with [[Logger]] */\n  public static readonly errorLog = (e: any) => Logger.logException(\"unhandled\", e);\n\n  private static _telemetry: OnUnexpectedError[] = [];\n  private static _handler = this.errorLog; // default to error logging\n  private constructor() { } // this is a singleton\n\n  /** Add a \"telemetry tracker\" for unexpected errors. Useful for tracking/reporting errors without changing handler.\n   * @returns a method to remove the tracker\n   */\n  public static addTelemetry(tracker: OnUnexpectedError): () => void {\n    this._telemetry.push(tracker);\n    return () => this._telemetry.splice(this._telemetry.indexOf(tracker), 1);\n  }\n\n  /** call this method when an unexpected error happens so the global handler can process it.\n   * @param error the unexpected error\n   * @param notifyTelemetry if false, don't notify telemetry trackers. Use this for exceptions from third-party code, for example.\n   */\n  public static handle(error: any, notifyTelemetry = true): void {\n    this._handler(error);\n    if (notifyTelemetry) {\n      this._telemetry.forEach((telemetry) => {\n        try {\n          telemetry(error);\n        } catch (_) {\n          // ignore errors from telemetry trackers\n        }\n      });\n    }\n  }\n\n  /** establish a new global *unexpected error* handler.\n   * @param handler the new global handler. You may provide your own function or use one of the static members of this class.\n   * The default is [[errorLog]].\n   * @returns the previous handler. Useful to temporarily change the handler.\n   */\n  public static setHandler(handler: OnUnexpectedError): OnUnexpectedError {\n    const oldHandler = this._handler;\n    this._handler = handler;\n    return oldHandler;\n  }\n}\n"]}
+{"version":3,"file":"UnexpectedErrors.js","sourceRoot":"","sources":["../../src/UnexpectedErrors.ts"],"names":[],"mappings":"AAAA;;;+FAG+F;AAC/F;;GAEG;;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAOlC;;;;;;GAMG;AACH,MAAM,OAAO,gBAAgB;IAY3B,gBAAwB,CAAC,CAAC,sBAAsB;IAEhD;;OAEG;IACI,MAAM,CAAC,YAAY,CAAC,OAA0B;QACnD,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAC9B,OAAO,GAAG,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC,CAAC;IAC3E,CAAC;IAED;;;OAGG;IACI,MAAM,CAAC,MAAM,CAAC,KAAU,EAAE,eAAe,GAAG,IAAI;QACrD,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;QACrB,IAAI,eAAe,EAAE;YACnB,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,SAAS,EAAE,EAAE;gBACpC,IAAI;oBACF,SAAS,CAAC,KAAK,CAAC,CAAC;iBAClB;gBAAC,OAAO,CAAC,EAAE;oBACV,wCAAwC;iBACzC;YACH,CAAC,CAAC,CAAC;SACJ;IACH,CAAC;IAED;;;;OAIG;IACI,MAAM,CAAC,UAAU,CAAC,OAA0B;QACjD,MAAM,UAAU,GAAG,IAAI,CAAC,QAAQ,CAAC;QACjC,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAC;QACxB,OAAO,UAAU,CAAC;IACpB,CAAC;;;AA/CD,kDAAkD;AAC3B,iCAAgB,GAAG,CAAC,CAAM,EAAE,EAAE,GAAG,MAAM,CAAC,CAAC,CAAC,CAAE,CAAA;AACnE,kHAAkH;AAC3F,gCAAe,GAAG,CAAC,CAAM,EAAE,EAAE,CAAC,UAAU,CAAC,GAAG,EAAE,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAE,CAAA;AACvF,+CAA+C;AACxB,2BAAU,GAAG,CAAC,CAAM,EAAE,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAE,CAAA,CAAC,iCAAiC;AACnG,oDAAoD;AAC7B,yBAAQ,GAAG,CAAC,CAAM,EAAE,EAAE,CAAC,MAAM,CAAC,YAAY,CAAC,WAAW,EAAE,CAAC,CAAE,CAAA;AAEnE,2BAAU,GAAwB,EAAG,CAAA;AACrC,yBAAQ,GAAG,EAAI,CAAC,QAAS,CAAA,CAAC,2BAA2B","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 Errors\r\n */\r\n\r\nimport { Logger } from \"./Logger\";\r\n\r\n/** A function to be notified when an unexpected error happens\r\n * @public\r\n */\r\nexport type OnUnexpectedError = (error: any) => void;\r\n\r\n/**\r\n * Utility for handling/reporting unexpected runtime errors. This class establishes a global handler for\r\n * unexpected errors, and programmers should use its `handle` method when they occur. Generally, unexpected\r\n * errors should not cause program termination, and should instead be logged and swallowed. However, for\r\n * development/debugging, it can be helpful to re-throw exceptions so they are not missed.\r\n * @public\r\n */\r\nexport class UnexpectedErrors {\r\n  /** handler for re-throwing exceptions directly */\r\n  public static readonly reThrowImmediate = (e: any) => { throw e; };\r\n  /** handler for re-throwing exceptions from an asynchronous interval (so the current call stack is not aborted) */\r\n  public static readonly reThrowDeferred = (e: any) => setTimeout(() => { throw e; }, 0);\r\n  /** handler for logging exception to console */\r\n  public static readonly consoleLog = (e: any) => console.error(e); // eslint-disable-line no-console\r\n  /** handler for logging exception with [[Logger]] */\r\n  public static readonly errorLog = (e: any) => Logger.logException(\"unhandled\", e);\r\n\r\n  private static _telemetry: OnUnexpectedError[] = [];\r\n  private static _handler = this.errorLog; // default to error logging\r\n  private constructor() { } // this is a singleton\r\n\r\n  /** Add a \"telemetry tracker\" for unexpected errors. Useful for tracking/reporting errors without changing handler.\r\n   * @returns a method to remove the tracker\r\n   */\r\n  public static addTelemetry(tracker: OnUnexpectedError): () => void {\r\n    this._telemetry.push(tracker);\r\n    return () => this._telemetry.splice(this._telemetry.indexOf(tracker), 1);\r\n  }\r\n\r\n  /** call this method when an unexpected error happens so the global handler can process it.\r\n   * @param error the unexpected error\r\n   * @param notifyTelemetry if false, don't notify telemetry trackers. Use this for exceptions from third-party code, for example.\r\n   */\r\n  public static handle(error: any, notifyTelemetry = true): void {\r\n    this._handler(error);\r\n    if (notifyTelemetry) {\r\n      this._telemetry.forEach((telemetry) => {\r\n        try {\r\n          telemetry(error);\r\n        } catch (_) {\r\n          // ignore errors from telemetry trackers\r\n        }\r\n      });\r\n    }\r\n  }\r\n\r\n  /** establish a new global *unexpected error* handler.\r\n   * @param handler the new global handler. You may provide your own function or use one of the static members of this class.\r\n   * The default is [[errorLog]].\r\n   * @returns the previous handler. Useful to temporarily change the handler.\r\n   */\r\n  public static setHandler(handler: OnUnexpectedError): OnUnexpectedError {\r\n    const oldHandler = this._handler;\r\n    this._handler = handler;\r\n    return oldHandler;\r\n  }\r\n}\r\n"]}

package/lib/esm/UtilityTypes.d.ts

@@ -1,97 +1,97 @@
-/** @packageDocumentation
- * @module Utils
- */
-/** The inverse of TypeScript's Readonly<T> type, producing a type that has all the properties of `T` with any `readonly` modifiers removed.
- * @public
- */
-export declare type Mutable<T> = {
-    -readonly [K in keyof T]: T[K];
-};
-/** Make a new type from an existing type `T`, with set of required properties `K` optional.
- * @public
- */
-export declare type Optional<T, K extends keyof T> = Pick<Partial<T>, K> & Omit<T, K>;
-/** Make a new type from an existing type `T`, with set of optional properties `K` required.
- * @public
- */
-export declare type MarkRequired<T, K extends keyof T> = Pick<Required<T>, K> & Omit<T, K>;
-/** Generically represents a class `T`, for use in type annotations.
- * @note A variable of type `Constructor<T>` matches a class `T` only if `T` has a **public** constructor.
- * @see [[asInstanceOf]] to attempt to cast an arbitrary value to class `T`.
- * @see [[isInstanceOf]] to determine if an arbitrary value is an instance of class `T`.
- * @public
- */
-export declare type Constructor<T> = new (...args: any[]) => T;
-/** Returns true if `obj` is an object of class `T`.
- * @see [[asInstanceOf]] to cast `obj` to class `T`.
- * @public
- */
-export declare function isInstanceOf<T>(obj: any, constructor: Constructor<T>): boolean;
-/** Cast `obj` to an instance of class `T`, or return undefined if `obj` is not an instance of class `T`.
- * @see [[isInstanceOf]] to query whether `obj` is of class `T`.
- * @public
- */
-export declare function asInstanceOf<T>(obj: any, constructor: Constructor<T>): T | undefined;
-/** Extracts the names of all public properties of `T` that are not of type `function`.
- * This includes properties defined using `get` syntax. Care should be used when using this type in conjunction with
- * the object spread (`...`) operator, because the spread operator omits properties defined using `get` syntax and, therefore,
- * so too does the type that TypeScript infers from that operator.
- * `get` syntax. For example:
- * ```ts
- *  class Thing {
- *     private _a = "a"; // a private variable
- *     public b = "b"; // a public variable
- *     public get c() { return "c"; } // a public property
- *     public d() { return "d"; } // a public method
- *     public e = () => "e"; // a public variable of type `function`
- *  }
- *
- *  // The following can have the values "b" or "c" - those are the public, non-function properties of Thing.
- *  let nonFunctionProperty: NonFunctionPropertyNamesOf<Thing> = "c";
- *
- *  // The following produces an error: "Property 'c' is missing in type '{ b: string; e: () => string; }' but required in type 'NonFunctionPropertiesOf<Thing>'"
- *  const thing1 = new Thing();
- *  const thing2: NonFunctionPropertiesOf<Thing> = { ...thing1 };
- * ```
- * @see [[NonFunctionPropertiesOf]] to obtain a type that includes only these properties.
- * @public
- */
-export declare type NonFunctionPropertyNamesOf<T> = {
-    [K in keyof T]: T[K] extends Function ? never : K;
-}[keyof T];
-/** Produces a type consisting of all of the public properties of `T` except for those of type `function`.
- * @see [[NonFunctionPropertyNamesOf]] for potential pitfalls when used in conjunction with the object spread operator.
- * @public
- */
-export declare type NonFunctionPropertiesOf<T> = Pick<T, NonFunctionPropertyNamesOf<T>>;
-/** Any function returning a Promise.
- * @see [[AsyncMethodsOf]] to extract all async methods from a type.
- * @see [[PromiseReturnType]] to extract the type to which the Promise resolves.
- * @public
- */
-export declare type AsyncFunction = (...args: any) => Promise<any>;
-/** The members of `T` that are async functions (functions that return a promise), and no other properties
- * @public
- */
-export declare type PickAsyncMethods<T> = {
-    [P in keyof T]: T[P] extends AsyncFunction ? T[P] : never;
-};
-/** Extracts the names of all function properties of `T` that return a Promise.
- * @public
- */
-export declare type AsyncMethodsOf<T> = {
-    [P in keyof T]: T[P] extends AsyncFunction ? P : never;
-}[keyof T];
-/** Extracts the type to which the Promise returned by an async function resolves.
- * @public
- */
-export declare type PromiseReturnType<T extends AsyncFunction> = T extends (...args: any) => Promise<infer R> ? R : any;
-/** A runtime property omitter, makes a shallow copy of the given object without the specified properties
- * Compatible with the typescript `Omit` mapped type:
- * ```js
- * const testvar: Omit<{x: string, y: object}, "y"> = omit({x: "hello", y: {}}, ["y"]);
- * ```
- * @public
- */
-export declare function omit<T extends {}, K extends readonly (keyof T)[]>(t: T, keys: K): Omit<T, K[number]>;
+/** @packageDocumentation
+ * @module Utils
+ */
+/** The inverse of TypeScript's Readonly<T> type, producing a type that has all the properties of `T` with any `readonly` modifiers removed.
+ * @public
+ */
+export declare type Mutable<T> = {
+    -readonly [K in keyof T]: T[K];
+};
+/** Make a new type from an existing type `T`, with set of required properties `K` optional.
+ * @public
+ */
+export declare type Optional<T, K extends keyof T> = Pick<Partial<T>, K> & Omit<T, K>;
+/** Make a new type from an existing type `T`, with set of optional properties `K` required.
+ * @public
+ */
+export declare type MarkRequired<T, K extends keyof T> = Pick<Required<T>, K> & Omit<T, K>;
+/** Generically represents a class `T`, for use in type annotations.
+ * @note A variable of type `Constructor<T>` matches a class `T` only if `T` has a **public** constructor.
+ * @see [[asInstanceOf]] to attempt to cast an arbitrary value to class `T`.
+ * @see [[isInstanceOf]] to determine if an arbitrary value is an instance of class `T`.
+ * @public
+ */
+export declare type Constructor<T> = new (...args: any[]) => T;
+/** Returns true if `obj` is an object of class `T`.
+ * @see [[asInstanceOf]] to cast `obj` to class `T`.
+ * @public
+ */
+export declare function isInstanceOf<T>(obj: any, constructor: Constructor<T>): boolean;
+/** Cast `obj` to an instance of class `T`, or return undefined if `obj` is not an instance of class `T`.
+ * @see [[isInstanceOf]] to query whether `obj` is of class `T`.
+ * @public
+ */
+export declare function asInstanceOf<T>(obj: any, constructor: Constructor<T>): T | undefined;
+/** Extracts the names of all public properties of `T` that are not of type `function`.
+ * This includes properties defined using `get` syntax. Care should be used when using this type in conjunction with
+ * the object spread (`...`) operator, because the spread operator omits properties defined using `get` syntax and, therefore,
+ * so too does the type that TypeScript infers from that operator.
+ * `get` syntax. For example:
+ * ```ts
+ *  class Thing {
+ *     private _a = "a"; // a private variable
+ *     public b = "b"; // a public variable
+ *     public get c() { return "c"; } // a public property
+ *     public d() { return "d"; } // a public method
+ *     public e = () => "e"; // a public variable of type `function`
+ *  }
+ *
+ *  // The following can have the values "b" or "c" - those are the public, non-function properties of Thing.
+ *  let nonFunctionProperty: NonFunctionPropertyNamesOf<Thing> = "c";
+ *
+ *  // The following produces an error: "Property 'c' is missing in type '{ b: string; e: () => string; }' but required in type 'NonFunctionPropertiesOf<Thing>'"
+ *  const thing1 = new Thing();
+ *  const thing2: NonFunctionPropertiesOf<Thing> = { ...thing1 };
+ * ```
+ * @see [[NonFunctionPropertiesOf]] to obtain a type that includes only these properties.
+ * @public
+ */
+export declare type NonFunctionPropertyNamesOf<T> = {
+    [K in keyof T]: T[K] extends Function ? never : K;
+}[keyof T];
+/** Produces a type consisting of all of the public properties of `T` except for those of type `function`.
+ * @see [[NonFunctionPropertyNamesOf]] for potential pitfalls when used in conjunction with the object spread operator.
+ * @public
+ */
+export declare type NonFunctionPropertiesOf<T> = Pick<T, NonFunctionPropertyNamesOf<T>>;
+/** Any function returning a Promise.
+ * @see [[AsyncMethodsOf]] to extract all async methods from a type.
+ * @see [[PromiseReturnType]] to extract the type to which the Promise resolves.
+ * @public
+ */
+export declare type AsyncFunction = (...args: any) => Promise<any>;
+/** The members of `T` that are async functions (functions that return a promise), and no other properties
+ * @public
+ */
+export declare type PickAsyncMethods<T> = {
+    [P in keyof T]: T[P] extends AsyncFunction ? T[P] : never;
+};
+/** Extracts the names of all function properties of `T` that return a Promise.
+ * @public
+ */
+export declare type AsyncMethodsOf<T> = {
+    [P in keyof T]: T[P] extends AsyncFunction ? P : never;
+}[keyof T];
+/** Extracts the type to which the Promise returned by an async function resolves.
+ * @public
+ */
+export declare type PromiseReturnType<T extends AsyncFunction> = T extends (...args: any) => Promise<infer R> ? R : any;
+/** A runtime property omitter, makes a shallow copy of the given object without the specified properties
+ * Compatible with the typescript `Omit` mapped type:
+ * ```js
+ * const testvar: Omit<{x: string, y: object}, "y"> = omit({x: "hello", y: {}}, ["y"]);
+ * ```
+ * @public
+ */
+export declare function omit<T extends {}, K extends readonly (keyof T)[]>(t: T, keys: K): Omit<T, K[number]>;
 //# sourceMappingURL=UtilityTypes.d.ts.map

package/lib/esm/UtilityTypes.js

@@ -1,35 +1,35 @@
-/*---------------------------------------------------------------------------------------------
-* 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
- */
-/** Returns true if `obj` is an object of class `T`.
- * @see [[asInstanceOf]] to cast `obj` to class `T`.
- * @public
- */
-export function isInstanceOf(obj, constructor) {
-    return "object" === typeof obj && obj instanceof constructor;
-}
-/** Cast `obj` to an instance of class `T`, or return undefined if `obj` is not an instance of class `T`.
- * @see [[isInstanceOf]] to query whether `obj` is of class `T`.
- * @public
- */
-export function asInstanceOf(obj, constructor) {
-    return isInstanceOf(obj, constructor) ? obj : undefined;
-}
-/** A runtime property omitter, makes a shallow copy of the given object without the specified properties
- * Compatible with the typescript `Omit` mapped type:
- * ```js
- * const testvar: Omit<{x: string, y: object}, "y"> = omit({x: "hello", y: {}}, ["y"]);
- * ```
- * @public
- */
-export function omit(t, keys) {
-    const clone = { ...t };
-    for (const key of keys)
-        delete clone[key];
-    return clone;
-}
+/*---------------------------------------------------------------------------------------------
+* 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
+ */
+/** Returns true if `obj` is an object of class `T`.
+ * @see [[asInstanceOf]] to cast `obj` to class `T`.
+ * @public
+ */
+export function isInstanceOf(obj, constructor) {
+    return "object" === typeof obj && obj instanceof constructor;
+}
+/** Cast `obj` to an instance of class `T`, or return undefined if `obj` is not an instance of class `T`.
+ * @see [[isInstanceOf]] to query whether `obj` is of class `T`.
+ * @public
+ */
+export function asInstanceOf(obj, constructor) {
+    return isInstanceOf(obj, constructor) ? obj : undefined;
+}
+/** A runtime property omitter, makes a shallow copy of the given object without the specified properties
+ * Compatible with the typescript `Omit` mapped type:
+ * ```js
+ * const testvar: Omit<{x: string, y: object}, "y"> = omit({x: "hello", y: {}}, ["y"]);
+ * ```
+ * @public
+ */
+export function omit(t, keys) {
+    const clone = { ...t };
+    for (const key of keys)
+        delete clone[key];
+    return clone;
+}
 //# sourceMappingURL=UtilityTypes.js.map

package/lib/esm/UtilityTypes.js.map

@@ -1 +1 @@
-{"version":3,"file":"UtilityTypes.js","sourceRoot":"","sources":["../../src/UtilityTypes.ts"],"names":[],"mappings":"AAAA;;;+FAG+F;AAC/F;;GAEG;AA2BH;;;GAGG;AACH,MAAM,UAAU,YAAY,CAAI,GAAQ,EAAE,WAA2B;IACnE,OAAO,QAAQ,KAAK,OAAO,GAAG,IAAI,GAAG,YAAY,WAAW,CAAC;AAC/D,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,YAAY,CAAI,GAAQ,EAAE,WAA2B;IACnE,OAAO,YAAY,CAAI,GAAG,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC,GAAQ,CAAC,CAAC,CAAC,SAAS,CAAC;AAClE,CAAC;AA0DD;;;;;;GAMG;AACH,MAAM,UAAU,IAAI,CAA+C,CAAI,EAAE,IAAO;IAC9E,MAAM,KAAK,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC;IACvB,KAAK,MAAM,GAAG,IAAI,IAAI;QACpB,OAAO,KAAK,CAAC,GAAG,CAAC,CAAC;IACpB,OAAO,KAAK,CAAC;AACf,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\n/** The inverse of TypeScript's Readonly<T> type, producing a type that has all the properties of `T` with any `readonly` modifiers removed.\n * @public\n */\nexport type Mutable<T> = {\n  -readonly [K in keyof T]: T[K];\n};\n\n/** Make a new type from an existing type `T`, with set of required properties `K` optional.\n * @public\n */\nexport type Optional<T, K extends keyof T> = Pick<Partial<T>, K> & Omit<T, K>;\n\n/** Make a new type from an existing type `T`, with set of optional properties `K` required.\n * @public\n */\nexport type MarkRequired<T, K extends keyof T> = Pick<Required<T>, K> & Omit<T, K>;\n\n/** Generically represents a class `T`, for use in type annotations.\n * @note A variable of type `Constructor<T>` matches a class `T` only if `T` has a **public** constructor.\n * @see [[asInstanceOf]] to attempt to cast an arbitrary value to class `T`.\n * @see [[isInstanceOf]] to determine if an arbitrary value is an instance of class `T`.\n * @public\n */\nexport type Constructor<T> = new (...args: any[]) => T;\n\n/** Returns true if `obj` is an object of class `T`.\n * @see [[asInstanceOf]] to cast `obj` to class `T`.\n * @public\n */\nexport function isInstanceOf<T>(obj: any, constructor: Constructor<T>): boolean {\n  return \"object\" === typeof obj && obj instanceof constructor;\n}\n\n/** Cast `obj` to an instance of class `T`, or return undefined if `obj` is not an instance of class `T`.\n * @see [[isInstanceOf]] to query whether `obj` is of class `T`.\n * @public\n */\nexport function asInstanceOf<T>(obj: any, constructor: Constructor<T>): T | undefined {\n  return isInstanceOf<T>(obj, constructor) ? obj as T : undefined;\n}\n\n/** Extracts the names of all public properties of `T` that are not of type `function`.\n * This includes properties defined using `get` syntax. Care should be used when using this type in conjunction with\n * the object spread (`...`) operator, because the spread operator omits properties defined using `get` syntax and, therefore,\n * so too does the type that TypeScript infers from that operator.\n * `get` syntax. For example:\n * ```ts\n *  class Thing {\n *     private _a = \"a\"; // a private variable\n *     public b = \"b\"; // a public variable\n *     public get c() { return \"c\"; } // a public property\n *     public d() { return \"d\"; } // a public method\n *     public e = () => \"e\"; // a public variable of type `function`\n *  }\n *\n *  // The following can have the values \"b\" or \"c\" - those are the public, non-function properties of Thing.\n *  let nonFunctionProperty: NonFunctionPropertyNamesOf<Thing> = \"c\";\n *\n *  // The following produces an error: \"Property 'c' is missing in type '{ b: string; e: () => string; }' but required in type 'NonFunctionPropertiesOf<Thing>'\"\n *  const thing1 = new Thing();\n *  const thing2: NonFunctionPropertiesOf<Thing> = { ...thing1 };\n * ```\n * @see [[NonFunctionPropertiesOf]] to obtain a type that includes only these properties.\n * @public\n */\nexport type NonFunctionPropertyNamesOf<T> = {\n  [K in keyof T]: T[K] extends Function ? never : K;\n}[keyof T];\n\n/** Produces a type consisting of all of the public properties of `T` except for those of type `function`.\n * @see [[NonFunctionPropertyNamesOf]] for potential pitfalls when used in conjunction with the object spread operator.\n * @public\n */\nexport type NonFunctionPropertiesOf<T> = Pick<T, NonFunctionPropertyNamesOf<T>>;\n\n/** Any function returning a Promise.\n * @see [[AsyncMethodsOf]] to extract all async methods from a type.\n * @see [[PromiseReturnType]] to extract the type to which the Promise resolves.\n * @public\n */\nexport type AsyncFunction = (...args: any) => Promise<any>;\n\n/** The members of `T` that are async functions (functions that return a promise), and no other properties\n * @public\n */\nexport type PickAsyncMethods<T> = { [P in keyof T]: T[P] extends AsyncFunction ? T[P] : never; };\n\n/** Extracts the names of all function properties of `T` that return a Promise.\n * @public\n */\nexport type AsyncMethodsOf<T> = { [P in keyof T]: T[P] extends AsyncFunction ? P : never }[keyof T];\n\n/** Extracts the type to which the Promise returned by an async function resolves.\n * @public\n */\nexport type PromiseReturnType<T extends AsyncFunction> = T extends (...args: any) => Promise<infer R> ? R : any;\n\n/** A runtime property omitter, makes a shallow copy of the given object without the specified properties\n * Compatible with the typescript `Omit` mapped type:\n * ```js\n * const testvar: Omit<{x: string, y: object}, \"y\"> = omit({x: \"hello\", y: {}}, [\"y\"]);\n * ```\n * @public\n */\nexport function omit<T extends {}, K extends readonly (keyof T)[]>(t: T, keys: K): Omit<T, K[number]> {\n  const clone = { ...t };\n  for (const key of keys)\n    delete clone[key];\n  return clone;\n}\n"]}
+{"version":3,"file":"UtilityTypes.js","sourceRoot":"","sources":["../../src/UtilityTypes.ts"],"names":[],"mappings":"AAAA;;;+FAG+F;AAC/F;;GAEG;AA2BH;;;GAGG;AACH,MAAM,UAAU,YAAY,CAAI,GAAQ,EAAE,WAA2B;IACnE,OAAO,QAAQ,KAAK,OAAO,GAAG,IAAI,GAAG,YAAY,WAAW,CAAC;AAC/D,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,YAAY,CAAI,GAAQ,EAAE,WAA2B;IACnE,OAAO,YAAY,CAAI,GAAG,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC,GAAQ,CAAC,CAAC,CAAC,SAAS,CAAC;AAClE,CAAC;AA0DD;;;;;;GAMG;AACH,MAAM,UAAU,IAAI,CAA+C,CAAI,EAAE,IAAO;IAC9E,MAAM,KAAK,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC;IACvB,KAAK,MAAM,GAAG,IAAI,IAAI;QACpB,OAAO,KAAK,CAAC,GAAG,CAAC,CAAC;IACpB,OAAO,KAAK,CAAC;AACf,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\n/** The inverse of TypeScript's Readonly<T> type, producing a type that has all the properties of `T` with any `readonly` modifiers removed.\r\n * @public\r\n */\r\nexport type Mutable<T> = {\r\n  -readonly [K in keyof T]: T[K];\r\n};\r\n\r\n/** Make a new type from an existing type `T`, with set of required properties `K` optional.\r\n * @public\r\n */\r\nexport type Optional<T, K extends keyof T> = Pick<Partial<T>, K> & Omit<T, K>;\r\n\r\n/** Make a new type from an existing type `T`, with set of optional properties `K` required.\r\n * @public\r\n */\r\nexport type MarkRequired<T, K extends keyof T> = Pick<Required<T>, K> & Omit<T, K>;\r\n\r\n/** Generically represents a class `T`, for use in type annotations.\r\n * @note A variable of type `Constructor<T>` matches a class `T` only if `T` has a **public** constructor.\r\n * @see [[asInstanceOf]] to attempt to cast an arbitrary value to class `T`.\r\n * @see [[isInstanceOf]] to determine if an arbitrary value is an instance of class `T`.\r\n * @public\r\n */\r\nexport type Constructor<T> = new (...args: any[]) => T;\r\n\r\n/** Returns true if `obj` is an object of class `T`.\r\n * @see [[asInstanceOf]] to cast `obj` to class `T`.\r\n * @public\r\n */\r\nexport function isInstanceOf<T>(obj: any, constructor: Constructor<T>): boolean {\r\n  return \"object\" === typeof obj && obj instanceof constructor;\r\n}\r\n\r\n/** Cast `obj` to an instance of class `T`, or return undefined if `obj` is not an instance of class `T`.\r\n * @see [[isInstanceOf]] to query whether `obj` is of class `T`.\r\n * @public\r\n */\r\nexport function asInstanceOf<T>(obj: any, constructor: Constructor<T>): T | undefined {\r\n  return isInstanceOf<T>(obj, constructor) ? obj as T : undefined;\r\n}\r\n\r\n/** Extracts the names of all public properties of `T` that are not of type `function`.\r\n * This includes properties defined using `get` syntax. Care should be used when using this type in conjunction with\r\n * the object spread (`...`) operator, because the spread operator omits properties defined using `get` syntax and, therefore,\r\n * so too does the type that TypeScript infers from that operator.\r\n * `get` syntax. For example:\r\n * ```ts\r\n *  class Thing {\r\n *     private _a = \"a\"; // a private variable\r\n *     public b = \"b\"; // a public variable\r\n *     public get c() { return \"c\"; } // a public property\r\n *     public d() { return \"d\"; } // a public method\r\n *     public e = () => \"e\"; // a public variable of type `function`\r\n *  }\r\n *\r\n *  // The following can have the values \"b\" or \"c\" - those are the public, non-function properties of Thing.\r\n *  let nonFunctionProperty: NonFunctionPropertyNamesOf<Thing> = \"c\";\r\n *\r\n *  // The following produces an error: \"Property 'c' is missing in type '{ b: string; e: () => string; }' but required in type 'NonFunctionPropertiesOf<Thing>'\"\r\n *  const thing1 = new Thing();\r\n *  const thing2: NonFunctionPropertiesOf<Thing> = { ...thing1 };\r\n * ```\r\n * @see [[NonFunctionPropertiesOf]] to obtain a type that includes only these properties.\r\n * @public\r\n */\r\nexport type NonFunctionPropertyNamesOf<T> = {\r\n  [K in keyof T]: T[K] extends Function ? never : K;\r\n}[keyof T];\r\n\r\n/** Produces a type consisting of all of the public properties of `T` except for those of type `function`.\r\n * @see [[NonFunctionPropertyNamesOf]] for potential pitfalls when used in conjunction with the object spread operator.\r\n * @public\r\n */\r\nexport type NonFunctionPropertiesOf<T> = Pick<T, NonFunctionPropertyNamesOf<T>>;\r\n\r\n/** Any function returning a Promise.\r\n * @see [[AsyncMethodsOf]] to extract all async methods from a type.\r\n * @see [[PromiseReturnType]] to extract the type to which the Promise resolves.\r\n * @public\r\n */\r\nexport type AsyncFunction = (...args: any) => Promise<any>;\r\n\r\n/** The members of `T` that are async functions (functions that return a promise), and no other properties\r\n * @public\r\n */\r\nexport type PickAsyncMethods<T> = { [P in keyof T]: T[P] extends AsyncFunction ? T[P] : never; };\r\n\r\n/** Extracts the names of all function properties of `T` that return a Promise.\r\n * @public\r\n */\r\nexport type AsyncMethodsOf<T> = { [P in keyof T]: T[P] extends AsyncFunction ? P : never }[keyof T];\r\n\r\n/** Extracts the type to which the Promise returned by an async function resolves.\r\n * @public\r\n */\r\nexport type PromiseReturnType<T extends AsyncFunction> = T extends (...args: any) => Promise<infer R> ? R : any;\r\n\r\n/** A runtime property omitter, makes a shallow copy of the given object without the specified properties\r\n * Compatible with the typescript `Omit` mapped type:\r\n * ```js\r\n * const testvar: Omit<{x: string, y: object}, \"y\"> = omit({x: \"hello\", y: {}}, [\"y\"]);\r\n * ```\r\n * @public\r\n */\r\nexport function omit<T extends {}, K extends readonly (keyof T)[]>(t: T, keys: K): Omit<T, K[number]> {\r\n  const clone = { ...t };\r\n  for (const key of keys)\r\n    delete clone[key];\r\n  return clone;\r\n}\r\n"]}

package/lib/esm/YieldManager.d.ts

@@ -1,19 +1,19 @@
-/** @internal options for constructing yield managers */
-export interface YieldManagerOptions {
-    iterationsBeforeYield?: number;
-}
-/**
- * @internal
- * An object allowing code to optionally yield with some frequency.
- * useful in some intense loops that make processes unresponsive.
- * primarily a workaround for: https://github.com/nodejs/node-addon-api/issues/1140
- * @note see [[defaultYieldManagerOptions]], the default amount of times it must be called to cause an actual yield is 1000
- */
-export declare class YieldManager {
-    options: Readonly<Required<YieldManagerOptions>>;
-    private _counter;
-    constructor(options?: YieldManagerOptions);
-    allowYield(): Promise<void>;
-    protected actualYield(): Promise<void>;
-}
+/** @internal options for constructing yield managers */
+export interface YieldManagerOptions {
+    iterationsBeforeYield?: number;
+}
+/**
+ * @internal
+ * An object allowing code to optionally yield with some frequency.
+ * useful in some intense loops that make processes unresponsive.
+ * primarily a workaround for: https://github.com/nodejs/node-addon-api/issues/1140
+ * @note see [[defaultYieldManagerOptions]], the default amount of times it must be called to cause an actual yield is 1000
+ */
+export declare class YieldManager {
+    options: Readonly<Required<YieldManagerOptions>>;
+    private _counter;
+    constructor(options?: YieldManagerOptions);
+    allowYield(): Promise<void>;
+    protected actualYield(): Promise<void>;
+}
 //# sourceMappingURL=YieldManager.d.ts.map

package/lib/esm/YieldManager.js

@@ -1,31 +1,31 @@
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-/** @internal the default options when constructing yield managers */
-const defaultYieldManagerOptions = {
-    iterationsBeforeYield: 1000,
-};
-/**
- * @internal
- * An object allowing code to optionally yield with some frequency.
- * useful in some intense loops that make processes unresponsive.
- * primarily a workaround for: https://github.com/nodejs/node-addon-api/issues/1140
- * @note see [[defaultYieldManagerOptions]], the default amount of times it must be called to cause an actual yield is 1000
- */
-export class YieldManager {
-    constructor(options = {}) {
-        this._counter = 0;
-        this.options = { ...defaultYieldManagerOptions, ...options };
-    }
-    async allowYield() {
-        this._counter = (this._counter + 1) % this.options.iterationsBeforeYield;
-        if (this._counter === 0) {
-            await this.actualYield();
-        }
-    }
-    async actualYield() {
-        await new Promise((r) => setTimeout(r, 0));
-    }
-}
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @internal the default options when constructing yield managers */
+const defaultYieldManagerOptions = {
+    iterationsBeforeYield: 1000,
+};
+/**
+ * @internal
+ * An object allowing code to optionally yield with some frequency.
+ * useful in some intense loops that make processes unresponsive.
+ * primarily a workaround for: https://github.com/nodejs/node-addon-api/issues/1140
+ * @note see [[defaultYieldManagerOptions]], the default amount of times it must be called to cause an actual yield is 1000
+ */
+export class YieldManager {
+    constructor(options = {}) {
+        this._counter = 0;
+        this.options = { ...defaultYieldManagerOptions, ...options };
+    }
+    async allowYield() {
+        this._counter = (this._counter + 1) % this.options.iterationsBeforeYield;
+        if (this._counter === 0) {
+            await this.actualYield();
+        }
+    }
+    async actualYield() {
+        await new Promise((r) => setTimeout(r, 0));
+    }
+}
 //# sourceMappingURL=YieldManager.js.map

package/lib/esm/YieldManager.js.map

@@ -1 +1 @@
-{"version":3,"file":"YieldManager.js","sourceRoot":"","sources":["../../src/YieldManager.ts"],"names":[],"mappings":"AAAA;;;+FAG+F;AAO/F,qEAAqE;AACrE,MAAM,0BAA0B,GAAkC;IAChE,qBAAqB,EAAE,IAAI;CAC5B,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,OAAO,YAAY;IAIvB,YAAmB,UAA+B,EAAE;QAF5C,aAAQ,GAAG,CAAC,CAAC;QAGnB,IAAI,CAAC,OAAO,GAAG,EAAE,GAAG,0BAA0B,EAAE,GAAG,OAAO,EAAE,CAAC;IAC/D,CAAC;IAEM,KAAK,CAAC,UAAU;QACrB,IAAI,CAAC,QAAQ,GAAG,CAAC,IAAI,CAAC,QAAQ,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,qBAAqB,CAAC;QACzE,IAAI,IAAI,CAAC,QAAQ,KAAK,CAAC,EAAE;YACvB,MAAM,IAAI,CAAC,WAAW,EAAE,CAAC;SAC1B;IACH,CAAC;IAES,KAAK,CAAC,WAAW;QACzB,MAAM,IAAI,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IAC7C,CAAC;CACF","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\n/** @internal options for constructing yield managers */\nexport interface YieldManagerOptions {\n  iterationsBeforeYield?: number;\n}\n\n/** @internal the default options when constructing yield managers */\nconst defaultYieldManagerOptions: Required<YieldManagerOptions> = {\n  iterationsBeforeYield: 1000,\n};\n\n/**\n * @internal\n * An object allowing code to optionally yield with some frequency.\n * useful in some intense loops that make processes unresponsive.\n * primarily a workaround for: https://github.com/nodejs/node-addon-api/issues/1140\n * @note see [[defaultYieldManagerOptions]], the default amount of times it must be called to cause an actual yield is 1000\n */\nexport class YieldManager {\n  public options: Readonly<Required<YieldManagerOptions>>;\n  private _counter = 0;\n\n  public constructor(options: YieldManagerOptions = {}) {\n    this.options = { ...defaultYieldManagerOptions, ...options };\n  }\n\n  public async allowYield() {\n    this._counter = (this._counter + 1) % this.options.iterationsBeforeYield;\n    if (this._counter === 0) {\n      await this.actualYield();\n    }\n  }\n\n  protected async actualYield() {\n    await new Promise((r) => setTimeout(r, 0));\n  }\n}\n"]}
+{"version":3,"file":"YieldManager.js","sourceRoot":"","sources":["../../src/YieldManager.ts"],"names":[],"mappings":"AAAA;;;+FAG+F;AAO/F,qEAAqE;AACrE,MAAM,0BAA0B,GAAkC;IAChE,qBAAqB,EAAE,IAAI;CAC5B,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,OAAO,YAAY;IAIvB,YAAmB,UAA+B,EAAE;QAF5C,aAAQ,GAAG,CAAC,CAAC;QAGnB,IAAI,CAAC,OAAO,GAAG,EAAE,GAAG,0BAA0B,EAAE,GAAG,OAAO,EAAE,CAAC;IAC/D,CAAC;IAEM,KAAK,CAAC,UAAU;QACrB,IAAI,CAAC,QAAQ,GAAG,CAAC,IAAI,CAAC,QAAQ,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,qBAAqB,CAAC;QACzE,IAAI,IAAI,CAAC,QAAQ,KAAK,CAAC,EAAE;YACvB,MAAM,IAAI,CAAC,WAAW,EAAE,CAAC;SAC1B;IACH,CAAC;IAES,KAAK,CAAC,WAAW;QACzB,MAAM,IAAI,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IAC7C,CAAC;CACF","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\r\n/** @internal options for constructing yield managers */\r\nexport interface YieldManagerOptions {\r\n  iterationsBeforeYield?: number;\r\n}\r\n\r\n/** @internal the default options when constructing yield managers */\r\nconst defaultYieldManagerOptions: Required<YieldManagerOptions> = {\r\n  iterationsBeforeYield: 1000,\r\n};\r\n\r\n/**\r\n * @internal\r\n * An object allowing code to optionally yield with some frequency.\r\n * useful in some intense loops that make processes unresponsive.\r\n * primarily a workaround for: https://github.com/nodejs/node-addon-api/issues/1140\r\n * @note see [[defaultYieldManagerOptions]], the default amount of times it must be called to cause an actual yield is 1000\r\n */\r\nexport class YieldManager {\r\n  public options: Readonly<Required<YieldManagerOptions>>;\r\n  private _counter = 0;\r\n\r\n  public constructor(options: YieldManagerOptions = {}) {\r\n    this.options = { ...defaultYieldManagerOptions, ...options };\r\n  }\r\n\r\n  public async allowYield() {\r\n    this._counter = (this._counter + 1) % this.options.iterationsBeforeYield;\r\n    if (this._counter === 0) {\r\n      await this.actualYield();\r\n    }\r\n  }\r\n\r\n  protected async actualYield() {\r\n    await new Promise((r) => setTimeout(r, 0));\r\n  }\r\n}\r\n"]}