@softsky/utils 2.2.0 → 2.3.0

package/README.md

@@ -183,6 +183,18 @@ ${\textsf{\color{CornflowerBlue}function}}$ log - Format logging
 ---
 ${\textsf{\color{CornflowerBlue}function}}$ capitalizeFirstLetter - Capitalize first letter
 
+---
+${\textsf{\color{CornflowerBlue}function}}$ pipe - pipe() can be called on one or more functions, each of which can take the return of previous value.
+
+```ts
+// Takes string, converts to int, calc sqrt, convert and return date
+pipe(
+(x: string) => Number.parseInt(x),
+(x) => Math.sqrt(x),
+(x) => new Date(x)
+)('69')
+```
+
 ---
 
 
@@ -339,9 +351,15 @@ $b(5);
 ---
 ${\textsf{\color{CornflowerBlue}function}}$ when - __SIGNALS SYSTEM__
 
-Returns promise that is resolved when check function returns truthy value
+Returns ImmediatePromise that is resolved when check function returns truthy value.
+If you want to, you can resolve or reject promise beforehand.
+
 ```ts
-await when(()=>$a()>5)
+await when(() => $a()>5)
+// With timeout
+const promise = when(() => $a() > 5)
+const timeout = setTimeout(() => promise.reject('Timeout')}, 5000)
+primise.then(() => clearTimeout(timeout))
 ```
 
 ---

package/dist/formatting.d.ts

@@ -40,3 +40,26 @@ export declare function formatBytes(bytes: number): string;
 export declare function log(...agrs: unknown[]): void;
 /** Capitalize first letter */
 export declare function capitalizeFirstLetter(value: string): string;
+/**
+ * pipe() can be called on one or more functions, each of which can take the return of previous value.
+ *
+ * ```ts
+ * // Takes string, converts to int, calc sqrt, convert and return date
+ * pipe(
+ *  (x: string) => Number.parseInt(x),
+ *  (x) => Math.sqrt(x),
+ *  (x) => new Date(x)
+ * )('69')
+ * ```
+ */
+export declare function pipe(): <T>(x: T) => T;
+export declare function pipe<T, A>(function1: (x: T) => A): (x: T) => A;
+export declare function pipe<T, A, B>(function1: (x: T) => A, function2: (x: A) => B): (x: T) => B;
+export declare function pipe<T, A, B, C>(function1: (x: T) => A, function2: (x: A) => B, function3: (x: B) => C): (x: T) => C;
+export declare function pipe<T, A, B, C, D>(function1: (x: T) => A, function2: (x: A) => B, function3: (x: B) => C, function4: (x: C) => D): (x: T) => D;
+export declare function pipe<T, A, B, C, D, E>(function1: (x: T) => A, function2: (x: A) => B, function3: (x: B) => C, function4: (x: C) => D, function5: (x: D) => E): (x: T) => E;
+export declare function pipe<T, A, B, C, D, E, F>(function1: (x: T) => A, function2: (x: A) => B, function3: (x: B) => C, function4: (x: C) => D, function5: (x: D) => E, function6: (x: E) => F): (x: T) => F;
+export declare function pipe<T, A, B, C, D, E, F, G>(function1: (x: T) => A, function2: (x: A) => B, function3: (x: B) => C, function4: (x: C) => D, function5: (x: D) => E, function6: (x: E) => F, function7: (x: F) => G): (x: T) => G;
+export declare function pipe<T, A, B, C, D, E, F, G, H>(function1: (x: T) => A, function2: (x: A) => B, function3: (x: B) => C, function4: (x: C) => D, function5: (x: D) => E, function6: (x: E) => F, function7: (x: F) => G, function8: (x: G) => H): (x: T) => H;
+export declare function pipe<T, A, B, C, D, E, F, G, H, I>(function1: (x: T) => A, function2: (x: A) => B, function3: (x: B) => C, function4: (x: C) => D, function5: (x: D) => E, function6: (x: E) => F, function7: (x: F) => G, function8: (x: G) => H, function9: (x: H) => I): (x: T) => I;
+export declare function pipe<T, A, B, C, D, E, F, G, H>(function1: (x: T) => A, function2: (x: A) => B, function3: (x: B) => C, function4: (x: C) => D, function5: (x: D) => E, function6: (x: E) => F, function7: (x: F) => G, function8: (x: G) => H, function9: (x: H) => unknown, ...fns: ((x: unknown) => unknown)[]): (x: T) => unknown;

package/dist/formatting.js

@@ -117,3 +117,10 @@ export function log(...agrs) {
 export function capitalizeFirstLetter(value) {
     return value.charAt(0).toUpperCase() + value.slice(1);
 }
+export function pipe(...fns) {
+    return (input) => {
+        for (let index = 0; index < fns.length; index++)
+            input = fns[index](input);
+        return input;
+    };
+}

package/dist/signals.d.ts

@@ -100,9 +100,15 @@ export declare function batch(handler: AnyFunction): void;
 /**
  * __SIGNALS SYSTEM__
  *
- * Returns promise that is resolved when check function returns truthy value
+ * Returns ImmediatePromise that is resolved when check function returns truthy value.
+ * If you want to, you can resolve or reject promise beforehand.
+ *
  * ```ts
- * await when(()=>$a()>5)
+ * await when(() => $a()>5)
+ * // With timeout
+ * const promise = when(() => $a() > 5)
+ * const timeout = setTimeout(() => promise.reject('Timeout')}, 5000)
+ * primise.then(() => clearTimeout(timeout))
  * ```
  */
 export declare function when(check: () => unknown): ImmediatePromise<undefined>;

package/dist/signals.js

@@ -22,12 +22,24 @@ export function signal(value) {
                     subscriber();
         }
         else if (currentEffect) {
-            effectsMap.set(currentEffect, subscribers);
             subscribers.add(currentEffect);
+            // This is for clear() of effects
+            let effectSubscribers = effectsMap.get(currentEffect);
+            if (!effectSubscribers) {
+                effectSubscribers = new Set();
+                effectsMap.set(currentEffect, effectSubscribers);
+            }
+            effectSubscribers.add(subscribers);
         }
         return value;
     };
 }
+function clearEffect(handler) {
+    const signalSubscribers = effectsMap.get(handler);
+    if (signalSubscribers)
+        for (const subscribers of signalSubscribers)
+            subscribers.delete(handler);
+}
 /**
  * __SIGNALS SYSTEM__
  *
@@ -56,7 +68,7 @@ export function effect(handler, initialValue) {
     wrappedHandler();
     currentEffect = undefined;
     return () => {
-        effectsMap.get(wrappedHandler)?.delete(wrappedHandler);
+        clearEffect(wrappedHandler);
     };
 }
 /**
@@ -88,7 +100,7 @@ export function derived(handler, initialValue) {
     return {
         signal: signal$,
         clear: () => {
-            effectsMap.get(wrappedHandler)?.delete(wrappedHandler);
+            clearEffect(wrappedHandler);
         },
     };
 }
@@ -122,19 +134,25 @@ export function batch(handler) {
 /**
  * __SIGNALS SYSTEM__
  *
- * Returns promise that is resolved when check function returns truthy value
+ * Returns ImmediatePromise that is resolved when check function returns truthy value.
+ * If you want to, you can resolve or reject promise beforehand.
+ *
  * ```ts
- * await when(()=>$a()>5)
+ * await when(() => $a()>5)
+ * // With timeout
+ * const promise = when(() => $a() > 5)
+ * const timeout = setTimeout(() => promise.reject('Timeout')}, 5000)
+ * primise.then(() => clearTimeout(timeout))
  * ```
  */
 export function when(check) {
     const promise = new ImmediatePromise();
     const clear = effect(() => {
         if (check())
-            setTimeout(() => {
-                clear();
-                promise.resolve();
-            });
+            promise.resolve();
+    });
+    void promise.finally(() => {
+        clear();
     });
     return promise;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@softsky/utils",
-  "version": "2.2.0",
+  "version": "2.3.0",
   "description": "JavaScript/TypeScript utilities",
   "main": "dist/index.js",
   "scripts": {