silentium-components 0.0.70 → 0.0.71

package/src/behaviors/Path.ts

@@ -1,27 +1,26 @@
-import { All, EventType } from "silentium";
+import { All, Event, EventType, Transport } from "silentium";
 
 /**
  * Return source Of record path
  * https://silentium-lab.github.io/silentium-components/#/behaviors/path
  */
-export function Path<R, T extends object | Array<any>, K extends string = any>(
-  baseSrc: EventType<T>,
-  keySrc: EventType<K>,
-): EventType<R> {
-  return (user) => {
-    All(
-      baseSrc,
-      keySrc,
-    )(([base, key]) => {
-      const keyChunks = key.split(".");
-      let value: unknown = base;
-      keyChunks.forEach((keyChunk) => {
-        value = (value as Record<string, unknown>)[keyChunk];
-      });
-
-      if (value !== undefined && value !== base) {
-        user(value as R);
-      }
-    });
-  };
+export function Path<
+  R,
+  T extends object | Array<any> = any,
+  K extends string = any,
+>($base: EventType<T>, $keyed: EventType<K>): EventType<R> {
+  return Event((transport) => {
+    All($base, $keyed).event(
+      Transport(([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) {
+          transport.use(value as R);
+        }
+      }),
+    );
+  });
 }

package/src/behaviors/Polling.test.ts

@@ -1,25 +1,25 @@
-import { EventType, Late, Primitive } from "silentium";
+import { Event, EventType, Late, Primitive } from "silentium";
 import { expect, test } from "vitest";
 import { Polling } from "../behaviors/Polling";
 
 test("Polling.test", () => {
-  const triggerSrc = Late(1);
+  const $trigger = Late(1);
   let calls = 0;
-  const callsSrc: EventType<number> = (o) => {
+  const $calls: EventType<number> = Event((o) => {
     calls += 1;
-    o(calls);
-  };
-  const s = Primitive(Polling(callsSrc, triggerSrc.event));
+    o.use(calls);
+  });
+  const s = Primitive(Polling($calls, $trigger));
 
   expect(s.primitive()).toBe(1);
 
-  triggerSrc.use(1);
+  $trigger.use(1);
 
   expect(s.primitive()).toBe(2);
 
-  triggerSrc.use(1);
-  triggerSrc.use(1);
-  triggerSrc.use(1);
+  $trigger.use(1);
+  $trigger.use(1);
+  $trigger.use(1);
 
   expect(s.primitive()).toBe(5);
 });

package/src/behaviors/Polling.ts

@@ -1,12 +1,14 @@
-import { EventType } from "silentium";
+import { Event, EventType, Transport } from "silentium";
 
 export function Polling<T>(
-  baseSrc: EventType<T>,
-  triggerSrc: EventType<T>,
+  $base: EventType<T>,
+  $trigger: EventType<T>,
 ): EventType<T> {
-  return (user) => {
-    triggerSrc(() => {
-      baseSrc(user);
-    });
-  };
+  return Event((transport) => {
+    $trigger.event(
+      Transport(() => {
+        $base.event(transport);
+      }),
+    );
+  });
 }

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

@@ -1,29 +1,29 @@
-import { Late, Shared } from "silentium";
+import { Late, Shared, Transport } from "silentium";
 import { Shot } from "../behaviors/Shot";
 import { expect, test, vi } from "vitest";
 
 test("Shot._main.test", () => {
-  const baseSrc = Late();
-  const shotSrc = Late();
+  const $base = Late();
+  const $trigger = Late();
 
-  const shotResult = Shared(Shot(baseSrc.event, shotSrc.event));
+  const $shotted = Shared(Shot($base, $trigger));
   const g = vi.fn();
-  shotResult.event(g);
+  $shotted.event(Transport(g));
 
-  baseSrc.use(1);
-  shotSrc.use(1);
+  $base.use(1);
+  $trigger.use(1);
 
   expect(g).toHaveBeenLastCalledWith(1);
 
-  baseSrc.use(2);
+  $base.use(2);
 
   expect(g).toHaveBeenLastCalledWith(1);
 
-  shotSrc.use(1);
+  $trigger.use(1);
 
   expect(g).toHaveBeenLastCalledWith(2);
 
   const g2 = vi.fn();
-  shotResult.event(g2);
+  $shotted.event(Transport(g2));
   expect(g2).toHaveBeenLastCalledWith(2);
 });

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

@@ -1,34 +1,36 @@
-import { Late, Shared } from "silentium";
+import { Late, Shared, Transport } from "silentium";
 import { OnlyChanged } from "../behaviors/OnlyChanged";
 import { Shot } from "../behaviors/Shot";
 import { expect, test } from "vitest";
 
 test("Shot._onlyChanged.test", () => {
-  const baseSrc = Late<number>(123);
-  const sharedBase = Shared(baseSrc.event, true);
-  const resultSrc = Shot(sharedBase.event, OnlyChanged(sharedBase.event));
+  const $base = Late<number>(123);
+  const $shared = Shared($base, true);
+  const $result = Shot($shared, OnlyChanged($shared));
 
   const vals: number[] = [];
 
-  resultSrc((v) => {
-    vals.push(v);
-  });
+  $result.event(
+    Transport((v) => {
+      vals.push(v);
+    }),
+  );
 
   expect(vals).toStrictEqual([]);
 
-  baseSrc.use(222);
+  $base.use(222);
 
   expect(vals).toStrictEqual([]);
 
-  baseSrc.use(222);
+  $base.use(222);
 
   expect(vals).toStrictEqual([222]);
 
-  baseSrc.use(333);
+  $base.use(333);
 
   expect(vals).toStrictEqual([222, 333]);
 
-  baseSrc.use(123);
+  $base.use(123);
 
   expect(vals).toStrictEqual([222, 333, 123]);
 });

package/src/behaviors/Shot.ts

@@ -1,21 +1,24 @@
-import { EventType, isFilled, Primitive } from "silentium";
+import { Event, EventType, isFilled, Primitive, Transport } 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>(
-  targetSrc: EventType<T>,
-  triggerSrc: EventType,
+  $target: EventType<T>,
+  $trigger: EventType,
 ): EventType<T> {
-  return (user) => {
-    const targetSync = Primitive(targetSrc);
+  return Event((transport) => {
+    const targetSync = Primitive($target);
+    targetSync.primitive();
 
-    triggerSrc(() => {
-      const value = targetSync.primitive();
-      if (isFilled(value)) {
-        user(value);
-      }
-    });
-  };
+    $trigger.event(
+      Transport(() => {
+        const value = targetSync.primitive();
+        if (isFilled(value)) {
+          transport.use(value);
+        }
+      }),
+    );
+  });
 }

package/src/behaviors/Task.ts

@@ -1,10 +1,10 @@
-import { EventType, ExecutorApplied } from "silentium";
+import { Event, EventType, ExecutorApplied } from "silentium";
 
 export function Task<T>(
   baseSrc: EventType<T>,
   delay: number = 0,
 ): EventType<T> {
-  return (user) => {
+  return Event((transport) => {
     let prevTimer: unknown | null = null;
     ExecutorApplied(baseSrc, (fn) => {
       return (v) => {
@@ -15,6 +15,6 @@ export function Task<T>(
           fn(v);
         }, delay);
       };
-    })(user);
-  };
+    }).event(transport);
+  });
 }

package/src/behaviors/Tick.test.ts

@@ -1,4 +1,4 @@
-import { Any, Late, Shared } from "silentium";
+import { Any, Late, Shared, Transport } from "silentium";
 import { Tick } from "../behaviors/Tick";
 import { afterEach, beforeEach, expect, test, vi } from "vitest";
 
@@ -12,15 +12,15 @@ afterEach(() => {
 });
 
 test("Tick.test", async () => {
-  const s1 = Late<number>(1);
-  const s2 = Late<number>(2);
-  const tickSrc = Shared(Tick(Any(s1.event, s2.event)), true);
+  const $s1 = Late<number>(1);
+  const $s2 = Late<number>(2);
+  const $tick = Shared(Tick(Any($s1, $s2)), true);
 
   const g = vi.fn();
-  tickSrc.event(g);
+  $tick.event(Transport(g));
 
-  s1.use(3);
-  s2.use(4);
+  $s1.use(3);
+  $s2.use(4);
 
   await vi.advanceTimersByTimeAsync(10);
   vi.runAllTicks();

package/src/behaviors/Tick.ts

@@ -1,11 +1,11 @@
-import { EventType } from "silentium";
+import { Event, EventType, Transport } 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>(baseSrc: EventType<T>): EventType<T> {
-  return (user) => {
+export function Tick<T>($base: EventType<T>): EventType<T> {
+  return Event((transport) => {
     let microtaskScheduled = false;
     let lastValue: T | null = null;
 
@@ -14,17 +14,19 @@ export function Tick<T>(baseSrc: EventType<T>): EventType<T> {
       queueMicrotask(() => {
         microtaskScheduled = false;
         if (lastValue !== null) {
-          user(lastValue);
+          transport.use(lastValue);
           lastValue = null;
         }
       });
     };
 
-    baseSrc((v) => {
-      lastValue = v;
-      if (!microtaskScheduled) {
-        scheduleMicrotask();
-      }
-    });
-  };
+    $base.event(
+      Transport((v) => {
+        lastValue = v;
+        if (!microtaskScheduled) {
+          scheduleMicrotask();
+        }
+      }),
+    );
+  });
 }

package/src/behaviors/Transaction.test.ts

@@ -6,7 +6,7 @@ describe("Transaction.test", () => {
   test("value inside transaction", () => {
     const $base = LateShared(1);
 
-    const t = Transaction($base.event, ($b) => {
+    const t = Transaction($base, ($b) => {
       return Applied($b, (x) => x * 2);
     });
 
@@ -18,11 +18,11 @@ describe("Transaction.test", () => {
     const $mult = LateShared(2);
 
     const t = Transaction(
-      $base.event,
+      $base,
       ($b, $m) => {
         return Applied(All($b, $m), ([x, m]) => x * m);
       },
-      $mult.event,
+      $mult,
     );
 
     expect(Primitive(t).primitiveWithException()).toBe(2);

package/src/behaviors/Transaction.ts

@@ -1,10 +1,11 @@
 import {
   ConstructorType,
   DestroyableType,
-  Destructor,
+  Event,
   EventType,
   LateShared,
   Of,
+  Transport,
 } from "silentium";
 import { Detached } from "../behaviors/Detached";
 
@@ -20,22 +21,22 @@ export function Transaction<T, R = unknown>(
   >,
   ...args: EventType[]
 ): EventType<R> {
-  return (user) => {
+  return Event((transport) => {
     const $res = LateShared<R>();
     const destructors: DestroyableType[] = [];
 
-    $base((v) => {
-      const $event = Destructor(
-        eventBuilder(Of(v), ...args.map((a) => Detached(a))),
-      );
-      destructors.push($event);
-      $event.event($res.use);
-    });
-    $res.event(user);
+    $base.event(
+      Transport((v) => {
+        const $event = eventBuilder(Of(v), ...args.map((a) => Detached(a)));
+        destructors.push($event as unknown as DestroyableType);
+        $event.event($res);
+      }),
+    );
+    $res.event(transport);
 
     return () => {
-      destructors.forEach((d) => d.destroy());
+      destructors.forEach((d) => d?.destroy());
       destructors.length = 0;
     };
-  };
+  });
 }

package/src/boolean/And.test.ts

@@ -1,24 +1,24 @@
-import { Late } from "silentium";
+import { Late, Transport } from "silentium";
 import { expect, test, vi } from "vitest";
 import { And } from "../boolean/And";
 
 test("And.test", () => {
-  const one = Late<boolean>(false);
-  const two = Late<boolean>(false);
-  const result = And(one.event, two.event);
+  const $one = Late<boolean>(false);
+  const $two = Late<boolean>(false);
+  const result = And($one, $two);
   const g = vi.fn();
-  result(g);
+  result.event(Transport(g));
   expect(g).toHaveBeenLastCalledWith(false);
 
-  one.use(true);
-  two.use(false);
+  $one.use(true);
+  $two.use(false);
   expect(g).toHaveBeenLastCalledWith(false);
 
-  one.use(false);
-  two.use(true);
+  $one.use(false);
+  $two.use(true);
   expect(g).toHaveBeenLastCalledWith(false);
 
-  one.use(true);
-  two.use(true);
+  $one.use(true);
+  $two.use(true);
   expect(g).toHaveBeenLastCalledWith(true);
 });

package/src/boolean/And.ts

@@ -1,18 +1,17 @@
-import { All, EventType } from "silentium";
+import { All, Event, EventType, Transport } from "silentium";
 
 /**
  * https://silentium-lab.github.io/silentium-components/#/boolean/and
  */
 export function And(
-  oneSrc: EventType<boolean>,
-  twoSrc: EventType<boolean>,
+  $one: EventType<boolean>,
+  $two: EventType<boolean>,
 ): EventType<boolean> {
-  return (user) => {
-    All(
-      oneSrc,
-      twoSrc,
-    )(([one, two]) => {
-      user(one && two);
-    });
-  };
+  return Event((transport) => {
+    All($one, $two).event(
+      Transport(([one, two]) => {
+        transport.use(one && two);
+      }),
+    );
+  });
 }

package/src/boolean/Bool.test.ts

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

package/src/boolean/Bool.ts

@@ -1,11 +1,11 @@
-import { Applied, EventType } from "silentium";
+import { Applied, Event, EventType } from "silentium";
 
 /**
  * Convert Any source to boolean source
  * https://silentium-lab.github.io/silentium-components/#/boolean/bool
  */
-export function Bool(baseSrc: EventType): EventType<boolean> {
-  return (user) => {
-    Applied(baseSrc, Boolean)(user);
-  };
+export function Bool($base: EventType): EventType<boolean> {
+  return Event((transport) => {
+    Applied($base, Boolean).event(transport);
+  });
 }

package/src/boolean/Not.test.ts

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

package/src/boolean/Not.ts

@@ -1,12 +1,14 @@
-import { EventType } from "silentium";
+import { Event, EventType, Transport } from "silentium";
 
 /**
  * https://silentium-lab.github.io/silentium-components/#/boolean/not
  */
-export function Not(baseSrc: EventType<boolean>): EventType<boolean> {
-  return (user) => {
-    baseSrc((v) => {
-      user(!v);
-    });
-  };
+export function Not($base: EventType<boolean>): EventType<boolean> {
+  return Event((transport) => {
+    $base.event(
+      Transport((v) => {
+        transport.use(!v);
+      }),
+    );
+  });
 }

package/src/boolean/Or.test.ts

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

package/src/boolean/Or.ts

@@ -1,18 +1,17 @@
-import { All, EventType } from "silentium";
+import { All, Event, EventType, Transport } from "silentium";
 
 /**
  * https://silentium-lab.github.io/silentium-components/#/boolean/or
  */
 export function Or(
-  oneSrc: EventType<boolean>,
-  twoSrc: EventType<boolean>,
+  $one: EventType<boolean>,
+  $two: EventType<boolean>,
 ): EventType<boolean> {
-  return (user) => {
-    All(
-      oneSrc,
-      twoSrc,
-    )(([one, two]) => {
-      user(one || two);
-    });
-  };
+  return Event((transport) => {
+    All($one, $two).event(
+      Transport(([one, two]) => {
+        transport.use(one || two);
+      }),
+    );
+  });
 }

package/src/formats/FromJson.ts

@@ -1,19 +1,21 @@
-import { EventType, EventUserType } from "silentium";
+import { Event, EventType, Transport, TransportType } from "silentium";
 
 /**
  * Represents object from json
  */
 export function FromJson<T = Record<string, unknown>>(
-  jsonSrc: EventType<string>,
-  errorOwner?: EventUserType,
+  $json: EventType<string>,
+  error?: TransportType,
 ): EventType<T> {
-  return (user) => {
-    jsonSrc((json) => {
-      try {
-        user(JSON.parse(json));
-      } catch (error) {
-        errorOwner?.(new Error(`Failed to parse JSON: ${error}`));
-      }
-    });
-  };
+  return Event((transport) => {
+    $json.event(
+      Transport((json) => {
+        try {
+          transport.use(JSON.parse(json));
+        } catch (e) {
+          error?.use(new Error(`Failed to parse JSON: ${e}`));
+        }
+      }),
+    );
+  });
 }

package/src/formats/ToJson.ts

@@ -1,19 +1,21 @@
-import { EventType, EventUserType } from "silentium";
+import { Event, EventType, Transport, TransportType } from "silentium";
 
 /**
  * Represents json from object
  */
 export function ToJson(
-  dataSrc: EventType,
-  errorOwner?: EventUserType,
+  $data: EventType,
+  error?: TransportType,
 ): EventType<string> {
-  return (user) => {
-    dataSrc((data: unknown) => {
-      try {
-        user(JSON.stringify(data));
-      } catch {
-        errorOwner?.(new Error("Failed to convert to JSON"));
-      }
-    });
-  };
+  return Event((transport) => {
+    $data.event(
+      Transport((data: unknown) => {
+        try {
+          transport.use(JSON.stringify(data));
+        } catch {
+          error?.use(new Error("Failed to convert to JSON"));
+        }
+      }),
+    );
+  });
 }