@itwin/core-bentley 3.5.0-dev.14 → 3.5.0-dev.16

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

@@ -1,27 +1,27 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-/** @packageDocumentation
- * @module Utils
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.asInstanceOf = exports.isInstanceOf = void 0;
-/** Returns true if `obj` is an object of class `T`.
- * @see [[asInstanceOf]] to cast `obj` to class `T`.
- * @public
- */
-function isInstanceOf(obj, constructor) {
-    return "object" === typeof obj && obj instanceof constructor;
-}
-exports.isInstanceOf = isInstanceOf;
-/** 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
- */
-function asInstanceOf(obj, constructor) {
-    return isInstanceOf(obj, constructor) ? obj : undefined;
-}
-exports.asInstanceOf = asInstanceOf;
+"use strict";
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module Utils
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.asInstanceOf = exports.isInstanceOf = void 0;
+/** Returns true if `obj` is an object of class `T`.
+ * @see [[asInstanceOf]] to cast `obj` to class `T`.
+ * @public
+ */
+function isInstanceOf(obj, constructor) {
+    return "object" === typeof obj && obj instanceof constructor;
+}
+exports.isInstanceOf = isInstanceOf;
+/** 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
+ */
+function asInstanceOf(obj, constructor) {
+    return isInstanceOf(obj, constructor) ? obj : undefined;
+}
+exports.asInstanceOf = asInstanceOf;
 //# sourceMappingURL=UtilityTypes.js.map

package/lib/cjs/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,SAAgB,YAAY,CAAI,GAAQ,EAAE,WAA2B;IACnE,OAAO,QAAQ,KAAK,OAAO,GAAG,IAAI,GAAG,YAAY,WAAW,CAAC;AAC/D,CAAC;AAFD,oCAEC;AAED;;;GAGG;AACH,SAAgB,YAAY,CAAI,GAAQ,EAAE,WAA2B;IACnE,OAAO,YAAY,CAAI,GAAG,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC,GAAQ,CAAC,CAAC,CAAC,SAAS,CAAC;AAClE,CAAC;AAFD,oCAEC","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"]}
+{"version":3,"file":"UtilityTypes.js","sourceRoot":"","sources":["../../src/UtilityTypes.ts"],"names":[],"mappings":";AAAA;;;+FAG+F;AAC/F;;GAEG;;;AA2BH;;;GAGG;AACH,SAAgB,YAAY,CAAI,GAAQ,EAAE,WAA2B;IACnE,OAAO,QAAQ,KAAK,OAAO,GAAG,IAAI,GAAG,YAAY,WAAW,CAAC;AAC/D,CAAC;AAFD,oCAEC;AAED;;;GAGG;AACH,SAAgB,YAAY,CAAI,GAAQ,EAAE,WAA2B;IACnE,OAAO,YAAY,CAAI,GAAG,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC,GAAQ,CAAC,CAAC,CAAC,SAAS,CAAC;AAClE,CAAC;AAFD,oCAEC","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"]}

package/lib/cjs/YieldManager.d.ts

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

package/lib/cjs/YieldManager.js

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

package/lib/cjs/YieldManager.js.map

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

package/lib/cjs/core-bentley.d.ts

@@ -1,75 +1,75 @@
-export * from "./AccessToken";
-export * from "./Assert";
-export * from "./AsyncMutex";
-export * from "./BeEvent";
-export * from "./BentleyError";
-export * from "./BentleyLoggerCategory";
-export * from "./StatusCategory";
-export * from "./BeSQLite";
-export * from "./ByteStream";
-export * from "./ClassUtils";
-export * from "./Compare";
-export * from "./CompressedId64Set";
-export * from "./Dictionary";
-export * from "./Disposable";
-export * from "./Id";
-export * from "./IndexMap";
-export * from "./JsonSchema";
-export * from "./JsonUtils";
-export * from "./Logger";
-export * from "./LRUMap";
-export * from "./ObservableSet";
-export * from "./OneAtATimeAction";
-export * from "./OrderedId64Iterable";
-export * from "./OrderedSet";
-export * from "./partitionArray";
-export * from "./PriorityQueue";
-export * from "./ProcessDetector";
-export * from "./SortedArray";
-export * from "./StringUtils";
-export * from "./Time";
-export * from "./Tracing";
-export * from "./TypedArrayBuilder";
-export * from "./UnexpectedErrors";
-export * from "./UtilityTypes";
-export * from "./YieldManager";
-/** @docs-package-description
- * The core-bentley package contains classes to solve problems that are common for both client and server use cases.
- */
-/**
- * @docs-group-description BeSQLite
- * Classes for working with SQLite databases. SQLite underlies IModelDb and ECDb - see [Executing ECSQL]($docs/learning/ECSQL.md)
- */
-/**
- * @docs-group-description Errors
- * Classes for working with errors.
- */
-/**
- * @docs-group-description Events
- * Classes for raising and handling events.
- */
-/**
- * @docs-group-description Ids
- * Classes for working with unique identifiers.
- */
-/**
- * @docs-group-description Logging
- * Classes for configuring and logging diagnostic messages - see [Learning about Logging]($docs/learning/common/Logging.md)
- */
-/**
- * @docs-group-description Collections
- * Specialized, customizable collection classes like priority queues.
- */
-/**
- * @docs-group-description Json
- * utilities for dealing with Json strings and files.
- */
-/**
- * @docs-group-description Utils
- * Miscellaneous utility classes.
- */
-/**
- * @docs-group-description ProcessDetector
- * Functions for determining the type of the current JavaScript process.
- */
+export * from "./AccessToken";
+export * from "./Assert";
+export * from "./AsyncMutex";
+export * from "./BeEvent";
+export * from "./BentleyError";
+export * from "./BentleyLoggerCategory";
+export * from "./StatusCategory";
+export * from "./BeSQLite";
+export * from "./ByteStream";
+export * from "./ClassUtils";
+export * from "./Compare";
+export * from "./CompressedId64Set";
+export * from "./Dictionary";
+export * from "./Disposable";
+export * from "./Id";
+export * from "./IndexMap";
+export * from "./JsonSchema";
+export * from "./JsonUtils";
+export * from "./Logger";
+export * from "./LRUMap";
+export * from "./ObservableSet";
+export * from "./OneAtATimeAction";
+export * from "./OrderedId64Iterable";
+export * from "./OrderedSet";
+export * from "./partitionArray";
+export * from "./PriorityQueue";
+export * from "./ProcessDetector";
+export * from "./SortedArray";
+export * from "./StringUtils";
+export * from "./Time";
+export * from "./Tracing";
+export * from "./TypedArrayBuilder";
+export * from "./UnexpectedErrors";
+export * from "./UtilityTypes";
+export * from "./YieldManager";
+/** @docs-package-description
+ * The core-bentley package contains classes to solve problems that are common for both client and server use cases.
+ */
+/**
+ * @docs-group-description BeSQLite
+ * Classes for working with SQLite databases. SQLite underlies IModelDb and ECDb - see [Executing ECSQL]($docs/learning/ECSQL.md)
+ */
+/**
+ * @docs-group-description Errors
+ * Classes for working with errors.
+ */
+/**
+ * @docs-group-description Events
+ * Classes for raising and handling events.
+ */
+/**
+ * @docs-group-description Ids
+ * Classes for working with unique identifiers.
+ */
+/**
+ * @docs-group-description Logging
+ * Classes for configuring and logging diagnostic messages - see [Learning about Logging]($docs/learning/common/Logging.md)
+ */
+/**
+ * @docs-group-description Collections
+ * Specialized, customizable collection classes like priority queues.
+ */
+/**
+ * @docs-group-description Json
+ * utilities for dealing with Json strings and files.
+ */
+/**
+ * @docs-group-description Utils
+ * Miscellaneous utility classes.
+ */
+/**
+ * @docs-group-description ProcessDetector
+ * Functions for determining the type of the current JavaScript process.
+ */
 //# sourceMappingURL=core-bentley.d.ts.map