@furystack/utils 7.0.1 → 8.0.0

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('/')
   }
 
   /**

package/src/using-async.spec.ts

@@ -0,0 +1,93 @@
+import { describe, expect, it, vi } from 'vitest'
+import { usingAsync } from './using-async.js'
+import { MockDisposable } from './using.spec.js'
+
+export class MockAsyncDisposable implements AsyncDisposable {
+  private disposed = false
+  public isDisposed = () => this.disposed
+  /**
+   * Disposes the MockDisposable instance, calls the dispose callback
+   */
+  public async [Symbol.asyncDispose]() {
+    this.disposed = true
+    this.disposeCallback && this.disposeCallback()
+  }
+
+  /**
+   * Mock to throw an error
+   */
+  public whooops() {
+    throw Error('Whooops')
+  }
+
+  /**
+   * Defines the callback that will be called on dispose
+   */
+  public disposeCallback!: () => void
+}
+
+/**
+ * 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 implements AsyncDisposable {
+      /** flag */
+      public isDisposed = false
+      /** set isDisposed with a timeout */
+      public async [Symbol.asyncDispose]() {
+        await new Promise<void>((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)
+  })
+})

package/src/using-async.ts

@@ -0,0 +1,24 @@
+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 <T extends Disposable | AsyncDisposable, TReturns>(
+  resource: T,
+  callback: (r: T) => Promise<TReturns>,
+) => {
+  try {
+    return await callback(resource)
+  } finally {
+    if (isAsyncDisposable(resource)) {
+      await resource[Symbol.asyncDispose]()
+    }
+    if (isDisposable(resource)) {
+      resource[Symbol.dispose]()
+    }
+  }
+}

package/src/using.spec.ts

@@ -0,0 +1,67 @@
+import { describe, expect, it, vi } from 'vitest'
+import { using } from './using.js'
+
+export class MockDisposable implements Disposable {
+  private disposed = false
+  public isDisposed = () => this.disposed
+  /**
+   * Disposes the MockDisposable instance, calls the dispose callback
+   */
+  public [Symbol.dispose]() {
+    this.disposed = true
+    this.disposeCallback && this.disposeCallback()
+  }
+
+  /**
+   * Mock to throw an error
+   */
+  public whooops() {
+    throw Error('Whooops')
+  }
+
+  /**
+   * Defines the callback that will be called on dispose
+   */
+  public disposeCallback!: () => void
+}
+
+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()
+    })
+  })
+})

package/src/using.ts

@@ -0,0 +1,13 @@
+/**
+ * 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 = <T extends Disposable, TReturns>(resource: T, callback: (r: T) => TReturns) => {
+  try {
+    return callback(resource)
+  } finally {
+    resource[Symbol.dispose]()
+  }
+}

package/src/value-observer.ts

@@ -1,4 +1,3 @@
-import type { Disposable } from './disposable.js'
 import type { ObservableValue, ValueChangeCallback } from './observable-value.js'
 
 export type ValueObserverOptions<T> = {
@@ -21,9 +20,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
  */
@@ -31,7 +30,7 @@ export class ValueObserver<T> implements Disposable {
   /**
    * Disposes the ValueObserver instance. Unsubscribes from the observable
    */
-  public dispose() {
+  public [Symbol.dispose]() {
     this.observable.unsubscribe(this)
   }
 

package/esm/disposable.d.ts

@@ -1,49 +0,0 @@
-/**
- *
- * You can implement *IDisposable* resources and use them with a *using()* or *usingAsync()* syntax.
- *
- * Usage example:
- *
- * ```ts
- * class Resource implements IDisposable{
- *       dispose(){
- *           // cleanup logics
- *      }
- * }
- *
- *
- * using(new Resource(), (resource)=>{
- *      // do something with the resource
- * })
- *
- * usingAsync(new Resource(), async (resource)=>{
- *      // do something with the resource, allows awaiting promises
- * })
- * ```
- */
-/** */
-/**
- * Resources in using an usingAsync should implement this interface
- *
- */
-export interface Disposable {
-    /**
-     * Method called when the IDisposable is disposed.
-     */
-    dispose: () => void | Promise<void>;
-}
-/**
- * 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;
-/**
- * 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 declare const usingAsync: <T extends Disposable, TReturns>(resource: T, callback: (r: T) => Promise<TReturns>) => Promise<TReturns>;
-//# sourceMappingURL=disposable.d.ts.map

package/esm/disposable.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"disposable.d.ts","sourceRoot":"","sources":["../src/disposable.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM;AAEN;;;GAGG;AACH,MAAM,WAAW,UAAU;IACzB;;OAEG;IACH,OAAO,EAAE,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CACpC;AAED;;;;;GAKG;AACH,eAAO,MAAM,KAAK,6CAA8C,CAAC,YAAY,CAAC,CAAC,EAAE,CAAC,KAAK,QAAQ,aAM9F,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,UAAU,6CACX,CAAC,YACD,CAAC,CAAC,EAAE,CAAC,KAAK,QAAQ,QAAQ,CAAC,sBAUtC,CAAA"}

package/esm/disposable.js

@@ -1,56 +0,0 @@
-/**
- *
- * You can implement *IDisposable* resources and use them with a *using()* or *usingAsync()* syntax.
- *
- * Usage example:
- *
- * ```ts
- * class Resource implements IDisposable{
- *       dispose(){
- *           // cleanup logics
- *      }
- * }
- *
- *
- * using(new Resource(), (resource)=>{
- *      // do something with the resource
- * })
- *
- * usingAsync(new Resource(), async (resource)=>{
- *      // do something with the resource, allows awaiting promises
- * })
- * ```
- */
-/** */
-/**
- * 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.dispose();
-    }
-};
-/**
- * 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 {
-        const disposeResult = resource.dispose();
-        if (disposeResult instanceof Promise) {
-            await disposeResult;
-        }
-    }
-};
-//# sourceMappingURL=disposable.js.map

package/esm/disposable.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"disposable.js","sourceRoot":"","sources":["../src/disposable.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM;AAaN;;;;;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,OAAO,EAAE,CAAA;IACpB,CAAC;AACH,CAAC,CAAA;AAED;;;;;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,MAAM,aAAa,GAAG,QAAQ,CAAC,OAAO,EAAE,CAAA;QACxC,IAAI,aAAa,YAAY,OAAO,EAAE,CAAC;YACrC,MAAM,aAAa,CAAA;QACrB,CAAC;IACH,CAAC;AACH,CAAC,CAAA"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"disposable.spec.d.ts","sourceRoot":"","sources":["../src/disposable.spec.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAGjD,qBAAa,cAAe,YAAW,UAAU;IAC/C,OAAO,CAAC,QAAQ,CAAQ;IACjB,UAAU,gBAAsB;IACvC;;OAEG;IACI,OAAO,aAGb;IAED;;OAEG;IACI,OAAO;IAId;;OAEG;IACI,eAAe,EAAG,MAAM,IAAI,CAAA;CACpC;AAED;;GAEG;AACH,eAAO,MAAM,eAAe,qCAkG1B,CAAA"}

package/esm/disposable.spec.js

@@ -1,118 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { using, usingAsync } from './disposable.js';
-export class MockDisposable {
-    disposed = false;
-    isDisposed = () => this.disposed;
-    /**
-     * Disposes the MockDisposable instance, calls the dispose callback
-     */
-    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;
-}
-/**
- * Unit tests for disposables
- */
-export const disposableTests = describe('Disposable', () => {
-    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);
-    });
-    it('Should return a value from an async callback', async () => {
-        const returned = await usingAsync(new MockDisposable(), async () => {
-            return 2;
-        });
-        expect(returned).toBe(2);
-    });
-    describe('isDisposed', () => {
-        it('should return a correct value before and after disposition', () => {
-            const d = new MockDisposable();
-            expect(d.isDisposed()).toBe(false);
-            d.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();
-        });
-        it('should be called with usingAsync()', async () => {
-            const callbackMethod = vi.fn();
-            await usingAsync(new MockDisposable(), async (d) => {
-                d.disposeCallback = () => {
-                    callbackMethod();
-                };
-                return new Promise((resolve) => {
-                    setTimeout(resolve, 1);
-                });
-            });
-            expect(callbackMethod).toBeCalled();
-        });
-        it('should be called when async fails', async () => {
-            const callbackMethod = vi.fn();
-            try {
-                await usingAsync(new MockDisposable(), 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 dispose() {
-                    await new Promise((resolve) => setTimeout(() => {
-                        this.isDisposed = true;
-                        resolve();
-                    }, 10));
-                }
-            }
-            const asyncDispose = new AsyncDispose();
-            await usingAsync(asyncDispose, async () => {
-                /** */
-            });
-            expect(asyncDispose.isDisposed).toBe(true);
-        });
-    });
-});
-//# sourceMappingURL=disposable.spec.js.map

package/esm/disposable.spec.js.map

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