silentium-components 0.0.83 → 0.0.85

package/src/behaviors/Deadline.ts

@@ -5,8 +5,6 @@ import {
   Message,
   MessageType,
   Shared,
-  Tap,
-  TapType,
 } from "silentium";
 
 /**
@@ -15,38 +13,33 @@ import {
  * respond before $timeout then the value from base will be returned
  */
 export function Deadline<T>(
-  error: TapType<Error>,
   $base: MessageType<T>,
   _timeout: MaybeMessage<number>,
 ) {
   const $timeout = ActualMessage(_timeout);
-  return Message<T>(function () {
+  return Message<T>(function DeadlineImpl(resolve, reject) {
     let timer: ReturnType<typeof setTimeout> | number = 0;
-    const base = Shared($base, true);
-    $timeout.pipe(
-      Tap((timeout) => {
-        if (timer) {
-          clearTimeout(timer);
-        }
-        let timeoutReached = false;
+    const base = Shared($base);
+    $timeout.then((timeout) => {
+      if (timer) {
+        clearTimeout(timer);
+      }
+      let timeoutReached = false;
 
-        timer = setTimeout(() => {
-          if (timeoutReached) {
-            return;
-          }
-          timeoutReached = true;
-          error.use(new Error("Timeout reached in Deadline"));
-        }, timeout);
+      timer = setTimeout(() => {
+        if (timeoutReached) {
+          return;
+        }
+        timeoutReached = true;
+        reject(new Error("Timeout reached in Deadline"));
+      }, timeout);
 
-        const f = Filtered(base, () => !timeoutReached);
-        f.pipe(this);
+      const f = Filtered(base, () => !timeoutReached);
+      f.then(resolve);
 
-        base.pipe(
-          Tap(() => {
-            timeoutReached = true;
-          }),
-        );
-      }),
-    );
+      base.then(() => {
+        timeoutReached = true;
+      });
+    });
   });
 }

package/src/behaviors/Deferred.test.ts

@@ -1,7 +1,8 @@
-import { Late, Primitive, Shared, Tap } from "silentium";
-import { Deferred } from "../behaviors/Deferred";
+import { Late, Primitive, Shared } from "silentium";
 import { expect, test, vi } from "vitest";
 
+import { Deferred } from "../behaviors/Deferred";
+
 test("Deferred.test", () => {
   const $url = Late<string>("http://hello.com");
   const $layout = Late<string>();
@@ -9,13 +10,13 @@ test("Deferred.test", () => {
   const urlWithLayoutSrc = Shared(Deferred($url, $layout));
 
   const g1 = vi.fn();
-  urlWithLayoutSrc.pipe(Tap(g1));
+  urlWithLayoutSrc.then(g1);
   expect(g1).not.toHaveBeenCalled();
 
   $layout.use("layout here");
 
   const g2 = vi.fn();
-  urlWithLayoutSrc.pipe(Tap(g2));
+  urlWithLayoutSrc.then(g2);
   $url.use("http://new.com");
   expect(g2).toHaveBeenCalledWith("http://hello.com");
 

package/src/behaviors/Deferred.ts

@@ -1,4 +1,4 @@
-import { isFilled, Message, MessageType, Primitive, Tap } from "silentium";
+import { isFilled, Message, MessageType, Primitive } from "silentium";
 
 /**
  * Defer one source after another, gives values Of baseSrc only when triggerSrc responds
@@ -8,15 +8,13 @@ export function Deferred<T>(
   $base: MessageType<T>,
   $trigger: MessageType<unknown>,
 ) {
-  return Message(function () {
+  return Message<T>(function DeferredImpl(r) {
     const base = Primitive($base);
-    $trigger.pipe(
-      Tap(() => {
-        const value = base.primitive();
-        if (isFilled(value)) {
-          this.use(value);
-        }
-      }),
-    );
+    $trigger.then(() => {
+      const value = base.primitive();
+      if (isFilled(value)) {
+        r(value);
+      }
+    });
   });
 }

package/src/behaviors/Detached.test.ts

@@ -1,5 +1,6 @@
-import { LateShared, Tap } from "silentium";
+import { LateShared } from "silentium";
 import { expect, test, vi } from "vitest";
+
 import { Detached } from "../behaviors/Detached";
 
 test("Detached.test.ts", function DetachedTest() {
@@ -7,14 +8,14 @@ test("Detached.test.ts", function DetachedTest() {
   const l2 = Detached(l);
 
   const g1 = vi.fn();
-  l2.pipe(Tap(g1));
+  l2.then(g1);
 
   l.use(2);
 
   expect(g1).toHaveBeenCalledWith(1);
 
   const g2 = vi.fn();
-  l.pipe(Tap(g2));
+  l.then(g2);
 
   expect(g2).toHaveBeenCalledWith(2);
 });

package/src/behaviors/Detached.ts

@@ -6,10 +6,10 @@ import { isFilled, Message, MessageType, Primitive } from "silentium";
  * but not react to new values of the base message
  */
 export function Detached<T>($base: MessageType<T>): MessageType<T> {
-  return Message(function () {
+  return Message<T>(function DetachedImpl(r) {
     const v = Primitive($base).primitive();
     if (isFilled(v)) {
-      this.use(v);
+      r(v);
     }
   });
 }

package/src/behaviors/Dirty.test.ts

@@ -1,7 +1,8 @@
-import { Late, Tap } from "silentium";
-import { Dirty } from "../behaviors/Dirty";
+import { Late } from "silentium";
 import { expect, test, vi } from "vitest";
 
+import { Dirty } from "../behaviors/Dirty";
+
 test("Dirty.test", () => {
   const form = Late({
     name: "one",
@@ -9,7 +10,7 @@ test("Dirty.test", () => {
   });
   const d = Dirty(form);
   const g = vi.fn();
-  d.pipe(Tap(g));
+  d.then(g);
 
   d.use({
     name: "new",

package/src/behaviors/Dirty.ts

@@ -1,12 +1,4 @@
-import {
-  All,
-  Applied,
-  Late,
-  MessageType,
-  SourceType,
-  Tap,
-  TapType,
-} from "silentium";
+import { All, Applied, Late, MessageSource, MessageType } from "silentium";
 
 /**
  * Takes source and remember it first value
@@ -18,54 +10,35 @@ export function Dirty<T>(
   keep: string[] = [],
   exclude: string[] = [],
   cloner?: (v: T) => T,
-): SourceType<T> {
-  return new DirtySource($base, keep, exclude, cloner);
-}
-
-class DirtySource<T> implements SourceType<T> {
-  private $comparing = Late<T>();
-  private cloner: (v: T) => T;
-
-  public constructor(
-    private $base: MessageType<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;
-    }
+) {
+  const $comparing = Late<T>();
+  if (cloner === undefined) {
+    cloner = (value) => JSON.parse(JSON.stringify(value));
   }
-
-  public pipe(transport: TapType<T>) {
-    const $comparing = Applied(this.$comparing, this.cloner);
-    All($comparing, this.$base).pipe(
-      Tap(([comparing, base]) => {
+  return MessageSource<T>(
+    function DirtyImpl(r) {
+      const $comparingClone = Applied($comparing, cloner);
+      All($comparingClone, $base).then(([comparing, base]) => {
         if (!comparing) {
           return;
         }
-        transport.use(
+        r(
           Object.fromEntries(
             Object.entries(comparing).filter(([key, value]) => {
-              if (this.keep.includes(key)) {
+              if (keep.includes(key)) {
                 return true;
               }
-              if (this.exclude.includes(key)) {
+              if (exclude.includes(key)) {
                 return false;
               }
               return value !== (base as Record<string, unknown>)[key];
             }),
           ) as T,
         );
-      }),
-    );
-    return this;
-  }
-
-  public use(v: T) {
-    this.$comparing.use(v);
-    return this;
-  }
+      });
+    },
+    (v) => {
+      $comparing.use(v);
+    },
+  );
 }

package/src/behaviors/Loading.test.ts

@@ -1,13 +1,14 @@
-import { Late, Tap } from "silentium";
-import { Loading } from "../behaviors/Loading";
+import { Late } from "silentium";
 import { expect, test, vi } from "vitest";
 
+import { Loading } from "../behaviors/Loading";
+
 test("Loading.test", () => {
   const $loadingStart = Late();
   const $loadingFinish = Late();
   const $loading = Loading($loadingStart, $loadingFinish);
   const g = vi.fn();
-  $loading.pipe(Tap(g));
+  $loading.then(g);
   $loadingStart.use({});
   expect(g).toHaveBeenLastCalledWith(true);
   $loadingFinish.use({});

package/src/behaviors/Loading.ts

@@ -1,4 +1,4 @@
-import { Message, MessageType, Tap } from "silentium";
+import { Message, MessageType } from "silentium";
 
 /**
  * Representation Of loading process
@@ -10,8 +10,8 @@ export function Loading(
   $start: MessageType<unknown>,
   $finish: MessageType<unknown>,
 ) {
-  return Message<boolean>(function () {
-    $start.pipe(Tap(() => this.use(true)));
-    $finish.pipe(Tap(() => this.use(false)));
+  return Message<boolean>(function LoadingImpl(r) {
+    $start.then(() => r(true));
+    $finish.then(() => r(false));
   });
 }

package/src/behaviors/Lock.test.ts

@@ -1,7 +1,8 @@
-import { Late, Shared, Tap } from "silentium";
-import { Lock } from "../behaviors/Lock";
+import { Late, Shared } from "silentium";
 import { expect, test, vi } from "vitest";
 
+import { Lock } from "../behaviors/Lock";
+
 test("Lock.test", () => {
   const source = Late<number>(1);
   const lockSrc = Late<boolean>(false);
@@ -9,7 +10,7 @@ test("Lock.test", () => {
   const ls = Lock(source, lockSrc);
   const lockedSrc = Shared(ls);
   const g = vi.fn();
-  lockedSrc.pipe(Tap(g));
+  lockedSrc.then(g);
 
   expect(g).toHaveBeenLastCalledWith(1);
 

package/src/behaviors/Lock.ts

@@ -1,4 +1,4 @@
-import { Filtered, Message, MessageType, Tap } from "silentium";
+import { Filtered, Message, MessageType } from "silentium";
 
 /**
  * Allows locking messages
@@ -6,14 +6,12 @@ import { Filtered, Message, MessageType, Tap } from "silentium";
  * https://silentium-lab.github.io/silentium-components/#/behaviors/lock
  */
 export function Lock<T>($base: MessageType<T>, $lock: MessageType<boolean>) {
-  return Message<T>(function () {
+  return Message<T>(function LockImpl(r) {
     let locked = false;
-    $lock.pipe(
-      Tap((newLock) => {
-        locked = newLock;
-      }),
-    );
+    $lock.then((newLock) => {
+      locked = newLock;
+    });
     const i = Filtered($base, () => !locked);
-    i.pipe(this);
+    i.then(r);
   });
 }

package/src/behaviors/Memo.test.ts

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

package/src/behaviors/Memo.ts

@@ -1,19 +1,17 @@
-import { isFilled, Message, MessageType, Tap } from "silentium";
+import { isFilled, Message, MessageType } 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>($base: MessageType<T>) {
-  return Message<T>(function () {
+  return Message<T>(function MemoImpl(r) {
     let last: T | null = null;
-    $base.pipe(
-      Tap((v) => {
-        if (v !== last && isFilled(v)) {
-          this.use(v);
-          last = v;
-        }
-      }),
-    );
+    $base.then((v) => {
+      if (v !== last && isFilled(v)) {
+        r(v);
+        last = v;
+      }
+    });
   });
 }

package/src/behaviors/OnlyChanged.test.ts

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

package/src/behaviors/OnlyChanged.ts

@@ -1,20 +1,18 @@
-import { Message, MessageType, Tap } from "silentium";
+import { Message, MessageType } from "silentium";
 
 /**
  * Represents source what was changed at least once
  * https://silentium-lab.github.io/silentium-components/#/behaviors/only-changed
  */
 export function OnlyChanged<T>($base: MessageType<T>) {
-  return Message<T>(function () {
+  return Message<T>(function OnlyChangedImpl(r) {
     let first = false;
-    $base.pipe(
-      Tap((v) => {
-        if (first === false) {
-          first = true;
-        } else {
-          this.use(v);
-        }
-      }),
-    );
+    $base.then((v) => {
+      if (first === false) {
+        first = true;
+      } else {
+        r(v);
+      }
+    });
   });
 }

package/src/behaviors/Part.test.ts

@@ -1,18 +1,17 @@
-import { Late, Of, SharedSource, Tap } from "silentium";
+import { LateShared, Of } from "silentium";
 import { describe, expect, test, vi } from "vitest";
+
 import { Part } from "../behaviors/Part";
 
 describe("Part.test", () => {
   test("regular", () => {
-    const $record = SharedSource(
-      Late({
-        name: "Peter",
-        surname: "Parker",
-      }),
-    );
+    const $record = LateShared({
+      name: "Peter",
+      surname: "Parker",
+    });
     const $name = Part<string>($record, Of("name"));
     const g = vi.fn();
-    $record.pipe(Tap(g));
+    $record.then(g);
     expect(g).toHaveBeenLastCalledWith({ name: "Peter", surname: "Parker" });
 
     $name.use("Shmiter");
@@ -20,15 +19,13 @@ describe("Part.test", () => {
   });
 
   test("raw key", () => {
-    const $record = SharedSource(
-      Late({
-        name: "Peter",
-        surname: "Parker",
-      }),
-    );
+    const $record = LateShared({
+      name: "Peter",
+      surname: "Parker",
+    });
     const $name = Part<string>($record, "name");
     const g = vi.fn();
-    $record.pipe(Tap(g));
+    $record.then(g);
     expect(g).toHaveBeenLastCalledWith({ name: "Peter", surname: "Parker" });
 
     $name.use("Shmiter");

package/src/behaviors/Part.ts

@@ -3,13 +3,11 @@ import {
   All,
   isFilled,
   MaybeMessage,
-  MessageType,
+  MessageSource,
+  MessageSourceType,
   Primitive,
   Shared,
-  SharedSource,
   SourceType,
-  Tap,
-  TapType,
 } from "silentium";
 
 /**
@@ -20,46 +18,31 @@ export function Part<
   R,
   T extends object | Array<any> = any,
   K extends string = any,
->($base: SourceType<T>, $key: MaybeMessage<K>): SourceType<R> {
-  return new PartImpl($base, ActualMessage($key));
-}
-
-class PartImpl<R, T extends object | Array<any>, K extends string = any>
-  implements SourceType<R>
-{
-  private $base: SourceType<T>;
-  private $keyed: MessageType<K>;
-
-  public constructor($base: SourceType<T>, $key: MessageType<K>) {
-    this.$base = SharedSource($base);
-    this.$keyed = Shared($key);
-  }
-
-  public pipe(transport: TapType<R, null>): this {
-    All(this.$base, this.$keyed).pipe(
-      Tap(([base, keyed]) => {
+>($base: MessageSourceType<T>, key: MaybeMessage<K>): SourceType<R> {
+  const $baseShared = Shared($base);
+  const $keyedShared = Shared(ActualMessage(key));
+  return MessageSource(
+    function PartImpl(r) {
+      All($baseShared, $keyedShared).then(([base, keyed]) => {
         const keys = keyed.split(".");
         let value: unknown = base;
-        keys.forEach((key) => {
+        keys.forEach((key: string) => {
           value = (value as Record<string, unknown>)[key];
         });
         if (value !== undefined && value !== base) {
-          transport.use(value as R);
+          r(value as R);
         }
-      }),
-    );
-    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;
-  }
+      });
+    },
+    (value) => {
+      const key = Primitive($keyedShared);
+      if (isFilled(key)) {
+        const base = Primitive($base);
+        $base.use({
+          ...base.primitiveWithException(),
+          [key.primitiveWithException()]: value,
+        } as T);
+      }
+    },
+  );
 }

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

@@ -1,5 +1,6 @@
-import { Of, Tap } from "silentium";
+import { Of } from "silentium";
 import { expect, test, vi } from "vitest";
+
 import { Path } from "./Path";
 
 test("Path._keyRaw.test", () => {
@@ -9,6 +10,6 @@ test("Path._keyRaw.test", () => {
   };
   const name = Path<string>(Of(record), "name");
   const g = vi.fn();
-  name.pipe(Tap(g));
+  name.then(g);
   expect(g).toHaveBeenLastCalledWith("Peter");
 });

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

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

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

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

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

@@ -1,7 +1,8 @@
-import { Of, Tap } from "silentium";
-import { Path } from "../behaviors/Path";
+import { Of } from "silentium";
 import { expect, test, vi } from "vitest";
 
+import { Path } from "../behaviors/Path";
+
 test("Path.nested.test", () => {
   const record = {
     name: "Peter",
@@ -12,6 +13,6 @@ test("Path.nested.test", () => {
   };
   const typeName = Path(Of(record), Of("type.name"));
   const g = vi.fn();
-  typeName.pipe(Tap(g));
+  typeName.then(g);
   expect(g).toHaveBeenLastCalledWith("spider-man");
 });