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

package/lib/cjs/Disposable.js

@@ -1,121 +1,121 @@
-"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.DisposableList = exports.using = exports.disposeArray = exports.dispose = exports.isIDisposable = void 0;
-/**
- * A type guard that checks whether the given argument implements `IDisposable` interface
- * @public
- */
-function isIDisposable(obj) {
-    // eslint-disable-next-line @typescript-eslint/unbound-method
-    return !!obj && (obj instanceof Object) && !!obj.dispose && (typeof obj.dispose === "function");
-}
-exports.isIDisposable = isIDisposable;
-/** Convenience function for disposing of a disposable object that may be undefined.
- * This is primarily used to simplify implementations of [[IDisposable.dispose]].
- * As a simple example:
- * ```ts
- *  class Disposable implements IDisposable {
- *    public member1?: DisposableType1;
- *    public member2?: DisposableType2;
- *
- *    public dispose() {
- *      this.member1 = dispose(this.member1); // If member1 is defined, dispose of it and set it to undefined.
- *      this.member2 = dispose(this.member2); // Likewise for member2.
- *    }
- *  }
- * ```
- * @param disposable The object to be disposed of.
- * @returns undefined
- * @public
- */
-function dispose(disposable) {
-    if (undefined !== disposable)
-        disposable.dispose();
-    return undefined;
-}
-exports.dispose = dispose;
-/** Disposes of and empties a list of disposable objects.
- * @param list The list of disposable objects.
- * @returns undefined
- * @public
- */
-function disposeArray(list) {
-    if (undefined === list)
-        return undefined;
-    for (const entry of list)
-        dispose(entry);
-    list.length = 0;
-    return undefined;
-}
-exports.disposeArray = disposeArray;
-/** A 'using' function which is a substitution for .NET's using statement. It makes sure that 'dispose'
- * is called on the resource no matter if the func returns or throws. If func returns, the return value
- * of this function is equal to return value of func. If func throws, this function also throws (after
- * disposing the resource).
- * @public
- */
-function using(resources, func) {
-    if (!Array.isArray(resources))
-        return using([resources], func);
-    const doDispose = () => resources.forEach((disposable) => disposable.dispose());
-    let shouldDisposeImmediately = true;
-    try {
-        const result = func(...resources);
-        if (result instanceof Promise) {
-            shouldDisposeImmediately = false;
-            result.then(doDispose, doDispose);
-        }
-        return result;
-    }
-    finally {
-        if (shouldDisposeImmediately)
-            doDispose();
-    }
-}
-exports.using = using;
-class FuncDisposable {
-    constructor(disposeFunc) { this._disposeFunc = disposeFunc; }
-    dispose() { this._disposeFunc(); }
-}
-/** A disposable container of disposable objects.
- * @public
- */
-class DisposableList {
-    /** Creates a disposable list. */
-    constructor(disposables = []) {
-        this._disposables = [];
-        disposables.forEach((disposable) => {
-            this.add(disposable);
-        });
-    }
-    isDisposable(x) {
-        return x.dispose !== undefined;
-    }
-    /** Register an object for disposal. */
-    add(disposable) {
-        if (this.isDisposable(disposable))
-            this._disposables.push(disposable);
-        else
-            this._disposables.push(new FuncDisposable(disposable));
-    }
-    /** Unregister disposable object. */
-    remove(disposable) {
-        const idx = this._disposables.indexOf(disposable);
-        if (-1 !== idx)
-            this._disposables.splice(idx, 1);
-    }
-    /** Disposes all registered objects. */
-    dispose() {
-        for (const disposable of this._disposables)
-            disposable.dispose();
-    }
-}
-exports.DisposableList = DisposableList;
+"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.DisposableList = exports.using = exports.disposeArray = exports.dispose = exports.isIDisposable = void 0;
+/**
+ * A type guard that checks whether the given argument implements `IDisposable` interface
+ * @public
+ */
+function isIDisposable(obj) {
+    // eslint-disable-next-line @typescript-eslint/unbound-method
+    return !!obj && (obj instanceof Object) && !!obj.dispose && (typeof obj.dispose === "function");
+}
+exports.isIDisposable = isIDisposable;
+/** Convenience function for disposing of a disposable object that may be undefined.
+ * This is primarily used to simplify implementations of [[IDisposable.dispose]].
+ * As a simple example:
+ * ```ts
+ *  class Disposable implements IDisposable {
+ *    public member1?: DisposableType1;
+ *    public member2?: DisposableType2;
+ *
+ *    public dispose() {
+ *      this.member1 = dispose(this.member1); // If member1 is defined, dispose of it and set it to undefined.
+ *      this.member2 = dispose(this.member2); // Likewise for member2.
+ *    }
+ *  }
+ * ```
+ * @param disposable The object to be disposed of.
+ * @returns undefined
+ * @public
+ */
+function dispose(disposable) {
+    if (undefined !== disposable)
+        disposable.dispose();
+    return undefined;
+}
+exports.dispose = dispose;
+/** Disposes of and empties a list of disposable objects.
+ * @param list The list of disposable objects.
+ * @returns undefined
+ * @public
+ */
+function disposeArray(list) {
+    if (undefined === list)
+        return undefined;
+    for (const entry of list)
+        dispose(entry);
+    list.length = 0;
+    return undefined;
+}
+exports.disposeArray = disposeArray;
+/** A 'using' function which is a substitution for .NET's using statement. It makes sure that 'dispose'
+ * is called on the resource no matter if the func returns or throws. If func returns, the return value
+ * of this function is equal to return value of func. If func throws, this function also throws (after
+ * disposing the resource).
+ * @public
+ */
+function using(resources, func) {
+    if (!Array.isArray(resources))
+        return using([resources], func);
+    const doDispose = () => resources.forEach((disposable) => disposable.dispose());
+    let shouldDisposeImmediately = true;
+    try {
+        const result = func(...resources);
+        if (result instanceof Promise) {
+            shouldDisposeImmediately = false;
+            result.then(doDispose, doDispose);
+        }
+        return result;
+    }
+    finally {
+        if (shouldDisposeImmediately)
+            doDispose();
+    }
+}
+exports.using = using;
+class FuncDisposable {
+    constructor(disposeFunc) { this._disposeFunc = disposeFunc; }
+    dispose() { this._disposeFunc(); }
+}
+/** A disposable container of disposable objects.
+ * @public
+ */
+class DisposableList {
+    /** Creates a disposable list. */
+    constructor(disposables = []) {
+        this._disposables = [];
+        disposables.forEach((disposable) => {
+            this.add(disposable);
+        });
+    }
+    isDisposable(x) {
+        return x.dispose !== undefined;
+    }
+    /** Register an object for disposal. */
+    add(disposable) {
+        if (this.isDisposable(disposable))
+            this._disposables.push(disposable);
+        else
+            this._disposables.push(new FuncDisposable(disposable));
+    }
+    /** Unregister disposable object. */
+    remove(disposable) {
+        const idx = this._disposables.indexOf(disposable);
+        if (-1 !== idx)
+            this._disposables.splice(idx, 1);
+    }
+    /** Disposes all registered objects. */
+    dispose() {
+        for (const disposable of this._disposables)
+            disposable.dispose();
+    }
+}
+exports.DisposableList = DisposableList;
 //# sourceMappingURL=Disposable.js.map

package/lib/cjs/Disposable.js.map

@@ -1 +1 @@
-{"version":3,"file":"Disposable.js","sourceRoot":"","sources":["../../src/Disposable.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 Utils\r\n */\r\n\r\n/** Interface adopted by a type which has deterministic cleanup logic.\r\n * For example:\r\n *  - Most rendering-related types, such as [[RenderGraphic]] and [[Viewport]], own WebGL resources which must be explicitly released when no longer needed.\r\n *  - Some low-level objects like [[ECDb]] own native types defined in C++ code which must be explicitly released when no longer needed.\r\n *\r\n * A similar concept exists in languages like C++ (implemented as \"destructors\") and C# (\"IDisposable\").\r\n * However, because TypeScript and Javascript lack any built-in support for deterministic destruction, it is up to the programmer to ensure dispose() is called appropriately.\r\n * Failure to do so may result in memory leaks or leaking of other resources.\r\n *\r\n * IDisposable tends to be contagious; that is, if a type has members which implement IDisposable, that type should also implement IDisposable to dispose of those members.\r\n *\r\n * Implementations of IDisposable tend to be more \"low-level\" types. The disposal of such types is often handled on your behalf.\r\n * However, always consult the documentation for an IDisposable type to determine under what circumstances you are expected to explicitly dispose of it.\r\n * @public\r\n */\r\nexport interface IDisposable {\r\n  /** Disposes of any resources owned by this object.\r\n   * @note The object is generally considered unusable after it has been disposed of.\r\n   */\r\n  dispose(): void;\r\n}\r\n\r\n/**\r\n * A type guard that checks whether the given argument implements `IDisposable` interface\r\n * @public\r\n */\r\nexport function isIDisposable(obj: unknown): obj is IDisposable {\r\n  // eslint-disable-next-line @typescript-eslint/unbound-method\r\n  return !!obj && (obj instanceof Object) && !!(obj as IDisposable).dispose && (typeof (obj as IDisposable).dispose === \"function\");\r\n}\r\n\r\n/** Convenience function for disposing of a disposable object that may be undefined.\r\n * This is primarily used to simplify implementations of [[IDisposable.dispose]].\r\n * As a simple example:\r\n * ```ts\r\n *  class Disposable implements IDisposable {\r\n *    public member1?: DisposableType1;\r\n *    public member2?: DisposableType2;\r\n *\r\n *    public dispose() {\r\n *      this.member1 = dispose(this.member1); // If member1 is defined, dispose of it and set it to undefined.\r\n *      this.member2 = dispose(this.member2); // Likewise for member2.\r\n *    }\r\n *  }\r\n * ```\r\n * @param disposable The object to be disposed of.\r\n * @returns undefined\r\n * @public\r\n */\r\nexport function dispose(disposable?: IDisposable): undefined {\r\n  if (undefined !== disposable)\r\n    disposable.dispose();\r\n  return undefined;\r\n}\r\n\r\n/** Disposes of and empties a list of disposable objects.\r\n * @param list The list of disposable objects.\r\n * @returns undefined\r\n * @public\r\n */\r\nexport function disposeArray(list?: IDisposable[]): undefined {\r\n  if (undefined === list)\r\n    return undefined;\r\n\r\n  for (const entry of list)\r\n    dispose(entry);\r\n\r\n  list.length = 0;\r\n  return undefined;\r\n}\r\n\r\n/** A 'using' function which is a substitution for .NET's using statement. It makes sure that 'dispose'\r\n * is called on the resource no matter if the func returns or throws. If func returns, the return value\r\n * of this function is equal to return value of func. If func throws, this function also throws (after\r\n * disposing the resource).\r\n * @public\r\n */\r\nexport function using<T extends IDisposable, TResult>(resources: T | T[], func: (...r: T[]) => TResult): TResult {\r\n  if (!Array.isArray(resources))\r\n    return using([resources], func);\r\n\r\n  const doDispose = () => resources.forEach((disposable) => disposable.dispose());\r\n  let shouldDisposeImmediately = true;\r\n\r\n  try {\r\n    const result = func(...resources);\r\n    if (result instanceof Promise) {\r\n      shouldDisposeImmediately = false;\r\n      result.then(doDispose, doDispose);\r\n    }\r\n    return result;\r\n  } finally {\r\n    if (shouldDisposeImmediately)\r\n      doDispose();\r\n  }\r\n}\r\n\r\n/** A definition of function which may be called to dispose an object\r\n * @public\r\n */\r\nexport type DisposeFunc = () => void;\r\n\r\nclass FuncDisposable implements IDisposable {\r\n  private _disposeFunc: () => void;\r\n  constructor(disposeFunc: () => void) { this._disposeFunc = disposeFunc; }\r\n  public dispose() { this._disposeFunc(); }\r\n}\r\n\r\n/** A disposable container of disposable objects.\r\n * @public\r\n */\r\nexport class DisposableList implements IDisposable {\r\n  private _disposables: IDisposable[];\r\n\r\n  /** Creates a disposable list. */\r\n  constructor(disposables: Array<IDisposable | DisposeFunc> = []) {\r\n    this._disposables = [];\r\n    disposables.forEach((disposable) => {\r\n      this.add(disposable);\r\n    });\r\n  }\r\n\r\n  private isDisposable(x: IDisposable | DisposeFunc): x is IDisposable {\r\n    return (x as IDisposable).dispose !== undefined;\r\n  }\r\n\r\n  /** Register an object for disposal. */\r\n  public add(disposable: IDisposable | DisposeFunc) {\r\n    if (this.isDisposable(disposable))\r\n      this._disposables.push(disposable);\r\n    else\r\n      this._disposables.push(new FuncDisposable(disposable));\r\n  }\r\n\r\n  /** Unregister disposable object. */\r\n  public remove(disposable: IDisposable): void {\r\n    const idx = this._disposables.indexOf(disposable);\r\n    if (-1 !== idx)\r\n      this._disposables.splice(idx, 1);\r\n  }\r\n\r\n  /** Disposes all registered objects. */\r\n  public dispose(): void {\r\n    for (const disposable of this._disposables)\r\n      disposable.dispose();\r\n  }\r\n}\r\n"]}
+{"version":3,"file":"Disposable.js","sourceRoot":"","sources":["../../src/Disposable.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 Utils\n */\n\n/** Interface adopted by a type which has deterministic cleanup logic.\n * For example:\n *  - Most rendering-related types, such as [[RenderGraphic]] and [[Viewport]], own WebGL resources which must be explicitly released when no longer needed.\n *  - Some low-level objects like [[ECDb]] own native types defined in C++ code which must be explicitly released when no longer needed.\n *\n * A similar concept exists in languages like C++ (implemented as \"destructors\") and C# (\"IDisposable\").\n * However, because TypeScript and Javascript lack any built-in support for deterministic destruction, it is up to the programmer to ensure dispose() is called appropriately.\n * Failure to do so may result in memory leaks or leaking of other resources.\n *\n * IDisposable tends to be contagious; that is, if a type has members which implement IDisposable, that type should also implement IDisposable to dispose of those members.\n *\n * Implementations of IDisposable tend to be more \"low-level\" types. The disposal of such types is often handled on your behalf.\n * However, always consult the documentation for an IDisposable type to determine under what circumstances you are expected to explicitly dispose of it.\n * @public\n */\nexport interface IDisposable {\n  /** Disposes of any resources owned by this object.\n   * @note The object is generally considered unusable after it has been disposed of.\n   */\n  dispose(): void;\n}\n\n/**\n * A type guard that checks whether the given argument implements `IDisposable` interface\n * @public\n */\nexport function isIDisposable(obj: unknown): obj is IDisposable {\n  // eslint-disable-next-line @typescript-eslint/unbound-method\n  return !!obj && (obj instanceof Object) && !!(obj as IDisposable).dispose && (typeof (obj as IDisposable).dispose === \"function\");\n}\n\n/** Convenience function for disposing of a disposable object that may be undefined.\n * This is primarily used to simplify implementations of [[IDisposable.dispose]].\n * As a simple example:\n * ```ts\n *  class Disposable implements IDisposable {\n *    public member1?: DisposableType1;\n *    public member2?: DisposableType2;\n *\n *    public dispose() {\n *      this.member1 = dispose(this.member1); // If member1 is defined, dispose of it and set it to undefined.\n *      this.member2 = dispose(this.member2); // Likewise for member2.\n *    }\n *  }\n * ```\n * @param disposable The object to be disposed of.\n * @returns undefined\n * @public\n */\nexport function dispose(disposable?: IDisposable): undefined {\n  if (undefined !== disposable)\n    disposable.dispose();\n  return undefined;\n}\n\n/** Disposes of and empties a list of disposable objects.\n * @param list The list of disposable objects.\n * @returns undefined\n * @public\n */\nexport function disposeArray(list?: IDisposable[]): undefined {\n  if (undefined === list)\n    return undefined;\n\n  for (const entry of list)\n    dispose(entry);\n\n  list.length = 0;\n  return undefined;\n}\n\n/** A 'using' function which is a substitution for .NET's using statement. It makes sure that 'dispose'\n * is called on the resource no matter if the func returns or throws. If func returns, the return value\n * of this function is equal to return value of func. If func throws, this function also throws (after\n * disposing the resource).\n * @public\n */\nexport function using<T extends IDisposable, TResult>(resources: T | T[], func: (...r: T[]) => TResult): TResult {\n  if (!Array.isArray(resources))\n    return using([resources], func);\n\n  const doDispose = () => resources.forEach((disposable) => disposable.dispose());\n  let shouldDisposeImmediately = true;\n\n  try {\n    const result = func(...resources);\n    if (result instanceof Promise) {\n      shouldDisposeImmediately = false;\n      result.then(doDispose, doDispose);\n    }\n    return result;\n  } finally {\n    if (shouldDisposeImmediately)\n      doDispose();\n  }\n}\n\n/** A definition of function which may be called to dispose an object\n * @public\n */\nexport type DisposeFunc = () => void;\n\nclass FuncDisposable implements IDisposable {\n  private _disposeFunc: () => void;\n  constructor(disposeFunc: () => void) { this._disposeFunc = disposeFunc; }\n  public dispose() { this._disposeFunc(); }\n}\n\n/** A disposable container of disposable objects.\n * @public\n */\nexport class DisposableList implements IDisposable {\n  private _disposables: IDisposable[];\n\n  /** Creates a disposable list. */\n  constructor(disposables: Array<IDisposable | DisposeFunc> = []) {\n    this._disposables = [];\n    disposables.forEach((disposable) => {\n      this.add(disposable);\n    });\n  }\n\n  private isDisposable(x: IDisposable | DisposeFunc): x is IDisposable {\n    return (x as IDisposable).dispose !== undefined;\n  }\n\n  /** Register an object for disposal. */\n  public add(disposable: IDisposable | DisposeFunc) {\n    if (this.isDisposable(disposable))\n      this._disposables.push(disposable);\n    else\n      this._disposables.push(new FuncDisposable(disposable));\n  }\n\n  /** Unregister disposable object. */\n  public remove(disposable: IDisposable): void {\n    const idx = this._disposables.indexOf(disposable);\n    if (-1 !== idx)\n      this._disposables.splice(idx, 1);\n  }\n\n  /** Disposes all registered objects. */\n  public dispose(): void {\n    for (const disposable of this._disposables)\n      disposable.dispose();\n  }\n}\n"]}