silentium-components 0.0.13 → 0.0.17

package/src/behaviors/Branch.ts

@@ -0,0 +1,35 @@
+import { patron, patronOnce, sourceOf, SourceType, value } from "silentium";
+
+/**
+ * https://silentium-lab.github.io/silentium-components/#/behaviors/branch
+ */
+export const branch = <Then, Else>(
+  conditionSrc: SourceType<boolean>,
+  thenSrc: SourceType<Then>,
+  elseSrc?: SourceType<Else>,
+): SourceType<Then | Else> => {
+  const result = sourceOf<Then | Else>();
+
+  value(
+    conditionSrc,
+    patron((v) => {
+      if (v === true) {
+        value(
+          thenSrc,
+          patronOnce((v) => {
+            result.give(v);
+          }),
+        );
+      } else if (elseSrc !== undefined) {
+        value(
+          elseSrc,
+          patronOnce((v) => {
+            result.give(v);
+          }),
+        );
+      }
+    }),
+  );
+
+  return result.value;
+};

package/src/behaviors/Deferred.test.ts

@@ -0,0 +1,28 @@
+import { sourceOf, sourceSync, value } from "silentium";
+import { deferred } from "../behaviors/Deferred";
+import { expect, test, vi } from "vitest";
+
+test("Deferred.test", () => {
+  const urlSrc = sourceOf<string>("http://hello.com");
+  const layoutSrc = sourceOf();
+
+  const urlWithLayoutSrc = sourceSync(deferred(urlSrc, layoutSrc));
+
+  const g1 = vi.fn();
+  value(urlWithLayoutSrc, g1);
+  expect(g1).not.toHaveBeenCalled();
+
+  layoutSrc.give("layout here");
+
+  const g2 = vi.fn();
+  value(urlWithLayoutSrc, g2);
+  expect(g2).toHaveBeenCalledWith("http://hello.com");
+
+  urlSrc.give("http://new.com");
+
+  expect(urlWithLayoutSrc.syncValue()).toBe("http://hello.com");
+
+  layoutSrc.give("layout here again");
+
+  expect(urlWithLayoutSrc.syncValue()).toBe("http://new.com");
+});

package/src/behaviors/Deferred.ts

@@ -0,0 +1,27 @@
+import {
+  patron,
+  sourceOf,
+  sourceResettable,
+  SourceType,
+  value,
+} from "silentium";
+
+/**
+ * Defer one source after another, gives values of baseSrc only once when triggerSrc responds
+ * https://silentium-lab.github.io/silentium-components/#/behaviors/deferred
+ */
+export const deferred = <T>(
+  baseSrc: SourceType<T>,
+  triggerSrc: SourceType<unknown>,
+) => {
+  const result = sourceResettable<T>(sourceOf(), baseSrc as SourceType);
+
+  value(
+    triggerSrc,
+    patron(() => {
+      value(baseSrc, result);
+    }),
+  );
+
+  return result.value;
+};

package/src/behaviors/Fork.ts

@@ -6,6 +6,7 @@ import {
   patron,
   removePatronFromPools,
   GuestObjectType,
+  patronOnce,
 } from "silentium";
 
 /**
@@ -34,10 +35,10 @@ export const fork = <T, Then, Else>(
         removePatronFromPools(elsePatron);
       }
       if (predicate(v)) {
-        thenPatron = patron(result);
+        thenPatron = patronOnce(result);
         value(thenSrc, thenPatron);
       } else if (elseSrc) {
-        elsePatron = patron(result);
+        elsePatron = patronOnce(result);
         value(elseSrc, elsePatron);
       }
     }),

package/src/behaviors/Lock.test.ts

@@ -0,0 +1,26 @@
+import { sourceOf, sourceSync, value } from "silentium";
+import { expect, test, vi } from "vitest";
+import { lock } from "../behaviors/Lock";
+
+test("Lock.test", () => {
+  const source = sourceOf<number>(1);
+  const lockSrc = sourceOf();
+
+  const lockedSrc = lock(source, lockSrc);
+  const lockedSync = sourceSync(lockedSrc);
+
+  expect(lockedSync.syncValue()).toBe(1);
+
+  source.give(2);
+
+  expect(lockedSync.syncValue()).toBe(2);
+
+  lockSrc.give(1);
+  source.give(3);
+  source.give(4);
+  source.give(5);
+
+  const g = vi.fn();
+  value(lockedSrc, g);
+  expect(g).not.toBeCalled();
+});

package/src/behaviors/Lock.ts

@@ -0,0 +1,36 @@
+import {
+  destroy,
+  guestDisposable,
+  patron,
+  patronOnce,
+  sourceOf,
+  sourceResettable,
+  SourceType,
+  subSource,
+  value,
+} from "silentium";
+
+/**
+ * https://silentium-lab.github.io/silentium-components/#/behaviors/lock
+ */
+export const lock = <T>(
+  baseSrc: SourceType<T>,
+  lockSrc: SourceType<unknown>,
+) => {
+  const result = sourceOf();
+  const resultResettable = sourceResettable(result, lockSrc);
+  let locked = false;
+  subSource(result, baseSrc);
+
+  value(baseSrc, patron(guestDisposable(result.give, () => locked)));
+
+  value(
+    lockSrc,
+    patronOnce(() => {
+      locked = true;
+      destroy([result]);
+    }),
+  );
+
+  return resultResettable.value;
+};

package/src/behaviors/Memo.test.ts

@@ -0,0 +1,24 @@
+import { patron, sourceOf, sourceSync, value } from "silentium";
+import { memo } from "../behaviors/Memo";
+import { expect, test } from "vitest";
+
+test("Memo.test", () => {
+  const src = sourceOf<number>(1);
+  const srcMemo = sourceSync(memo(src));
+  let counter = 0;
+  value(
+    srcMemo,
+    patron(() => {
+      counter += 1;
+    }),
+  );
+
+  src.give(2);
+  src.give(2);
+  src.give(2);
+  src.give(2);
+  src.give(2);
+
+  expect(srcMemo.syncValue()).toBe(2);
+  expect(counter).toBe(2);
+});

package/src/behaviors/Memo.ts

@@ -0,0 +1,22 @@
+import { patron, sourceOf, SourceType, value } from "silentium";
+
+/**
+ * Didn't respond if new value of baseSrc equals to old value
+ * https://silentium-lab.github.io/silentium-components/#/behaviors/memo
+ */
+export const memo = <T>(baseSrc: SourceType<T>) => {
+  const result = sourceOf<T>();
+  let lastValue: T | null = null;
+
+  value(
+    baseSrc,
+    patron((v) => {
+      if (v !== lastValue) {
+        result.give(v);
+        lastValue = v;
+      }
+    }),
+  );
+
+  return result.value;
+};

package/src/behaviors/Moment.test.ts

@@ -0,0 +1,24 @@
+import { patron, sourceOf, sourceSync, value } from "silentium";
+import { moment } from "../behaviors/Moment";
+import { expect, test } from "vitest";
+
+test("Moment.test", () => {
+  const src = sourceOf<number>(1);
+  const srcMoment = sourceSync(moment(src));
+  let counter = 0;
+  value(
+    srcMoment,
+    patron(() => {
+      counter += 1;
+    }),
+  );
+
+  src.give(2);
+  src.give(3);
+  src.give(4);
+  src.give(5);
+  src.give(6);
+
+  expect(srcMoment.syncValue()).toBe(1);
+  expect(counter).toBe(1);
+});

package/src/behaviors/Moment.ts

@@ -0,0 +1,17 @@
+import { give, guestSync, GuestType, SourceType, value } from "silentium";
+
+/**
+ * Get's value from source in moment of component call and than return this value every time
+ * https://silentium-lab.github.io/silentium-components/#/behaviors/moment
+ */
+export const moment = <T>(
+  baseSrc: SourceType<T>,
+  defaultValue?: T,
+): SourceType<T> => {
+  const guest = guestSync(defaultValue);
+  value(baseSrc, guest);
+
+  return (g: GuestType<T>) => {
+    give(guest.value(), g);
+  };
+};

package/src/behaviors/Path.ts

@@ -12,11 +12,14 @@ import {
  * Return source of record path
  * https://silentium-lab.github.io/silentium-components/#/behaviors/path
  */
-export const path = <T extends Record<string, unknown>, K extends string>(
+export const path = <
+  T extends Record<string, unknown> | Array<unknown>,
+  K extends string,
+>(
   baseSrc: SourceType<T>,
   keySrc: SourceType<K>,
 ) => {
-  const pathSrc = sourceOf<T[K]>();
+  const pathSrc = sourceOf<unknown>();
   subSourceMany(pathSrc, [baseSrc, keySrc]);
 
   value(
@@ -25,11 +28,11 @@ export const path = <T extends Record<string, unknown>, K extends string>(
       const keyChunks = key.split(".");
       let value: unknown = base;
       keyChunks.forEach((keyChunk) => {
-        value = (value as T)[keyChunk];
+        value = (value as Record<string, unknown>)[keyChunk];
       });
 
       if (value !== undefined && value !== base) {
-        give(value as T[K], pathSrc);
+        give(value, pathSrc);
       }
     }),
   );

package/src/behaviors/index.ts

@@ -4,3 +4,8 @@ export * from "./Path";
 export * from "./Deadline";
 export * from "./Tick";
 export * from "./Fork";
+export * from "./Deferred";
+export * from "./Branch";
+export * from "./Memo";
+export * from "./Lock";
+export * from "./Moment";

package/src/boolean/And.test.ts

@@ -0,0 +1,22 @@
+import { sourceOf, sourceSync } from "silentium";
+import { and } from "../boolean/And";
+import { expect, test } from "vitest";
+
+test("And.test", () => {
+  const one = sourceOf<boolean>(false);
+  const two = sourceOf<boolean>(false);
+  const result = sourceSync(and(one, two));
+  expect(result.syncValue()).toBe(false);
+
+  one.give(true);
+  two.give(false);
+  expect(result.syncValue()).toBe(false);
+
+  one.give(false);
+  two.give(true);
+  expect(result.syncValue()).toBe(false);
+
+  one.give(true);
+  two.give(true);
+  expect(result.syncValue()).toBe(true);
+});

package/src/boolean/And.ts

@@ -0,0 +1,16 @@
+import { give, GuestType, sourceCombined, SourceType } from "silentium";
+
+/**
+ * https://silentium-lab.github.io/silentium-components/#/boolean/and
+ */
+export const and = (
+  oneSrc: SourceType<boolean>,
+  twoSrc: SourceType<boolean>,
+) => {
+  return sourceCombined(
+    oneSrc,
+    twoSrc,
+  )((guest: GuestType<boolean>, one, two) => {
+    give(one && two, guest);
+  });
+};

package/src/boolean/Bool.ts

@@ -0,0 +1,7 @@
+import { sourceApplied, SourceType } from "silentium";
+
+/**
+ * Convert any source to boolean source
+ * https://silentium-lab.github.io/silentium-components/#/boolean/bool
+ */
+export const bool = (baseSrc: SourceType) => sourceApplied(baseSrc, Boolean);

package/src/boolean/Not.test.ts

@@ -0,0 +1,12 @@
+import { sourceOf, sourceSync } from "silentium";
+import { expect, test } from "vitest";
+import { not } from "../boolean/Not";
+
+test("Not.test", () => {
+  const one = sourceOf<boolean>(false);
+  const result = sourceSync(not(one));
+  expect(result.syncValue()).toBe(true);
+
+  one.give(true);
+  expect(result.syncValue()).toBe(false);
+});

package/src/boolean/Not.ts

@@ -0,0 +1,15 @@
+import { give, guestCast, GuestType, SourceType, value } from "silentium";
+
+/**
+ * https://silentium-lab.github.io/silentium-components/#/boolean/not
+ */
+export const not = (baseSrc: SourceType<boolean>) => {
+  return (g: GuestType<boolean>) => {
+    value(
+      baseSrc,
+      guestCast(g, (base) => {
+        give(!base, g);
+      }),
+    );
+  };
+};

package/src/boolean/Or.test.ts

@@ -0,0 +1,22 @@
+import { sourceOf, sourceSync } from "silentium";
+import { or } from "../boolean/Or";
+import { expect, test } from "vitest";
+
+test("Or.test", () => {
+  const one = sourceOf<boolean>(false);
+  const two = sourceOf<boolean>(false);
+  const result = sourceSync(or(one, two));
+  expect(result.syncValue()).toBe(false);
+
+  one.give(true);
+  two.give(false);
+  expect(result.syncValue()).toBe(true);
+
+  one.give(false);
+  two.give(true);
+  expect(result.syncValue()).toBe(true);
+
+  one.give(true);
+  two.give(true);
+  expect(result.syncValue()).toBe(true);
+});

package/src/boolean/Or.ts

@@ -0,0 +1,16 @@
+import { give, GuestType, sourceCombined, SourceType } from "silentium";
+
+/**
+ * https://silentium-lab.github.io/silentium-components/#/boolean/or
+ */
+export const or = (
+  oneSrc: SourceType<boolean>,
+  twoSrc: SourceType<boolean>,
+) => {
+  return sourceCombined(
+    oneSrc,
+    twoSrc,
+  )((guest: GuestType<boolean>, one, two) => {
+    give(one || two, guest);
+  });
+};

package/src/boolean/index.ts

@@ -0,0 +1,3 @@
+export * from "./And";
+export * from "./Or";
+export * from "./Not";

package/src/index.ts

@@ -4,3 +4,4 @@ export * from "./structures";
 export * from "./strings";
 export * from "./navigation";
 export * from "./system";
+export * from "./boolean";

package/src/structures/Record.concatenated.test.ts

@@ -0,0 +1,40 @@
+import { patron, source, sourceOf, sourceSync } from "silentium";
+import { expect, test } from "vitest";
+import { record } from "./Record";
+import { concatenated } from "../strings";
+
+test("Record.concatenated.test", () => {
+  const three = sourceOf<string>("three");
+  const concatPart = sourceOf<string>("part");
+  const recordSrc = sourceSync(
+    record({
+      one: "one",
+      two: source("two"),
+      three,
+      nested: concatenated(["one", concatPart]),
+    }),
+  );
+  let counter = 0;
+  recordSrc.value(
+    patron(() => {
+      counter += 1;
+    }),
+  );
+
+  expect(recordSrc.syncValue()).toStrictEqual({
+    one: "one",
+    two: "two",
+    three: "three",
+    nested: "onepart",
+  });
+
+  concatPart.give("changed");
+
+  expect(recordSrc.syncValue()).toStrictEqual({
+    one: "one",
+    two: "two",
+    three: "three",
+    nested: "onechanged",
+  });
+  expect(counter).toBe(2);
+});

package/src/system/RegexpMatch._group.test.ts

@@ -0,0 +1,11 @@
+import { sourceOf, sourceSync } from "silentium";
+import { regexpMatch } from "./RegexpMatch";
+import { expect, test } from "vitest";
+import { path } from "../behaviors";
+
+test("RegexpMatch._group.test", () => {
+  const urlSrc = sourceOf<string>("http://domain.com/some/url/");
+  const matchedSrc = sourceSync(path(regexpMatch("/(s\\w+)/", urlSrc), "1"));
+
+  expect(matchedSrc.syncValue()).toBe("some");
+});

package/src/system/RegexpMatch.test.ts

@@ -0,0 +1,11 @@
+import { sourceOf, sourceSync } from "silentium";
+import { regexpMatch } from "../system/RegexpMatch";
+import { expect, test } from "vitest";
+import { path } from "../behaviors";
+
+test("RegexpMatch.test", () => {
+  const urlSrc = sourceOf<string>("http://domain.com/some/url/");
+  const matchedSrc = sourceSync(path(regexpMatch("/(s\\w+)/", urlSrc), "0"));
+
+  expect(matchedSrc.syncValue()).toBe("/some/");
+});

package/src/system/RegexpMatch.ts

@@ -0,0 +1,19 @@
+import { give, GuestType, sourceCombined, SourceType } from "silentium";
+
+/**
+ * First match of regexp
+ * https://silentium-lab.github.io/silentium-components/#/system/regexp-matched
+ */
+export const regexpMatch = (
+  patternSrc: SourceType<string>,
+  valueSrc: SourceType<string>,
+  flagsSrc: SourceType<string> = "",
+): SourceType<string[]> =>
+  sourceCombined(
+    patternSrc,
+    valueSrc,
+    flagsSrc,
+  )((g: GuestType<string[]>, pattern, value, flags) => {
+    const result = new RegExp(pattern, flags).exec(value);
+    give(result ?? [], g);
+  });

package/src/system/Set.test.ts

@@ -0,0 +1,22 @@
+import { sourceOf, sourceSync } from "silentium";
+import { set } from "../system/Set";
+import { expect, test } from "vitest";
+
+test("Set.test", () => {
+  const value = sourceOf();
+  const object = sourceSync(
+    set(
+      {
+        value: "hello",
+      },
+      "value",
+      value,
+    ),
+  );
+
+  expect(object.syncValue().value).toBe("hello");
+
+  value.give("bue!");
+
+  expect(object.syncValue().value).toBe("bue!");
+});

package/src/system/Set.ts

@@ -0,0 +1,20 @@
+import { patron, sourceAll, SourceType, value } from "silentium";
+
+/**
+ * Ability to mutate some object, helpful when integrate to procedure systems
+ * https://silentium-lab.github.io/silentium-components/#/system/set
+ */
+export const set = <T extends Record<string, unknown>>(
+  baseSrc: SourceType<T>,
+  keySrc: SourceType<string>,
+  valueSrc: SourceType<unknown>,
+) => {
+  value(
+    sourceAll([baseSrc, keySrc, valueSrc]),
+    patron(([base, key, value]) => {
+      (base as Record<string, unknown>)[key] = value;
+    }),
+  );
+
+  return baseSrc;
+};

package/src/system/index.ts

@@ -1,2 +1,4 @@
 export * from "./RegexpMatched";
 export * from "./RegexpReplaced";
+export * from "./RegexpMatch";
+export * from "./Set";