@furystack/utils 3.1.7 → 4.0.0

package/package.json

@@ -1,18 +1,30 @@
 {
   "name": "@furystack/utils",
-  "version": "3.1.7",
+  "version": "4.0.0",
   "description": "General utilities",
-  "main": "dist/index.js",
-  "typings": "./types/index.d.ts",
+  "type": "module",
+  "scripts": {
+    "build:es6": "tsc --outDir ./esm"
+  },
+  "exports": {
+    ".": {
+      "import": "./esm/index.js",
+      "types": "./types/index.d.ts"
+    },
+    "./package.json": "./package.json"
+  },
+  "typesVersions": {
+    "*": {
+      "*": [
+        "types/*"
+      ]
+    }
+  },
   "files": [
     "dist",
     "types",
     "src"
   ],
-  "scripts": {
-    "fix:prettier": "prettier \"{,!(dist|temp)/**/}*.{ts,tsx}\" --write",
-    "build": "tsc -b"
-  },
   "repository": {
     "type": "git",
     "url": "https://github.com/furystack/furystack.git"
@@ -31,6 +43,7 @@
   },
   "homepage": "https://github.com/furystack/furystack",
   "devDependencies": {
-    "@types/jest": "^29.5.0"
+    "typescript": "^5.0.4",
+    "vitest": "^0.30.1"
   }
 }

package/src/debounce.spec.ts

@@ -1,3 +1,4 @@
+import { describe, it, expect, vi } from 'vitest'
 import { debounce } from './debounce'
 import { sleepAsync } from './sleep-async'
 
@@ -5,35 +6,37 @@ import { sleepAsync } from './sleep-async'
  * Tests for debounce
  */
 export const debounceTests = describe('debounce', () => {
-  it('Simple method execution', (done) => {
-    const method = debounce(() => {
-      done()
+  it('Simple method execution', async () => {
+    const method = vi.fn()
+    await new Promise<void>((resolve) => {
+      const debouncedMethod = debounce(() => {
+        resolve()
+        method()
+      })
+      debouncedMethod()
     })
-    method()
+    expect(method).toBeCalledTimes(1)
   })
 
   it('Should be executed once when triggered multiple time in a given range', async () => {
-    let counter = 0
-    const method = debounce(() => {
-      counter++
-    }, 10)
+    const method = vi.fn()
+
+    const debouncedMethod = debounce(method, 10)
     for (let index = 0; index < 10; index++) {
-      method()
+      debouncedMethod()
     }
     await sleepAsync(300)
-    expect(counter).toBe(1)
+    expect(method).toBeCalledTimes(1)
   })
 
   it('Should be executed multiple times  when triggered multiple times out of a a given range', async () => {
-    let counter = 0
-    const method = debounce(() => {
-      counter++
-    }, 10)
+    const method = vi.fn()
+
+    const debouncedMethod = debounce(method, 10)
     for (let index = 0; index < 10; index++) {
-      method()
+      debouncedMethod()
       await sleepAsync(15)
     }
-    await sleepAsync(300)
-    expect(counter).toBe(10)
+    expect(method).toBeCalledTimes(10)
   })
 })

package/src/deep-merge.spec.ts

@@ -1,3 +1,4 @@
+import { describe, it, expect } from 'vitest'
 import { deepMerge } from './deep-merge'
 
 describe('DeepMerge tests', () => {

package/src/deep-merge.ts

@@ -5,7 +5,6 @@ export type DeepPartial<T> = { [K in keyof T]?: DeepPartial<T[K]> }
 
 /**
  * Deep merge two objects.
- *
  * @param  target The source object to be merged
  * @param sources The source objects
  * @returns A new instance with the merged values

package/src/disposable.spec.ts

@@ -1,3 +1,4 @@
+import { describe, it, expect, vi } from 'vitest'
 import type { Disposable } from './disposable'
 import { using, usingAsync } from './disposable'
 
@@ -59,42 +60,49 @@ export const disposableTests = describe('Disposable', () => {
   })
 
   describe('dispose()', () => {
-    it('should be called on error', (done) => {
+    it('should be called on error', () => {
+      const callbackMethod = vi.fn()
       try {
         using(new MockDisposable(), (d) => {
           d.disposeCallback = () => {
-            done()
+            callbackMethod()
           }
-
           d.whooops()
         })
       } catch {
         /** ignore */
       }
+      expect(callbackMethod).toBeCalled()
     })
 
-    it('should be called with usingAsync()', (done) => {
-      usingAsync(new MockDisposable(), async (d) => {
+    it('should be called with usingAsync()', async () => {
+      const callbackMethod = vi.fn()
+      await usingAsync(new MockDisposable(), async (d) => {
         d.disposeCallback = () => {
-          done()
+          callbackMethod()
         }
         return new Promise((resolve) => {
           setTimeout(resolve, 1)
         })
       })
+      expect(callbackMethod).toBeCalled()
     })
 
-    it('should be called when async fails', (done) => {
-      usingAsync(new MockDisposable(), async (d) => {
-        d.disposeCallback = () => {
-          done()
-        }
-        return new Promise((_resolve, reject) => {
-          setTimeout(reject, 1)
+    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(() => {
+      } catch (error) {
         /** ignore */
-      })
+      }
+      expect(callbackMethod).toBeCalled()
     })
 
     it('should await dispose for asyncs with usingAsync()', async () => {

package/src/disposable.ts

@@ -36,7 +36,6 @@ export interface Disposable {
 
 /**
  * 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
@@ -51,7 +50,6 @@ export const using = <T extends Disposable, TReturns>(resource: T, callback: (r:
 
 /**
  * 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

package/src/observable-value.spec.ts

@@ -1,64 +1,77 @@
+import { describe, it, expect, vi } from 'vitest'
 import { ObservableValue } from './observable-value'
 
 /**
  * Observable Value tests
  */
 export const observableTests = describe('Observable', () => {
-  it('should be constructed without initial value', (done) => {
+  it('should be constructed without initial value', () => {
     const v = new ObservableValue()
+    const doneCallback = vi.fn()
     v.subscribe(() => {
       expect(v.getValue()).toBe(undefined)
-      done()
+      doneCallback()
     }, true)
     expect(v).toBeInstanceOf(ObservableValue)
+    expect(doneCallback).toBeCalled()
   })
 
-  it('should be constructed with initial value', (done) => {
+  it('should be constructed with initial value', () => {
     const v = new ObservableValue(1)
+    const doneCallback = vi.fn()
+
     v.subscribe(() => {
       expect(v.getValue()).toBe(1)
-      done()
+      doneCallback()
     }, true)
+    expect(doneCallback).toBeCalled()
   })
 
   describe('Subscription callback', () => {
-    it('should be triggered only when a value is changed', (done) => {
+    it('should be triggered only when a value is changed', () => {
       const v = new ObservableValue(1)
+      const doneCallback = vi.fn()
+
       v.subscribe(() => {
         expect(v.getValue()).toBe(2)
-        done()
+        doneCallback()
       }, false)
       v.setValue(1)
       v.setValue(1)
       v.setValue(2)
+      expect(doneCallback).toBeCalledTimes(1)
     })
 
-    it('should be triggered only on change when getLast is false', (done) => {
+    it('should be triggered only on change when getLast is false', () => {
       const v = new ObservableValue(1)
+      const doneCallback = vi.fn()
+
       v.subscribe((value) => {
         expect(value).toBe(2)
-        done()
+        doneCallback()
       }, false)
       v.setValue(2)
+      expect(doneCallback).toBeCalledTimes(1)
     })
   })
 
   describe('Unsubscribe', () => {
-    it('should remove the subscription on unsubscribe()', (done) => {
-      const callback1 = () => {
-        done(Error('Shouldnt be triggered'))
-      }
+    it('should remove the subscription on unsubscribe()', () => {
+      const shouldNotCall = vi.fn()
 
-      const callback2 = (value: number) => {
+      const doneCallback = vi.fn((value: number) => {
         expect(value).toBe(2)
-        done()
-      }
+      })
+
       const v = new ObservableValue(1)
-      const observer1 = v.subscribe(callback1)
-      v.subscribe(callback2)
+      const observer1 = v.subscribe(shouldNotCall)
+      v.subscribe(doneCallback)
 
       v.unsubscribe(observer1)
       v.setValue(2)
+
+      expect(doneCallback).toBeCalledTimes(1)
+      expect(shouldNotCall).not.toBeCalled()
     })
 
     it('should remove the subscription on Observable dispose', () => {
@@ -93,16 +106,28 @@ export const observableTests = describe('Observable', () => {
       expect(() => v.setValue(3)).toThrowError('Observable already disposed')
     })
 
-    it('should throw an error for setValue() when the observer has been disposed', () => {
+    it('should throw an error for getValue() when the observer has been disposed', () => {
       const v = new ObservableValue(1)
       v.dispose()
       expect(() => v.getValue()).toThrowError('Observable already disposed')
     })
 
-    it('should remove the subscription only from the disposed Observer', (done) => {
+    it('should throw an error for subscribe() when the observer has been disposed', () => {
+      const v = new ObservableValue(1)
+      v.dispose()
+      expect(() =>
+        v.subscribe(() => {
+          /** */
+        }),
+      ).toThrowError('Observable already disposed')
+    })
+
+    it('should remove the subscription only from the disposed Observer', () => {
+      const doneCallback = vi.fn()
+
       class Alma {
         public Callback() {
-          done()
+          doneCallback()
         }
       }
       const v = new ObservableValue(1)
@@ -112,6 +137,8 @@ export const observableTests = describe('Observable', () => {
       observer.dispose()
       expect(v.getObservers().length).toBe(1)
       v.setValue(3)
+
+      expect(doneCallback).toBeCalledTimes(1)
     })
   })
 })

package/src/observable-value.ts

@@ -24,7 +24,7 @@ export type ValueChangeCallback<T> = (next: T) => void
  * ```ts
  * const observableValue = new ObservableValue<number>(0);
  * const observer = observableValue.subscribe((newValue) => {
- *    console.log("Value changed:", newValue);
+ * console.log("Value changed:", newValue);
  * });
  * // To update the value
  * observableValue.setValue(Math.random());
@@ -33,7 +33,6 @@ export type ValueChangeCallback<T> = (next: T) => void
  * // if you want to dispose the whole observableValue with all of its observers:
  * observableValue.dispose();
  * ```
- *
  * @param T Generic argument to indicate the value type
  */
 export class ObservableValue<T> implements Disposable {
@@ -55,12 +54,14 @@ export class ObservableValue<T> implements Disposable {
 
   /**
    * Subscribes to a value changes
-   *
    * @param callback The callback method that will be called on each change
    * @param getLast Will call the callback with the last known value right after subscription
    * @returns The ValueObserver instance
    */
   public subscribe(callback: ValueChangeCallback<T>, getLast = false) {
+    if (this._isDisposed) {
+      throw new ObservableAlreadyDisposedError()
+    }
     const observer = new ValueObserver<T>(this, callback)
     this.observers.add(observer)
     if (getLast) {
@@ -71,7 +72,6 @@ export class ObservableValue<T> implements Disposable {
 
   /**
    * The observer will unsubscribe from the Observable
-   *
    * @param observer The ValueObserver instance
    * @returns if unsubscribing was successfull
    */
@@ -81,7 +81,6 @@ export class ObservableValue<T> implements Disposable {
 
   /**
    * Gets the current Value
-   *
    * @returns The current value
    */
   public getValue(): T {
@@ -93,7 +92,6 @@ export class ObservableValue<T> implements Disposable {
 
   /**
    * Sets a new value and notifies the observers.
-   *
    * @param newValue The new value to be set
    */
   public setValue(newValue: T) {
@@ -110,7 +108,6 @@ export class ObservableValue<T> implements Disposable {
 
   /**
    * Gets the observers
-   *
    * @returns The subscribed observers
    */
   public getObservers() {

package/src/path-helper.spec.ts

@@ -1,3 +1,4 @@
+import { describe, it, expect } from 'vitest'
 import { PathHelper } from './path-helper'
 
 /**

package/src/path-helper.ts

@@ -6,7 +6,6 @@
 export class PathHelper {
   /**
    * Trims the slash characters from the beginning and from the end of the path to avoid duplicated slashes
-   *
    * @param {string} path The source path that should be trimmed
    * @returns the trimmed path
    */
@@ -23,7 +22,6 @@ export class PathHelper {
   /**
    * Splits a full path into path segments,
    * e.g.: /Root/Example/stuff
-   *
    * @param path The path to be splitted
    * @returns {string[]} the segments for the path
    */
@@ -33,7 +31,6 @@ export class PathHelper {
 
   /**
    * Method that allows to join paths without multiple or missing slashes
-   *
    * @param args The list of the paths to join
    * @returns the joined path string
    */
@@ -43,7 +40,6 @@ export class PathHelper {
 
   /**
    * Checks if the ancestorPath is really the ancestor of the descendantPath
-   *
    * @param {string} ancestorPath the ancestor path
    * @param {string} descendantPath the descendant path
    * @returns {boolean} if the provided path is the ancestor of the descendant
@@ -57,7 +53,6 @@ export class PathHelper {
    * e.g. "/Root/Example/Content" will return "/Root/Example"
    *
    * "Root" will always return "Root"
-   *
    * @param path The content path
    * @returns the parent path
    */

package/src/sleep-async.spec.ts

@@ -1,3 +1,4 @@
+import { describe, it, expect } from 'vitest'
 import { sleepAsync } from './sleep-async'
 
 /**

package/src/sleep-async.ts

@@ -1,6 +1,5 @@
 /**
  * Returns a simple promise that will be resolved within a discrete timeout
- *
  * @param timeout The timeout in millisecs
  */
 export const sleepAsync = (timeout = 250) =>

package/src/sort-by.spec.ts

@@ -1,3 +1,4 @@
+import { describe, it, expect } from 'vitest'
 import './sort-by'
 describe('sortBy', () => {
   it('Should sort by ascending by default', () => {

package/src/trace.spec.ts

@@ -1,3 +1,4 @@
+import { describe, it, expect, vi } from 'vitest'
 import { Trace } from './trace'
 
 class MockClass {
@@ -30,22 +31,25 @@ class MockClass {
 
 export const traceTests = describe('Trace tests', () => {
   describe('Static method traces', () => {
-    it('Static Methods call should be traced with args', (done) => {
+    it('Static Methods call should be traced with args', () => {
       const args = [1, 2, 3]
+      const doneCallback = vi.fn()
       const observer = Trace.method({
         object: MockClass,
         method: MockClass.addStatic,
         onCalled: (traceData) => {
           expect(args).toEqual(traceData.methodArguments)
           observer.dispose()
-          done()
+          doneCallback()
         },
       })
       MockClass.addStatic(...args)
+      expect(doneCallback).toBeCalled()
     })
 
-    it('Static Methods call should be traced with args and return value', (done) => {
+    it('Static Methods call should be traced with args and return value', () => {
       const args = [1, 2, 3]
+      const doneCallback = vi.fn()
       const observer = Trace.method({
         object: MockClass,
         method: MockClass.addStatic,
@@ -53,19 +57,23 @@ export const traceTests = describe('Trace tests', () => {
           expect(args).toEqual(traceData.methodArguments)
           expect(traceData.returned).toBe(1 + 2 + 3)
           observer.dispose()
-          done()
+          doneCallback()
         },
       })
       MockClass.addStatic(...args)
+      expect(doneCallback).toBeCalled()
     })
 
-    it("shouldn't be triggered after observer is disposed", (done) => {
+    it("shouldn't be triggered after observer is disposed", () => {
       const args = [1, 2, 3]
+      const shouldNotCall = vi.fn()
+      const doneCallback = vi.fn()
+
       const observer = Trace.method({
         object: MockClass,
         method: MockClass.addStatic,
         onCalled: () => {
-          done("Shouldn't be triggered here")
+          shouldNotCall("Shouldn't be triggered here")
         },
       })
       const observer2 = Trace.method({
@@ -73,19 +81,23 @@ export const traceTests = describe('Trace tests', () => {
         method: MockClass.addStatic,
         onCalled: () => {
           observer2.dispose()
-          done()
+          doneCallback()
         },
       })
       observer.dispose()
       const returned = MockClass.addStatic(...args)
       expect(returned).toEqual(1 + 2 + 3)
+      expect(doneCallback).toBeCalled()
+      expect(shouldNotCall).not.toBeCalled()
     })
   })
 
   describe('Instance method traces', () => {
-    it('should be traced with arguments', (done) => {
+    it('should be traced with arguments', () => {
       const instance = new MockClass()
       const args = [1, 2, 3]
+      const doneCallback = vi.fn()
+
       const observer = Trace.method({
         object: instance,
         method: instance.addInstance,
@@ -93,15 +105,18 @@ export const traceTests = describe('Trace tests', () => {
           expect(args).toEqual(traceData.methodArguments)
           expect(traceData.returned).toBe(1 + 2 + 3)
           observer.dispose()
-          done()
+          doneCallback()
         },
       })
       instance.addInstance(...args)
+      expect(doneCallback).toBeCalled()
     })
 
-    it('should be traced asynchronously', (done) => {
+    it('should be traced asynchronously', async () => {
       const instance = new MockClass()
       const args = [1, 2, 3]
+      const doneCallback = vi.fn()
+
       const observer = Trace.method({
         object: instance,
         method: instance.addInstanceAsync,
@@ -111,14 +126,17 @@ export const traceTests = describe('Trace tests', () => {
           const { returned } = traceData
           expect(returned).toBe(1 + 2 + 3)
           observer.dispose()
-          done()
+          doneCallback()
         },
       })
-      instance.addInstanceAsync(...args)
+      await instance.addInstanceAsync(...args)
+      expect(doneCallback).toBeCalled()
     })
 
-    it("should have a valid 'this' scope", (done) => {
+    it("should have a valid 'this' scope", () => {
       const instance = new MockClass('testValue')
+      const doneCallback = vi.fn()
+
       const observer = Trace.method({
         object: instance,
         method: instance.testScope,
@@ -126,15 +144,18 @@ export const traceTests = describe('Trace tests', () => {
           if (traceData.returned) {
             expect(traceData.returned).toBe('testValue')
             observer.dispose()
-            done()
+            doneCallback()
           }
         },
       })
       expect(instance.testScope()).toBe('testValue')
+      expect(doneCallback).toBeCalled()
     })
 
-    it('should handle throwing errors', (done) => {
+    it('should handle throwing errors', () => {
       const instance = new MockClass('testValue')
+      const doneCallback = vi.fn()
+
       const observer = Trace.method({
         object: instance,
         method: instance.testError,
@@ -142,17 +163,20 @@ export const traceTests = describe('Trace tests', () => {
           if (traceData.error) {
             expect(traceData.error.message).toBe('message')
             observer.dispose()
-            done()
+            doneCallback()
           }
         },
       })
       expect(() => {
         instance.testError('message')
       }).toThrow()
+      expect(doneCallback).toBeCalled()
     })
 
-    it('should handle throwing errors with asyncs', (done) => {
+    it('should handle throwing errors with asyncs', async () => {
       const instance = new MockClass('testValue')
+      const doneCallback = vi.fn()
+
       const observer = Trace.method({
         object: instance,
         method: instance.testErrorAsync,
@@ -161,18 +185,16 @@ export const traceTests = describe('Trace tests', () => {
           if (traceData.error) {
             expect(traceData.error.message).toBe('message')
             observer.dispose()
-            done()
+            doneCallback()
           }
         },
       })
-      instance
-        .testErrorAsync('message')
-        .then(() => {
-          done('Should throw error')
-        })
-        .catch(() => {
-          /** ignore, done handled in the onError callback */
-        })
+      try {
+        await instance.testErrorAsync('message')
+      } catch (error) {
+        // ignore
+      }
+      expect(doneCallback).toBeCalled()
     })
   })
 })

package/src/trace.ts

@@ -202,7 +202,6 @@ export class Trace {
 
   /**
    * Creates an observer that will be observe method calls, finishes and errors
-   *
    * @param options The options object for the trace
    * @returns the trace object that can be disposed after usage
    */