silentium-components 0.0.113 → 0.0.115

package/src/behaviors/StateRecord.test.ts

@@ -0,0 +1,126 @@
+import { Late, Value } from "silentium";
+import { describe, expect, test } from "vitest";
+
+import { StateRecord } from "./StateRecord";
+
+describe("StateRecord", () => {
+  test("Work example", () => {
+    const state$ = Late("start");
+    const value$ = Late();
+    const record$ = Value(StateRecord(state$, value$, ["one", "two"]));
+    expect(record$.value).toBe(null);
+
+    state$.use("one");
+    value$.use(123);
+    state$.use("two");
+    value$.use(456);
+
+    expect(record$.value).toStrictEqual({
+      one: 123,
+      two: 456,
+    });
+  });
+
+  test("Broken sequence", () => {
+    const state$ = Late("start");
+    const value$ = Late();
+    const record$ = Value(StateRecord(state$, value$, ["one", "two", "three"]));
+    expect(record$.value).toBe(null);
+
+    state$.use("one");
+    value$.use(123);
+    state$.use("three");
+    value$.use(456);
+    state$.use("two");
+    value$.use(321);
+
+    expect(record$.value).toBeNull();
+  });
+
+  test("Broken sequence and restored", () => {
+    const state$ = Late("start");
+    const value$ = Late();
+    const record$ = Value(StateRecord(state$, value$, ["one", "two", "three"]));
+    expect(record$.value).toBe(null);
+
+    state$.use("one");
+    value$.use(123);
+    state$.use("three"); // Broken here, resets to looking for "one"
+    value$.use(456);
+    state$.use("two"); // Nothing here, it is not "one"
+    value$.use(321);
+    state$.use("one");
+    value$.use(123);
+    state$.use("two");
+    value$.use(321);
+    state$.use("three"); // Restored and returns value
+    value$.use(456);
+
+    expect(record$.value).toStrictEqual({
+      one: 123,
+      two: 321,
+      three: 456,
+    });
+  });
+
+  test("Changing", () => {
+    const state$ = Late("start");
+    const value$ = Late();
+    const results: any[] = [];
+    StateRecord(state$, value$, ["one", "two"]).then((v) => {
+      results.push(v);
+    });
+
+    state$.use("one");
+    value$.use(123);
+    state$.use("two");
+    value$.use(456);
+    value$.use(789);
+
+    expect(results).toStrictEqual([
+      {
+        one: 123,
+        two: 456,
+      },
+    ]);
+
+    state$.use("one");
+    value$.use(321);
+    state$.use("two");
+    value$.use(654);
+
+    expect(results).toStrictEqual([
+      {
+        one: 123,
+        two: 456,
+      },
+      {
+        one: 321,
+        two: 654,
+      },
+    ]);
+
+    // Many times setting "one"
+    state$.use("one");
+    value$.use(321);
+    value$.use(222);
+    value$.use(111);
+    state$.use("two");
+    value$.use(222);
+
+    expect(results).toStrictEqual([
+      {
+        one: 123,
+        two: 456,
+      },
+      {
+        one: 321,
+        two: 654,
+      },
+      {
+        one: 111,
+        two: 222,
+      },
+    ]);
+  });
+});

package/src/behaviors/StateRecord.ts

@@ -0,0 +1,52 @@
+import {
+  Actual,
+  DestroyContainer,
+  MaybeMessage,
+  Message,
+  MessageType,
+  Value,
+} from "silentium";
+
+export function StateRecord(
+  state$: MessageType,
+  values$: MessageType,
+  sequence: MaybeMessage<unknown[]>,
+) {
+  const dc = DestroyContainer();
+  let stateIndex = -1;
+  let latestState: string | null = null;
+  let result: Record<string, unknown> = {};
+  const sequence$ = Value(Actual(sequence));
+  return Message((resolve, reject) => {
+    dc.add(
+      state$
+        .then((state) => {
+          if (state === sequence$.value?.[stateIndex + 1]) {
+            stateIndex += 1;
+            latestState = state as string;
+          } else {
+            stateIndex = -1;
+            latestState = null;
+            result = {};
+          }
+        })
+        .catch(reject),
+    );
+    dc.add(
+      values$
+        .then((value) => {
+          if (latestState !== null) {
+            result[latestState] = value;
+          }
+          if (stateIndex + 1 === sequence$.value?.length) {
+            resolve(result);
+            stateIndex = -1;
+            latestState = null;
+            result = {};
+          }
+        })
+        .catch(reject),
+    );
+    return () => dc.destroy();
+  });
+}

package/src/behaviors/Switch.test.ts

@@ -1,4 +1,4 @@
-import { Late, Message, Void } from "silentium";
+import { Late, Message, Value, Void } from "silentium";
 import { describe, expect, test } from "vitest";
 
 import { Switch } from "./Switch";
@@ -28,7 +28,7 @@ describe("Switch.test", () => {
     ]);
     const data: string[] = [];
     src.then((v) => {
-      data.push(v);
+      data.push(v as string);
     });
 
     expect(data).toStrictEqual(["Option A"]);
@@ -69,7 +69,7 @@ describe("Switch.test", () => {
     ]);
     const data: string[] = [];
     src.then((v) => {
-      data.push(v);
+      data.push(v as string);
     });
 
     expect(data).toStrictEqual([]);
@@ -120,7 +120,7 @@ describe("Switch.test", () => {
     ]);
     const data: string[] = [];
     src.then((v) => {
-      data.push(v);
+      data.push(v as string);
     });
     src.destroy();
 
@@ -129,4 +129,34 @@ describe("Switch.test", () => {
     $trigger.use("b");
     expect(data).toStrictEqual(["Option A"]);
   });
+
+  test("Switch.multipleVariants", () => {
+    const $trigger = Late("a");
+    const src = Value(
+      Switch($trigger, [
+        [
+          "a",
+          Message((resolve) => {
+            resolve("Option A");
+          }),
+        ],
+        [
+          ["b", "c"],
+          Message((resolve) => {
+            resolve("B or C");
+          }),
+        ],
+      ]),
+    );
+    expect(src.value).toBe("Option A");
+
+    $trigger.use("c");
+    expect(src.value).toBe("B or C");
+
+    $trigger.use("b");
+    expect(src.value).toBe("B or C");
+
+    $trigger.use("a");
+    expect(src.value).toBe("Option A");
+  });
 });

package/src/behaviors/Switch.ts

@@ -11,14 +11,16 @@ import {
  */
 export function Switch<T, K>(
   _base: MaybeMessage,
-  options: [K, MessageType<T>][],
+  options: [K | K[], MessageType<T>][],
 ) {
   const $base = Actual(_base);
   return Message<T>((resolve, reject) => {
     const dc = DestroyContainer();
     $base
       .then((v) => {
-        const msg = options.find((entry) => entry[0] === v);
+        const msg = options.find((entry) =>
+          Array.isArray(entry[0]) ? entry[0].includes(v as K) : entry[0] === v,
+        );
         if (msg) {
           dc.add(msg[1].then(resolve).catch(reject));
         }

package/src/behaviors/index.ts

@@ -14,6 +14,7 @@ export * from "./Part";
 export * from "./Path";
 export * from "./Polling";
 export * from "./RecordTruncated";
+export * from "./StateRecord";
 export * from "./Switch";
 export * from "./Task";
 export * from "./Tick";