silentium-components 0.0.83 → 0.0.85

package/src/behaviors/Path.ts

@@ -4,7 +4,6 @@ import {
   MaybeMessage,
   Message,
   MessageType,
-  Tap,
 } from "silentium";
 
 /**
@@ -17,18 +16,16 @@ export function Path<
   K extends string = any,
 >($base: MessageType<T>, _keyed: MaybeMessage<K>) {
   const $keyed = ActualMessage(_keyed);
-  return Message<R>(function () {
-    All($base, $keyed).pipe(
-      Tap(([base, keyed]) => {
-        const keys = keyed.split(".");
-        let value: unknown = base;
-        keys.forEach((key) => {
-          value = (value as Record<string, unknown>)[key];
-        });
-        if (value !== undefined && value !== base) {
-          this.use(value as R);
-        }
-      }),
-    );
+  return Message<R>(function PathImpl(r) {
+    All($base, $keyed).then(([base, keyed]) => {
+      const keys = keyed.split(".");
+      let value: unknown = base;
+      keys.forEach((key) => {
+        value = (value as Record<string, unknown>)[key];
+      });
+      if (value !== undefined && value !== base) {
+        r(value as R);
+      }
+    });
   });
 }

package/src/behaviors/Polling.test.ts

@@ -1,13 +1,14 @@
 import { Late, Message, MessageType, Primitive } from "silentium";
 import { expect, test } from "vitest";
+
 import { Polling } from "../behaviors/Polling";
 
 test("Polling.test", () => {
   const $trigger = Late(1);
   let calls = 0;
-  const $calls: MessageType<number> = Message((o) => {
+  const $calls: MessageType<number> = Message((r) => {
     calls += 1;
-    o.use(calls);
+    r(calls);
   });
   const s = Primitive(Polling($calls, $trigger));
 

package/src/behaviors/Polling.ts

@@ -1,15 +1,13 @@
-import { Message, MessageType, Tap } from "silentium";
+import { Message, MessageType } from "silentium";
 
 /**
  * Active polling of $base message
  * synchronized with $trigger message
  */
 export function Polling<T>($base: MessageType<T>, $trigger: MessageType<T>) {
-  return Message<T>(function () {
-    $trigger.pipe(
-      Tap(() => {
-        $base.pipe(this);
-      }),
-    );
+  return Message<T>(function PollingImpl(r) {
+    $trigger.then(() => {
+      $base.then(r);
+    });
   });
 }

package/src/behaviors/Shot._main.test.ts

@@ -1,14 +1,15 @@
-import { Late, Shared, Tap } from "silentium";
-import { Shot } from "../behaviors/Shot";
+import { Late, Shared } from "silentium";
 import { expect, test, vi } from "vitest";
 
+import { Shot } from "../behaviors/Shot";
+
 test("Shot._main.test", () => {
   const $base = Late();
   const $trigger = Late();
 
   const $shotted = Shared(Shot($base, $trigger));
   const g = vi.fn();
-  $shotted.pipe(Tap(g));
+  $shotted.then(g);
 
   $base.use(1);
   $trigger.use(1);
@@ -24,6 +25,6 @@ test("Shot._main.test", () => {
   expect(g).toHaveBeenLastCalledWith(2);
 
   const g2 = vi.fn();
-  $shotted.pipe(Tap(g2));
+  $shotted.then(g2);
   expect(g2).toHaveBeenLastCalledWith(2);
 });

package/src/behaviors/Shot._onlyChanged.test.ts

@@ -1,24 +1,23 @@
-import { Late, Shared, Tap } from "silentium";
+import { Late, Shared } from "silentium";
+import { expect, test } from "vitest";
+
 import { OnlyChanged } from "../behaviors/OnlyChanged";
 import { Shot } from "../behaviors/Shot";
-import { expect, test } from "vitest";
 
 test("Shot._onlyChanged.test", () => {
-  const $base = Late<number>(123);
-  const $shared = Shared($base, true);
+  const $base = Late<number>();
+  const $shared = Shared($base);
   const $result = Shot($shared, OnlyChanged($shared));
 
   const vals: number[] = [];
 
-  $result.pipe(
-    Tap((v) => {
-      vals.push(v);
-    }),
-  );
+  $result.then((v) => {
+    vals.push(v);
+  });
 
   expect(vals).toStrictEqual([]);
 
-  $base.use(222);
+  $base.use(123);
 
   expect(vals).toStrictEqual([]);
 

package/src/behaviors/Shot.ts

@@ -1,20 +1,18 @@
-import { isFilled, Message, MessageType, Primitive, Tap } from "silentium";
+import { isFilled, Message, MessageType, Primitive } from "silentium";
 
 /**
  * Helps to represent only last fresh value Of some source, refreshing controls by shotSrc
  * https://silentium-lab.github.io/silentium-components/#/behaviors/shot
  */
 export function Shot<T>($target: MessageType<T>, $trigger: MessageType) {
-  return Message<T>(function () {
+  return Message<T>(function ShotImpl(r) {
     const targetSync = Primitive($target);
     targetSync.primitive();
-    $trigger.pipe(
-      Tap(() => {
-        const value = targetSync.primitive();
-        if (isFilled(value)) {
-          this.use(value);
-        }
-      }),
-    );
+    $trigger.then(() => {
+      const value = targetSync.primitive();
+      if (isFilled(value)) {
+        r(value);
+      }
+    });
   });
 }

package/src/behaviors/Task.test.ts

@@ -1,7 +1,8 @@
-import { Late, Tap } from "silentium";
-import { Task } from "../behaviors/Task";
+import { Late } from "silentium";
 import { afterEach, beforeEach, expect, test, vi } from "vitest";
 
+import { Task } from "../behaviors/Task";
+
 beforeEach(() => {
   vi.useFakeTimers({ shouldAdvanceTime: true });
 });
@@ -15,11 +16,9 @@ test("Task delays emission", () => {
   const $trigger = Late<string>();
   const delayed = Task($trigger, 100);
   const data: string[] = [];
-  delayed.pipe(
-    Tap((v) => {
-      data.push(v);
-    }),
-  );
+  delayed.then((v) => {
+    data.push(v);
+  });
 
   $trigger.use("first");
 
@@ -36,11 +35,9 @@ test("Task emits only last value when multiple before delay", () => {
   const $trigger = Late<string>();
   const delayed = Task($trigger, 100);
   const data: string[] = [];
-  delayed.pipe(
-    Tap((v) => {
-      data.push(v);
-    }),
-  );
+  delayed.then((v) => {
+    data.push(v);
+  });
 
   $trigger.use("first");
   $trigger.use("second");

package/src/behaviors/Task.ts

@@ -1,14 +1,20 @@
-import { ExecutorApplied, Message, MessageType } from "silentium";
+import {
+  ActualMessage,
+  ExecutorApplied,
+  MaybeMessage,
+  Message,
+} from "silentium";
 
 /**
  * Defer a message to the event loop
  * so that it executes once within
  * a certain timer firing interval
  */
-export function Task<T>(baseSrc: MessageType<T>, delay: number = 0) {
-  return Message<T>(function () {
+export function Task<T>(baseSrc: MaybeMessage<T>, delay: number = 0) {
+  const $base = ActualMessage(baseSrc);
+  return Message<T>(function TaskImpl(r) {
     let prevTimer: unknown | null = null;
-    ExecutorApplied(baseSrc, (fn) => {
+    ExecutorApplied($base, (fn) => {
       return (v) => {
         if (prevTimer) {
           clearTimeout(prevTimer as number);
@@ -17,6 +23,6 @@ export function Task<T>(baseSrc: MessageType<T>, delay: number = 0) {
           fn(v);
         }, delay);
       };
-    }).pipe(this);
+    }).then(r);
   });
 }

package/src/behaviors/Tick.test.ts

@@ -1,7 +1,8 @@
-import { Any, Late, Shared, Tap } from "silentium";
-import { Tick } from "../behaviors/Tick";
+import { Any, Late, Shared } from "silentium";
 import { afterEach, beforeEach, expect, test, vi } from "vitest";
 
+import { Tick } from "../behaviors/Tick";
+
 beforeEach(() => {
   vi.useFakeTimers({ shouldAdvanceTime: true });
 });
@@ -14,10 +15,10 @@ afterEach(() => {
 test("Tick.test", async () => {
   const $s1 = Late<number>(1);
   const $s2 = Late<number>(2);
-  const $tick = Shared(Tick(Any($s1, $s2)), true);
+  const $tick = Shared(Tick(Any($s1, $s2)));
 
   const g = vi.fn();
-  $tick.pipe(Tap(g));
+  $tick.then(g);
 
   $s1.use(3);
   $s2.use(4);

package/src/behaviors/Tick.ts

@@ -1,11 +1,11 @@
-import { Message, MessageType, Tap } from "silentium";
+import { Message, MessageType } from "silentium";
 
 /**
  * Accumulates the last value Of the source and returns one result once per tick
  * https://silentium-lab.github.io/silentium-components/#/behaviors/tick
  */
 export function Tick<T>($base: MessageType<T>) {
-  return Message(function () {
+  return Message<T>(function TickImpl(r) {
     let microtaskScheduled = false;
     let lastValue: T | null = null;
 
@@ -14,19 +14,17 @@ export function Tick<T>($base: MessageType<T>) {
       queueMicrotask(() => {
         microtaskScheduled = false;
         if (lastValue !== null) {
-          this.use(lastValue);
+          r(lastValue);
           lastValue = null;
         }
       });
     };
 
-    $base.pipe(
-      Tap((v) => {
-        lastValue = v;
-        if (!microtaskScheduled) {
-          scheduleMicrotask();
-        }
-      }),
-    );
+    $base.then((v) => {
+      lastValue = v;
+      if (!microtaskScheduled) {
+        scheduleMicrotask();
+      }
+    });
   });
 }

package/src/behaviors/index.ts

@@ -15,4 +15,3 @@ export * from "./Polling";
 export * from "./Shot";
 export * from "./Task";
 export * from "./Tick";
-export * from "./Transaction";

package/src/boolean/And.test.ts

@@ -1,5 +1,6 @@
-import { Late, Tap } from "silentium";
+import { Late } from "silentium";
 import { expect, test, vi } from "vitest";
+
 import { And } from "../boolean/And";
 
 test("And.test", () => {
@@ -7,7 +8,7 @@ test("And.test", () => {
   const $two = Late<boolean>(false);
   const result = And($one, $two);
   const g = vi.fn();
-  result.pipe(Tap(g));
+  result.then(g);
   expect(g).toHaveBeenLastCalledWith(false);
 
   $one.use(true);

package/src/boolean/And.ts

@@ -1,15 +1,13 @@
-import { All, Message, MessageType, Tap } from "silentium";
+import { All, Message, MessageType } from "silentium";
 
 /**
  * Logical AND over two messages
  * https://silentium-lab.github.io/silentium-components/#/boolean/and
  */
 export function And($one: MessageType<boolean>, $two: MessageType<boolean>) {
-  return Message<boolean>(function () {
-    All($one, $two).pipe(
-      Tap(([one, two]) => {
-        this.use(!!(one && two));
-      }),
-    );
+  return Message<boolean>(function AndImpl(r) {
+    All($one, $two).then(([one, two]) => {
+      r(!!(one && two));
+    });
   });
 }

package/src/boolean/Bool.test.ts

@@ -1,9 +1,10 @@
-import { Of, Tap } from "silentium";
-import { Bool } from "../boolean/Bool";
+import { Of } from "silentium";
 import { expect, test, vi } from "vitest";
 
+import { Bool } from "../boolean/Bool";
+
 test("Bool.test", () => {
   const o = vi.fn();
-  Bool(Of(1)).pipe(Tap(o));
+  Bool(Of(1)).then(o);
   expect(o).toHaveBeenCalledWith(true);
 });

package/src/boolean/Bool.ts

@@ -5,7 +5,7 @@ import { Applied, Message, MessageType } from "silentium";
  * https://silentium-lab.github.io/silentium-components/#/boolean/bool
  */
 export function Bool($base: MessageType) {
-  return Message<boolean>(function () {
-    Applied($base, Boolean).pipe(this);
+  return Message<boolean>(function BoolImpl(r) {
+    Applied($base, Boolean).then(r);
   });
 }

package/src/boolean/Not.test.ts

@@ -1,12 +1,13 @@
-import { Late, Tap } from "silentium";
-import { Not } from "../boolean/Not";
+import { Late } from "silentium";
 import { expect, test, vi } from "vitest";
 
+import { Not } from "../boolean/Not";
+
 test("Not.test", () => {
   const one = Late<boolean>(false);
   const result = Not(one);
   const g = vi.fn();
-  result.pipe(Tap(g));
+  result.then(g);
   expect(g).toHaveBeenLastCalledWith(true);
 
   one.use(true);

package/src/boolean/Not.ts

@@ -1,15 +1,13 @@
-import { Message, MessageType, Tap } from "silentium";
+import { Message, MessageType } from "silentium";
 
 /**
  * Logical negation of message
  * https://silentium-lab.github.io/silentium-components/#/boolean/not
  */
 export function Not($base: MessageType<boolean>) {
-  return Message<boolean>(function () {
-    $base.pipe(
-      Tap((v) => {
-        this.use(!v);
-      }),
-    );
+  return Message<boolean>(function NotImpl(r) {
+    $base.then((v) => {
+      r(!v);
+    });
   });
 }

package/src/boolean/Or.test.ts

@@ -1,13 +1,14 @@
-import { Late, Tap } from "silentium";
-import { Or } from "../boolean/Or";
+import { Late } from "silentium";
 import { expect, test, vi } from "vitest";
 
+import { Or } from "../boolean/Or";
+
 test("Or.test", () => {
   const one = Late<boolean>(false);
   const two = Late<boolean>(false);
   const result = Or(one, two);
   const g = vi.fn();
-  result.pipe(Tap(g));
+  result.then(g);
   expect(g).toHaveBeenLastCalledWith(false);
 
   one.use(true);

package/src/boolean/Or.ts

@@ -1,15 +1,13 @@
-import { All, Message, MessageType, Tap } from "silentium";
+import { All, Message, MessageType } from "silentium";
 
 /**
  * Logical OR over two messages
  * https://silentium-lab.github.io/silentium-components/#/boolean/or
  */
 export function Or($one: MessageType<boolean>, $two: MessageType<boolean>) {
-  return Message<boolean>(function () {
-    All($one, $two).pipe(
-      Tap(([one, two]) => {
-        this.use(!!(one || two));
-      }),
-    );
+  return Message<boolean>(function OrImpl(r) {
+    All($one, $two).then(([one, two]) => {
+      r(!!(one || two));
+    });
   });
 }

package/src/boolean/index.ts

@@ -1,4 +1,4 @@
 export * from "./And";
-export * from "./Or";
-export * from "./Not";
 export * from "./Bool";
+export * from "./Not";
+export * from "./Or";

package/src/formats/FromJson.test.ts

@@ -1,7 +1,8 @@
 import { Of, Primitive } from "silentium";
-import { FromJson } from "../formats/FromJson";
 import { expect, test } from "vitest";
 
+import { FromJson } from "../formats/FromJson";
+
 test("FromJson.test", () => {
   const one = Of('{"hello": "world"}');
   const objectSync = Primitive(FromJson<{ hello: string }>(one));

package/src/formats/FromJson.ts

@@ -1,21 +1,18 @@
-import { Message, MessageType, Tap, TapType } from "silentium";
+import { Message, MessageType } from "silentium";
 
 /**
  * Represents object from json
  */
 export function FromJson<T = Record<string, unknown>>(
   $json: MessageType<string>,
-  error?: TapType,
 ) {
-  return Message<T>(function () {
-    $json.pipe(
-      Tap((json) => {
-        try {
-          this.use(JSON.parse(json));
-        } catch (e) {
-          error?.use(new Error(`Failed to parse JSON: ${e}`));
-        }
-      }),
-    );
+  return Message<T>(function FromJsonImpl(resolve, reject) {
+    $json.then((json) => {
+      try {
+        resolve(JSON.parse(json));
+      } catch (e) {
+        reject(new Error(`Failed to parse JSON: ${e}`));
+      }
+    });
   });
 }

package/src/formats/ToJson.test.ts

@@ -1,5 +1,6 @@
 import { Of, Primitive } from "silentium";
 import { expect, test } from "vitest";
+
 import { ToJson } from "../formats/ToJson";
 
 test("ToJson.test", () => {

package/src/formats/ToJson.ts

@@ -1,18 +1,16 @@
-import { Message, MessageType, Tap, TapType } from "silentium";
+import { Message, MessageType } from "silentium";
 
 /**
  * Represents json from object
  */
-export function ToJson($data: MessageType, error?: TapType) {
-  return Message<string>(function () {
-    $data.pipe(
-      Tap((data: unknown) => {
-        try {
-          this.use(JSON.stringify(data));
-        } catch {
-          error?.use(new Error("Failed to convert to JSON"));
-        }
-      }),
-    );
+export function ToJson($data: MessageType) {
+  return Message<string>(function ToJsonImpl(resolve, reject) {
+    $data.then((data: unknown) => {
+      try {
+        resolve(JSON.stringify(data));
+      } catch {
+        reject(new Error("Failed to convert to JSON"));
+      }
+    });
   });
 }

package/src/index.ts

@@ -1,8 +1,8 @@
 export * from "./behaviors";
-export * from "./structures";
-export * from "./strings";
-export * from "./navigation";
-export * from "./system";
 export * from "./boolean";
 export * from "./formats";
 export * from "./lists";
+export * from "./navigation";
+export * from "./strings";
+export * from "./structures";
+export * from "./system";

package/src/lists/First.test.ts

@@ -1,10 +1,11 @@
-import { Of, Tap } from "silentium";
+import { Of } from "silentium";
 import { expect, test, vi } from "vitest";
+
 import { First } from "./First";
 
 test("first", () => {
   const f = First(Of([1, 2, 3]));
   const g = vi.fn();
-  f.pipe(Tap(g));
+  f.then(g);
   expect(g).toHaveBeenCalledWith(1);
 });

package/src/lists/First.ts

@@ -4,7 +4,7 @@ import { Applied, Message, MessageType } from "silentium";
  * Represents the first element Of an array.
  */
 export function First<T extends Array<unknown>>($base: MessageType<T>) {
-  return Message<T[0]>(function () {
-    Applied($base, (a) => a[0]).pipe(this);
+  return Message<T[0]>(function FirstImpl(r) {
+    Applied($base, (a) => a[0]).then(r);
   });
 }

package/src/navigation/Router._destroy.test.ts

@@ -1,15 +1,8 @@
-import {
-  Applied,
-  Late,
-  Message,
-  Of,
-  Shared,
-  Tap,
-  TapMessage,
-} from "silentium";
-import { Router } from "../navigation/Router";
+import { Applied, Late, Message, Of, Shared } from "silentium";
 import { expect, test, vi } from "vitest";
 
+import { Router } from "../navigation/Router";
+
 const drop = (dropPart: string) => (value: string) => {
   return value.replace(dropPart, "");
 };
@@ -18,33 +11,30 @@ test("Router destroys previous route messages when switching routes", () => {
   const $url = Late<string>("http://domain.com/");
   const $urlPath = Shared(Applied($url, drop("http://domain.com")));
   const g = vi.fn();
-  $urlPath.pipe(Tap(g));
+  $urlPath.then(g);
 
   // Create mock destroyable messages for routes
   const firstRouteDestroy = vi.fn();
   const secondRouteDestroy = vi.fn();
   const defaultDestroy = vi.fn();
 
-  const $firstRoute = TapMessage(() =>
+  const $firstRoute = () =>
     Message<string>((transport) => {
-      transport.use("first-route-response");
+      transport("first-route-response");
       return firstRouteDestroy;
-    }),
-  );
+    });
 
-  const $secondRoute = TapMessage(() =>
+  const $secondRoute = () =>
     Message<string>((transport) => {
-      transport.use("second-route-response");
+      transport("second-route-response");
       return secondRouteDestroy;
-    }),
-  );
+    });
 
-  const $default = TapMessage(() =>
+  const $default = () =>
     Message<string>((transport) => {
-      transport.use("default-response");
+      transport("default-response");
       return defaultDestroy;
-    }),
-  );
+    });
 
   const $router = Router(
     $urlPath,
@@ -62,7 +52,7 @@ test("Router destroys previous route messages when switching routes", () => {
   );
 
   const g2 = vi.fn();
-  $router.pipe(Tap(g2));
+  $router.then(g2);
 
   // Initially no route matches, should use default
   expect(g2).toHaveBeenLastCalledWith("default-response");