silentium 0.0.162 → 0.0.164

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "silentium",
-  "version": "0.0.162",
+  "version": "0.0.164",
   "description": "",
   "license": "MIT",
   "type": "module",

package/src/base/Local.ts

@@ -7,13 +7,14 @@ import { MaybeMessage } from "types/MessageType";
  */
 export function Local<T>(_base: MaybeMessage<T>) {
   const $base = ActualMessage(_base);
-  return Message<T>(function LocalImpl(r) {
+  return Message<T>(function LocalImpl(resolve, reject) {
     let destroyed = false;
     $base.then((v) => {
       if (!destroyed) {
-        r(v);
+        resolve(v);
       }
     });
+    $base.catch(reject);
     return () => {
       destroyed = true;
     };

package/src/components/Applied.test.ts

@@ -21,4 +21,13 @@ describe("Applied.test", () => {
 
     expect(g).toBeCalledWith(4);
   });
+
+  test("value with applied function", () => {
+    const doubled = Applied(2, String);
+
+    const g = vi.fn();
+    doubled.then(g);
+
+    expect(g).toBeCalledWith("2");
+  });
 });

package/src/components/AppliedDestructured.test.ts

@@ -1,6 +1,7 @@
 import { describe, expect, test, vi } from "vitest";
 import { AppliedDestructured } from "components/AppliedDestructured";
 import { Of } from "base/Of";
+import { All } from "components/All";
 
 describe("AppliedDestructured.test", () => {
   test("message with destructured applied function", () => {
@@ -24,8 +25,14 @@ describe("AppliedDestructured.test", () => {
 
   test("values with destructured applied function", async () => {
     const sum = AppliedDestructured([1, 2, 3], (a, b, c) => a + b + c);
-    const r = await sum;
+    expect(await sum).toBe(6);
+  });
 
-    expect(r).toBe(6);
+  test("values with destructured applied function", async () => {
+    const sum = AppliedDestructured(
+      All(Of(1), Of(2), Of(3)),
+      (a, b, c) => a + b + c,
+    );
+    expect(await sum).toBe(6);
   });
 });

package/src/components/AppliedDestructured.ts

@@ -8,7 +8,7 @@ import { MaybeMessage } from "types/MessageType";
  */
 export function AppliedDestructured<const T extends any[], R>(
   $base: MaybeMessage<T>,
-  applier: ConstructorType<T[number][], R>,
+  applier: ConstructorType<any[], R>,
 ) {
   return Applied($base, function AppliedDestructuredImpl(args) {
     return applier(...args);

package/src/components/Map.test.ts

@@ -1,6 +1,7 @@
 import { Message } from "base/Message";
 import { Of } from "base/Of";
 import { Applied } from "components/Applied";
+import { LateShared } from "components/LateShared";
 import { Map } from "components/Map";
 import { Diagram } from "testing/Diagram";
 import { wait } from "testing/wait";
@@ -62,4 +63,16 @@ describe("Map.test", () => {
 
     expect(d.toString()).toBe("2,4,6,18");
   });
+
+  test("map preserves array length", () => {
+    const d = Diagram();
+    const input = LateShared([1, 2, 3, 4, 5]);
+    const infoMapped = Map(input, x2);
+
+    Applied(infoMapped, (arr) => arr.length).then(d.resolver);
+    expect(d.toString()).toBe("5");
+
+    input.use([6, 7, 9]);
+    expect(d.toString()).toBe("5|3");
+  });
 });

package/src/components/Map.ts

@@ -21,6 +21,7 @@ export function Map<T, TG>(
     const infos: MessageType<TG>[] = [];
     const dc = DestroyContainer();
     $base.then((v) => {
+      infos.length = 0;
       dc.destroy();
       v.forEach((val) => {
         let $val: MessageType<T> | T = val;