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

package/lib/cjs/TypedArrayBuilder.js

@@ -1,209 +1,207 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-/** @packageDocumentation
- * @module Collections
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UintArrayBuilder = exports.Uint32ArrayBuilder = exports.Uint16ArrayBuilder = exports.Uint8ArrayBuilder = exports.TypedArrayBuilder = void 0;
-const Assert_1 = require("./Assert");
-/** Incrementally builds a [TypedArray](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray) of unsigned 8-, 16-, or 32-bit integers.
- * Sometimes you wish to populate a `TypedArray`, but you don't know how many elements you will need.
- * `TypedArray` requires you to specify the size upon construction, and does not permit you to change the size later.
- *
- * `TypedArrayBuilder` manages a `TypedArray`, permitting you to [[push]] and [[append]] elements to it. It exposes two "size" properties":
- *  - [[capacity]], the number of elements it has currently allocated space for - i.e., the length of the underlying TypedArray; and
- *  - [[length]], the number of elements that have so far been added to it, which is never bigger than [[capacity]].
- * When [[capacity]] is exceeded, a new, bigger TypedArray is allocated and the contents of the previous array are copied over to it.
- *
- * Once you've finished adding elements, you can obtain the finished `TypedArray` via [[toTypedArray]].
- * @see [[Uint8ArrayBuilder]], [[Uint16ArrayBuilder]], and [[Uint32ArrayBuilder]] to build specific types of arrays.
- * @see [[UintArrayBuilder]] when you don't know the maximum number of bytes required for each element in the array.
- * @public
- */
-class TypedArrayBuilder {
-    /** Constructs a new builder from the specified options, with a [[length]] of zero. */
-    constructor(constructor, options) {
-        var _a, _b;
-        this._constructor = constructor;
-        this._data = new constructor((_a = options === null || options === void 0 ? void 0 : options.initialCapacity) !== null && _a !== void 0 ? _a : 0);
-        this.growthFactor = Math.max(1.0, (_b = options === null || options === void 0 ? void 0 : options.growthFactor) !== null && _b !== void 0 ? _b : 1.5);
-        this._length = 0;
-    }
-    /** The number of elements currently in the array. */
-    get length() {
-        return this._length;
-    }
-    /** The number of elements that can fit into the memory currently allocated for the array. */
-    get capacity() {
-        return this._data.length;
-    }
-    /** Like [TypedArray.at](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/at),
-     * returns the element at the specified index, with negative integers counting back from the end of the array.
-     * @note It is your responsibility to ensure the index falls within the bounds of the array.
-     */
-    at(index) {
-        if (index < 0)
-            index = this.length - index;
-        const value = this._data[index];
-        (0, Assert_1.assert)(value !== undefined, "index out of bounds");
-        return value;
-    }
-    /** Ensure that [[capacity]] is at least equal to `newCapacity`.
-     * This is used internally by methods like [[push]] and [[append]] to ensure the array has room for the element(s) to be added.
-     * It can also be useful when you know you intend to add some number of additional elements, to minimize reallocations.
-     *
-     * If `newCapacity` is not greater than the current [[capacity]], this function does nothing.
-     * Otherwise, it allocates a new `TypedArray` with room for `newCapacity * growthFactor` elements, and copies the contents of the previous `TypedArray` into it.
-     * [[length]] remains unchanged; [[capacity]] reflects the size of the new TypeArray.
-     */
-    ensureCapacity(newCapacity) {
-        if (this.capacity >= newCapacity)
-            return this.capacity;
-        (0, Assert_1.assert)(this.growthFactor >= 1.0);
-        newCapacity = Math.ceil(newCapacity * this.growthFactor);
-        const prevData = this._data;
-        this._data = new this._constructor(newCapacity);
-        this._data.set(prevData, 0);
-        (0, Assert_1.assert)(this.capacity === newCapacity);
-        return this.capacity;
-    }
-    /** Append the specified value, resizing if necessary. */
-    push(value) {
-        this.ensureCapacity(this.length + 1);
-        this._data[this.length] = value;
-        ++this._length;
-    }
-    /** Append an array of values, resizing (at most once) if necessary. */
-    append(values) {
-        const newLength = this.length + values.length;
-        this.ensureCapacity(newLength);
-        this._data.set(values, this.length);
-        this._length = newLength;
-    }
-    /** Obtain the finished array.
-     * @param includeUnusedCapacity If true, the length of the returned array will be equal to [[capacity]], with extra bytes initialized to zero; otherwise, the
-     * returned array's length will be equal to [[length]].
-     */
-    toTypedArray(includeUnusedCapacity = false) {
-        if (includeUnusedCapacity)
-            return this._data;
-        const subarray = this._data.subarray(0, this.length);
-        (0, Assert_1.assert)(subarray instanceof this._constructor);
-        (0, Assert_1.assert)(subarray.buffer === this._data.buffer);
-        return subarray;
-    }
-}
-exports.TypedArrayBuilder = TypedArrayBuilder;
-/** A [[TypedArrayBuilder]] for producing a [Uint8Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array).
- * @public
- */
-class Uint8ArrayBuilder extends TypedArrayBuilder {
-    /** See [[TypedArrayBuilder]] constructor. */
-    constructor(options) {
-        super(Uint8Array, options);
-    }
-}
-exports.Uint8ArrayBuilder = Uint8ArrayBuilder;
-/** A [[TypedArrayBuilder]] for producing a [Uint16Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint16Array).
- * @public
- */
-class Uint16ArrayBuilder extends TypedArrayBuilder {
-    /** See [[TypedArrayBuilder]] constructor. */
-    constructor(options) {
-        super(Uint16Array, options);
-    }
-}
-exports.Uint16ArrayBuilder = Uint16ArrayBuilder;
-/** A [[TypedArrayBuilder]] for producing a [Uint32Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint32Array).
- * @public
- */
-class Uint32ArrayBuilder extends TypedArrayBuilder {
-    /** See [[TypedArrayBuilder]] constructor. */
-    constructor(options) {
-        super(Uint32Array, options);
-    }
-    /** Obtain a view of the finished array as an array of bytes. */
-    toUint8Array(includeUnusedCapacity = false) {
-        if (includeUnusedCapacity)
-            return new Uint8Array(this._data.buffer);
-        return new Uint8Array(this._data.buffer, 0, this.length * 4);
-    }
-}
-exports.Uint32ArrayBuilder = Uint32ArrayBuilder;
-/** A [[TypedArrayBuilder]] that can populate a [[UintArray]] with the minimum
- * [bytes per element](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/BYTES_PER_ELEMENT) required.
- *
- * By default, the underlying array is a `Uint8Array`, though this can be configured via [[UintArrayBuilderOptions.initialType]].
- * As values are added to the array, if the bytes per element supported by the underlying array is too small to hold one of the new values, the array is
- * reallocated to a type large enough to hold all of the new values. For example, the following produces a `Uint8Array` because all values are less than 256:
- *
- * ```ts
- *  const builder = new UintArrayBuilder();
- *  builder.append([1, 2, 254, 255]);
- *  const array = builder.toTypedArray();
- *  assert(array instanceof Uint8Array);
- * ```
- *
- * However, the following produces a `Uint16Array` because one of the values is larger than 255 but none are larger than 65,535:
- *
- * ```ts
- *  const builder = new UintArrayBuilder();
- *  builder.append([1, 255, 257, 65535]);
- *  const array = builder.toTypedArray();
- *  assert(array instanceof Uint16Array);
- * ```
- *
- * @see [[Uint8ArrayBuilder]], [[Uint16ArrayBuilder]], or [[Uint32ArrayBuilder]] if you know the number of bytes you want to allocate for each element in the array.
- * @public
- */
-class UintArrayBuilder extends TypedArrayBuilder {
-    constructor(options) {
-        var _a;
-        super((_a = options === null || options === void 0 ? void 0 : options.initialType) !== null && _a !== void 0 ? _a : Uint8Array, options);
-    }
-    /** The number of bytes (1, 2, or 4) currently allocated per element by the underlying array.
-     * This may change as larger values are added to the array.
-     */
-    get bytesPerElement() {
-        return this._data.BYTES_PER_ELEMENT;
-    }
-    /** Ensures that the underlying array is of a type that can contain the largest value in `newValues`.
-     * For example, if `_data` is a `Uint16Array` and `newValues` contains any value(s) larger than 65,535, it will be replaced with a `Uint32Array`.
-     * This method is invoked by [[push]] and [[append]].
-     */
-    ensureBytesPerElement(newValues) {
-        const curBytesPerElem = this.bytesPerElement;
-        (0, Assert_1.assert)(curBytesPerElem === 1 || curBytesPerElem === 2 || curBytesPerElem === 4);
-        if (curBytesPerElem >= 4)
-            return;
-        let neededBytesPerElem = curBytesPerElem;
-        for (const value of newValues) {
-            if (value > 0xffff) {
-                neededBytesPerElem = 4;
-                break;
-            }
-            else if (value > 0xff) {
-                neededBytesPerElem = 2;
-            }
-        }
-        if (neededBytesPerElem <= curBytesPerElem)
-            return;
-        this._constructor = neededBytesPerElem === 1 ? Uint8Array : (neededBytesPerElem === 2 ? Uint16Array : Uint32Array);
-        this._data = new this._constructor(this._data);
-    }
-    /** See [[TypedArrayBuilder.push]]. */
-    push(value) {
-        this.ensureBytesPerElement([value]);
-        super.push(value);
-    }
-    /** See [[TypedArrayBuilder.append]]. */
-    append(values) {
-        this.ensureBytesPerElement(values);
-        super.append(values);
-    }
-}
-exports.UintArrayBuilder = UintArrayBuilder;
+"use strict";
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module Collections
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UintArrayBuilder = exports.Uint32ArrayBuilder = exports.Uint16ArrayBuilder = exports.Uint8ArrayBuilder = exports.TypedArrayBuilder = void 0;
+const Assert_1 = require("./Assert");
+/** Incrementally builds a [TypedArray](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray) of unsigned 8-, 16-, or 32-bit integers.
+ * Sometimes you wish to populate a `TypedArray`, but you don't know how many elements you will need.
+ * `TypedArray` requires you to specify the size upon construction, and does not permit you to change the size later.
+ *
+ * `TypedArrayBuilder` manages a `TypedArray`, permitting you to [[push]] and [[append]] elements to it. It exposes two "size" properties":
+ *  - [[capacity]], the number of elements it has currently allocated space for - i.e., the length of the underlying TypedArray; and
+ *  - [[length]], the number of elements that have so far been added to it, which is never bigger than [[capacity]].
+ * When [[capacity]] is exceeded, a new, bigger TypedArray is allocated and the contents of the previous array are copied over to it.
+ *
+ * Once you've finished adding elements, you can obtain the finished `TypedArray` via [[toTypedArray]].
+ * @see [[Uint8ArrayBuilder]], [[Uint16ArrayBuilder]], and [[Uint32ArrayBuilder]] to build specific types of arrays.
+ * @see [[UintArrayBuilder]] when you don't know the maximum number of bytes required for each element in the array.
+ * @public
+ */
+class TypedArrayBuilder {
+    /** Constructs a new builder from the specified options, with a [[length]] of zero. */
+    constructor(constructor, options) {
+        this._constructor = constructor;
+        this._data = new constructor(options?.initialCapacity ?? 0);
+        this.growthFactor = Math.max(1.0, options?.growthFactor ?? 1.5);
+        this._length = 0;
+    }
+    /** The number of elements currently in the array. */
+    get length() {
+        return this._length;
+    }
+    /** The number of elements that can fit into the memory currently allocated for the array. */
+    get capacity() {
+        return this._data.length;
+    }
+    /** Like [TypedArray.at](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/at),
+     * returns the element at the specified index, with negative integers counting back from the end of the array.
+     * @note It is your responsibility to ensure the index falls within the bounds of the array.
+     */
+    at(index) {
+        if (index < 0)
+            index = this.length - index;
+        const value = this._data[index];
+        (0, Assert_1.assert)(value !== undefined, "index out of bounds");
+        return value;
+    }
+    /** Ensure that [[capacity]] is at least equal to `newCapacity`.
+     * This is used internally by methods like [[push]] and [[append]] to ensure the array has room for the element(s) to be added.
+     * It can also be useful when you know you intend to add some number of additional elements, to minimize reallocations.
+     *
+     * If `newCapacity` is not greater than the current [[capacity]], this function does nothing.
+     * Otherwise, it allocates a new `TypedArray` with room for `newCapacity * growthFactor` elements, and copies the contents of the previous `TypedArray` into it.
+     * [[length]] remains unchanged; [[capacity]] reflects the size of the new TypeArray.
+     */
+    ensureCapacity(newCapacity) {
+        if (this.capacity >= newCapacity)
+            return this.capacity;
+        (0, Assert_1.assert)(this.growthFactor >= 1.0);
+        newCapacity = Math.ceil(newCapacity * this.growthFactor);
+        const prevData = this._data;
+        this._data = new this._constructor(newCapacity);
+        this._data.set(prevData, 0);
+        (0, Assert_1.assert)(this.capacity === newCapacity);
+        return this.capacity;
+    }
+    /** Append the specified value, resizing if necessary. */
+    push(value) {
+        this.ensureCapacity(this.length + 1);
+        this._data[this.length] = value;
+        ++this._length;
+    }
+    /** Append an array of values, resizing (at most once) if necessary. */
+    append(values) {
+        const newLength = this.length + values.length;
+        this.ensureCapacity(newLength);
+        this._data.set(values, this.length);
+        this._length = newLength;
+    }
+    /** Obtain the finished array.
+     * @param includeUnusedCapacity If true, the length of the returned array will be equal to [[capacity]], with extra bytes initialized to zero; otherwise, the
+     * returned array's length will be equal to [[length]].
+     */
+    toTypedArray(includeUnusedCapacity = false) {
+        if (includeUnusedCapacity)
+            return this._data;
+        const subarray = this._data.subarray(0, this.length);
+        (0, Assert_1.assert)(subarray instanceof this._constructor);
+        (0, Assert_1.assert)(subarray.buffer === this._data.buffer);
+        return subarray;
+    }
+}
+exports.TypedArrayBuilder = TypedArrayBuilder;
+/** A [[TypedArrayBuilder]] for producing a [Uint8Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array).
+ * @public
+ */
+class Uint8ArrayBuilder extends TypedArrayBuilder {
+    /** See [[TypedArrayBuilder]] constructor. */
+    constructor(options) {
+        super(Uint8Array, options);
+    }
+}
+exports.Uint8ArrayBuilder = Uint8ArrayBuilder;
+/** A [[TypedArrayBuilder]] for producing a [Uint16Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint16Array).
+ * @public
+ */
+class Uint16ArrayBuilder extends TypedArrayBuilder {
+    /** See [[TypedArrayBuilder]] constructor. */
+    constructor(options) {
+        super(Uint16Array, options);
+    }
+}
+exports.Uint16ArrayBuilder = Uint16ArrayBuilder;
+/** A [[TypedArrayBuilder]] for producing a [Uint32Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint32Array).
+ * @public
+ */
+class Uint32ArrayBuilder extends TypedArrayBuilder {
+    /** See [[TypedArrayBuilder]] constructor. */
+    constructor(options) {
+        super(Uint32Array, options);
+    }
+    /** Obtain a view of the finished array as an array of bytes. */
+    toUint8Array(includeUnusedCapacity = false) {
+        if (includeUnusedCapacity)
+            return new Uint8Array(this._data.buffer);
+        return new Uint8Array(this._data.buffer, 0, this.length * 4);
+    }
+}
+exports.Uint32ArrayBuilder = Uint32ArrayBuilder;
+/** A [[TypedArrayBuilder]] that can populate a [[UintArray]] with the minimum
+ * [bytes per element](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/BYTES_PER_ELEMENT) required.
+ *
+ * By default, the underlying array is a `Uint8Array`, though this can be configured via [[UintArrayBuilderOptions.initialType]].
+ * As values are added to the array, if the bytes per element supported by the underlying array is too small to hold one of the new values, the array is
+ * reallocated to a type large enough to hold all of the new values. For example, the following produces a `Uint8Array` because all values are less than 256:
+ *
+ * ```ts
+ *  const builder = new UintArrayBuilder();
+ *  builder.append([1, 2, 254, 255]);
+ *  const array = builder.toTypedArray();
+ *  assert(array instanceof Uint8Array);
+ * ```
+ *
+ * However, the following produces a `Uint16Array` because one of the values is larger than 255 but none are larger than 65,535:
+ *
+ * ```ts
+ *  const builder = new UintArrayBuilder();
+ *  builder.append([1, 255, 257, 65535]);
+ *  const array = builder.toTypedArray();
+ *  assert(array instanceof Uint16Array);
+ * ```
+ *
+ * @see [[Uint8ArrayBuilder]], [[Uint16ArrayBuilder]], or [[Uint32ArrayBuilder]] if you know the number of bytes you want to allocate for each element in the array.
+ * @public
+ */
+class UintArrayBuilder extends TypedArrayBuilder {
+    constructor(options) {
+        super(options?.initialType ?? Uint8Array, options);
+    }
+    /** The number of bytes (1, 2, or 4) currently allocated per element by the underlying array.
+     * This may change as larger values are added to the array.
+     */
+    get bytesPerElement() {
+        return this._data.BYTES_PER_ELEMENT;
+    }
+    /** Ensures that the underlying array is of a type that can contain the largest value in `newValues`.
+     * For example, if `_data` is a `Uint16Array` and `newValues` contains any value(s) larger than 65,535, it will be replaced with a `Uint32Array`.
+     * This method is invoked by [[push]] and [[append]].
+     */
+    ensureBytesPerElement(newValues) {
+        const curBytesPerElem = this.bytesPerElement;
+        (0, Assert_1.assert)(curBytesPerElem === 1 || curBytesPerElem === 2 || curBytesPerElem === 4);
+        if (curBytesPerElem >= 4)
+            return;
+        let neededBytesPerElem = curBytesPerElem;
+        for (const value of newValues) {
+            if (value > 0xffff) {
+                neededBytesPerElem = 4;
+                break;
+            }
+            else if (value > 0xff) {
+                neededBytesPerElem = 2;
+            }
+        }
+        if (neededBytesPerElem <= curBytesPerElem)
+            return;
+        this._constructor = neededBytesPerElem === 1 ? Uint8Array : (neededBytesPerElem === 2 ? Uint16Array : Uint32Array);
+        this._data = new this._constructor(this._data);
+    }
+    /** See [[TypedArrayBuilder.push]]. */
+    push(value) {
+        this.ensureBytesPerElement([value]);
+        super.push(value);
+    }
+    /** See [[TypedArrayBuilder.append]]. */
+    append(values) {
+        this.ensureBytesPerElement(values);
+        super.append(values);
+    }
+}
+exports.UintArrayBuilder = UintArrayBuilder;
 //# sourceMappingURL=TypedArrayBuilder.js.map

package/lib/cjs/TypedArrayBuilder.js.map

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

package/lib/cjs/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 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/cjs/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;IAa9D;;;;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,MAAM,MAAM,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"}