@itwin/core-bentley 4.0.0-dev.52 → 4.0.0-dev.55

package/lib/esm/Disposable.js

@@ -1,113 +1,113 @@
-/*---------------------------------------------------------------------------------------------
-* 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
- */
-/**
- * A type guard that checks whether the given argument implements `IDisposable` interface
- * @public
- */
-export function isIDisposable(obj) {
-    // eslint-disable-next-line @typescript-eslint/unbound-method
-    return !!obj && (obj instanceof Object) && !!obj.dispose && (typeof obj.dispose === "function");
-}
-/** 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
- */
-export function dispose(disposable) {
-    if (undefined !== disposable)
-        disposable.dispose();
-    return undefined;
-}
-/** Disposes of and empties a list of disposable objects.
- * @param list The list of disposable objects.
- * @returns undefined
- * @public
- */
-export function disposeArray(list) {
-    if (undefined === list)
-        return undefined;
-    for (const entry of list)
-        dispose(entry);
-    list.length = 0;
-    return undefined;
-}
-/** 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
- */
-export 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();
-    }
-}
-class FuncDisposable {
-    constructor(disposeFunc) { this._disposeFunc = disposeFunc; }
-    dispose() { this._disposeFunc(); }
-}
-/** A disposable container of disposable objects.
- * @public
- */
-export 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();
-    }
-}
+/*---------------------------------------------------------------------------------------------
+* 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
+ */
+/**
+ * A type guard that checks whether the given argument implements `IDisposable` interface
+ * @public
+ */
+export function isIDisposable(obj) {
+    // eslint-disable-next-line @typescript-eslint/unbound-method
+    return !!obj && (obj instanceof Object) && !!obj.dispose && (typeof obj.dispose === "function");
+}
+/** 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
+ */
+export function dispose(disposable) {
+    if (undefined !== disposable)
+        disposable.dispose();
+    return undefined;
+}
+/** Disposes of and empties a list of disposable objects.
+ * @param list The list of disposable objects.
+ * @returns undefined
+ * @public
+ */
+export function disposeArray(list) {
+    if (undefined === list)
+        return undefined;
+    for (const entry of list)
+        dispose(entry);
+    list.length = 0;
+    return undefined;
+}
+/** 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
+ */
+export 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();
+    }
+}
+class FuncDisposable {
+    constructor(disposeFunc) { this._disposeFunc = disposeFunc; }
+    dispose() { this._disposeFunc(); }
+}
+/** A disposable container of disposable objects.
+ * @public
+ */
+export 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();
+    }
+}
 //# sourceMappingURL=Disposable.js.map