@itwin/core-bentley 3.4.0-dev.9 → 3.5.0-dev.5

package/lib/esm/TypedArrayBuilder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TypedArrayBuilder.js","sourceRoot":"","sources":["../../src/TypedArrayBuilder.ts"],"names":[],"mappings":"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","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 Collections\n */\n\nimport { Constructor } from \"./UtilityTypes\";\nimport { assert } from \"./Assert\";\n\n/** Options used to construct a [[TypedArrayBuilder]].\n * @public\n */\nexport interface TypedArrayBuilderOptions {\n  /** Controls how much additional memory is allocated when the TypedArray needs to be resized to accomodate more elements.\n   * [[TypedArrayBuilder.ensureCapacity]] multiplies the required capacity by this factor to determine the new capacity.\n   * Default: 1.5\n   * Minimum: 1.0, which causes the TypedArray to allocate exactly the space it needs each time it is resized.\n   */\n  growthFactor?: number;\n  /** The number of elements to allocate memory for in the TypedArray when creating the builder.\n   * If you know the minimum number of elements you intend to add to the builder, you should specify that as the\n   * initial capacity to avoid reallocations when populating the array.\n   * Default: 0.\n   * Minimum: 0.\n   */\n  initialCapacity?: number;\n}\n\n/** Incrementally builds a [TypedArray] of unsigned 8-, 16-, or 32-bit integers.\n * Sometimes you wish to populate a `TypedArray`, but you don't know how many elements you will need.\n * `TypedArray` requires you to specify the size upon construction, and does not permit you to change the size later.\n *\n * `TypedArrayBuilder` manages a `TypedArray`, permitting you to [[push]] and [[append]] elements to it. It exposes two \"size\" properties\":\n *  - [[capacity]], the number of elements it has currently allocated space for - i.e., the length of the underlying TypedArray; and\n *  - [[length]], the number of elements that have so far been added to it, which is never bigger than [[capacity]].\n * When [[capacity]] is exceeded, a new, bigger TypedArray is allocated and the contents of the previous array are copied over to it.\n *\n * Once you've finished adding elements, you can obtain the finished `TypedArray` via [[toTypedArray]].\n * @see [[Uint8ArrayBuilder]], [[Uint16ArrayBuilder]], and [[Uint32ArrayBuilder]] to build specific types of arrays.\n * @public\n */\nexport class TypedArrayBuilder<T extends Uint8Array | Uint16Array | Uint32Array> {\n  /** The constructor for the specific type of array being populated. */\n  protected readonly _constructor: Constructor<T>;\n  /** The underlying typed array, to be reallocated and copied when its capacity is exceeded. */\n  protected _data: T;\n  /** The number of elements added to the array so far. */\n  protected _length: number;\n  /** Multiplier applied to required capacity by [[ensureCapacity]]. */\n  public readonly growthFactor: number;\n\n  /** Constructs a new builder from the specified options, with a [[length]] of zero. */\n  protected constructor(constructor: Constructor<T>, options?: TypedArrayBuilderOptions) {\n    this._constructor = constructor;\n    this._data = new constructor(options?.initialCapacity ?? 0);\n    this.growthFactor = Math.max(1.0, options?.growthFactor ?? 1.5);\n    this._length = 0;\n  }\n\n  /** The number of elements currently in the array. */\n  public get length(): number {\n    return this._length;\n  }\n\n  /** The number of elements that can fit into the memory currently allocated for the array. */\n  public get capacity(): number {\n    return this._data.length;\n  }\n\n  /** Like [TypedArray.at](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/at),\n   * returns the element at the specified index, with negative integers counting back from the end of the array.\n   * @note It is your responsibility to ensure the index falls within the bounds of the array.\n   */\n  public at(index: number): number {\n    if (index < 0)\n      index = this.length - index;\n\n    const value = this._data[index];\n    assert(value !== undefined, \"index out of bounds\");\n    return value;\n  }\n\n  /** Ensure that [[capacity]] is at least equal to `newCapacity`.\n   * This is used internally by methods like [[push]] and [[append]] to ensure the array has room for the element(s) to be added.\n   * It can also be useful when you know you intend to add some number of additional elements, to minimize reallocations.\n   *\n   * If `newCapacity` is not greater than the current [[capacity]], this function does nothing.\n   * Otherwise, it allocates a new `TypedArray` with room for `newCapacity * growthFactor` elements, and copies the contents of the previous `TypedArray` into it.\n   * [[length]] remains unchanged; [[capacity]] reflects the size of the new TypeArray.\n   */\n  public ensureCapacity(newCapacity: number): number {\n    if (this.capacity >= newCapacity)\n      return this.capacity;\n\n    assert(this.growthFactor >= 1.0);\n    newCapacity = Math.ceil(newCapacity * this.growthFactor);\n    const prevData = this._data;\n    this._data = new this._constructor(newCapacity);\n    this._data.set(prevData, 0);\n\n    assert(this.capacity === newCapacity);\n    return this.capacity;\n  }\n\n  /** Append the specified value, resizing if necessary. */\n  public push(value: number): void {\n    this.ensureCapacity(this.length + 1);\n    this._data[this.length] = value;\n    ++this._length;\n  }\n\n  /** Append an array of values, resizing (at most once) if necessary. */\n  public append(values: T): void {\n    const newLength = this.length + values.length;\n    this.ensureCapacity(newLength);\n    this._data.set(values, this.length);\n    this._length = newLength;\n  }\n\n  /** Obtain the finished array.\n   * @param includeUnusedCapacity If true, the length of the returned array will be equal to [[capacity]], with extra bytes initialized to zero; otherwise, the\n   * returned array's length will be equal to [[length]].\n   */\n  public toTypedArray(includeUnusedCapacity = false): T {\n    if (includeUnusedCapacity)\n      return this._data;\n\n    const subarray = this._data.subarray(0, this.length);\n    assert(subarray instanceof this._constructor);\n    assert(subarray.buffer === this._data.buffer);\n    return subarray;\n  }\n}\n\n/** A [[TypedArrayBuilder]] for producing a [Uint8Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array).\n * @public\n */\nexport class Uint8ArrayBuilder extends TypedArrayBuilder<Uint8Array> {\n  /** @see [[TypedArrayBuilder]] constructor. */\n  public constructor(options?: TypedArrayBuilderOptions) {\n    super(Uint8Array, options);\n  }\n}\n\n/** A [[TypedArrayBuilder]] for producing a [Uint16Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint16Array).\n * @public\n */\nexport class Uint16ArrayBuilder extends TypedArrayBuilder<Uint16Array> {\n  /** @see [[TypedArrayBuilder]] constructor. */\n  public constructor(options?: TypedArrayBuilderOptions) {\n    super(Uint16Array, options);\n  }\n}\n\n/** A [[TypedArrayBuilder]] for producing a [Uint32Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint32Array).\n * @public\n */\nexport class Uint32ArrayBuilder extends TypedArrayBuilder<Uint32Array> {\n  /** @see [[TypedArrayBuilder]] constructor. */\n  public constructor(options?: TypedArrayBuilderOptions) {\n    super(Uint32Array, options);\n  }\n\n  /** Obtain a view of the finished array as an array of bytes. */\n  public toUint8Array(includeUnusedCapacity = false): Uint8Array {\n    if (includeUnusedCapacity)\n      return new Uint8Array(this._data.buffer);\n\n    return new Uint8Array(this._data.buffer, 0, this.length * 4);\n  }\n}\n"]}

package/lib/esm/UnexpectedErrors.d.ts

@@ -1,44 +1,44 @@
-/** @packageDocumentation
- * @module Errors
- */
-/// <reference types="node" />
-/** A function to be notified when an unexpected error happens
- * @public
- */
-export declare type OnUnexpectedError = (error: any) => void;
-/**
- * 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 declare class UnexpectedErrors {
-    /** handler for re-throwing exceptions directly */
-    static readonly reThrowImmediate: (e: any) => never;
-    /** handler for re-throwing exceptions from an asynchronous interval (so the current call stack is not aborted) */
-    static readonly reThrowDeferred: (e: any) => NodeJS.Timeout;
-    /** handler for logging exception to console */
-    static readonly consoleLog: (e: any) => void;
-    /** handler for logging exception with [[Logger]] */
-    static readonly errorLog: (e: any) => void;
-    private static _telemetry;
-    private static _handler;
-    private constructor();
-    /** 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: OnUnexpectedError): () => void;
-    /** 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: any, notifyTelemetry?: boolean): void;
-    /** 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: OnUnexpectedError): OnUnexpectedError;
-}
+/** @packageDocumentation
+ * @module Errors
+ */
+/// <reference types="node" />
+/** A function to be notified when an unexpected error happens
+ * @public
+ */
+export declare type OnUnexpectedError = (error: any) => void;
+/**
+ * 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 declare class UnexpectedErrors {
+    /** handler for re-throwing exceptions directly */
+    static readonly reThrowImmediate: (e: any) => never;
+    /** handler for re-throwing exceptions from an asynchronous interval (so the current call stack is not aborted) */
+    static readonly reThrowDeferred: (e: any) => NodeJS.Timeout;
+    /** handler for logging exception to console */
+    static readonly consoleLog: (e: any) => void;
+    /** handler for logging exception with [[Logger]] */
+    static readonly errorLog: (e: any) => void;
+    private static _telemetry;
+    private static _handler;
+    private constructor();
+    /** 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: OnUnexpectedError): () => void;
+    /** 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: any, notifyTelemetry?: boolean): void;
+    /** 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: OnUnexpectedError): OnUnexpectedError;
+}
 //# sourceMappingURL=UnexpectedErrors.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"UnexpectedErrors.d.ts","sourceRoot":"","sources":["../../src/UnexpectedErrors.ts"],"names":[],"mappings":"AAIA;;GAEG;;AAIH;;GAEG;AACH,oBAAY,iBAAiB,GAAG,CAAC,KAAK,EAAE,GAAG,KAAK,IAAI,CAAC;AAErD;;;;;;GAMG;AACH,qBAAa,gBAAgB;IAC3B,kDAAkD;IAClD,gBAAuB,gBAAgB,MAAO,GAAG,WAAkB;IACnE,kHAAkH;IAClH,gBAAuB,eAAe,MAAO,GAAG,oBAAuC;IACvF,+CAA+C;IAC/C,gBAAuB,UAAU,MAAO,GAAG,UAAsB;IACjE,oDAAoD;IACpD,gBAAuB,QAAQ,MAAO,GAAG,UAAyC;IAElF,OAAO,CAAC,MAAM,CAAC,UAAU,CAA2B;IACpD,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAiB;IACxC,OAAO;IAEP;;OAEG;WACW,YAAY,CAAC,OAAO,EAAE,iBAAiB,GAAG,MAAM,IAAI;IAKlE;;;OAGG;WACW,MAAM,CAAC,KAAK,EAAE,GAAG,EAAE,eAAe,UAAO,GAAG,IAAI;IAQ9D;;;;OAIG;WACW,UAAU,CAAC,OAAO,EAAE,iBAAiB,GAAG,iBAAiB;CAKxE"}
+{"version":3,"file":"UnexpectedErrors.d.ts","sourceRoot":"","sources":["../../src/UnexpectedErrors.ts"],"names":[],"mappings":"AAIA;;GAEG;;AAIH;;GAEG;AACH,oBAAY,iBAAiB,GAAG,CAAC,KAAK,EAAE,GAAG,KAAK,IAAI,CAAC;AAErD;;;;;;GAMG;AACH,qBAAa,gBAAgB;IAC3B,kDAAkD;IAClD,gBAAuB,gBAAgB,MAAO,GAAG,WAAkB;IACnE,kHAAkH;IAClH,gBAAuB,eAAe,MAAO,GAAG,oBAAuC;IACvF,+CAA+C;IAC/C,gBAAuB,UAAU,MAAO,GAAG,UAAsB;IACjE,oDAAoD;IACpD,gBAAuB,QAAQ,MAAO,GAAG,UAAyC;IAElF,OAAO,CAAC,MAAM,CAAC,UAAU,CAA2B;IACpD,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAiB;IACxC,OAAO;IAEP;;OAEG;WACW,YAAY,CAAC,OAAO,EAAE,iBAAiB,GAAG,MAAM,IAAI;IAKlE;;;OAGG;WACW,MAAM,CAAC,KAAK,EAAE,GAAG,EAAE,eAAe,UAAO,GAAG,IAAI;IAa9D;;;;OAIG;WACW,UAAU,CAAC,OAAO,EAAE,iBAAiB,GAAG,iBAAiB;CAKxE"}

package/lib/esm/UnexpectedErrors.js

@@ -1,62 +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;YACjB,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,SAAS,EAAE,EAAE;gBACpC,IAAI;oBAAE,SAAS,CAAC,KAAK,CAAC,CAAC;iBAAE;gBAAC,OAAO,CAAC,EAAE,GAAG,CAAC,wCAAwC;YAClF,CAAC,CAAC,CAAC;IACP,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;;;AA1CD,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 { telemetry(error); } catch (_) { } // ignore errors from telemetry trackers\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"]}
+{"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"]}

package/lib/esm/UtilityTypes.d.ts

@@ -1,87 +1,87 @@
-/** @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>;
-/** 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;
-/** Extracts a subset of literals `U` from a union of literals `T` in a type-safe way.
- * @beta
- */
-export declare type ExtractLiterals<T, U extends T> = Extract<T, U>;
+/** @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>;
+/** 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;
+/** Extracts a subset of literals `U` from a union of literals `T` in a type-safe way.
+ * @beta
+ */
+export declare type ExtractLiterals<T, U extends T> = Extract<T, U>;
 //# sourceMappingURL=UtilityTypes.d.ts.map

package/lib/esm/UtilityTypes.js

@@ -1,22 +1,22 @@
-/*---------------------------------------------------------------------------------------------
-* 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;
-}
+/*---------------------------------------------------------------------------------------------
+* 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;
+}
 //# 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","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/** 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/** Extracts a subset of literals `U` from a union of literals `T` in a type-safe way.\r\n * @beta\r\n */\r\nexport type ExtractLiterals<T, U extends T> = Extract<T, U>;\r\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","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/** 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/** Extracts a subset of literals `U` from a union of literals `T` in a type-safe way.\n * @beta\n */\nexport type ExtractLiterals<T, U extends T> = Extract<T, U>;\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