@furystack/utils 7.0.2 → 8.0.1

package/esm/using-async.js

@@ -0,0 +1,22 @@
+import { isAsyncDisposable } from './is-async-disposable.js';
+import { isDisposable } from './is-disposable.js';
+/**
+ * Method that accepts an IDisposable resource that will be disposed after the callback
+ * @param resource The resource that is used in the callback and will be disposed afterwards
+ * @param callback The callback that will be executed asynchrounously before the resource will be disposed
+ * @returns A promise that will be resolved with a return value after the resource is disposed
+ */
+export const usingAsync = async (resource, callback) => {
+    try {
+        return await callback(resource);
+    }
+    finally {
+        if (isAsyncDisposable(resource)) {
+            await resource[Symbol.asyncDispose]();
+        }
+        if (isDisposable(resource)) {
+            resource[Symbol.dispose]();
+        }
+    }
+};
+//# sourceMappingURL=using-async.js.map

package/esm/using-async.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"using-async.js","sourceRoot":"","sources":["../src/using-async.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAA;AAC5D,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAEjD;;;;;GAKG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,KAAK,EAC7B,QAAW,EACX,QAAqC,EACrC,EAAE;IACF,IAAI,CAAC;QACH,OAAO,MAAM,QAAQ,CAAC,QAAQ,CAAC,CAAA;IACjC,CAAC;YAAS,CAAC;QACT,IAAI,iBAAiB,CAAC,QAAQ,CAAC,EAAE,CAAC;YAChC,MAAM,QAAQ,CAAC,MAAM,CAAC,YAAY,CAAC,EAAE,CAAA;QACvC,CAAC;QACD,IAAI,YAAY,CAAC,QAAQ,CAAC,EAAE,CAAC;YAC3B,QAAQ,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,CAAA;QAC5B,CAAC;IACH,CAAC;AACH,CAAC,CAAA"}

package/esm/using-async.spec.d.ts

@@ -0,0 +1,17 @@
+export declare class MockAsyncDisposable implements AsyncDisposable {
+    private disposed;
+    isDisposed: () => boolean;
+    /**
+     * Disposes the MockDisposable instance, calls the dispose callback
+     */
+    [Symbol.asyncDispose](): Promise<void>;
+    /**
+     * Mock to throw an error
+     */
+    whooops(): void;
+    /**
+     * Defines the callback that will be called on dispose
+     */
+    disposeCallback: () => void;
+}
+//# sourceMappingURL=using-async.spec.d.ts.map

package/esm/using-async.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"using-async.spec.d.ts","sourceRoot":"","sources":["../src/using-async.spec.ts"],"names":[],"mappings":"AAIA,qBAAa,mBAAoB,YAAW,eAAe;IACzD,OAAO,CAAC,QAAQ,CAAQ;IACjB,UAAU,gBAAsB;IACvC;;OAEG;IACU,CAAC,MAAM,CAAC,YAAY,CAAC;IAKlC;;OAEG;IACI,OAAO;IAId;;OAEG;IACI,eAAe,EAAG,MAAM,IAAI,CAAA;CACpC"}

package/esm/using-async.spec.js

@@ -0,0 +1,84 @@
+import { describe, expect, it, vi } from 'vitest';
+import { usingAsync } from './using-async.js';
+import { MockDisposable } from './using.spec.js';
+export class MockAsyncDisposable {
+    disposed = false;
+    isDisposed = () => this.disposed;
+    /**
+     * Disposes the MockDisposable instance, calls the dispose callback
+     */
+    async [Symbol.asyncDispose]() {
+        this.disposed = true;
+        this.disposeCallback && this.disposeCallback();
+    }
+    /**
+     * Mock to throw an error
+     */
+    whooops() {
+        throw Error('Whooops');
+    }
+    /**
+     * Defines the callback that will be called on dispose
+     */
+    disposeCallback;
+}
+/**
+ * Unit tests for disposables
+ */
+describe('usingAsync()', () => {
+    it('dispose should be called with usingAsync()', async () => {
+        const callbackMethod = vi.fn();
+        await usingAsync(new MockAsyncDisposable(), async (d) => {
+            d.disposeCallback = () => {
+                callbackMethod();
+            };
+            return new Promise((resolve) => {
+                setTimeout(resolve, 1);
+            });
+        });
+        expect(callbackMethod).toBeCalled();
+    });
+    it('dispose should be called when async fails', async () => {
+        const callbackMethod = vi.fn();
+        try {
+            await usingAsync(new MockAsyncDisposable(), async (d) => {
+                d.disposeCallback = () => {
+                    callbackMethod();
+                };
+                return new Promise((_resolve, reject) => {
+                    setTimeout(reject, 1);
+                });
+            });
+        }
+        catch (error) {
+            /** ignore */
+        }
+        expect(callbackMethod).toBeCalled();
+    });
+    it('should await dispose for asyncs with usingAsync()', async () => {
+        class AsyncDispose {
+            /** flag */
+            isDisposed = false;
+            /** set isDisposed with a timeout */
+            async [Symbol.asyncDispose]() {
+                await new Promise((resolve) => setTimeout(() => {
+                    this.isDisposed = true;
+                    resolve();
+                }, 10));
+            }
+        }
+        const asyncDispose = new AsyncDispose();
+        await usingAsync(asyncDispose, async () => {
+            /** */
+        });
+        expect(asyncDispose.isDisposed).toBe(true);
+    });
+    it('Should dispose a non-async disposable object as well', async () => {
+        const createdResource = await usingAsync(new MockDisposable(), async (mock) => {
+            expect(mock).toBeInstanceOf(MockDisposable);
+            return mock;
+        });
+        expect(createdResource.isDisposed()).toBe(true);
+    });
+});
+//# sourceMappingURL=using-async.spec.js.map

package/esm/using-async.spec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"using-async.spec.js","sourceRoot":"","sources":["../src/using-async.spec.ts"],"names":[],"mappings":"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"}

package/esm/using.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Method that accepts an IDisposable resource that will be disposed after the callback
+ * @param resource The resource that is used in the callback and will be disposed afterwards
+ * @param callback The callback that will be executed synchrounously before the resource will be disposed
+ * @returns the value that will be returned by the callback method
+ */
+export declare const using: <T extends Disposable, TReturns>(resource: T, callback: (r: T) => TReturns) => TReturns;
+//# sourceMappingURL=using.d.ts.map

package/esm/using.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"using.d.ts","sourceRoot":"","sources":["../src/using.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,eAAO,MAAM,KAAK,GAAI,CAAC,SAAS,UAAU,EAAE,QAAQ,YAAY,CAAC,YAAY,CAAC,CAAC,EAAE,CAAC,KAAK,QAAQ,aAM9F,CAAA"}

package/esm/using.js

@@ -0,0 +1,15 @@
+/**
+ * Method that accepts an IDisposable resource that will be disposed after the callback
+ * @param resource The resource that is used in the callback and will be disposed afterwards
+ * @param callback The callback that will be executed synchrounously before the resource will be disposed
+ * @returns the value that will be returned by the callback method
+ */
+export const using = (resource, callback) => {
+    try {
+        return callback(resource);
+    }
+    finally {
+        resource[Symbol.dispose]();
+    }
+};
+//# sourceMappingURL=using.js.map

package/esm/using.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"using.js","sourceRoot":"","sources":["../src/using.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,CAAC,MAAM,KAAK,GAAG,CAAiC,QAAW,EAAE,QAA4B,EAAE,EAAE;IACjG,IAAI,CAAC;QACH,OAAO,QAAQ,CAAC,QAAQ,CAAC,CAAA;IAC3B,CAAC;YAAS,CAAC;QACT,QAAQ,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,CAAA;IAC5B,CAAC;AACH,CAAC,CAAA"}

package/esm/{disposable.spec.d.ts → using.spec.d.ts}

@@ -1,11 +1,10 @@
-import type { Disposable } from './disposable.js';
 export declare class MockDisposable implements Disposable {
     private disposed;
     isDisposed: () => boolean;
     /**
      * Disposes the MockDisposable instance, calls the dispose callback
      */
-    dispose: () => void;
+    [Symbol.dispose](): void;
     /**
      * Mock to throw an error
      */
@@ -15,8 +14,4 @@ export declare class MockDisposable implements Disposable {
      */
     disposeCallback: () => void;
 }
-/**
- * Unit tests for disposables
- */
-export declare const disposableTests: import("vitest").SuiteCollector<{}>;
-//# sourceMappingURL=disposable.spec.d.ts.map
+//# sourceMappingURL=using.spec.d.ts.map

package/esm/using.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"using.spec.d.ts","sourceRoot":"","sources":["../src/using.spec.ts"],"names":[],"mappings":"AAGA,qBAAa,cAAe,YAAW,UAAU;IAC/C,OAAO,CAAC,QAAQ,CAAQ;IACjB,UAAU,gBAAsB;IACvC;;OAEG;IACI,CAAC,MAAM,CAAC,OAAO,CAAC;IAKvB;;OAEG;IACI,OAAO;IAId;;OAEG;IACI,eAAe,EAAG,MAAM,IAAI,CAAA;CACpC"}

package/esm/using.spec.js

@@ -0,0 +1,62 @@
+import { describe, expect, it, vi } from 'vitest';
+import { using } from './using.js';
+export class MockDisposable {
+    disposed = false;
+    isDisposed = () => this.disposed;
+    /**
+     * Disposes the MockDisposable instance, calls the dispose callback
+     */
+    [Symbol.dispose]() {
+        this.disposed = true;
+        this.disposeCallback && this.disposeCallback();
+    }
+    /**
+     * Mock to throw an error
+     */
+    whooops() {
+        throw Error('Whooops');
+    }
+    /**
+     * Defines the callback that will be called on dispose
+     */
+    disposeCallback;
+}
+describe('Using', () => {
+    it('Can be constructed', () => {
+        using(new MockDisposable(), (d) => {
+            expect(d).toBeInstanceOf(MockDisposable);
+        });
+    });
+    it('Should return a value from a callback', () => {
+        const returned = using(new MockDisposable(), () => {
+            return 1;
+        });
+        expect(returned).toBe(1);
+    });
+    describe('isDisposed', () => {
+        it('should return a correct value before and after disposition', () => {
+            const d = new MockDisposable();
+            expect(d.isDisposed()).toBe(false);
+            d[Symbol.dispose]();
+            expect(d.isDisposed()).toBe(true);
+        });
+    });
+    describe('dispose()', () => {
+        it('should be called on error', () => {
+            const callbackMethod = vi.fn();
+            try {
+                using(new MockDisposable(), (d) => {
+                    d.disposeCallback = () => {
+                        callbackMethod();
+                    };
+                    d.whooops();
+                });
+            }
+            catch {
+                /** ignore */
+            }
+            expect(callbackMethod).toBeCalled();
+        });
+    });
+});
+//# sourceMappingURL=using.spec.js.map

package/esm/using.spec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"using.spec.js","sourceRoot":"","sources":["../src/using.spec.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,EAAE,MAAM,QAAQ,CAAA;AACjD,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAElC,MAAM,OAAO,cAAc;IACjB,QAAQ,GAAG,KAAK,CAAA;IACjB,UAAU,GAAG,GAAG,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAA;IACvC;;OAEG;IACI,CAAC,MAAM,CAAC,OAAO,CAAC;QACrB,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAA;QACpB,IAAI,CAAC,eAAe,IAAI,IAAI,CAAC,eAAe,EAAE,CAAA;IAChD,CAAC;IAED;;OAEG;IACI,OAAO;QACZ,MAAM,KAAK,CAAC,SAAS,CAAC,CAAA;IACxB,CAAC;IAED;;OAEG;IACI,eAAe,CAAa;CACpC;AAED,QAAQ,CAAC,OAAO,EAAE,GAAG,EAAE;IACrB,EAAE,CAAC,oBAAoB,EAAE,GAAG,EAAE;QAC5B,KAAK,CAAC,IAAI,cAAc,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE;YAChC,MAAM,CAAC,CAAC,CAAC,CAAC,cAAc,CAAC,cAAc,CAAC,CAAA;QAC1C,CAAC,CAAC,CAAA;IACJ,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,uCAAuC,EAAE,GAAG,EAAE;QAC/C,MAAM,QAAQ,GAAG,KAAK,CAAC,IAAI,cAAc,EAAE,EAAE,GAAG,EAAE;YAChD,OAAO,CAAC,CAAA;QACV,CAAC,CAAC,CAAA;QACF,MAAM,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAA;IAC1B,CAAC,CAAC,CAAA;IAEF,QAAQ,CAAC,YAAY,EAAE,GAAG,EAAE;QAC1B,EAAE,CAAC,4DAA4D,EAAE,GAAG,EAAE;YACpE,MAAM,CAAC,GAAG,IAAI,cAAc,EAAE,CAAA;YAC9B,MAAM,CAAC,CAAC,CAAC,UAAU,EAAE,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;YAClC,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,CAAA;YACnB,MAAM,CAAC,CAAC,CAAC,UAAU,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;QACnC,CAAC,CAAC,CAAA;IACJ,CAAC,CAAC,CAAA;IAEF,QAAQ,CAAC,WAAW,EAAE,GAAG,EAAE;QACzB,EAAE,CAAC,2BAA2B,EAAE,GAAG,EAAE;YACnC,MAAM,cAAc,GAAG,EAAE,CAAC,EAAE,EAAE,CAAA;YAC9B,IAAI,CAAC;gBACH,KAAK,CAAC,IAAI,cAAc,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE;oBAChC,CAAC,CAAC,eAAe,GAAG,GAAG,EAAE;wBACvB,cAAc,EAAE,CAAA;oBAClB,CAAC,CAAA;oBACD,CAAC,CAAC,OAAO,EAAE,CAAA;gBACb,CAAC,CAAC,CAAA;YACJ,CAAC;YAAC,MAAM,CAAC;gBACP,aAAa;YACf,CAAC;YACD,MAAM,CAAC,cAAc,CAAC,CAAC,UAAU,EAAE,CAAA;QACrC,CAAC,CAAC,CAAA;IACJ,CAAC,CAAC,CAAA;AACJ,CAAC,CAAC,CAAA"}

package/esm/value-observer.d.ts

@@ -1,4 +1,3 @@
-import type { Disposable } from './disposable.js';
 import type { ObservableValue, ValueChangeCallback } from './observable-value.js';
 export type ValueObserverOptions<T> = {
     filter?: (nextValue: T, lastValue: T) => boolean;
@@ -19,9 +18,9 @@ export type ValueObserverOptions<T> = {
  * // To update the value
  * observableValue.setValue(Math.random());
  * // if you want to dispose a single observer
- * observer.dispose();
+ * observer[Symbol.dispose]();
  * // if you want to dispose the whole observableValue with all of its observers:
- * observableValue.dispose();
+ * observableValue[Symbol.dispose]();
  * ```
  * @param T This type parameter is the value type to observe
  */
@@ -32,7 +31,7 @@ export declare class ValueObserver<T> implements Disposable {
     /**
      * Disposes the ValueObserver instance. Unsubscribes from the observable
      */
-    dispose(): void;
+    [Symbol.dispose](): void;
     /**
      * @constructs ValueObserver<T> the ValueObserver instance
      * @param observable The related Observable object

package/esm/value-observer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"value-observer.d.ts","sourceRoot":"","sources":["../src/value-observer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AACjD,OAAO,KAAK,EAAE,eAAe,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAA;AAEjF,MAAM,MAAM,oBAAoB,CAAC,CAAC,IAAI;IACpC,MAAM,CAAC,EAAE,CAAC,SAAS,EAAE,CAAC,EAAE,SAAS,EAAE,CAAC,KAAK,OAAO,CAAA;CACjD,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBAAa,aAAa,CAAC,CAAC,CAAE,YAAW,UAAU;aAe/B,UAAU,EAAE,eAAe,CAAC,CAAC,CAAC;IACvC,QAAQ,EAAE,mBAAmB,CAAC,CAAC,CAAC;aACvB,OAAO,CAAC;IAhB1B;;OAEG;IACI,OAAO;IAId;;;;;OAKG;gBAEe,UAAU,EAAE,eAAe,CAAC,CAAC,CAAC,EACvC,QAAQ,EAAE,mBAAmB,CAAC,CAAC,CAAC,EACvB,OAAO,CAAC,qCAAyB;CAEpD"}
+{"version":3,"file":"value-observer.d.ts","sourceRoot":"","sources":["../src/value-observer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAA;AAEjF,MAAM,MAAM,oBAAoB,CAAC,CAAC,IAAI;IACpC,MAAM,CAAC,EAAE,CAAC,SAAS,EAAE,CAAC,EAAE,SAAS,EAAE,CAAC,KAAK,OAAO,CAAA;CACjD,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBAAa,aAAa,CAAC,CAAC,CAAE,YAAW,UAAU;aAe/B,UAAU,EAAE,eAAe,CAAC,CAAC,CAAC;IACvC,QAAQ,EAAE,mBAAmB,CAAC,CAAC,CAAC;aACvB,OAAO,CAAC,EAAE,oBAAoB,CAAC,CAAC,CAAC;IAhBnD;;OAEG;IACI,CAAC,MAAM,CAAC,OAAO,CAAC;IAIvB;;;;;OAKG;gBAEe,UAAU,EAAE,eAAe,CAAC,CAAC,CAAC,EACvC,QAAQ,EAAE,mBAAmB,CAAC,CAAC,CAAC,EACvB,OAAO,CAAC,EAAE,oBAAoB,CAAC,CAAC,CAAC,YAAA;CAEpD"}

package/esm/value-observer.js

@@ -14,9 +14,9 @@
  * // To update the value
  * observableValue.setValue(Math.random());
  * // if you want to dispose a single observer
- * observer.dispose();
+ * observer[Symbol.dispose]();
  * // if you want to dispose the whole observableValue with all of its observers:
- * observableValue.dispose();
+ * observableValue[Symbol.dispose]();
  * ```
  * @param T This type parameter is the value type to observe
  */
@@ -27,7 +27,7 @@ export class ValueObserver {
     /**
      * Disposes the ValueObserver instance. Unsubscribes from the observable
      */
-    dispose() {
+    [Symbol.dispose]() {
         this.observable.unsubscribe(this);
     }
     /**

package/esm/value-observer.js.map

@@ -1 +1 @@
-{"version":3,"file":"value-observer.js","sourceRoot":"","sources":["../src/value-observer.ts"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,OAAO,aAAa;IAeN;IACT;IACS;IAhBlB;;OAEG;IACI,OAAO;QACZ,IAAI,CAAC,UAAU,CAAC,WAAW,CAAC,IAAI,CAAC,CAAA;IACnC,CAAC;IAED;;;;;OAKG;IACH,YACkB,UAA8B,EACvC,QAAgC,EACvB,OAAiC;QAFjC,eAAU,GAAV,UAAU,CAAoB;QACvC,aAAQ,GAAR,QAAQ,CAAwB;QACvB,YAAO,GAAP,OAAO,CAA0B;IAChD,CAAC;CACL"}
+{"version":3,"file":"value-observer.js","sourceRoot":"","sources":["../src/value-observer.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,OAAO,aAAa;IAeN;IACT;IACS;IAhBlB;;OAEG;IACI,CAAC,MAAM,CAAC,OAAO,CAAC;QACrB,IAAI,CAAC,UAAU,CAAC,WAAW,CAAC,IAAI,CAAC,CAAA;IACnC,CAAC;IAED;;;;;OAKG;IACH,YACkB,UAA8B,EACvC,QAAgC,EACvB,OAAiC;QAFjC,eAAU,GAAV,UAAU,CAAoB;QACvC,aAAQ,GAAR,QAAQ,CAAwB;QACvB,YAAO,GAAP,OAAO,CAA0B;IAChD,CAAC;CACL"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@furystack/utils",
-  "version": "7.0.2",
+  "version": "8.0.1",
   "description": "General utilities",
   "type": "module",
   "scripts": {
@@ -34,7 +34,7 @@
   },
   "homepage": "https://github.com/furystack/furystack",
   "devDependencies": {
-    "typescript": "^5.4.5",
-    "vitest": "^1.6.0"
+    "typescript": "^5.5.3",
+    "vitest": "^2.0.3"
   }
 }

package/src/deep-merge.spec.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect } from 'vitest'
+import { describe, expect, it } from 'vitest'
 import { deepMerge } from './deep-merge.js'
 
 describe('DeepMerge tests', () => {
@@ -12,7 +12,7 @@ describe('DeepMerge tests', () => {
   })
 
   it('Should skip falsy sources', () => {
-    expect(deepMerge({ a: 1, b: 0, c: 0 }, null as any, { b: 2 }, { c: 3 })).toEqual({ a: 1, b: 2, c: 3 })
+    expect(deepMerge({ a: 1, b: 0, c: 0 }, null as any as {}, { b: 2 }, { c: 3 })).toEqual({ a: 1, b: 2, c: 3 })
   })
 
   it('Should override arrays', () => {

package/src/event-hub.spec.ts

@@ -1,5 +1,5 @@
-import { EventHub } from './event-hub.js'
 import { describe, expect, it, vi } from 'vitest'
+import { EventHub } from './event-hub.js'
 
 describe('EventHub', () => {
   it('Should fail on type errors', () => {
@@ -74,7 +74,7 @@ describe('EventHub', () => {
     expect(objectListener2).toBeCalledTimes(1)
   })
 
-  it('Should add and remove a listener with subscription', () => {
+  it('Should add and remove a listener with subscription', async () => {
     const eventHub = new EventHub<{ ExampleNumberEvent: number }>()
     const numberListener = vi.fn((_val: number) => {})
 
@@ -82,7 +82,7 @@ describe('EventHub', () => {
     eventHub.emit('ExampleNumberEvent', 1)
 
     expect(numberListener).toBeCalledWith(1)
-    subscription.dispose()
+    subscription[Symbol.dispose]()
     eventHub.emit('ExampleNumberEvent', 2)
     expect(numberListener).toBeCalledTimes(1)
   })
@@ -93,7 +93,7 @@ describe('EventHub', () => {
     const listener = vi.fn((_val: string) => {})
 
     hub.addListener('test', listener)
-    hub.dispose()
+    hub[Symbol.dispose]()
     hub.emit('test', 'test')
     expect(listener).not.toBeCalled()
   })

package/src/event-hub.ts

@@ -1,5 +1,3 @@
-import type { Disposable } from './disposable.js'
-
 type ListenerFunction<EventTypeMap extends Object, T extends keyof EventTypeMap> = (arg: EventTypeMap[T]) => void
 
 export class EventHub<EventTypeMap extends Object> implements Disposable {
@@ -29,7 +27,7 @@ export class EventHub<EventTypeMap extends Object> implements Disposable {
     listener: ListenerFunction<EventTypeMap, TEvent>,
   ): Disposable {
     this.addListener(event, listener)
-    return { dispose: () => this.removeListener(event, listener) }
+    return { [Symbol.dispose]: () => this.removeListener(event, listener) }
   }
 
   public emit<TEvent extends keyof EventTypeMap>(event: TEvent, arg: EventTypeMap[TEvent]) {
@@ -38,7 +36,7 @@ export class EventHub<EventTypeMap extends Object> implements Disposable {
     }
   }
 
-  public dispose() {
+  public [Symbol.dispose]() {
     this.listeners.clear()
   }
 }

package/src/index.ts

@@ -1,11 +1,13 @@
-export * from './disposable.js'
-export * from './deep-merge.js'
 export * from './debounce.js'
+export * from './deep-merge.js'
 export * from './event-hub.js'
+export * from './is-async-disposable.js'
+export * from './is-disposable.js'
 export * from './observable-value.js'
-export * from './value-observer.js'
 export * from './path-helper.js'
 export * from './sleep-async.js'
 export * from './sort-by.js'
-export * from './trace.js'
 export * from './tuple.js'
+export * from './using-async.js'
+export * from './using.js'
+export * from './value-observer.js'

package/src/is-async-disposable.spec.ts

@@ -0,0 +1,23 @@
+import { describe, expect, it } from 'vitest'
+import { isAsyncDisposable } from './is-async-disposable.js'
+
+describe('isAsyndDisposable', () => {
+  it('should return true if the value is an instance of an async disposable object', () => {
+    const asyncDisposable = {
+      [Symbol.asyncDispose]: () => {},
+    }
+    expect(isAsyncDisposable(asyncDisposable)).toBe(true)
+  })
+
+  it('Should return false is the object has Symbol.asyncDispose but it is not a function', () => {
+    const asyncDisposable = {
+      [Symbol.asyncDispose]: 'not a function',
+    }
+    expect(isAsyncDisposable(asyncDisposable)).toBe(false)
+  })
+
+  it('Should return false is the object does not have Symbol.asyncDispose', () => {
+    const asyncDisposable = {}
+    expect(isAsyncDisposable(asyncDisposable)).toBe(false)
+  })
+})

package/src/is-async-disposable.ts

@@ -0,0 +1,8 @@
+/**
+ *
+ * @param value The value to check
+ * @returns if the value is an instance of an async disposable object
+ */
+export const isAsyncDisposable = (value: unknown): value is AsyncDisposable => {
+  return (value as AsyncDisposable)?.[Symbol.asyncDispose] instanceof Function
+}

package/src/is-disposable.spec.ts

@@ -0,0 +1,23 @@
+import { describe, expect, it } from 'vitest'
+import { isDisposable } from './is-disposable.js'
+
+describe('isDisposable', () => {
+  it('should return true if the value is an instance of a disposable object', () => {
+    const disposable = {
+      [Symbol.dispose]: () => {},
+    }
+    expect(isDisposable(disposable)).toBe(true)
+  })
+
+  it('Should return false is the object has Symbol.dispose but it is not a function', () => {
+    const disposable = {
+      [Symbol.dispose]: 'not a function',
+    }
+    expect(isDisposable(disposable)).toBe(false)
+  })
+
+  it('Should return false is the object does not have Symbol.dispose', () => {
+    const disposable = {}
+    expect(isDisposable(disposable)).toBe(false)
+  })
+})

package/src/is-disposable.ts

@@ -0,0 +1,8 @@
+/**
+ *
+ * @param value The value to check
+ * @returns if the value is an instance of a disposable object
+ */
+export const isDisposable = (value: unknown): value is Disposable => {
+  return (value as Disposable)?.[Symbol.dispose] instanceof Function
+}

package/src/observable-value.spec.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect, vi } from 'vitest'
+import { describe, expect, it, vi } from 'vitest'
 import { ObservableValue } from './observable-value.js'
 
 /**
@@ -74,8 +74,10 @@ export const observableTests = describe('Observable', () => {
       v.subscribe(callback1)
       v.subscribe(callback2)
       expect(v.getObservers().length).toBe(2)
-      v.dispose()
+      v[Symbol.dispose]()
       expect(v.getObservers().length).toBe(0)
+
+      expect(v.isDisposed).toBe(true)
     })
 
     it('should remove the subscription on Observer dispose', () => {
@@ -85,25 +87,25 @@ export const observableTests = describe('Observable', () => {
       const v = new ObservableValue(1)
       const observer = v.subscribe(callback1)
       expect(v.getObservers().length).toBe(1)
-      observer.dispose()
+      observer[Symbol.dispose]()
       expect(v.getObservers().length).toBe(0)
     })
 
     it('should throw an error for setValue() when the observer has been disposed', () => {
       const v = new ObservableValue(1)
-      v.dispose()
+      v[Symbol.dispose]()
       expect(() => v.setValue(3)).toThrowError('Observable already disposed')
     })
 
     it('should throw an error for getValue() when the observer has been disposed', () => {
       const v = new ObservableValue(1)
-      v.dispose()
+      v[Symbol.dispose]()
       expect(() => v.getValue()).toThrowError('Observable already disposed')
     })
 
     it('should throw an error for subscribe() when the observer has been disposed', () => {
       const v = new ObservableValue(1)
-      v.dispose()
+      v[Symbol.dispose]()
       expect(() =>
         v.subscribe(() => {
           /** */
@@ -120,10 +122,10 @@ export const observableTests = describe('Observable', () => {
         }
       }
       const v = new ObservableValue(1)
-      const observer = v.subscribe(new Alma().Callback)
-      v.subscribe(new Alma().Callback)
+      const observer = v.subscribe(() => new Alma().Callback())
+      v.subscribe(() => new Alma().Callback())
       expect(v.getObservers().length).toBe(2)
-      observer.dispose()
+      observer[Symbol.dispose]()
       expect(v.getObservers().length).toBe(1)
       v.setValue(3)
 

package/src/observable-value.ts

@@ -1,4 +1,3 @@
-import type { Disposable } from './disposable.js'
 import type { ValueObserverOptions } from './value-observer.js'
 import { ValueObserver } from './value-observer.js'
 
@@ -42,9 +41,9 @@ const defaultComparer = <T>(a: T, b: T) => a !== b
  * // To update the value
  * observableValue.setValue(Math.random());
  * // if you want to dispose a single observer
- * observer.dispose();
+ * observer[Symbol.dispose]();
  * // if you want to dispose the whole observableValue with all of its observers:
- * observableValue.dispose();
+ * observableValue[Symbol.dispose]();
  * ```
  * @param T Generic argument to indicate the value type
  */
@@ -58,7 +57,7 @@ export class ObservableValue<T> implements Disposable {
   /**
    * Disposes the ObservableValue object, removes all observers
    */
-  public dispose() {
+  public [Symbol.dispose]() {
     this.observers.clear()
     this._isDisposed = true
     // @ts-expect-error getting currentValue after disposing is not allowed

package/src/path-helper.spec.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect } from 'vitest'
+import { describe, expect, it } from 'vitest'
 import { PathHelper } from './path-helper.js'
 
 /**
@@ -69,4 +69,13 @@ export const pathHelperTests = describe('PathHelper', () => {
       expect(PathHelper.getParentPath('Root')).toBe('Root')
     })
   })
+
+  describe('#normalize()', () => {
+    it('Should normalize the path', () => {
+      expect(PathHelper.normalize('Root/Example/Content')).toBe('Root/Example/Content')
+      expect(PathHelper.normalize('/Root/Example/Content')).toBe('Root/Example/Content')
+      expect(PathHelper.normalize('Root/Example/Content/')).toBe('Root/Example/Content')
+      expect(PathHelper.normalize('/Root/Example/Content/')).toBe('Root/Example/Content')
+    })
+  })
 })

package/src/path-helper.ts

@@ -35,7 +35,7 @@ export class PathHelper {
    * @returns the joined path string
    */
   public static joinPaths(...args: string[]) {
-    return args.map(this.trimSlashes).join('/')
+    return args.map((path) => this.trimSlashes(path)).join('/')
   }
 
   /**