async-signals - npm Package Compare versions

Comparing version 0.1.6 to 0.1.7

dist/join.d.ts

@@ -1,4 +0,5 @@
-import { AsyncSignal } from "./async-signals.js";
+import { AsyncResult } from "./async-signals.js";
+type AsyncResultValue<T> = T extends AsyncResult<infer U> ? U : never;
 /**
- * Defines the behavior of the joining of the `AsyncSignals`
+ * Defines the behavior of the joining of the `AsyncResults`
  */
@@ -18,69 +19,70 @@ export interface JoinAsyncOptions {
 /**
- *  Joins an array of `AsyncSignals` into a single `AsyncSignal` of the array of values
+ *  Joins an array of `AsyncResults` into a single `AsyncResult` of the array of values
  */
-export declare function joinAsync<T>(signals: [AsyncSignal<T>], joinOptions?: JoinAsyncOptions): AsyncSignal<[T]>;
-export declare function joinAsync<T, U>(signals: [AsyncSignal<T>, AsyncSignal<U>], joinOptions?: JoinAsyncOptions): AsyncSignal<[T, U]>;
-export declare function joinAsync<T, U, V>(signals: [AsyncSignal<T>, AsyncSignal<U>, AsyncSignal<V>], joinOptions?: JoinAsyncOptions): AsyncSignal<[T, U, V]>;
-export declare function joinAsync<T, U, V, W>(signals: [AsyncSignal<T>, AsyncSignal<U>, AsyncSignal<V>, AsyncSignal<W>], joinOptions?: JoinAsyncOptions): AsyncSignal<[T, U, V, W]>;
-export declare function joinAsync<T, U, V, W, X>(signals: [
-    AsyncSignal<T>,
-    AsyncSignal<U>,
-    AsyncSignal<V>,
-    AsyncSignal<W>,
-    AsyncSignal<X>
-], joinOptions?: JoinAsyncOptions): AsyncSignal<[T, U, V, W, X]>;
-export declare function joinAsync<T, U, V, W, X, Y>(signals: [
-    AsyncSignal<T>,
-    AsyncSignal<U>,
-    AsyncSignal<V>,
-    AsyncSignal<W>,
-    AsyncSignal<X>,
-    AsyncSignal<Y>
-], joinOptions?: JoinAsyncOptions): AsyncSignal<[T, U, V, W, X, Y]>;
-export declare function joinAsync<T, U, V, W, X, Y, Z>(signals: [
-    AsyncSignal<T>,
-    AsyncSignal<U>,
-    AsyncSignal<V>,
-    AsyncSignal<W>,
-    AsyncSignal<X>,
-    AsyncSignal<Y>,
-    AsyncSignal<Z>
-], joinOptions?: JoinAsyncOptions): AsyncSignal<[T, U, V, W, X, Y, Z]>;
-export declare function joinAsync<T, U, V, W, X, Y, Z, A>(signals: [
-    AsyncSignal<T>,
-    AsyncSignal<U>,
-    AsyncSignal<V>,
-    AsyncSignal<W>,
-    AsyncSignal<X>,
-    AsyncSignal<Y>,
-    AsyncSignal<Z>,
-    AsyncSignal<A>
-], joinOptions?: JoinAsyncOptions): AsyncSignal<[T, U, V, W, X, Y, Z, A]>;
-export declare function joinAsync<T, U, V, W, X, Y, Z, A, B>(signals: [
-    AsyncSignal<T>,
-    AsyncSignal<U>,
-    AsyncSignal<V>,
-    AsyncSignal<W>,
-    AsyncSignal<X>,
-    AsyncSignal<Y>,
-    AsyncSignal<Z>,
-    AsyncSignal<A>,
-    AsyncSignal<B>
-], joinOptions?: JoinAsyncOptions): AsyncSignal<[T, U, V, W, X, Y, Z, A, B]>;
-export declare function joinAsync<T, U, V, W, X, Y, Z, A, B, C>(signals: [
-    AsyncSignal<T>,
-    AsyncSignal<U>,
-    AsyncSignal<V>,
-    AsyncSignal<W>,
-    AsyncSignal<X>,
-    AsyncSignal<Y>,
-    AsyncSignal<Z>,
-    AsyncSignal<A>,
-    AsyncSignal<B>,
-    AsyncSignal<C>
-], joinOptions?: JoinAsyncOptions): AsyncSignal<[T, U, V, W, X, Y, Z, A, B, C]>;
-export declare function joinAsync<T>(signals: Array<AsyncSignal<T>>, joinOptions?: JoinAsyncOptions): AsyncSignal<Array<T>>;
+export declare function joinAsync<T>(results: [AsyncResult<T>], joinOptions?: JoinAsyncOptions): AsyncResult<[T]>;
+export declare function joinAsync<T, U>(results: [AsyncResult<T>, AsyncResult<U>], joinOptions?: JoinAsyncOptions): AsyncResult<[T, U]>;
+export declare function joinAsync<T, U, V>(results: [AsyncResult<T>, AsyncResult<U>, AsyncResult<V>], joinOptions?: JoinAsyncOptions): AsyncResult<[T, U, V]>;
+export declare function joinAsync<T, U, V, W>(results: [AsyncResult<T>, AsyncResult<U>, AsyncResult<V>, AsyncResult<W>], joinOptions?: JoinAsyncOptions): AsyncResult<[T, U, V, W]>;
+export declare function joinAsync<T, U, V, W, X>(results: [
+    AsyncResult<T>,
+    AsyncResult<U>,
+    AsyncResult<V>,
+    AsyncResult<W>,
+    AsyncResult<X>
+], joinOptions?: JoinAsyncOptions): AsyncResult<[T, U, V, W, X]>;
+export declare function joinAsync<T, U, V, W, X, Y>(results: [
+    AsyncResult<T>,
+    AsyncResult<U>,
+    AsyncResult<V>,
+    AsyncResult<W>,
+    AsyncResult<X>,
+    AsyncResult<Y>
+], joinOptions?: JoinAsyncOptions): AsyncResult<[T, U, V, W, X, Y]>;
+export declare function joinAsync<T, U, V, W, X, Y, Z>(results: [
+    AsyncResult<T>,
+    AsyncResult<U>,
+    AsyncResult<V>,
+    AsyncResult<W>,
+    AsyncResult<X>,
+    AsyncResult<Y>,
+    AsyncResult<Z>
+], joinOptions?: JoinAsyncOptions): AsyncResult<[T, U, V, W, X, Y, Z]>;
+export declare function joinAsync<T, U, V, W, X, Y, Z, A>(results: [
+    AsyncResult<T>,
+    AsyncResult<U>,
+    AsyncResult<V>,
+    AsyncResult<W>,
+    AsyncResult<X>,
+    AsyncResult<Y>,
+    AsyncResult<Z>,
+    AsyncResult<A>
+], joinOptions?: JoinAsyncOptions): AsyncResult<[T, U, V, W, X, Y, Z, A]>;
+export declare function joinAsync<T, U, V, W, X, Y, Z, A, B>(results: [
+    AsyncResult<T>,
+    AsyncResult<U>,
+    AsyncResult<V>,
+    AsyncResult<W>,
+    AsyncResult<X>,
+    AsyncResult<Y>,
+    AsyncResult<Z>,
+    AsyncResult<A>,
+    AsyncResult<B>
+], joinOptions?: JoinAsyncOptions): AsyncResult<[T, U, V, W, X, Y, Z, A, B]>;
+export declare function joinAsync<T, U, V, W, X, Y, Z, A, B, C>(results: [
+    AsyncResult<T>,
+    AsyncResult<U>,
+    AsyncResult<V>,
+    AsyncResult<W>,
+    AsyncResult<X>,
+    AsyncResult<Y>,
+    AsyncResult<Z>,
+    AsyncResult<A>,
+    AsyncResult<B>,
+    AsyncResult<C>
+], joinOptions?: JoinAsyncOptions): AsyncResult<[T, U, V, W, X, Y, Z, A, B, C]>;
+export declare function joinAsync<T>(results: Array<AsyncResult<T>>, joinOptions?: JoinAsyncOptions): AsyncResult<Array<T>>;
 /**
- * Joins all the results in a HashMap of `AsyncSignals`
+ * Joins all the results in a HashMap of `AsyncResults`
  */
-export declare function joinAsyncMap<K, T, V extends AsyncSignal<any>>(map: ReadonlyMap<K, V>, joinOptions?: JoinAsyncOptions): AsyncSignal<ReadonlyMap<K, T>>;
+export declare function joinAsyncMap<K, V extends AsyncResult<any>>(map: ReadonlyMap<K, V>, joinOptions?: JoinAsyncOptions): AsyncResult<ReadonlyMap<K, AsyncResultValue<V>>>;
+export {};

dist/join.js

@@ -1,3 +0,2 @@
-import { AsyncComputed } from "./async-signals.js";
-export function joinAsync(signals, joinOptions) {
+export function joinAsync(results, joinOptions) {
     let options = {
@@ -13,31 +12,27 @@ errors: "bubble",
     }
-    return new AsyncComputed(() => {
-        const values = signals.map((s) => s.get());
-        if (options.errors === "bubble") {
-            const firstError = values.find((v) => v && v.status === "error");
-            if (firstError) {
-                return firstError;
-            }
+    if (options.errors === "bubble") {
+        const firstError = results.find((v) => v && v.status === "error");
+        if (firstError) {
+            return firstError;
         }
-        if (options.pendings === "bubble") {
-            const firstLoading = values.find((v) => v && v.status === "pending");
-            if (firstLoading) {
-                return firstLoading;
-            }
+    }
+    if (options.pendings === "bubble") {
+        const firstLoading = results.find((v) => v && v.status === "pending");
+        if (firstLoading) {
+            return firstLoading;
         }
-        const v = values
-            .filter((v) => v.status === "completed")
-            .map((v) => v.value);
-        return {
-            status: "completed",
-            value: v,
-        };
-    });
+    }
+    const v = results
+        .filter((v) => v.status === "completed")
+        .map((v) => v.value);
+    return {
+        status: "completed",
+        value: v,
+    };
 }
 /**
- * Joins all the results in a HashMap of `AsyncSignals`
+ * Joins all the results in a HashMap of `AsyncResults`
  */
 export function joinAsyncMap(map, joinOptions) {
-    const signalArray = Array.from(map.entries()).map(([key, signal]) => new AsyncComputed(() => {
-        const result = signal.get();
+    const resultsArray = Array.from(map.entries()).map(([key, result]) => {
         if (result.status !== "completed")
@@ -50,15 +45,12 @@ return result;
         };
-    }));
-    const arraySignal = joinAsync(signalArray, joinOptions);
-    return new AsyncComputed(() => {
-        const result = arraySignal.get();
-        if (result.status !== "completed")
-            return result;
-        const value = new Map(result.value);
-        return {
-            status: "completed",
-            value,
-        };
     });
+    const arrayResult = joinAsync(resultsArray, joinOptions);
+    if (arrayResult.status !== "completed")
+        return arrayResult;
+    const value = new Map(arrayResult.value);
+    return {
+        status: "completed",
+        value,
+    };
 }
 //# sourceMappingURL=join.js.map

package.json

 {
   "name": "async-signals",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "description": "Synthatic sugar and utilities to support async tasks on top of signal-polyfill",
@@ -5,0 +5,0 @@ "main": "dist/index.js",

src/join.ts

@@ -1,5 +0,7 @@
-import { AsyncComputed, AsyncResult, AsyncSignal } from "./async-signals.js";
+import { AsyncResult } from "./async-signals.js";
 
+type AsyncResultValue<T> = T extends AsyncResult<infer U> ? U : never;
+
 /**
- * Defines the behavior of the joining of the `AsyncSignals`
+ * Defines the behavior of the joining of the `AsyncResults`
  */
@@ -20,103 +22,103 @@ export interface JoinAsyncOptions {
 /**
- *  Joins an array of `AsyncSignals` into a single `AsyncSignal` of the array of values
+ *  Joins an array of `AsyncResults` into a single `AsyncResult` of the array of values
  */
 export function joinAsync<T>(
-  signals: [AsyncSignal<T>],
+  results: [AsyncResult<T>],
   joinOptions?: JoinAsyncOptions,
-): AsyncSignal<[T]>;
+): AsyncResult<[T]>;
 export function joinAsync<T, U>(
-  signals: [AsyncSignal<T>, AsyncSignal<U>],
+  results: [AsyncResult<T>, AsyncResult<U>],
   joinOptions?: JoinAsyncOptions,
-): AsyncSignal<[T, U]>;
+): AsyncResult<[T, U]>;
 export function joinAsync<T, U, V>(
-  signals: [AsyncSignal<T>, AsyncSignal<U>, AsyncSignal<V>],
+  results: [AsyncResult<T>, AsyncResult<U>, AsyncResult<V>],
   joinOptions?: JoinAsyncOptions,
-): AsyncSignal<[T, U, V]>;
+): AsyncResult<[T, U, V]>;
 export function joinAsync<T, U, V, W>(
-  signals: [AsyncSignal<T>, AsyncSignal<U>, AsyncSignal<V>, AsyncSignal<W>],
+  results: [AsyncResult<T>, AsyncResult<U>, AsyncResult<V>, AsyncResult<W>],
   joinOptions?: JoinAsyncOptions,
-): AsyncSignal<[T, U, V, W]>;
+): AsyncResult<[T, U, V, W]>;
 export function joinAsync<T, U, V, W, X>(
-  signals: [
-    AsyncSignal<T>,
-    AsyncSignal<U>,
-    AsyncSignal<V>,
-    AsyncSignal<W>,
-    AsyncSignal<X>,
+  results: [
+    AsyncResult<T>,
+    AsyncResult<U>,
+    AsyncResult<V>,
+    AsyncResult<W>,
+    AsyncResult<X>,
   ],
   joinOptions?: JoinAsyncOptions,
-): AsyncSignal<[T, U, V, W, X]>;
+): AsyncResult<[T, U, V, W, X]>;
 export function joinAsync<T, U, V, W, X, Y>(
-  signals: [
-    AsyncSignal<T>,
-    AsyncSignal<U>,
-    AsyncSignal<V>,
-    AsyncSignal<W>,
-    AsyncSignal<X>,
-    AsyncSignal<Y>,
+  results: [
+    AsyncResult<T>,
+    AsyncResult<U>,
+    AsyncResult<V>,
+    AsyncResult<W>,
+    AsyncResult<X>,
+    AsyncResult<Y>,
   ],
   joinOptions?: JoinAsyncOptions,
-): AsyncSignal<[T, U, V, W, X, Y]>;
+): AsyncResult<[T, U, V, W, X, Y]>;
 export function joinAsync<T, U, V, W, X, Y, Z>(
-  signals: [
-    AsyncSignal<T>,
-    AsyncSignal<U>,
-    AsyncSignal<V>,
-    AsyncSignal<W>,
-    AsyncSignal<X>,
-    AsyncSignal<Y>,
-    AsyncSignal<Z>,
+  results: [
+    AsyncResult<T>,
+    AsyncResult<U>,
+    AsyncResult<V>,
+    AsyncResult<W>,
+    AsyncResult<X>,
+    AsyncResult<Y>,
+    AsyncResult<Z>,
   ],
   joinOptions?: JoinAsyncOptions,
-): AsyncSignal<[T, U, V, W, X, Y, Z]>;
+): AsyncResult<[T, U, V, W, X, Y, Z]>;
 export function joinAsync<T, U, V, W, X, Y, Z, A>(
-  signals: [
-    AsyncSignal<T>,
-    AsyncSignal<U>,
-    AsyncSignal<V>,
-    AsyncSignal<W>,
-    AsyncSignal<X>,
-    AsyncSignal<Y>,
-    AsyncSignal<Z>,
-    AsyncSignal<A>,
+  results: [
+    AsyncResult<T>,
+    AsyncResult<U>,
+    AsyncResult<V>,
+    AsyncResult<W>,
+    AsyncResult<X>,
+    AsyncResult<Y>,
+    AsyncResult<Z>,
+    AsyncResult<A>,
   ],
   joinOptions?: JoinAsyncOptions,
-): AsyncSignal<[T, U, V, W, X, Y, Z, A]>;
+): AsyncResult<[T, U, V, W, X, Y, Z, A]>;
 export function joinAsync<T, U, V, W, X, Y, Z, A, B>(
-  signals: [
-    AsyncSignal<T>,
-    AsyncSignal<U>,
-    AsyncSignal<V>,
-    AsyncSignal<W>,
-    AsyncSignal<X>,
-    AsyncSignal<Y>,
-    AsyncSignal<Z>,
-    AsyncSignal<A>,
-    AsyncSignal<B>,
+  results: [
+    AsyncResult<T>,
+    AsyncResult<U>,
+    AsyncResult<V>,
+    AsyncResult<W>,
+    AsyncResult<X>,
+    AsyncResult<Y>,
+    AsyncResult<Z>,
+    AsyncResult<A>,
+    AsyncResult<B>,
   ],
   joinOptions?: JoinAsyncOptions,
-): AsyncSignal<[T, U, V, W, X, Y, Z, A, B]>;
+): AsyncResult<[T, U, V, W, X, Y, Z, A, B]>;
 export function joinAsync<T, U, V, W, X, Y, Z, A, B, C>(
-  signals: [
-    AsyncSignal<T>,
-    AsyncSignal<U>,
-    AsyncSignal<V>,
-    AsyncSignal<W>,
-    AsyncSignal<X>,
-    AsyncSignal<Y>,
-    AsyncSignal<Z>,
-    AsyncSignal<A>,
-    AsyncSignal<B>,
-    AsyncSignal<C>,
+  results: [
+    AsyncResult<T>,
+    AsyncResult<U>,
+    AsyncResult<V>,
+    AsyncResult<W>,
+    AsyncResult<X>,
+    AsyncResult<Y>,
+    AsyncResult<Z>,
+    AsyncResult<A>,
+    AsyncResult<B>,
+    AsyncResult<C>,
   ],
   joinOptions?: JoinAsyncOptions,
-): AsyncSignal<[T, U, V, W, X, Y, Z, A, B, C]>;
+): AsyncResult<[T, U, V, W, X, Y, Z, A, B, C]>;
 export function joinAsync<T>(
-  signals: Array<AsyncSignal<T>>,
+  results: Array<AsyncResult<T>>,
   joinOptions?: JoinAsyncOptions,
-): AsyncSignal<Array<T>>;
+): AsyncResult<Array<T>>;
 export function joinAsync<T>(
-  signals: Array<AsyncSignal<T>>,
+  results: Array<AsyncResult<T>>,
   joinOptions?: JoinAsyncOptions,
-): AsyncSignal<Array<T>> {
+): AsyncResult<Array<T>> {
   let options = {
@@ -132,62 +134,52 @@ errors: "bubble",
   }
-  return new AsyncComputed(() => {
-    const values = signals.map((s) => s.get());
-    if (options.errors === "bubble") {
-      const firstError = values.find(
-        (v) => v && (v as AsyncResult<any>).status === "error",
-      );
-      if (firstError) {
-        return firstError as AsyncResult<T[]>;
-      }
+  if (options.errors === "bubble") {
+    const firstError = results.find(
+      (v) => v && (v as AsyncResult<any>).status === "error",
+    );
+    if (firstError) {
+      return firstError as AsyncResult<T[]>;
     }
-    if (options.pendings === "bubble") {
-      const firstLoading = values.find(
-        (v) => v && (v as AsyncResult<any>).status === "pending",
-      );
-      if (firstLoading) {
-        return firstLoading as AsyncResult<T[]>;
-      }
+  }
+  if (options.pendings === "bubble") {
+    const firstLoading = results.find(
+      (v) => v && (v as AsyncResult<any>).status === "pending",
+    );
+    if (firstLoading) {
+      return firstLoading as AsyncResult<T[]>;
     }
+  }
 
-    const v = values
-      .filter((v) => v.status === "completed")
-      .map((v) => (v as any).value as T);
-    return {
-      status: "completed",
-      value: v,
-    } as AsyncResult<T[]>;
-  });
+  const v = results
+    .filter((v) => v.status === "completed")
+    .map((v) => (v as any).value as T);
+  return {
+    status: "completed",
+    value: v,
+  } as AsyncResult<T[]>;
 }
 
 /**
- * Joins all the results in a HashMap of `AsyncSignals`
+ * Joins all the results in a HashMap of `AsyncResults`
  */
-export function joinAsyncMap<K, T, V extends AsyncSignal<any>>(
+export function joinAsyncMap<K, V extends AsyncResult<any>>(
   map: ReadonlyMap<K, V>,
   joinOptions?: JoinAsyncOptions,
-): AsyncSignal<ReadonlyMap<K, T>> {
-  const signalArray = Array.from(map.entries()).map(
-    ([key, signal]) =>
-      new AsyncComputed<[K, T]>(() => {
-        const result = signal.get();
-        if (result.status !== "completed") return result;
-        const value = [key, result.value] as [K, T];
-        return {
-          status: "completed",
-          value,
-        };
-      }),
-  );
-  const arraySignal = joinAsync(signalArray, joinOptions);
-
-  return new AsyncComputed(() => {
-    const result = arraySignal.get();
+): AsyncResult<ReadonlyMap<K, AsyncResultValue<V>>> {
+  const resultsArray = Array.from(map.entries()).map(([key, result]) => {
     if (result.status !== "completed") return result;
-
-    const value = new Map(result.value);
+    const value = [key, result.value] as [K, AsyncResultValue<V>];
     return {
       status: "completed",
       value,
-    } as AsyncResult<ReadonlyMap<K, T>>;
+    } as AsyncResult<[K, AsyncResultValue<V>]>;
   });
+  const arrayResult = joinAsync(resultsArray, joinOptions);
+
+  if (arrayResult.status !== "completed") return arrayResult;
+
+  const value = new Map<K, AsyncResultValue<V>>(arrayResult.value);
+  return {
+    status: "completed",
+    value,
+  } as AsyncResult<ReadonlyMap<K, AsyncResultValue<V>>>;
 }

No alert changes

Worsened metrics

Total package byte prevSize

40129

decreased by-2.41%

Lines of code

590

decreased by-2.48%

No dependency changes