silentium-components 0.0.65 → 0.0.67

package/src/behaviors/Dirty.ts

@@ -1,27 +1,27 @@
-import { all, applied, EventType, late, SourceType } from "silentium";
+import { All, Applied, EventType, Late, SourceType } from "silentium";
 
 /**
  * Takes source and remember it first value
  * returns new record, what will contain only fields what was changed
  * https://silentium-lab.github.io/silentium-components/#/behaviors/dirty
  */
-export const dirty = <T>(
+export function Dirty<T>(
   baseEntitySource: EventType<T>,
   alwaysKeep: string[] = [],
   excludeKeys: string[] = [],
   cloneFn?: (v: T) => T,
-): SourceType<T> => {
-  const comparingSrc = late<T>();
+): SourceType<T> {
+  const comparingSrc = Late<T>();
 
   if (cloneFn === undefined) {
     cloneFn = (value) => JSON.parse(JSON.stringify(value));
   }
 
   return {
-    event: (u) => {
-      const comparingDetached = applied(comparingSrc.event, cloneFn);
+    event: (user) => {
+      const comparingDetached = Applied(comparingSrc.event, cloneFn);
 
-      all(
+      All(
         comparingDetached,
         baseEntitySource,
       )(([comparing, base]) => {
@@ -29,7 +29,7 @@ export const dirty = <T>(
           return;
         }
 
-        u(
+        user(
           Object.fromEntries(
             Object.entries(comparing).filter(([key, value]) => {
               if (alwaysKeep.includes(key)) {
@@ -48,4 +48,4 @@ export const dirty = <T>(
       comparingSrc.use(v);
     },
   };
-};
+}

package/src/behaviors/Loading.test.ts

@@ -1,11 +1,11 @@
-import { late } from "silentium";
-import { loading } from "../behaviors/Loading";
+import { Late } 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(
+  const loadingStartSource = Late();
+  const loadingFinishSource = Late();
+  const loadingSrc = Loading(
     loadingStartSource.event,
     loadingFinishSource.event,
   );

package/src/behaviors/Loading.ts

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

package/src/behaviors/Lock.test.ts

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

package/src/behaviors/Lock.ts

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

package/src/behaviors/Memo.test.ts

@@ -1,10 +1,10 @@
-import { late, shared } from "silentium";
-import { memo } from "../behaviors/Memo";
+import { Late, Shared } 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 l = Late<number>(1);
+  const mem = Shared(Memo(l.event));
   const g = vi.fn();
   mem.event(g);
   let counter = 0;

package/src/behaviors/Memo.ts

@@ -1,18 +1,18 @@
 import { EventType } from "silentium";
 
 /**
- * Didn't respond if new value of baseSrc equals to old value
+ * 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: EventType<T>): EventType<T> => {
-  return (u) => {
+export function Memo<T>(baseSrc: EventType<T>): EventType<T> {
+  return (user) => {
     let lastValue: T | null = null;
 
     baseSrc((v) => {
       if (v !== lastValue) {
-        u(v);
+        user(v);
         lastValue = v;
       }
     });
   };
-};
+}

package/src/behaviors/OnlyChanged.test.ts

@@ -1,10 +1,10 @@
-import { late, shared } from "silentium";
-import { onlyChanged } from "../behaviors/OnlyChanged";
+import { Late, Shared } 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 src = Late<number>(1);
+  const changedSrc = Shared(OnlyChanged(src.event));
 
   const g = vi.fn();
   changedSrc.event(g);

package/src/behaviors/OnlyChanged.ts

@@ -4,16 +4,16 @@ import { EventType } from "silentium";
  * Represents source what was changed at least once
  * https://silentium-lab.github.io/silentium-components/#/behaviors/only-changed
  */
-export const onlyChanged = <T>(baseSrc: EventType<T>): EventType<T> => {
-  return (u) => {
+export function OnlyChanged<T>(baseSrc: EventType<T>): EventType<T> {
+  return (user) => {
     let firstValue = false;
 
     baseSrc((v) => {
       if (firstValue === false) {
         firstValue = true;
       } else {
-        u(v);
+        user(v);
       }
     });
   };
-};
+}

package/src/behaviors/Part.test.ts

@@ -1,15 +1,15 @@
-import { late, of, sharedSource } from "silentium";
-import { part } from "../behaviors/Part";
+import { Late, Of, SharedSource } from "silentium";
+import { Part } from "../behaviors/Part";
 import { expect, test, vi } from "vitest";
 
 test("Part.test", () => {
-  const recordSrc = sharedSource(
-    late({
+  const recordSrc = SharedSource(
+    Late({
       name: "Peter",
       surname: "Parker",
     }),
   );
-  const nameSrc = part<string>(recordSrc, of("name"));
+  const nameSrc = Part<string>(recordSrc, Of("name"));
   const g = vi.fn();
   recordSrc.event(g);
   expect(g).toHaveBeenLastCalledWith({ name: "Peter", surname: "Parker" });

package/src/behaviors/Part.ts

@@ -1,22 +1,18 @@
-import { all, EventType, isFilled, primitive, SourceType } from "silentium";
+import { All, EventType, isFilled, Primitive, SourceType } from "silentium";
 
 /**
- * Return source of record path
+ * Return source Of record path
  * https://silentium-lab.github.io/silentium-components/#/behaviors/path
  */
-export const part = <
-  R,
-  T extends Record<string, unknown> | Array<unknown> = any,
-  K extends string = any,
->(
+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);
+): SourceType<R> {
+  const baseSync = Primitive(baseSrc.event);
+  const keySync = Primitive(keySrc);
   return {
-    event: (u) => {
-      all(
+    event: (user) => {
+      All(
         baseSrc.event,
         keySrc,
       )(([base, key]) => {
@@ -27,7 +23,7 @@ export const part = <
         });
 
         if (value !== undefined && value !== base) {
-          u(value as R);
+          user(value as R);
         }
       });
     },
@@ -41,4 +37,4 @@ export const part = <
       }
     },
   };
-};
+}

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

@@ -1,13 +1,13 @@
-import { of } from "silentium";
+import { Of } from "silentium";
 import { expect, test, vi } from "vitest";
-import { path } from "./Path";
+import { Path } from "./Path";
 
 test("Path._main.test", () => {
   const record = {
     name: "Peter",
     surname: "Parker",
   };
-  const name = path<string>(of(record), of("name"));
+  const name = Path<string>(Of(record), Of("name"));
   const g = vi.fn();
   name(g);
   expect(g).toHaveBeenLastCalledWith("Peter");

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

@@ -1,6 +1,6 @@
-import { of } from "silentium";
+import { Of } from "silentium";
 import { expect, test, vi } from "vitest";
-import { path } from "./Path";
+import { Path } from "./Path";
 
 test("Path.index.test", () => {
   const record = {
@@ -11,7 +11,7 @@ test("Path.index.test", () => {
       name: "spider-man",
     },
   };
-  const bestColor = path(of(record), of("colors.0"));
+  const bestColor = Path(Of(record), Of("colors.0"));
   const g = vi.fn();
   bestColor(g);
   expect(g).toHaveBeenLastCalledWith("blue");

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

@@ -1,5 +1,5 @@
-import { of } from "silentium";
-import { path } from "../behaviors/Path";
+import { Of } from "silentium";
+import { Path } from "../behaviors/Path";
 import { expect, test, vi } from "vitest";
 
 test("Path.nested.test", () => {
@@ -10,7 +10,7 @@ test("Path.nested.test", () => {
       name: "spider-man",
     },
   };
-  const typeName = path(of(record), of("type.name"));
+  const typeName = Path(Of(record), Of("type.name"));
   const g = vi.fn();
   typeName(g);
   expect(g).toHaveBeenLastCalledWith("spider-man");

package/src/behaviors/Path.ts

@@ -1,19 +1,15 @@
-import { all, EventType } from "silentium";
+import { All, EventType } from "silentium";
 
 /**
- * Return source of record path
+ * Return source Of record path
  * https://silentium-lab.github.io/silentium-components/#/behaviors/path
  */
-export const path = <
-  R,
-  T extends Record<string, unknown> | Array<unknown> = any,
-  K extends string = any,
->(
+export function Path<R, T extends object | Array<any>, K extends string = any>(
   baseSrc: EventType<T>,
   keySrc: EventType<K>,
-): EventType<R> => {
-  return (u) => {
-    all(
+): EventType<R> {
+  return (user) => {
+    All(
       baseSrc,
       keySrc,
     )(([base, key]) => {
@@ -24,8 +20,8 @@ export const path = <
       });
 
       if (value !== undefined && value !== base) {
-        u(value as R);
+        user(value as R);
       }
     });
   };
-};
+}

package/src/behaviors/Polling.test.ts

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

package/src/behaviors/Polling.ts

@@ -1,12 +1,12 @@
 import { EventType } from "silentium";
 
-export const polling = <T>(
+export function Polling<T>(
   baseSrc: EventType<T>,
   triggerSrc: EventType<T>,
-): EventType<T> => {
-  return (u) => {
+): EventType<T> {
+  return (user) => {
     triggerSrc(() => {
-      baseSrc(u);
+      baseSrc(user);
     });
   };
-};
+}

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

@@ -1,12 +1,12 @@
-import { late, shared } from "silentium";
-import { shot } from "../behaviors/Shot";
+import { Late, Shared } from "silentium";
+import { Shot } from "../behaviors/Shot";
 import { expect, test, vi } from "vitest";
 
 test("Shot._main.test", () => {
-  const baseSrc = late();
-  const shotSrc = late();
+  const baseSrc = Late();
+  const shotSrc = Late();
 
-  const shotResult = shared(shot(baseSrc.event, shotSrc.event));
+  const shotResult = Shared(Shot(baseSrc.event, shotSrc.event));
   const g = vi.fn();
   shotResult.event(g);
 

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

@@ -1,12 +1,12 @@
-import { late, shared } from "silentium";
-import { onlyChanged } from "../behaviors/OnlyChanged";
-import { shot } from "../behaviors/Shot";
+import { Late, Shared } 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 baseSrc = Late<number>(123);
+  const sharedBase = Shared(baseSrc.event, true);
+  const resultSrc = Shot(sharedBase.event, OnlyChanged(sharedBase.event));
 
   const vals: number[] = [];
 

package/src/behaviors/Shot.ts

@@ -1,21 +1,21 @@
-import { EventType, isFilled, primitive } from "silentium";
+import { EventType, isFilled, Primitive } from "silentium";
 
 /**
- * Helps to represent only last fresh value of some source, refreshing controls by shotSrc
+ * Helps to represent only last fresh value Of some source, refreshing controls by shotSrc
  * https://silentium-lab.github.io/silentium-components/#/behaviors/shot
  */
-export const shot = <T>(
+export function Shot<T>(
   targetSrc: EventType<T>,
   triggerSrc: EventType,
-): EventType<T> => {
-  return (u) => {
-    const targetSync = primitive(targetSrc);
+): EventType<T> {
+  return (user) => {
+    const targetSync = Primitive(targetSrc);
 
     triggerSrc(() => {
       const value = targetSync.primitive();
       if (isFilled(value)) {
-        u(value);
+        user(value);
       }
     });
   };
-};
+}

package/src/behaviors/Task.ts

@@ -1,12 +1,12 @@
-import { EventType, executorApplied } from "silentium";
+import { EventType, ExecutorApplied } from "silentium";
 
-export const task = <T>(
+export function Task<T>(
   baseSrc: EventType<T>,
   delay: number = 0,
-): EventType<T> => {
-  return (u) => {
+): EventType<T> {
+  return (user) => {
     let prevTimer: unknown | null = null;
-    executorApplied(baseSrc, (fn) => {
+    ExecutorApplied(baseSrc, (fn) => {
       return (v) => {
         if (prevTimer) {
           clearTimeout(prevTimer as number);
@@ -15,6 +15,6 @@ export const task = <T>(
           fn(v);
         }, delay);
       };
-    })(u);
+    })(user);
   };
-};
+}

package/src/behaviors/Tick.test.ts

@@ -1,5 +1,5 @@
-import { any, late, shared } from "silentium";
-import { tick } from "../behaviors/Tick";
+import { Any, Late, Shared } from "silentium";
+import { Tick } from "../behaviors/Tick";
 import { afterEach, beforeEach, expect, test, vi } from "vitest";
 
 beforeEach(() => {
@@ -12,9 +12,9 @@ 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 tickSrc = Shared(Tick(Any(s1.event, s2.event)), true);
 
   const g = vi.fn();
   tickSrc.event(g);

package/src/behaviors/Tick.ts

@@ -1,11 +1,11 @@
 import { EventType } from "silentium";
 
 /**
- * Accumulates the last value of the source and returns one result once per tick
+ * Accumulates the last value Of the source and returns one result once per tick
  * https://silentium-lab.github.io/silentium-components/#/behaviors/tick
  */
-export const tick = <T>(baseSrc: EventType<T>): EventType<T> => {
-  return (u) => {
+export function Tick<T>(baseSrc: EventType<T>): EventType<T> {
+  return (user) => {
     let microtaskScheduled = false;
     let lastValue: T | null = null;
 
@@ -14,7 +14,7 @@ export const tick = <T>(baseSrc: EventType<T>): EventType<T> => {
       queueMicrotask(() => {
         microtaskScheduled = false;
         if (lastValue !== null) {
-          u(lastValue);
+          user(lastValue);
           lastValue = null;
         }
       });
@@ -27,4 +27,4 @@ export const tick = <T>(baseSrc: EventType<T>): EventType<T> => {
       }
     });
   };
-};
+}

package/src/boolean/And.test.ts

@@ -1,11 +1,11 @@
-import { late } from "silentium";
+import { Late } from "silentium";
 import { expect, test, vi } from "vitest";
-import { and } from "../boolean/And";
+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.event, two.event);
   const g = vi.fn();
   result(g);
   expect(g).toHaveBeenLastCalledWith(false);

package/src/boolean/And.ts

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

package/src/boolean/Bool.test.ts

@@ -1,9 +1,9 @@
-import { of } from "silentium";
-import { bool } from "../boolean/Bool";
+import { Of } 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))(o);
   expect(o).toHaveBeenCalledWith(true);
 });

package/src/boolean/Bool.ts

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