silentium-components 0.0.70 → 0.0.71

package/src/behaviors/Deferred.test.ts

@@ -1,29 +1,29 @@
-import { Late, Primitive, Shared } from "silentium";
+import { Late, Primitive, Shared, Transport } from "silentium";
 import { Deferred } from "../behaviors/Deferred";
 import { expect, test, vi } from "vitest";
 
 test("Deferred.test", () => {
-  const urlSrc = Late<string>("http://hello.com");
-  const layoutSrc = Late<string>();
+  const $url = Late<string>("http://hello.com");
+  const $layout = Late<string>();
 
-  const urlWithLayoutSrc = Shared(Deferred(urlSrc.event, layoutSrc.event));
+  const urlWithLayoutSrc = Shared(Deferred($url, $layout));
 
   const g1 = vi.fn();
-  urlWithLayoutSrc.event(g1);
+  urlWithLayoutSrc.event(Transport(g1));
   expect(g1).not.toHaveBeenCalled();
 
-  layoutSrc.use("layout here");
+  $layout.use("layout here");
 
   const g2 = vi.fn();
-  urlWithLayoutSrc.event(g2);
-  urlSrc.use("http://new.com");
+  urlWithLayoutSrc.event(Transport(g2));
+  $url.use("http://new.com");
   expect(g2).toHaveBeenCalledWith("http://hello.com");
 
-  const urlSync = Primitive(urlWithLayoutSrc.event);
+  const urlSync = Primitive(urlWithLayoutSrc);
 
   expect(urlSync.primitive()).toBe("http://hello.com");
 
-  layoutSrc.use("layout here again");
+  $layout.use("layout here again");
 
   expect(urlSync.primitive()).toBe("http://new.com");
 });

package/src/behaviors/Deferred.ts

@@ -1,20 +1,22 @@
-import { EventType, isFilled, Primitive } from "silentium";
+import { Event, EventType, isFilled, Primitive, Transport } from "silentium";
 
 /**
  * Defer one source after another, gives values Of baseSrc only when triggerSrc responds
  * https://silentium-lab.github.io/silentium-components/#/behaviors/deferred
  */
 export function Deferred<T>(
-  baseSrc: EventType<T>,
-  triggerSrc: EventType<unknown>,
+  $base: EventType<T>,
+  $trigger: EventType<unknown>,
 ): EventType<T> {
-  return (user) => {
-    const baseSync = Primitive(baseSrc);
-    triggerSrc(() => {
-      const value = baseSync.primitive();
-      if (isFilled(value)) {
-        user(value);
-      }
-    });
-  };
+  return Event((transport) => {
+    const base = Primitive($base);
+    $trigger.event(
+      Transport(() => {
+        const value = base.primitive();
+        if (isFilled(value)) {
+          transport.use(value);
+        }
+      }),
+    );
+  });
 }

package/src/behaviors/Detached.test.ts

@@ -1,20 +1,20 @@
-import { LateShared } from "silentium";
+import { LateShared, Transport } from "silentium";
 import { expect, test, vi } from "vitest";
 import { Detached } from "../behaviors/Detached";
 
 test("Detached.test.ts", function DetachedTest() {
   const l = LateShared(1);
-  const l2 = Detached(l.event);
+  const l2 = Detached(l);
 
   const g1 = vi.fn();
-  l2(g1);
+  l2.event(Transport(g1));
 
   l.use(2);
 
   expect(g1).toHaveBeenCalledWith(1);
 
   const g2 = vi.fn();
-  l.event(g2);
+  l.event(Transport(g2));
 
   expect(g2).toHaveBeenCalledWith(2);
 });

package/src/behaviors/Detached.ts

@@ -1,10 +1,10 @@
-import { EventType, isFilled, Primitive } from "silentium";
+import { Event, EventType, isFilled, Primitive } from "silentium";
 
-export function Detached<T>(baseSrc: EventType<T>): EventType<T> {
-  return function Detached(user) {
-    const v = Primitive(baseSrc).primitive();
+export function Detached<T>($base: EventType<T>): EventType<T> {
+  return Event((transport) => {
+    const v = Primitive($base).primitive();
     if (isFilled(v)) {
-      user(v);
+      transport.use(v);
     }
-  };
+  });
 }

package/src/behaviors/Dirty.test.ts

@@ -1,4 +1,4 @@
-import { Late } from "silentium";
+import { Late, Transport } from "silentium";
 import { Dirty } from "../behaviors/Dirty";
 import { expect, test, vi } from "vitest";
 
@@ -7,9 +7,9 @@ test("Dirty.test", () => {
     name: "one",
     surname: "two",
   });
-  const d = Dirty(form.event);
+  const d = Dirty(form);
   const g = vi.fn();
-  d.event(g);
+  d.event(Transport(g));
 
   d.use({
     name: "new",

package/src/behaviors/Dirty.ts

@@ -1,4 +1,12 @@
-import { All, Applied, EventType, Late, SourceType } from "silentium";
+import {
+  All,
+  Applied,
+  EventType,
+  Late,
+  SourceType,
+  Transport,
+  TransportType,
+} from "silentium";
 
 /**
  * Takes source and remember it first value
@@ -6,46 +14,58 @@ import { All, Applied, EventType, Late, SourceType } from "silentium";
  * https://silentium-lab.github.io/silentium-components/#/behaviors/dirty
  */
 export function Dirty<T>(
-  baseEntitySource: EventType<T>,
-  alwaysKeep: string[] = [],
-  excludeKeys: string[] = [],
-  cloneFn?: (v: T) => T,
+  $base: EventType<T>,
+  keep: string[] = [],
+  exclude: string[] = [],
+  cloner?: (v: T) => T,
 ): SourceType<T> {
-  const comparingSrc = Late<T>();
+  return new DirtySource($base, keep, exclude, cloner);
+}
 
-  if (cloneFn === undefined) {
-    cloneFn = (value) => JSON.parse(JSON.stringify(value));
-  }
+class DirtySource<T> implements SourceType<T> {
+  private $comparing = Late<T>();
+  private cloner: (v: T) => T;
 
-  return {
-    event: (user) => {
-      const comparingDetached = Applied(comparingSrc.event, cloneFn);
+  public constructor(
+    private $base: EventType<T>,
+    private keep: string[] = [],
+    private exclude: string[] = [],
+    cloner?: (v: T) => T,
+  ) {
+    if (cloner === undefined) {
+      this.cloner = (value) => JSON.parse(JSON.stringify(value));
+    } else {
+      this.cloner = cloner;
+    }
+  }
 
-      All(
-        comparingDetached,
-        baseEntitySource,
-      )(([comparing, base]) => {
+  public event(transport: TransportType<T>) {
+    const $comparing = Applied(this.$comparing, this.cloner);
+    All($comparing, this.$base).event(
+      Transport(([comparing, base]) => {
         if (!comparing) {
           return;
         }
-
-        user(
+        transport.use(
           Object.fromEntries(
             Object.entries(comparing).filter(([key, value]) => {
-              if (alwaysKeep.includes(key)) {
+              if (this.keep.includes(key)) {
                 return true;
               }
-              if (excludeKeys.includes(key)) {
+              if (this.exclude.includes(key)) {
                 return false;
               }
               return value !== (base as any)[key];
             }),
           ) as T,
         );
-      });
-    },
-    use: (v) => {
-      comparingSrc.use(v);
-    },
-  };
+      }),
+    );
+    return this;
+  }
+
+  public use(v: T) {
+    this.$comparing.use(v);
+    return this;
+  }
 }

package/src/behaviors/Loading.test.ts

@@ -1,18 +1,15 @@
-import { Late } from "silentium";
+import { Late, Transport } from "silentium";
 import { Loading } from "../behaviors/Loading";
 import { expect, test, vi } from "vitest";
 
 test("Loading.test", () => {
-  const loadingStartSource = Late();
-  const loadingFinishSource = Late();
-  const loadingSrc = Loading(
-    loadingStartSource.event,
-    loadingFinishSource.event,
-  );
+  const $loadingStart = Late();
+  const $loadingFinish = Late();
+  const $loading = Loading($loadingStart, $loadingFinish);
   const g = vi.fn();
-  loadingSrc(g);
-  loadingStartSource.use({});
+  $loading.event(Transport(g));
+  $loadingStart.use({});
   expect(g).toHaveBeenLastCalledWith(true);
-  loadingFinishSource.use({});
+  $loadingFinish.use({});
   expect(g).toHaveBeenLastCalledWith(false);
 });

package/src/behaviors/Loading.ts

@@ -1,17 +1,17 @@
-import { EventType } from "silentium";
+import { Event, EventType, Transport } from "silentium";
 
 /**
  * Representation Of loading process
- * first informatin source begins loading
- * second information source stops loading
+ * first event begins loading
+ * second event stops loading
  * https://silentium-lab.github.io/silentium-components/#/behaviors/loading
  */
 export function Loading(
-  loadingStartSrc: EventType<unknown>,
-  loadingFinishSrc: EventType<unknown>,
+  $loadingStart: EventType<unknown>,
+  $loadingFinish: EventType<unknown>,
 ): EventType<boolean> {
-  return (user) => {
-    loadingStartSrc(() => user(true));
-    loadingFinishSrc(() => user(false));
-  };
+  return Event((transport) => {
+    $loadingStart.event(Transport(() => transport.use(true)));
+    $loadingFinish.event(Transport(() => transport.use(false)));
+  });
 }

package/src/behaviors/Lock.test.ts

@@ -1,4 +1,4 @@
-import { Late, Shared } from "silentium";
+import { Late, Shared, Transport } from "silentium";
 import { Lock } from "../behaviors/Lock";
 import { expect, test, vi } from "vitest";
 
@@ -6,10 +6,10 @@ test("Lock.test", () => {
   const source = Late<number>(1);
   const lockSrc = Late<boolean>(false);
 
-  const ls = Lock(source.event, lockSrc.event);
+  const ls = Lock(source, lockSrc);
   const lockedSrc = Shared(ls);
   const g = vi.fn();
-  lockedSrc.event(g);
+  lockedSrc.event(Transport(g));
 
   expect(g).toHaveBeenLastCalledWith(1);
 

package/src/behaviors/Lock.ts

@@ -1,18 +1,20 @@
-import { EventType, Filtered } from "silentium";
+import { Event, EventType, Filtered, Transport } from "silentium";
 
 /**
  * https://silentium-lab.github.io/silentium-components/#/behaviors/lock
  */
 export function Lock<T>(
-  baseSrc: EventType<T>,
-  lockSrc: EventType<boolean>,
+  $base: EventType<T>,
+  $lock: EventType<boolean>,
 ): EventType<T> {
-  return (user) => {
+  return Event((transport) => {
     let locked = false;
-    lockSrc((newLock) => {
-      locked = newLock;
-    });
-    const i = Filtered(baseSrc, () => !locked);
-    i(user);
-  };
+    $lock.event(
+      Transport((newLock) => {
+        locked = newLock;
+      }),
+    );
+    const i = Filtered($base, () => !locked);
+    i.event(transport);
+  });
 }

package/src/behaviors/Memo.test.ts

@@ -1,17 +1,19 @@
-import { Late, Shared } from "silentium";
+import { Late, Shared, Transport } from "silentium";
 import { Memo } from "../behaviors/Memo";
 import { expect, test, vi } from "vitest";
 
 test("Memo.test", () => {
   const l = Late<number>(1);
-  const mem = Shared(Memo(l.event));
+  const mem = Shared(Memo(l));
   const g = vi.fn();
-  mem.event(g);
+  mem.event(Transport(g));
   let counter = 0;
 
-  mem.event(() => {
-    counter += 1;
-  });
+  mem.event(
+    Transport(() => {
+      counter += 1;
+    }),
+  );
 
   l.use(2);
   l.use(2);

package/src/behaviors/Memo.ts

@@ -1,18 +1,19 @@
-import { EventType } from "silentium";
+import { Event, EventType, Transport } from "silentium";
 
 /**
  * Didn't respond if new value Of baseSrc equals to old value
  * https://silentium-lab.github.io/silentium-components/#/behaviors/memo
  */
-export function Memo<T>(baseSrc: EventType<T>): EventType<T> {
-  return (user) => {
-    let lastValue: T | null = null;
-
-    baseSrc((v) => {
-      if (v !== lastValue) {
-        user(v);
-        lastValue = v;
-      }
-    });
-  };
+export function Memo<T>($base: EventType<T>): EventType<T> {
+  return Event((transport) => {
+    let last: T | null = null;
+    $base.event(
+      Transport((v) => {
+        if (v !== last) {
+          transport.use(v);
+          last = v;
+        }
+      }),
+    );
+  });
 }

package/src/behaviors/OnlyChanged.test.ts

@@ -1,18 +1,18 @@
-import { Late, Shared } from "silentium";
+import { Late, Shared, Transport } from "silentium";
 import { OnlyChanged } from "../behaviors/OnlyChanged";
 import { expect, test, vi } from "vitest";
 
 test("OnlyChanged.test", () => {
   const src = Late<number>(1);
-  const changedSrc = Shared(OnlyChanged(src.event));
+  const changedSrc = Shared(OnlyChanged(src));
 
   const g = vi.fn();
-  changedSrc.event(g);
+  changedSrc.event(Transport(g));
   expect(g).not.toBeCalled();
 
   src.use(2);
 
   const g2 = vi.fn();
-  changedSrc.event(g2);
+  changedSrc.event(Transport(g2));
   expect(g2).toBeCalledWith(2);
 });

package/src/behaviors/OnlyChanged.ts

@@ -1,19 +1,20 @@
-import { EventType } from "silentium";
+import { Event, EventType, Transport } from "silentium";
 
 /**
  * Represents source what was changed at least once
  * https://silentium-lab.github.io/silentium-components/#/behaviors/only-changed
  */
-export function OnlyChanged<T>(baseSrc: EventType<T>): EventType<T> {
-  return (user) => {
-    let firstValue = false;
-
-    baseSrc((v) => {
-      if (firstValue === false) {
-        firstValue = true;
-      } else {
-        user(v);
-      }
-    });
-  };
+export function OnlyChanged<T>($base: EventType<T>): EventType<T> {
+  return Event((transport) => {
+    let first = false;
+    $base.event(
+      Transport((v) => {
+        if (first === false) {
+          first = true;
+        } else {
+          transport.use(v);
+        }
+      }),
+    );
+  });
 }

package/src/behaviors/Part.test.ts

@@ -1,19 +1,19 @@
-import { Late, Of, SharedSource } from "silentium";
-import { Part } from "../behaviors/Part";
+import { Late, Of, SharedSource, Transport } from "silentium";
 import { expect, test, vi } from "vitest";
+import { Part } from "../behaviors/Part";
 
 test("Part.test", () => {
-  const recordSrc = SharedSource(
+  const $record = SharedSource(
     Late({
       name: "Peter",
       surname: "Parker",
     }),
   );
-  const nameSrc = Part<string>(recordSrc, Of("name"));
+  const $name = Part<string>($record, Of("name"));
   const g = vi.fn();
-  recordSrc.event(g);
+  $record.event(Transport(g));
   expect(g).toHaveBeenLastCalledWith({ name: "Peter", surname: "Parker" });
 
-  nameSrc.use("Shmiter");
+  $name.use("Shmiter");
   expect(g).toHaveBeenLastCalledWith({ name: "Shmiter", surname: "Parker" });
 });

package/src/behaviors/Part.ts

@@ -1,40 +1,63 @@
-import { All, EventType, isFilled, Primitive, SourceType } from "silentium";
+import {
+  All,
+  EventType,
+  isFilled,
+  Primitive,
+  Shared,
+  SharedSource,
+  SourceType,
+  Transport,
+  TransportType,
+} from "silentium";
 
 /**
  * Return source Of record path
  * https://silentium-lab.github.io/silentium-components/#/behaviors/path
  */
-export function Part<R, T extends object | Array<any>, K extends string = any>(
-  baseSrc: SourceType<T>,
-  keySrc: EventType<K>,
-): SourceType<R> {
-  const baseSync = Primitive(baseSrc.event);
-  const keySync = Primitive(keySrc);
-  return {
-    event: (user) => {
-      All(
-        baseSrc.event,
-        keySrc,
-      )(([base, key]) => {
-        const keyChunks = key.split(".");
+export function Part<
+  R,
+  T extends object | Array<any> = any,
+  K extends string = any,
+>($base: SourceType<T>, $key: EventType<K>): SourceType<R> {
+  return new PartEvent($base, $key);
+}
+
+class PartEvent<R, T extends object | Array<any>, K extends string = any>
+  implements SourceType<R>
+{
+  private $base: SourceType<T>;
+  private $keyed: EventType<K>;
+
+  public constructor($base: SourceType<T>, $key: EventType<K>) {
+    this.$base = SharedSource($base);
+    this.$keyed = Shared($key);
+  }
+
+  public event(transport: TransportType<R, null>): this {
+    All(this.$base, this.$keyed).event(
+      Transport(([base, keyed]) => {
+        const keys = keyed.split(".");
         let value: unknown = base;
-        keyChunks.forEach((keyChunk) => {
-          value = (value as Record<string, unknown>)[keyChunk];
+        keys.forEach((key) => {
+          value = (value as Record<string, unknown>)[key];
         });
-
         if (value !== undefined && value !== base) {
-          user(value as R);
+          transport.use(value as R);
         }
-      });
-    },
-    use: (value: R) => {
-      const key = keySync.primitive();
-      if (isFilled(key)) {
-        baseSrc.use({
-          ...baseSync.primitive(),
-          [key]: value,
-        } as T);
-      }
-    },
-  };
+      }),
+    );
+    return this;
+  }
+
+  public use(value: R): this {
+    const key = Primitive(this.$keyed);
+    if (isFilled(key)) {
+      const base = Primitive(this.$base);
+      this.$base.use({
+        ...base.primitiveWithException(),
+        [key.primitiveWithException()]: value,
+      } as T);
+    }
+    return this;
+  }
 }

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

@@ -1,4 +1,4 @@
-import { Of } from "silentium";
+import { Of, Transport } from "silentium";
 import { expect, test, vi } from "vitest";
 import { Path } from "./Path";
 
@@ -9,6 +9,6 @@ test("Path._main.test", () => {
   };
   const name = Path<string>(Of(record), Of("name"));
   const g = vi.fn();
-  name(g);
+  name.event(Transport(g));
   expect(g).toHaveBeenLastCalledWith("Peter");
 });

package/src/behaviors/Path.index.test.ts

@@ -1,4 +1,4 @@
-import { Of } from "silentium";
+import { Of, Transport } from "silentium";
 import { expect, test, vi } from "vitest";
 import { Path } from "./Path";
 
@@ -13,6 +13,6 @@ test("Path.index.test", () => {
   };
   const bestColor = Path(Of(record), Of("colors.0"));
   const g = vi.fn();
-  bestColor(g);
+  bestColor.event(Transport(g));
   expect(g).toHaveBeenLastCalledWith("blue");
 });

package/src/behaviors/Path.nested.test.ts

@@ -1,4 +1,4 @@
-import { Of } from "silentium";
+import { Of, Transport } from "silentium";
 import { Path } from "../behaviors/Path";
 import { expect, test, vi } from "vitest";
 
@@ -12,6 +12,6 @@ test("Path.nested.test", () => {
   };
   const typeName = Path(Of(record), Of("type.name"));
   const g = vi.fn();
-  typeName(g);
+  typeName.event(Transport(g));
   expect(g).toHaveBeenLastCalledWith("spider-man");
 });