silentium 0.0.152 → 0.0.153

package/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+### [0.0.153](https://github.com/silentium-lab/silentium/compare/v0.0.152...v0.0.153) (2025-11-24)
+
+
+### Bug Fixes
+
+* **main:** process component added ([c2db805](https://github.com/silentium-lab/silentium/commit/c2db8051db80c248bc0c7be10f15fe843c85478b))
+
 ### [0.0.152](https://github.com/silentium-lab/silentium/compare/v0.0.151...v0.0.152) (2025-11-24)
 
 

package/package.json

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

package/src/components/Process.test.ts

@@ -0,0 +1,114 @@
+import { describe, expect, test } from "vitest";
+import { Message } from "base/Message";
+import { Process } from "components/Process";
+import { Late } from "components/Late";
+import { Diagram } from "testing/Diagram";
+import { Of } from "base/Of";
+
+describe("Process.test", () => {
+  test("basic process", async () => {
+    const $base = Of(10); // resolves to 10
+    const builder = (v: number) => Of(v * 2); // returns Message that resolves to v*2
+
+    const $proc = Process($base, builder);
+    const result = await $proc;
+    expect(result).toBe(20);
+  });
+
+  test("process with late shared", () => {
+    const d = Diagram();
+    const $base = Late<number>();
+    const builder = (v: number) =>
+      Message<number>((resolve) => {
+        resolve(v + 1);
+        return () => d.resolver(`destroy_${v}`);
+      });
+
+    const $proc = Process($base, builder);
+
+    $proc.then((v) => d.resolver(`proc_${v}`));
+
+    $base.use(5);
+
+    expect(d.toString()).toBe("proc_6");
+
+    $proc.destroy();
+
+    expect(d.toString()).toBe("proc_6|destroy_5");
+  });
+
+  test("error handling from built message", () => {
+    const $base = Of(10);
+    const builder = () =>
+      Message<number>((resolve, reject) => {
+        reject("error from builder");
+      });
+
+    const $proc = Process($base, builder);
+
+    let caught = false;
+    $proc.then(() => {
+      throw new Error("should not resolve");
+    });
+    $proc.catch((e) => {
+      expect(e).toBe("error from builder");
+      caught = true;
+    });
+
+    expect(caught).toBe(true);
+  });
+
+  test("error handling from base", () => {
+    const $base = Message<string>((resolve, reject) => {
+      reject("base error");
+    });
+    const builder = (v: string) => Of(`processed_${v}`);
+
+    const $proc = Process($base, builder);
+
+    let caught = false;
+    $proc.then(() => {
+      throw new Error("should not resolve");
+    });
+    $proc.catch((e) => {
+      expect(e).toBe("base error");
+      caught = true;
+    });
+
+    expect(caught).toBe(true);
+  });
+
+  test("chaining multiple processes", async () => {
+    const $base = Of(1);
+
+    // Process 1: add 2
+    const $proc1 = Process($base, (v: number) => Of(v + 2));
+
+    // Process 2: multiply by 3
+    const $proc2 = Process($proc1, (v: number) => Of(v * 3));
+
+    const result = await $proc2;
+    expect(result).toBe(9); // (1+2)*3
+  });
+
+  test("destruction calls destroy on created messages", () => {
+    let isDestroyed = false;
+    const $base = Late<number>();
+    const builder = (v: number) =>
+      Message<number>((resolve) => {
+        resolve(v * 2);
+        return () => {
+          isDestroyed = true;
+        };
+      });
+
+    const $proc = Process($base, builder);
+
+    $base.use(5); // Triggers creation if listened
+    $proc.then(() => {}); // Trigger the executor, add to dc
+    expect(isDestroyed).toBe(false);
+
+    $proc.destroy();
+    expect(isDestroyed).toBe(true);
+  });
+});

package/src/components/Process.ts

@@ -0,0 +1,28 @@
+import { DestroyContainer } from "base/DestroyContainer";
+import { Message } from "base/Message";
+import { LateShared } from "components/LateShared";
+import { ConstructorType } from "types/ConstructorType";
+import { MessageType } from "types/MessageType";
+
+export function Process<T, R = unknown>(
+  $base: MessageType<T>,
+  builder: ConstructorType<[T], MessageType<R>>,
+) {
+  return Message<R>((resolve, reject) => {
+    const $res = LateShared<R>();
+    const dc = DestroyContainer();
+
+    $base.then((v) => {
+      const $msg = builder(v);
+      dc.add($msg);
+      $res.chain($msg);
+      $msg.catch(reject);
+    });
+    $base.catch(reject);
+    $res.then(resolve);
+
+    return () => {
+      dc.destroy();
+    };
+  });
+}