silentium 0.0.172 → 0.0.173

package/src/components/Piped.test.ts

@@ -0,0 +1,167 @@
+import { describe, expect, test } from "vitest";
+import { Piped } from "components/Piped";
+import { Of } from "base/Of";
+import { Message } from "base/Message";
+import { Applied } from "components/Applied";
+
+describe("Piped.test", () => {
+  test("basic pipe with single constructor", async () => {
+    const $base = Of(10);
+    const double = ($msg: MessageType<number>) =>
+      Applied($msg, (v: number) => v * 2);
+
+    const $result = Piped($base, double);
+    const result = await $result;
+
+    expect(result).toBe(20);
+  });
+
+  test("pipe with multiple constructors", async () => {
+    const $base = Of(5);
+    const addTwo = ($msg: MessageType<number>) =>
+      Applied($msg, (v: number) => v + 2);
+    const multiplyThree = ($msg: MessageType<number>) =>
+      Applied($msg, (v: number) => v * 3);
+    const subtractOne = ($msg: MessageType<number>) =>
+      Applied($msg, (v: number) => v - 1);
+
+    const $result = Piped($base, addTwo, multiplyThree, subtractOne);
+    const result = await $result;
+
+    expect(result).toBe((5 + 2) * 3 - 1); // 7 * 3 - 1 = 20
+  });
+
+  test("pipe with raw value instead of message", async () => {
+    const rawValue = 10;
+    const double = ($msg: MessageType<number>) =>
+      Applied($msg, (v: number) => v * 2);
+
+    const $result = Piped(rawValue, double);
+    const result = await $result;
+
+    expect(result).toBe(20);
+  });
+
+  test("pipe with mixed raw value and message", async () => {
+    const rawValue = 5;
+    const addTwo = ($msg: MessageType<number>) =>
+      Applied($msg, (v: number) => v + 2);
+    const multiplyThree = ($msg: MessageType<number>) =>
+      Applied($msg, (v: number) => v * 3);
+
+    const $result = Piped(rawValue, addTwo, multiplyThree);
+    const result = await $result;
+
+    expect(result).toBe((5 + 2) * 3); // 21
+  });
+
+  test("pipe with string transformations", async () => {
+    const $base = Of("hello");
+    const toUpperCase = ($msg: MessageType<string>) =>
+      Applied($msg, (v: string) => v.toUpperCase());
+    const addExclamation = ($msg: MessageType<string>) =>
+      Applied($msg, (v: string) => v + "!");
+
+    const $result = Piped($base, toUpperCase, addExclamation);
+    const result = await $result;
+
+    expect(result).toBe("HELLO!");
+  });
+
+  test("pipe with object transformations", async () => {
+    const $base = Of({ name: "John", age: 30 });
+    const addCountry = ($msg: MessageType<{ name: string; age: number }>) =>
+      Applied($msg, (v) => ({ ...v, country: "USA" }));
+    const incrementAge = (
+      $msg: MessageType<{ name: string; age: number; country: string }>,
+    ) => Applied($msg, (v) => ({ ...v, age: v.age + 1 }));
+
+    const $result = Piped($base, addCountry, incrementAge);
+    const result = await $result;
+
+    expect(result).toEqual({ name: "John", age: 31, country: "USA" });
+  });
+
+  test("pipe with error handling in constructor", () => {
+    const $base = Of(10);
+    const errorConstructor = ($msg: MessageType<number>) =>
+      Message<number>((resolve, reject) => {
+        $msg.then(() => reject("error from constructor"));
+      });
+
+    const $result = Piped($base, errorConstructor);
+
+    let caught = false;
+    $result.then(() => {
+      throw new Error("should not resolve");
+    });
+    $result.catch((e: unknown) => {
+      expect(e).toBe("error from constructor");
+      caught = true;
+    });
+
+    expect(caught).toBe(true);
+  });
+
+  test("pipe with no constructors returns original message", () => {
+    const $base = Of(42);
+
+    const $result = Piped($base) as any;
+
+    const g = vi.fn();
+    $result.then(g);
+
+    expect(g).toBeCalledWith(42);
+  });
+
+  test("pipe with raw value and no constructors", async () => {
+    const rawValue = 42;
+
+    const $result = Piped(rawValue) as any;
+
+    // When no constructors are provided, Pipe returns the raw value directly
+    expect(await $result).toBe(42);
+  });
+
+  test("pipe with complex type transformations", async () => {
+    const $base = Of([1, 2, 3]);
+    const sumArray = ($msg: MessageType<number[]>) =>
+      Applied($msg, (v: number[]) => v.reduce((a, b) => a + b, 0));
+    const doubleSum = ($msg: MessageType<number>) =>
+      Applied($msg, (v: number) => v * 2);
+    const toString = ($msg: MessageType<number>) =>
+      Applied($msg, (v: number) => `Sum: ${v}`);
+
+    const $result = Piped($base, sumArray, doubleSum, toString);
+    const result = await $result;
+
+    expect(result).toBe("Sum: 12"); // (1+2+3)*2 = 12
+  });
+
+  test("pipe preserves message chainability", () => {
+    const $base = Of(10);
+    const addFive = ($msg: MessageType<number>) =>
+      Applied($msg, (v: number) => v + 5);
+
+    const $result = Piped($base, addFive) as any;
+
+    // Should be able to chain then/catch
+    let resolved = false;
+    let rejected = false;
+
+    $result.then((v: number) => {
+      expect(v).toBe(15);
+      resolved = true;
+    });
+
+    $result.catch(() => {
+      rejected = true;
+    });
+
+    expect(resolved).toBe(true);
+    expect(rejected).toBe(false);
+  });
+});
+
+import { MessageType } from "types/MessageType";
+import { vi } from "vitest";

package/src/components/Piped.ts

@@ -0,0 +1,18 @@
+import { ActualMessage } from "base/ActualMessage";
+import { MaybeMessage } from "types/MessageType";
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+type Last<T extends readonly any[]> = T extends readonly [...infer _, infer L]
+  ? L extends (...args: any) => any
+    ? L
+    : never
+  : never;
+
+export function Piped<T extends ((...vars: any) => MaybeMessage)[]>(
+  $m: MaybeMessage,
+  ...c: T
+) {
+  return c.reduce((msg, Constructor) => {
+    return ActualMessage(Constructor(msg));
+  }, ActualMessage($m)) as ReturnType<Last<T>>;
+}

package/src/global.d.ts

@@ -1,9 +1,13 @@
+import { MessageType } from "types/MessageType";
+
 export {};
 
 declare global {
   interface GlobalThis {
-    silentiumValue: (value: any) => any;
+    silentiumValue: ($message: MessageType) => unknown;
+    silentiumPrint: (...messages: MessageType[]) => void;
   }
 
-  function silentiumValue(value: any): any;
+  function silentiumValue($message: MessageType): unknown;
+  function silentiumPrint(...messages: MessageType[]): void;
 }

package/src/helpers/DevTools.ts

@@ -6,16 +6,15 @@ import { MessageType } from "types/MessageType";
 
 declare global {
   interface GlobalThis {
-    silentiumPrint: (...messages: MessageType[]) => MessageType;
     silentiumValue: ($message: MessageType) => unknown;
+    silentiumPrint: (...messages: MessageType[]) => void;
   }
 }
 
 const silentiumPrint = (...messages: MessageType[]) => {
-  Applied(All(...messages.map((e) => Shared(e))), (r) => ({
-    name,
-    ...r,
-  })).then(console.table);
+  Applied(All(...messages.map((e) => Shared(e))), JSON.stringify).then(
+    console.log,
+  );
 };
 const silentiumValue = ($message: MessageType) =>
   Primitive($message).primitive();

package/src/index.ts

@@ -28,6 +28,7 @@ export * from "./components/FromEvent";
 export * from "./components/Late";
 export * from "./components/Map";
 export * from "./components/Once";
+export * from "./components/Piped";
 export * from "./components/Primitive";
 export * from "./components/Process";
 export * from "./components/Race";