@x-oasis/disposable 0.1.36

package/README.md

@@ -0,0 +1,231 @@
+# @x-oasis/disposable
+
+A TypeScript library for managing disposable resources. Provides utilities for creating, managing, and disposing of resources that need cleanup.
+
+## Installation
+
+```bash
+$ npm i @x-oasis/disposable
+```
+
+## API
+
+### `IDisposable`
+
+Interface for objects that can be disposed.
+
+```typescript
+interface IDisposable {
+  dispose(): void;
+}
+```
+
+### `Disposable`
+
+A class that implements `IDisposable` and can register other disposables to be disposed together.
+
+```typescript
+class Disposable implements IDisposable {
+  static readonly None: IDisposable; // A no-op disposable
+  dispose(): void;
+  registerDisposable<T extends IDisposable>(disposable: T): T;
+}
+```
+
+### `DisposableStore`
+
+A store that manages multiple disposables and can dispose them all at once.
+
+```typescript
+class DisposableStore implements IDisposable {
+  dispose(): void;
+  get isDisposed(): boolean;
+  clear(): void;
+  add<T extends IDisposable>(thing: T): T;
+  delete<T extends IDisposable>(thing: T): void;
+}
+```
+
+### `dispose()`
+
+A utility function to dispose of a single disposable, an array of disposables, or an iterable of disposables.
+
+```typescript
+function dispose<T extends IDisposable>(disposable: T): T;
+function dispose<T extends IDisposable>(disposable: T | undefined): T | undefined;
+function dispose<T extends IDisposable>(arg: T | Iterable<T> | undefined): any;
+```
+
+### `isDisposable()`
+
+Type guard to check if an object implements `IDisposable`.
+
+```typescript
+function isDisposable<T extends object>(thing: T): thing is T & IDisposable;
+```
+
+### `toDisposable()`
+
+Converts a function to an `IDisposable` that will call the function when disposed.
+
+```typescript
+function toDisposable(fn: Function): IDisposable;
+```
+
+## Usage
+
+### Basic Usage
+
+```typescript
+import { Disposable, DisposableStore, dispose, toDisposable, isDisposable } from '@x-oasis/disposable';
+
+// Create a simple disposable
+const disposable = toDisposable(() => {
+  console.log('Cleaned up!');
+});
+
+// Dispose it
+disposable.dispose(); // Logs: "Cleaned up!"
+
+// Use Disposable class
+const disposableObj = new Disposable();
+disposableObj.registerDisposable(toDisposable(() => {
+  console.log('Resource 1 cleaned');
+}));
+disposableObj.registerDisposable(toDisposable(() => {
+  console.log('Resource 2 cleaned');
+}));
+
+disposableObj.dispose(); // Both resources are cleaned
+```
+
+### Using DisposableStore
+
+```typescript
+import { DisposableStore, toDisposable } from '@x-oasis/disposable';
+
+const store = new DisposableStore();
+
+// Add disposables to the store
+const cleanup1 = toDisposable(() => console.log('Cleanup 1'));
+const cleanup2 = toDisposable(() => console.log('Cleanup 2'));
+
+store.add(cleanup1);
+store.add(cleanup2);
+
+// Check if disposed
+console.log(store.isDisposed); // false
+
+// Dispose all at once
+store.dispose(); // Logs: "Cleanup 1", "Cleanup 2"
+console.log(store.isDisposed); // true
+
+// Clear without disposing
+store.clear(); // Removes all disposables without calling dispose()
+```
+
+### Disposing Multiple Resources
+
+```typescript
+import { dispose, toDisposable } from '@x-oasis/disposable';
+
+// Dispose an array
+const disposables = [
+  toDisposable(() => console.log('1')),
+  toDisposable(() => console.log('2')),
+  toDisposable(() => console.log('3')),
+];
+
+dispose(disposables); // All three are disposed
+
+// Dispose a Set
+const disposableSet = new Set([
+  toDisposable(() => console.log('A')),
+  toDisposable(() => console.log('B')),
+]);
+
+dispose(disposableSet); // Both are disposed
+
+// Dispose a single disposable
+const single = toDisposable(() => console.log('Single'));
+dispose(single); // Disposed
+```
+
+### Type Guard
+
+```typescript
+import { isDisposable } from '@x-oasis/disposable';
+
+const obj = {
+  dispose() {
+    console.log('Disposed');
+  },
+};
+
+if (isDisposable(obj)) {
+  // TypeScript now knows obj is IDisposable
+  obj.dispose();
+}
+```
+
+### Disposable.None
+
+```typescript
+import { Disposable } from '@x-oasis/disposable';
+
+// A no-op disposable that does nothing when disposed
+const none = Disposable.None;
+none.dispose(); // Does nothing, no error
+```
+
+## Examples
+
+### Managing Event Listeners
+
+```typescript
+import { DisposableStore, toDisposable } from '@x-oasis/disposable';
+
+class Component {
+  private store = new DisposableStore();
+
+  setup() {
+    const button = document.querySelector('#myButton');
+    
+    const handler = () => console.log('Clicked');
+    button?.addEventListener('click', handler);
+    
+    // Register cleanup
+    this.store.add(toDisposable(() => {
+      button?.removeEventListener('click', handler);
+    }));
+  }
+
+  destroy() {
+    this.store.dispose(); // All event listeners are removed
+  }
+}
+```
+
+### Managing Subscriptions
+
+```typescript
+import { Disposable, toDisposable } from '@x-oasis/disposable';
+
+class Service {
+  private disposable = new Disposable();
+
+  subscribe(callback: () => void) {
+    const subscription = createSubscription(callback);
+    
+    this.disposable.registerDisposable(toDisposable(() => {
+      subscription.unsubscribe();
+    }));
+    
+    return subscription;
+  }
+
+  cleanup() {
+    this.disposable.dispose(); // All subscriptions are unsubscribed
+  }
+}
+```

package/dist/Disposable.d.ts

@@ -0,0 +1,9 @@
+import { IDisposable } from './types/disposable';
+export declare function isDisposable<T extends object>(thing: T): thing is T & IDisposable;
+export declare function toDisposable(fn: Function): IDisposable;
+export declare class Disposable implements IDisposable {
+    static readonly None: Readonly<IDisposable>;
+    private readonly _store;
+    dispose(): void;
+    registerDisposable<T extends IDisposable>(disposable: T): void;
+}

package/dist/DisposableStore.d.ts

@@ -0,0 +1,13 @@
+import { IDisposable } from './types/disposable';
+export declare function dispose<T extends IDisposable>(disposable: T): T;
+export declare function dispose<T extends IDisposable>(disposable: T | undefined): T | undefined;
+export declare function dispose<T extends IDisposable>(arg: T | Iterable<T> | undefined): any;
+export default class DisposableStore implements IDisposable {
+    private readonly _toDispose;
+    private _isDisposed;
+    dispose(): void;
+    get isDisposed(): boolean;
+    clear(): void;
+    add<T extends IDisposable>(thing: T): T;
+    delete<T extends IDisposable>(thing: T): void;
+}

package/dist/disposable.cjs.development.js

@@ -0,0 +1,194 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor);
+  }
+}
+function _createClass(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+  if (staticProps) _defineProperties(Constructor, staticProps);
+  Object.defineProperty(Constructor, "prototype", {
+    writable: false
+  });
+  return Constructor;
+}
+function _unsupportedIterableToArray(o, minLen) {
+  if (!o) return;
+  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor) n = o.constructor.name;
+  if (n === "Map" || n === "Set") return Array.from(o);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+function _arrayLikeToArray(arr, len) {
+  if (len == null || len > arr.length) len = arr.length;
+  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+  return arr2;
+}
+function _createForOfIteratorHelperLoose(o, allowArrayLike) {
+  var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
+  if (it) return (it = it.call(o)).next.bind(it);
+  if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
+    if (it) o = it;
+    var i = 0;
+    return function () {
+      if (i >= o.length) return {
+        done: true
+      };
+      return {
+        done: false,
+        value: o[i++]
+      };
+    };
+  }
+  throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _toPrimitive(input, hint) {
+  if (typeof input !== "object" || input === null) return input;
+  var prim = input[Symbol.toPrimitive];
+  if (prim !== undefined) {
+    var res = prim.call(input, hint || "default");
+    if (typeof res !== "object") return res;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (hint === "string" ? String : Number)(input);
+}
+function _toPropertyKey(arg) {
+  var key = _toPrimitive(arg, "string");
+  return typeof key === "symbol" ? key : String(key);
+}
+
+function isObject(thing) {
+  return typeof thing === 'object' && thing !== null;
+}
+function isFunction(thing) {
+  return typeof thing === 'function';
+}
+function isArray(thing) {
+  return Array.isArray(thing);
+}
+function isIterable(thing) {
+  return thing && typeof thing === 'object' && typeof thing[Symbol.iterator] === 'function';
+}
+
+function dispose(disposables) {
+  if (isArray(disposables)) {
+    disposables.forEach(function (disposable) {
+      try {
+        disposable == null ? void 0 : disposable.dispose();
+      } catch (err) {
+      }
+    });
+    return [];
+  }
+  if (isIterable(disposables) && !isArray(disposables)) {
+    for (var _iterator = _createForOfIteratorHelperLoose(disposables), _step; !(_step = _iterator()).done;) {
+      var disposable = _step.value;
+      try {
+        disposable == null ? void 0 : disposable.dispose();
+      } catch (err) {
+      }
+    }
+    return undefined;
+  }
+  if (disposables && !isArray(disposables) && !isIterable(disposables) && isDisposable(disposables)) {
+    try {
+      disposables.dispose();
+    } catch (err) {
+    }
+    return disposables;
+  }
+  return undefined;
+}
+var DisposableStore = /*#__PURE__*/function () {
+  function DisposableStore() {
+    this._toDispose = new Set();
+    this._isDisposed = false;
+  }
+  var _proto = DisposableStore.prototype;
+  _proto.dispose = function dispose() {
+    if (this._isDisposed) {
+      return;
+    }
+    this._isDisposed = true;
+    this.clear();
+  };
+  _proto.clear = function clear() {
+    if (this._toDispose.size === 0) {
+      return;
+    }
+    dispose(this._toDispose);
+    this._toDispose.clear();
+  };
+  _proto.add = function add(thing) {
+    if (!thing) return thing;
+    if (thing === this) {
+      throw new Error('Cannot register a disposable on itself!');
+    }
+    if (this._isDisposed) ; else {
+      this._toDispose.add(thing);
+    }
+    return thing;
+  };
+  _proto["delete"] = function _delete(thing) {
+    if (!thing) {
+      return;
+    }
+    if (thing === this) {
+      throw new Error('Cannot dispose a disposable on itself!');
+    }
+    this._toDispose["delete"](thing);
+    thing.dispose();
+  };
+  _createClass(DisposableStore, [{
+    key: "isDisposed",
+    get: function get() {
+      return this._isDisposed;
+    }
+  }]);
+  return DisposableStore;
+}();
+
+function isDisposable(thing) {
+  return isObject(thing) && isFunction(thing.dispose);
+}
+function toDisposable(fn) {
+  return {
+    dispose: function dispose() {
+      return fn();
+    }
+  };
+}
+var Disposable = /*#__PURE__*/function () {
+  function Disposable() {
+    this._store = new DisposableStore();
+  }
+  var _proto = Disposable.prototype;
+  _proto.dispose = function dispose() {
+    this._store.dispose();
+  };
+  _proto.registerDisposable = function registerDisposable(disposable) {
+    if (disposable === this) {
+      throw new Error('Can not register itself');
+    }
+    this._store.add(disposable);
+  };
+  return Disposable;
+}();
+Disposable.None = /*#__PURE__*/Object.freeze({
+  dispose: function dispose() {}
+});
+
+exports.Disposable = Disposable;
+exports.DisposableStore = DisposableStore;
+exports.dispose = dispose;
+exports.isDisposable = isDisposable;
+exports.toDisposable = toDisposable;
+//# sourceMappingURL=disposable.cjs.development.js.map

package/dist/disposable.cjs.development.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"disposable.cjs.development.js","sources":["../src/utils.ts","../src/DisposableStore.ts","../src/Disposable.ts"],"sourcesContent":["export function isObject(thing: any): thing is Object {\n  return typeof thing === 'object' && thing !== null;\n}\n\nexport function isFunction(thing: any): thing is Function {\n  return typeof thing === 'function';\n}\n\nexport function isArray(thing: any): thing is any[] {\n  return Array.isArray(thing);\n}\n\nexport function isIterable<T = any>(thing: any): thing is Iterable<T> {\n  return (\n    thing &&\n    typeof thing === 'object' &&\n    typeof thing[Symbol.iterator] === 'function'\n  );\n}\n","import { isDisposable } from './Disposable';\nimport { IDisposable } from './types/disposable';\nimport { isArray, isIterable } from './utils';\n\nexport function dispose<T extends IDisposable>(disposable: T): T;\nexport function dispose<T extends IDisposable>(\n  disposable: T | undefined\n): T | undefined;\nexport function dispose<T extends IDisposable>(\n  arg: T | Iterable<T> | undefined\n): any;\nexport function dispose<T extends IDisposable>(\n  disposables: T | T[] | Iterable<T> | undefined\n): T | T[] | undefined {\n  const errors = [];\n  if (isArray(disposables)) {\n    disposables.forEach((disposable) => {\n      try {\n        disposable?.dispose();\n      } catch (err) {\n        errors.push(err);\n      }\n    });\n    return [];\n  }\n  if (isIterable<IDisposable>(disposables) && !isArray(disposables)) {\n    for (const disposable of disposables as Iterable<IDisposable>) {\n      try {\n        disposable?.dispose();\n      } catch (err) {\n        errors.push(err);\n      }\n    }\n    return undefined;\n  }\n  if (\n    disposables &&\n    !isArray(disposables) &&\n    !isIterable(disposables) &&\n    isDisposable<IDisposable>(disposables)\n  ) {\n    try {\n      (disposables as IDisposable).dispose();\n    } catch (err) {\n      errors.push(err);\n    }\n    return disposables as T;\n  }\n  return undefined;\n}\n\nexport default class DisposableStore implements IDisposable {\n  private readonly _toDispose = new Set<IDisposable>();\n\n  private _isDisposed = false;\n\n  public dispose(): void {\n    if (this._isDisposed) {\n      return;\n    }\n\n    this._isDisposed = true;\n    this.clear();\n  }\n\n  public get isDisposed(): boolean {\n    return this._isDisposed;\n  }\n\n  public clear(): void {\n    if (this._toDispose.size === 0) {\n      return;\n    }\n\n    dispose(this._toDispose);\n\n    this._toDispose.clear();\n  }\n\n  public add<T extends IDisposable>(thing: T): T {\n    if (!thing) return thing;\n    if ((thing as unknown as DisposableStore) === this) {\n      throw new Error('Cannot register a disposable on itself!');\n    }\n\n    if (this._isDisposed) {\n      // ...\n    } else {\n      this._toDispose.add(thing);\n    }\n\n    return thing;\n  }\n\n  public delete<T extends IDisposable>(thing: T): void {\n    if (!thing) {\n      return;\n    }\n    if ((thing as unknown as DisposableStore) === this) {\n      throw new Error('Cannot dispose a disposable on itself!');\n    }\n    this._toDispose.delete(thing);\n    thing.dispose();\n  }\n}\n","import DisposableStore from './DisposableStore';\nimport { IDisposable } from './types/disposable';\nimport { isFunction, isObject } from './utils';\n\nexport function isDisposable<T extends object>(\n  thing: T\n): thing is T & IDisposable {\n  return isObject(thing) && isFunction((thing as IDisposable).dispose);\n}\n\nexport function toDisposable(fn: Function): IDisposable {\n  return {\n    dispose: () => fn(),\n  };\n}\n\nexport class Disposable implements IDisposable {\n  static readonly None = Object.freeze<IDisposable>({ dispose() {} });\n\n  private readonly _store = new DisposableStore();\n\n  public dispose(): void {\n    this._store.dispose();\n  }\n\n  registerDisposable<T extends IDisposable>(disposable: T) {\n    if ((disposable as any) === this) {\n      throw new Error('Can not register itself');\n    }\n    this._store.add(disposable);\n  }\n}\n"],"names":["isObject","thing","isFunction","isArray","Array","isIterable","Symbol","iterator","dispose","disposables","forEach","disposable","err","_iterator","_createForOfIteratorHelperLoose","_step","done","value","undefined","isDisposable","DisposableStore","Set","_proto","prototype","_isDisposed","clear","_toDispose","size","add","Error","_delete","_createClass","key","get","toDisposable","fn","Disposable","_store","registerDisposable","Object","freeze"],"mappings":"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"}

package/dist/disposable.cjs.production.min.js

@@ -0,0 +1,2 @@
+"use strict";function t(t,e){(null==e||e>t.length)&&(e=t.length);for(var r=0,o=new Array(e);r<e;r++)o[r]=t[r];return o}function e(t){return Array.isArray(t)}function r(t){return t&&"object"==typeof t&&"function"==typeof t[Symbol.iterator]}function o(o){if(e(o))return o.forEach((function(t){try{null==t||t.dispose()}catch(t){}})),[];if(!r(o)||e(o)){if(o&&!e(o)&&!r(o)&&n(o)){try{o.dispose()}catch(t){}return o}}else for(var i,s=function(e,r){var o="undefined"!=typeof Symbol&&e[Symbol.iterator]||e["@@iterator"];if(o)return(o=o.call(e)).next.bind(o);if(Array.isArray(e)||(o=function(e,r){if(e){if("string"==typeof e)return t(e,void 0);var o=Object.prototype.toString.call(e).slice(8,-1);return"Object"===o&&e.constructor&&(o=e.constructor.name),"Map"===o||"Set"===o?Array.from(e):"Arguments"===o||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(o)?t(e,void 0):void 0}}(e))){o&&(e=o);var i=0;return function(){return i>=e.length?{done:!0}:{done:!1,value:e[i++]}}}throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}(o);!(i=s()).done;){var a=i.value;try{null==a||a.dispose()}catch(t){}}}Object.defineProperty(exports,"__esModule",{value:!0});var i=function(){function t(){this._toDispose=new Set,this._isDisposed=!1}var e,r,i=t.prototype;return i.dispose=function(){this._isDisposed||(this._isDisposed=!0,this.clear())},i.clear=function(){0!==this._toDispose.size&&(o(this._toDispose),this._toDispose.clear())},i.add=function(t){if(!t)return t;if(t===this)throw new Error("Cannot register a disposable on itself!");return this._isDisposed||this._toDispose.add(t),t},i.delete=function(t){if(t){if(t===this)throw new Error("Cannot dispose a disposable on itself!");this._toDispose.delete(t),t.dispose()}},e=t,(r=[{key:"isDisposed",get:function(){return this._isDisposed}}])&&function(t,e){for(var r=0;r<e.length;r++){var o=e[r];o.enumerable=o.enumerable||!1,o.configurable=!0,"value"in o&&(o.writable=!0),Object.defineProperty(t,"symbol"==typeof(i=function(t,e){if("object"!=typeof t||null===t)return t;var r=t[Symbol.toPrimitive];if(void 0!==r){var o=r.call(t,"string");if("object"!=typeof o)return o;throw new TypeError("@@toPrimitive must return a primitive value.")}return String(t)}(o.key))?i:String(i),o)}var i}(e.prototype,r),Object.defineProperty(e,"prototype",{writable:!1}),t}();function n(t){return function(t){return"object"==typeof t&&null!==t}(t)&&function(t){return"function"==typeof t}(t.dispose)}var s=function(){function t(){this._store=new i}var e=t.prototype;return e.dispose=function(){this._store.dispose()},e.registerDisposable=function(t){if(t===this)throw new Error("Can not register itself");this._store.add(t)},t}();s.None=Object.freeze({dispose:function(){}}),exports.Disposable=s,exports.DisposableStore=i,exports.dispose=o,exports.isDisposable=n,exports.toDisposable=function(t){return{dispose:function(){return t()}}};
+//# sourceMappingURL=disposable.cjs.production.min.js.map

package/dist/disposable.cjs.production.min.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"disposable.cjs.production.min.js","sources":["../src/utils.ts","../src/DisposableStore.ts","../src/Disposable.ts"],"sourcesContent":["export function isObject(thing: any): thing is Object {\n  return typeof thing === 'object' && thing !== null;\n}\n\nexport function isFunction(thing: any): thing is Function {\n  return typeof thing === 'function';\n}\n\nexport function isArray(thing: any): thing is any[] {\n  return Array.isArray(thing);\n}\n\nexport function isIterable<T = any>(thing: any): thing is Iterable<T> {\n  return (\n    thing &&\n    typeof thing === 'object' &&\n    typeof thing[Symbol.iterator] === 'function'\n  );\n}\n","import { isDisposable } from './Disposable';\nimport { IDisposable } from './types/disposable';\nimport { isArray, isIterable } from './utils';\n\nexport function dispose<T extends IDisposable>(disposable: T): T;\nexport function dispose<T extends IDisposable>(\n  disposable: T | undefined\n): T | undefined;\nexport function dispose<T extends IDisposable>(\n  arg: T | Iterable<T> | undefined\n): any;\nexport function dispose<T extends IDisposable>(\n  disposables: T | T[] | Iterable<T> | undefined\n): T | T[] | undefined {\n  const errors = [];\n  if (isArray(disposables)) {\n    disposables.forEach((disposable) => {\n      try {\n        disposable?.dispose();\n      } catch (err) {\n        errors.push(err);\n      }\n    });\n    return [];\n  }\n  if (isIterable<IDisposable>(disposables) && !isArray(disposables)) {\n    for (const disposable of disposables as Iterable<IDisposable>) {\n      try {\n        disposable?.dispose();\n      } catch (err) {\n        errors.push(err);\n      }\n    }\n    return undefined;\n  }\n  if (\n    disposables &&\n    !isArray(disposables) &&\n    !isIterable(disposables) &&\n    isDisposable<IDisposable>(disposables)\n  ) {\n    try {\n      (disposables as IDisposable).dispose();\n    } catch (err) {\n      errors.push(err);\n    }\n    return disposables as T;\n  }\n  return undefined;\n}\n\nexport default class DisposableStore implements IDisposable {\n  private readonly _toDispose = new Set<IDisposable>();\n\n  private _isDisposed = false;\n\n  public dispose(): void {\n    if (this._isDisposed) {\n      return;\n    }\n\n    this._isDisposed = true;\n    this.clear();\n  }\n\n  public get isDisposed(): boolean {\n    return this._isDisposed;\n  }\n\n  public clear(): void {\n    if (this._toDispose.size === 0) {\n      return;\n    }\n\n    dispose(this._toDispose);\n\n    this._toDispose.clear();\n  }\n\n  public add<T extends IDisposable>(thing: T): T {\n    if (!thing) return thing;\n    if ((thing as unknown as DisposableStore) === this) {\n      throw new Error('Cannot register a disposable on itself!');\n    }\n\n    if (this._isDisposed) {\n      // ...\n    } else {\n      this._toDispose.add(thing);\n    }\n\n    return thing;\n  }\n\n  public delete<T extends IDisposable>(thing: T): void {\n    if (!thing) {\n      return;\n    }\n    if ((thing as unknown as DisposableStore) === this) {\n      throw new Error('Cannot dispose a disposable on itself!');\n    }\n    this._toDispose.delete(thing);\n    thing.dispose();\n  }\n}\n","import DisposableStore from './DisposableStore';\nimport { IDisposable } from './types/disposable';\nimport { isFunction, isObject } from './utils';\n\nexport function isDisposable<T extends object>(\n  thing: T\n): thing is T & IDisposable {\n  return isObject(thing) && isFunction((thing as IDisposable).dispose);\n}\n\nexport function toDisposable(fn: Function): IDisposable {\n  return {\n    dispose: () => fn(),\n  };\n}\n\nexport class Disposable implements IDisposable {\n  static readonly None = Object.freeze<IDisposable>({ dispose() {} });\n\n  private readonly _store = new DisposableStore();\n\n  public dispose(): void {\n    this._store.dispose();\n  }\n\n  registerDisposable<T extends IDisposable>(disposable: T) {\n    if ((disposable as any) === this) {\n      throw new Error('Can not register itself');\n    }\n    this._store.add(disposable);\n  }\n}\n"],"names":["isArray","thing","Array","isIterable","Symbol","iterator","dispose","disposables","forEach","disposable","err","isDisposable","_step","_iterator","_createForOfIteratorHelperLoose","done","value","DisposableStore","this","Set","_proto","prototype","_isDisposed","clear","_toDispose","size","add","Error","key","get","isObject","isFunction","Disposable","_store","registerDisposable","Object","freeze","fn"],"mappings":"gIAQgBA,EAAQC,GACtB,OAAOC,MAAMF,QAAQC,YAGPE,EAAoBF,GAClC,OACEA,GACiB,iBAAVA,GAC2B,mBAA3BA,EAAMG,OAAOC,mBCLRC,EACdC,GAGA,GAAIP,EAAQO,GAQV,OAPAA,EAAYC,SAAQ,SAACC,GACnB,UACEA,GAAAA,EAAYH,UACZ,MAAOI,QAIJ,GAET,IAAIP,EAAwBI,IAAiBP,EAAQO,IAUrD,GACEA,IACCP,EAAQO,KACRJ,EAAWI,IACZI,EAA0BJ,GAC1B,CACA,IACGA,EAA4BD,UAC7B,MAAOI,IAGT,OAAOH,QApBP,QAA6DK,EAA7DC,qrBAAAC,CAAyBP,KAAoCK,EAAAC,KAAAE,MAAE,CAAA,IAApDN,EAAUG,EAAAI,MACnB,UACEP,GAAAA,EAAYH,UACZ,MAAOI,6DAoBd,IAEoBO,aAArB,SAAAA,IACmBC,gBAAa,IAAIC,IAE1BD,kBAAc,EAkDvB,QAAAE,EAAAH,EAAAI,UArCE,OAqCFD,EAhDQd,QAAA,WACDY,KAAKI,cAITJ,KAAKI,aAAc,EACnBJ,KAAKK,UACNH,EAMMG,MAAA,WACwB,IAAzBL,KAAKM,WAAWC,OAIpBnB,EAAQY,KAAKM,YAEbN,KAAKM,WAAWD,UACjBH,EAEMM,IAAA,SAA2BzB,GAChC,IAAKA,EAAO,OAAOA,EACnB,GAAKA,IAAyCiB,KAC5C,MAAM,IAAIS,MAAM,2CASlB,OANIT,KAAKI,aAGPJ,KAAKM,WAAWE,IAAIzB,GAGfA,GACRmB,SAEM,SAA8BnB,GACnC,GAAKA,EAAL,CAGA,GAAKA,IAAyCiB,KAC5C,MAAM,IAAIS,MAAM,0CAElBT,KAAKM,kBAAkBvB,GACvBA,EAAMK,cACPW,OAAAW,iBAAAC,IAtCD,WACE,OAAOX,KAAKI,8gBACbL,cC/DaN,EACdV,GAEA,gBFPuBA,GACvB,MAAwB,iBAAVA,GAAgC,OAAVA,EEM7B6B,CAAS7B,aFHSA,GACzB,MAAwB,mBAAVA,EEEY8B,CAAY9B,EAAsBK,SAS9D,IAAa0B,aAAb,SAAAA,IAGmBd,YAAS,IAAID,EAY/B,IAAAG,EAAAY,EAAAX,UADE,OACFD,EAVQd,QAAA,WACLY,KAAKe,OAAO3B,WACbc,EAEDc,mBAAA,SAA0CzB,GACxC,GAAKA,IAAuBS,KAC1B,MAAM,IAAIS,MAAM,2BAElBT,KAAKe,OAAOP,IAAIjB,IACjBuB,KAbeA,OAAOG,OAAOC,OAAoB,CAAE9B,6IAPzB+B,GAC3B,MAAO,CACL/B,QAAS,WAAA,OAAM+B"}

package/dist/disposable.esm.js

@@ -0,0 +1,186 @@
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor);
+  }
+}
+function _createClass(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+  if (staticProps) _defineProperties(Constructor, staticProps);
+  Object.defineProperty(Constructor, "prototype", {
+    writable: false
+  });
+  return Constructor;
+}
+function _unsupportedIterableToArray(o, minLen) {
+  if (!o) return;
+  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor) n = o.constructor.name;
+  if (n === "Map" || n === "Set") return Array.from(o);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+function _arrayLikeToArray(arr, len) {
+  if (len == null || len > arr.length) len = arr.length;
+  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+  return arr2;
+}
+function _createForOfIteratorHelperLoose(o, allowArrayLike) {
+  var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
+  if (it) return (it = it.call(o)).next.bind(it);
+  if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
+    if (it) o = it;
+    var i = 0;
+    return function () {
+      if (i >= o.length) return {
+        done: true
+      };
+      return {
+        done: false,
+        value: o[i++]
+      };
+    };
+  }
+  throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _toPrimitive(input, hint) {
+  if (typeof input !== "object" || input === null) return input;
+  var prim = input[Symbol.toPrimitive];
+  if (prim !== undefined) {
+    var res = prim.call(input, hint || "default");
+    if (typeof res !== "object") return res;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (hint === "string" ? String : Number)(input);
+}
+function _toPropertyKey(arg) {
+  var key = _toPrimitive(arg, "string");
+  return typeof key === "symbol" ? key : String(key);
+}
+
+function isObject(thing) {
+  return typeof thing === 'object' && thing !== null;
+}
+function isFunction(thing) {
+  return typeof thing === 'function';
+}
+function isArray(thing) {
+  return Array.isArray(thing);
+}
+function isIterable(thing) {
+  return thing && typeof thing === 'object' && typeof thing[Symbol.iterator] === 'function';
+}
+
+function dispose(disposables) {
+  if (isArray(disposables)) {
+    disposables.forEach(function (disposable) {
+      try {
+        disposable == null ? void 0 : disposable.dispose();
+      } catch (err) {
+      }
+    });
+    return [];
+  }
+  if (isIterable(disposables) && !isArray(disposables)) {
+    for (var _iterator = _createForOfIteratorHelperLoose(disposables), _step; !(_step = _iterator()).done;) {
+      var disposable = _step.value;
+      try {
+        disposable == null ? void 0 : disposable.dispose();
+      } catch (err) {
+      }
+    }
+    return undefined;
+  }
+  if (disposables && !isArray(disposables) && !isIterable(disposables) && isDisposable(disposables)) {
+    try {
+      disposables.dispose();
+    } catch (err) {
+    }
+    return disposables;
+  }
+  return undefined;
+}
+var DisposableStore = /*#__PURE__*/function () {
+  function DisposableStore() {
+    this._toDispose = new Set();
+    this._isDisposed = false;
+  }
+  var _proto = DisposableStore.prototype;
+  _proto.dispose = function dispose() {
+    if (this._isDisposed) {
+      return;
+    }
+    this._isDisposed = true;
+    this.clear();
+  };
+  _proto.clear = function clear() {
+    if (this._toDispose.size === 0) {
+      return;
+    }
+    dispose(this._toDispose);
+    this._toDispose.clear();
+  };
+  _proto.add = function add(thing) {
+    if (!thing) return thing;
+    if (thing === this) {
+      throw new Error('Cannot register a disposable on itself!');
+    }
+    if (this._isDisposed) ; else {
+      this._toDispose.add(thing);
+    }
+    return thing;
+  };
+  _proto["delete"] = function _delete(thing) {
+    if (!thing) {
+      return;
+    }
+    if (thing === this) {
+      throw new Error('Cannot dispose a disposable on itself!');
+    }
+    this._toDispose["delete"](thing);
+    thing.dispose();
+  };
+  _createClass(DisposableStore, [{
+    key: "isDisposed",
+    get: function get() {
+      return this._isDisposed;
+    }
+  }]);
+  return DisposableStore;
+}();
+
+function isDisposable(thing) {
+  return isObject(thing) && isFunction(thing.dispose);
+}
+function toDisposable(fn) {
+  return {
+    dispose: function dispose() {
+      return fn();
+    }
+  };
+}
+var Disposable = /*#__PURE__*/function () {
+  function Disposable() {
+    this._store = new DisposableStore();
+  }
+  var _proto = Disposable.prototype;
+  _proto.dispose = function dispose() {
+    this._store.dispose();
+  };
+  _proto.registerDisposable = function registerDisposable(disposable) {
+    if (disposable === this) {
+      throw new Error('Can not register itself');
+    }
+    this._store.add(disposable);
+  };
+  return Disposable;
+}();
+Disposable.None = /*#__PURE__*/Object.freeze({
+  dispose: function dispose() {}
+});
+
+export { Disposable, DisposableStore, dispose, isDisposable, toDisposable };
+//# sourceMappingURL=disposable.esm.js.map

package/dist/disposable.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"disposable.esm.js","sources":["../src/utils.ts","../src/DisposableStore.ts","../src/Disposable.ts"],"sourcesContent":["export function isObject(thing: any): thing is Object {\n  return typeof thing === 'object' && thing !== null;\n}\n\nexport function isFunction(thing: any): thing is Function {\n  return typeof thing === 'function';\n}\n\nexport function isArray(thing: any): thing is any[] {\n  return Array.isArray(thing);\n}\n\nexport function isIterable<T = any>(thing: any): thing is Iterable<T> {\n  return (\n    thing &&\n    typeof thing === 'object' &&\n    typeof thing[Symbol.iterator] === 'function'\n  );\n}\n","import { isDisposable } from './Disposable';\nimport { IDisposable } from './types/disposable';\nimport { isArray, isIterable } from './utils';\n\nexport function dispose<T extends IDisposable>(disposable: T): T;\nexport function dispose<T extends IDisposable>(\n  disposable: T | undefined\n): T | undefined;\nexport function dispose<T extends IDisposable>(\n  arg: T | Iterable<T> | undefined\n): any;\nexport function dispose<T extends IDisposable>(\n  disposables: T | T[] | Iterable<T> | undefined\n): T | T[] | undefined {\n  const errors = [];\n  if (isArray(disposables)) {\n    disposables.forEach((disposable) => {\n      try {\n        disposable?.dispose();\n      } catch (err) {\n        errors.push(err);\n      }\n    });\n    return [];\n  }\n  if (isIterable<IDisposable>(disposables) && !isArray(disposables)) {\n    for (const disposable of disposables as Iterable<IDisposable>) {\n      try {\n        disposable?.dispose();\n      } catch (err) {\n        errors.push(err);\n      }\n    }\n    return undefined;\n  }\n  if (\n    disposables &&\n    !isArray(disposables) &&\n    !isIterable(disposables) &&\n    isDisposable<IDisposable>(disposables)\n  ) {\n    try {\n      (disposables as IDisposable).dispose();\n    } catch (err) {\n      errors.push(err);\n    }\n    return disposables as T;\n  }\n  return undefined;\n}\n\nexport default class DisposableStore implements IDisposable {\n  private readonly _toDispose = new Set<IDisposable>();\n\n  private _isDisposed = false;\n\n  public dispose(): void {\n    if (this._isDisposed) {\n      return;\n    }\n\n    this._isDisposed = true;\n    this.clear();\n  }\n\n  public get isDisposed(): boolean {\n    return this._isDisposed;\n  }\n\n  public clear(): void {\n    if (this._toDispose.size === 0) {\n      return;\n    }\n\n    dispose(this._toDispose);\n\n    this._toDispose.clear();\n  }\n\n  public add<T extends IDisposable>(thing: T): T {\n    if (!thing) return thing;\n    if ((thing as unknown as DisposableStore) === this) {\n      throw new Error('Cannot register a disposable on itself!');\n    }\n\n    if (this._isDisposed) {\n      // ...\n    } else {\n      this._toDispose.add(thing);\n    }\n\n    return thing;\n  }\n\n  public delete<T extends IDisposable>(thing: T): void {\n    if (!thing) {\n      return;\n    }\n    if ((thing as unknown as DisposableStore) === this) {\n      throw new Error('Cannot dispose a disposable on itself!');\n    }\n    this._toDispose.delete(thing);\n    thing.dispose();\n  }\n}\n","import DisposableStore from './DisposableStore';\nimport { IDisposable } from './types/disposable';\nimport { isFunction, isObject } from './utils';\n\nexport function isDisposable<T extends object>(\n  thing: T\n): thing is T & IDisposable {\n  return isObject(thing) && isFunction((thing as IDisposable).dispose);\n}\n\nexport function toDisposable(fn: Function): IDisposable {\n  return {\n    dispose: () => fn(),\n  };\n}\n\nexport class Disposable implements IDisposable {\n  static readonly None = Object.freeze<IDisposable>({ dispose() {} });\n\n  private readonly _store = new DisposableStore();\n\n  public dispose(): void {\n    this._store.dispose();\n  }\n\n  registerDisposable<T extends IDisposable>(disposable: T) {\n    if ((disposable as any) === this) {\n      throw new Error('Can not register itself');\n    }\n    this._store.add(disposable);\n  }\n}\n"],"names":["isObject","thing","isFunction","isArray","Array","isIterable","Symbol","iterator","dispose","disposables","forEach","disposable","err","_iterator","_createForOfIteratorHelperLoose","_step","done","value","undefined","isDisposable","DisposableStore","Set","_proto","prototype","_isDisposed","clear","_toDispose","size","add","Error","_delete","_createClass","key","get","toDisposable","fn","Disposable","_store","registerDisposable","Object","freeze"],"mappings":"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"}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { Disposable, toDisposable, isDisposable } from './Disposable';
+export { default as DisposableStore, dispose } from './DisposableStore';
+export * from './types';

package/dist/index.js

@@ -0,0 +1,8 @@
+
+'use strict'
+
+if (process.env.NODE_ENV === 'production') {
+  module.exports = require('./disposable.cjs.production.min.js')
+} else {
+  module.exports = require('./disposable.cjs.development.js')
+}

package/dist/types/disposable.d.ts

@@ -0,0 +1,3 @@
+export interface IDisposable {
+    dispose(): void;
+}

package/dist/types/index.d.ts

@@ -0,0 +1 @@
+export * from './disposable';

package/dist/utils.d.ts

@@ -0,0 +1,4 @@
+export declare function isObject(thing: any): thing is Object;
+export declare function isFunction(thing: any): thing is Function;
+export declare function isArray(thing: any): thing is any[];
+export declare function isIterable<T = any>(thing: any): thing is Iterable<T>;

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@x-oasis/disposable",
+  "version": "0.1.36",
+  "description": "disposable function",
+  "main": "dist/index.js",
+  "typings": "dist/index.d.ts",
+  "module": "dist/disposable.esm.js",
+  "files": [
+    "dist",
+    "index.ts",
+    "src"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "tsdx": "^0.14.1"
+  },
+  "dependencies": {
+    "@x-oasis/is-object": "0.1.36"
+  },
+  "scripts": {
+    "build": "tsdx build --tsconfig tsconfig.build.json",
+    "clean": "rimraf ./dist",
+    "test": "vitest",
+    "compile": "tsc -p tsconfig.build.json"
+  }
+}

package/src/Disposable.ts

@@ -0,0 +1,32 @@
+import DisposableStore from './DisposableStore';
+import { IDisposable } from './types/disposable';
+import { isFunction, isObject } from './utils';
+
+export function isDisposable<T extends object>(
+  thing: T
+): thing is T & IDisposable {
+  return isObject(thing) && isFunction((thing as IDisposable).dispose);
+}
+
+export function toDisposable(fn: Function): IDisposable {
+  return {
+    dispose: () => fn(),
+  };
+}
+
+export class Disposable implements IDisposable {
+  static readonly None = Object.freeze<IDisposable>({ dispose() {} });
+
+  private readonly _store = new DisposableStore();
+
+  public dispose(): void {
+    this._store.dispose();
+  }
+
+  registerDisposable<T extends IDisposable>(disposable: T) {
+    if ((disposable as any) === this) {
+      throw new Error('Can not register itself');
+    }
+    this._store.add(disposable);
+  }
+}

package/src/DisposableStore.ts

@@ -0,0 +1,105 @@
+import { isDisposable } from './Disposable';
+import { IDisposable } from './types/disposable';
+import { isArray, isIterable } from './utils';
+
+export function dispose<T extends IDisposable>(disposable: T): T;
+export function dispose<T extends IDisposable>(
+  disposable: T | undefined
+): T | undefined;
+export function dispose<T extends IDisposable>(
+  arg: T | Iterable<T> | undefined
+): any;
+export function dispose<T extends IDisposable>(
+  disposables: T | T[] | Iterable<T> | undefined
+): T | T[] | undefined {
+  const errors = [];
+  if (isArray(disposables)) {
+    disposables.forEach((disposable) => {
+      try {
+        disposable?.dispose();
+      } catch (err) {
+        errors.push(err);
+      }
+    });
+    return [];
+  }
+  if (isIterable<IDisposable>(disposables) && !isArray(disposables)) {
+    for (const disposable of disposables as Iterable<IDisposable>) {
+      try {
+        disposable?.dispose();
+      } catch (err) {
+        errors.push(err);
+      }
+    }
+    return undefined;
+  }
+  if (
+    disposables &&
+    !isArray(disposables) &&
+    !isIterable(disposables) &&
+    isDisposable<IDisposable>(disposables)
+  ) {
+    try {
+      (disposables as IDisposable).dispose();
+    } catch (err) {
+      errors.push(err);
+    }
+    return disposables as T;
+  }
+  return undefined;
+}
+
+export default class DisposableStore implements IDisposable {
+  private readonly _toDispose = new Set<IDisposable>();
+
+  private _isDisposed = false;
+
+  public dispose(): void {
+    if (this._isDisposed) {
+      return;
+    }
+
+    this._isDisposed = true;
+    this.clear();
+  }
+
+  public get isDisposed(): boolean {
+    return this._isDisposed;
+  }
+
+  public clear(): void {
+    if (this._toDispose.size === 0) {
+      return;
+    }
+
+    dispose(this._toDispose);
+
+    this._toDispose.clear();
+  }
+
+  public add<T extends IDisposable>(thing: T): T {
+    if (!thing) return thing;
+    if ((thing as unknown as DisposableStore) === this) {
+      throw new Error('Cannot register a disposable on itself!');
+    }
+
+    if (this._isDisposed) {
+      // ...
+    } else {
+      this._toDispose.add(thing);
+    }
+
+    return thing;
+  }
+
+  public delete<T extends IDisposable>(thing: T): void {
+    if (!thing) {
+      return;
+    }
+    if ((thing as unknown as DisposableStore) === this) {
+      throw new Error('Cannot dispose a disposable on itself!');
+    }
+    this._toDispose.delete(thing);
+    thing.dispose();
+  }
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export { Disposable, toDisposable, isDisposable } from './Disposable';
+export { default as DisposableStore, dispose } from './DisposableStore';
+export * from './types';

package/src/types/disposable.ts

@@ -0,0 +1,3 @@
+export interface IDisposable {
+  dispose(): void;
+}

package/src/types/index.ts

@@ -0,0 +1 @@
+export * from './disposable';

package/src/utils.ts

@@ -0,0 +1,19 @@
+export function isObject(thing: any): thing is Object {
+  return typeof thing === 'object' && thing !== null;
+}
+
+export function isFunction(thing: any): thing is Function {
+  return typeof thing === 'function';
+}
+
+export function isArray(thing: any): thing is any[] {
+  return Array.isArray(thing);
+}
+
+export function isIterable<T = any>(thing: any): thing is Iterable<T> {
+  return (
+    thing &&
+    typeof thing === 'object' &&
+    typeof thing[Symbol.iterator] === 'function'
+  );
+}