silentium-components 0.0.65 → 0.0.67

package/dist/silentium-components.js

@@ -1,11 +1,11 @@
-import { primitive, shared, filtered, isFilled, late, applied, all, executorApplied, of, destructor } from 'silentium';
+import { Primitive, Shared, Filtered, isFilled, Late, Applied, All, ExecutorApplied, Of, Destructor } from 'silentium';
 
-const branch = (conditionSrc, leftSrc, rightSrc) => {
-  return (u) => {
-    const leftSync = primitive(leftSrc);
+function Branch(conditionSrc, leftSrc, rightSrc) {
+  return (user) => {
+    const leftSync = Primitive(leftSrc);
     let rightSync;
     if (rightSrc !== void 0) {
-      rightSync = primitive(rightSrc);
+      rightSync = Primitive(rightSrc);
     }
     conditionSrc((v) => {
       let result = null;
@@ -15,18 +15,18 @@ const branch = (conditionSrc, leftSrc, rightSrc) => {
         result = rightSync.primitive();
       }
       if (result !== null) {
-        u(result);
+        user(result);
       }
     });
   };
-};
+}
 
-const branchLazy = (conditionSrc, leftSrc, rightSrc) => {
-  return (u) => {
-    let destructor;
+function BranchLazy(conditionSrc, leftSrc, rightSrc) {
+  return (user) => {
+    let Destructor;
     conditionSrc((v) => {
-      if (destructor !== void 0 && typeof destructor === "function") {
-        destructor();
+      if (Destructor !== void 0 && typeof Destructor === "function") {
+        Destructor();
       }
       let instance = null;
       if (v) {
@@ -35,27 +35,27 @@ const branchLazy = (conditionSrc, leftSrc, rightSrc) => {
         instance = rightSrc();
       }
       if (instance) {
-        destructor = instance(u);
+        Destructor = instance(user);
       }
     });
     return () => {
-      destructor?.();
+      Destructor?.();
     };
   };
-};
+}
 
-const constant = (permanentValue, triggerSrc) => {
-  return (u) => {
+function Constant(permanentValue, triggerSrc) {
+  return (user) => {
     triggerSrc(() => {
-      u(permanentValue);
+      user(permanentValue);
     });
   };
-};
+}
 
-const deadline = (error, baseSrc, timeoutSrc) => {
-  return (u) => {
+function Deadline(error, baseSrc, timeoutSrc) {
+  return (user) => {
     let timerHead = null;
-    const s = shared(baseSrc, true);
+    const s = Shared(baseSrc, true);
     timeoutSrc((timeout) => {
       if (timerHead) {
         clearTimeout(timerHead);
@@ -68,52 +68,52 @@ const deadline = (error, baseSrc, timeoutSrc) => {
         timeoutReached = true;
         error(new Error("Timeout reached in Deadline class"));
       }, timeout);
-      const f = filtered(s.event, () => !timeoutReached);
-      f(u);
+      const f = Filtered(s.event, () => !timeoutReached);
+      f(user);
       s.event(() => {
         timeoutReached = true;
       });
     });
   };
-};
+}
 
-const deferred = (baseSrc, triggerSrc) => {
-  return (u) => {
-    const baseSync = primitive(baseSrc);
+function Deferred(baseSrc, triggerSrc) {
+  return (user) => {
+    const baseSync = Primitive(baseSrc);
     triggerSrc(() => {
       const value = baseSync.primitive();
       if (isFilled(value)) {
-        u(value);
+        user(value);
       }
     });
   };
-};
+}
 
-const detached = (baseSrc) => {
-  return function Detached(user) {
-    const v = primitive(baseSrc).primitive();
+function Detached(baseSrc) {
+  return function Detached2(user) {
+    const v = Primitive(baseSrc).primitive();
     if (isFilled(v)) {
       user(v);
     }
   };
-};
+}
 
-const dirty = (baseEntitySource, alwaysKeep = [], excludeKeys = [], cloneFn) => {
-  const comparingSrc = late();
+function Dirty(baseEntitySource, alwaysKeep = [], excludeKeys = [], cloneFn) {
+  const comparingSrc = Late();
   if (cloneFn === void 0) {
     cloneFn = (value) => JSON.parse(JSON.stringify(value));
   }
   return {
-    event: (u) => {
-      const comparingDetached = applied(comparingSrc.event, cloneFn);
-      all(
+    event: (user) => {
+      const comparingDetached = Applied(comparingSrc.event, cloneFn);
+      All(
         comparingDetached,
         baseEntitySource
       )(([comparing, base]) => {
         if (!comparing) {
           return;
         }
-        u(
+        user(
           Object.fromEntries(
             Object.entries(comparing).filter(([key, value]) => {
               if (alwaysKeep.includes(key)) {
@@ -132,57 +132,57 @@ const dirty = (baseEntitySource, alwaysKeep = [], excludeKeys = [], cloneFn) =>
       comparingSrc.use(v);
     }
   };
-};
+}
 
-const loading = (loadingStartSrc, loadingFinishSrc) => {
-  return (u) => {
-    loadingStartSrc(() => u(true));
-    loadingFinishSrc(() => u(false));
+function Loading(loadingStartSrc, loadingFinishSrc) {
+  return (user) => {
+    loadingStartSrc(() => user(true));
+    loadingFinishSrc(() => user(false));
   };
-};
+}
 
-const lock = (baseSrc, lockSrc) => {
-  return (u) => {
+function Lock(baseSrc, lockSrc) {
+  return (user) => {
     let locked = false;
     lockSrc((newLock) => {
       locked = newLock;
     });
-    const i = filtered(baseSrc, () => !locked);
-    i(u);
+    const i = Filtered(baseSrc, () => !locked);
+    i(user);
   };
-};
+}
 
-const memo = (baseSrc) => {
-  return (u) => {
+function Memo(baseSrc) {
+  return (user) => {
     let lastValue = null;
     baseSrc((v) => {
       if (v !== lastValue) {
-        u(v);
+        user(v);
         lastValue = v;
       }
     });
   };
-};
+}
 
-const onlyChanged = (baseSrc) => {
-  return (u) => {
+function OnlyChanged(baseSrc) {
+  return (user) => {
     let firstValue = false;
     baseSrc((v) => {
       if (firstValue === false) {
         firstValue = true;
       } else {
-        u(v);
+        user(v);
       }
     });
   };
-};
+}
 
-const part = (baseSrc, keySrc) => {
-  const baseSync = primitive(baseSrc.event);
-  const keySync = primitive(keySrc);
+function Part(baseSrc, keySrc) {
+  const baseSync = Primitive(baseSrc.event);
+  const keySync = Primitive(keySrc);
   return {
-    event: (u) => {
-      all(
+    event: (user) => {
+      All(
         baseSrc.event,
         keySrc
       )(([base, key]) => {
@@ -192,7 +192,7 @@ const part = (baseSrc, keySrc) => {
           value = value[keyChunk];
         });
         if (value !== void 0 && value !== base) {
-          u(value);
+          user(value);
         }
       });
     },
@@ -206,11 +206,11 @@ const part = (baseSrc, keySrc) => {
       }
     }
   };
-};
+}
 
-const path = (baseSrc, keySrc) => {
-  return (u) => {
-    all(
+function Path(baseSrc, keySrc) {
+  return (user) => {
+    All(
       baseSrc,
       keySrc
     )(([base, key]) => {
@@ -220,36 +220,36 @@ const path = (baseSrc, keySrc) => {
         value = value[keyChunk];
       });
       if (value !== void 0 && value !== base) {
-        u(value);
+        user(value);
       }
     });
   };
-};
+}
 
-const polling = (baseSrc, triggerSrc) => {
-  return (u) => {
+function Polling(baseSrc, triggerSrc) {
+  return (user) => {
     triggerSrc(() => {
-      baseSrc(u);
+      baseSrc(user);
     });
   };
-};
+}
 
-const shot = (targetSrc, triggerSrc) => {
-  return (u) => {
-    const targetSync = primitive(targetSrc);
+function Shot(targetSrc, triggerSrc) {
+  return (user) => {
+    const targetSync = Primitive(targetSrc);
     triggerSrc(() => {
       const value = targetSync.primitive();
       if (isFilled(value)) {
-        u(value);
+        user(value);
       }
     });
   };
-};
+}
 
-const task = (baseSrc, delay = 0) => {
-  return (u) => {
+function Task(baseSrc, delay = 0) {
+  return (user) => {
     let prevTimer = null;
-    executorApplied(baseSrc, (fn) => {
+    ExecutorApplied(baseSrc, (fn) => {
       return (v) => {
         if (prevTimer) {
           clearTimeout(prevTimer);
@@ -258,12 +258,12 @@ const task = (baseSrc, delay = 0) => {
           fn(v);
         }, delay);
       };
-    })(u);
+    })(user);
   };
-};
+}
 
-const tick = (baseSrc) => {
-  return (u) => {
+function Tick(baseSrc) {
+  return (user) => {
     let microtaskScheduled = false;
     let lastValue = null;
     const scheduleMicrotask = () => {
@@ -271,7 +271,7 @@ const tick = (baseSrc) => {
       queueMicrotask(() => {
         microtaskScheduled = false;
         if (lastValue !== null) {
-          u(lastValue);
+          user(lastValue);
           lastValue = null;
         }
       });
@@ -283,52 +283,52 @@ const tick = (baseSrc) => {
       }
     });
   };
-};
+}
 
-const hashTable = (baseSrc) => {
-  return (u) => {
+function HashTable(baseSrc) {
+  return (user) => {
     const record = {};
     baseSrc(([key, value]) => {
       record[key] = value;
-      u(record);
+      user(record);
     });
   };
-};
+}
 
-const recordOf = (recordSrc) => {
-  return (u) => {
+function RecordOf(recordSrc) {
+  return (user) => {
     const keys = Object.keys(recordSrc);
-    all(...Object.values(recordSrc))((entries) => {
+    All(...Object.values(recordSrc))((entries) => {
       const record = {};
       entries.forEach((entry, index) => {
         record[keys[index]] = entry;
       });
-      u(record);
+      user(record);
     });
   };
-};
+}
 
-const concatenated = (sources, joinPartSrc = of("")) => {
-  return (u) => {
-    all(
+function Concatenated(sources, joinPartSrc = Of("")) {
+  return (user) => {
+    All(
       joinPartSrc,
       ...sources
     )(([joinPart, ...strings]) => {
-      u(strings.join(joinPart));
+      user(strings.join(joinPart));
     });
   };
-};
+}
 
-const template = (theSrc = of(""), placesSrc = of({})) => {
+function Template(theSrc = Of(""), placesSrc = Of({})) {
   let placesCounter = 0;
   const vars = {
-    $TPL: of("$TPL")
+    $TPL: Of("$TPL")
   };
   const destructors = [];
   return {
-    value: (u) => {
-      const varsSrc = recordOf(vars);
-      applied(all(theSrc, placesSrc, varsSrc), ([base, rules, vars2]) => {
+    value: (user) => {
+      const varsSrc = RecordOf(vars);
+      Applied(All(theSrc, placesSrc, varsSrc), ([base, rules, vars2]) => {
         Object.entries(rules).forEach(([ph, val]) => {
           base = base.replaceAll(ph, String(val));
         });
@@ -336,189 +336,189 @@ const template = (theSrc = of(""), placesSrc = of({})) => {
           base = base.replaceAll(ph, String(val));
         });
         return base;
-      })(u);
+      })(user);
     },
     template: (value) => {
-      theSrc = of(value);
+      theSrc = Of(value);
     },
     /**
      * Ability to register variable
-     * in concrete place of template
+     * in concrete place Of template
      */
     var: (src) => {
       const varName = `$var${placesCounter}`;
       placesCounter += 1;
-      vars[varName] = destructor(src, (d) => {
+      vars[varName] = Destructor(src, (d) => {
         destructors.push(d);
-      }).value;
+      }).event;
       return varName;
     },
     destroy() {
       destructors.forEach((d) => d());
     }
   };
-};
+}
 
-const regexpMatched = (patternSrc, valueSrc, flagsSrc = of("")) => {
-  return (u) => {
-    all(
+function RegexpMatched(patternSrc, valueSrc, flagsSrc = Of("")) {
+  return (user) => {
+    All(
       patternSrc,
       valueSrc,
       flagsSrc
     )(([pattern, value, flags]) => {
-      u(new RegExp(pattern, flags).test(value));
+      user(new RegExp(pattern, flags).test(value));
     });
   };
-};
+}
 
-const regexpReplaced = (valueSrc, patternSrc, replaceValueSrc, flagsSrc = of("")) => {
-  return (u) => {
-    all(
+function RegexpReplaced(valueSrc, patternSrc, replaceValueSrc, flagsSrc = Of("")) {
+  return (user) => {
+    All(
       patternSrc,
       valueSrc,
       replaceValueSrc,
       flagsSrc
     )(([pattern, value, replaceValue, flags]) => {
-      u(String(value).replace(new RegExp(pattern, flags), replaceValue));
+      user(String(value).replace(new RegExp(pattern, flags), replaceValue));
     });
   };
-};
+}
 
-const regexpMatch = (patternSrc, valueSrc, flagsSrc = of("")) => {
-  return (u) => {
-    all(
+function RegexpMatch(patternSrc, valueSrc, flagsSrc = Of("")) {
+  return (user) => {
+    All(
       patternSrc,
       valueSrc,
       flagsSrc
     )(([pattern, value, flags]) => {
       const result = new RegExp(pattern, flags).exec(value);
-      u(result ?? []);
+      user(result ?? []);
     });
   };
-};
+}
 
-const set = (baseSrc, keySrc, valueSrc) => {
-  return (u) => {
-    all(
+function Set(baseSrc, keySrc, valueSrc) {
+  return (user) => {
+    All(
       baseSrc,
       keySrc,
       valueSrc
     )(([base, key, value]) => {
       base[key] = value;
-      u(base);
+      user(base);
     });
   };
-};
+}
 
-const emptySrc = () => of(false);
-const router = (urlSrc, routesSrc, defaultSrc) => {
-  return (u) => {
+const emptySrc = () => Of(false);
+function Router(urlSrc, routesSrc, defaultSrc) {
+  return (user) => {
     const destructors = [];
     const destroyAllData = () => {
       destructors.forEach((d) => d());
       destructors.length = 0;
     };
-    all(
+    All(
       routesSrc,
       urlSrc
     )(([routes, url]) => {
       destroyAllData();
-      const instance = all(
+      const instance = All(
         defaultSrc(),
-        all(
+        All(
           ...routes.map(
-            (r) => destructor(
-              branchLazy(
-                regexpMatched(
-                  of(r.pattern),
-                  of(url),
-                  r.patternFlags ? of(r.patternFlags) : void 0
+            (r) => Destructor(
+              BranchLazy(
+                RegexpMatched(
+                  Of(r.pattern),
+                  Of(url),
+                  r.patternFlags ? Of(r.patternFlags) : void 0
                 ),
                 r.template,
                 emptySrc
               ),
               (d) => destructors.push(d)
-            ).value
+            ).event
           )
         )
       );
-      applied(instance, (r) => {
+      Applied(instance, (r) => {
         const firstReal = r[1].find((r2) => r2 !== false);
         if (firstReal) {
           return firstReal;
         }
         return r[0];
-      })(u);
+      })(user);
     });
     return destroyAllData;
   };
-};
+}
 
-const and = (oneSrc, twoSrc) => {
-  return (u) => {
-    all(
+function And(oneSrc, twoSrc) {
+  return (user) => {
+    All(
       oneSrc,
       twoSrc
     )(([one, two]) => {
-      u(one && two);
+      user(one && two);
     });
   };
-};
+}
 
-const or = (oneSrc, twoSrc) => {
-  return (u) => {
-    all(
+function Or(oneSrc, twoSrc) {
+  return (user) => {
+    All(
       oneSrc,
       twoSrc
     )(([one, two]) => {
-      u(one || two);
+      user(one || two);
     });
   };
-};
+}
 
-const not = (baseSrc) => {
-  return (u) => {
+function Not(baseSrc) {
+  return (user) => {
     baseSrc((v) => {
-      u(!v);
+      user(!v);
     });
   };
-};
+}
 
-const bool = (baseSrc) => {
-  return (u) => {
-    applied(baseSrc, Boolean)(u);
+function Bool(baseSrc) {
+  return (user) => {
+    Applied(baseSrc, Boolean)(user);
   };
-};
+}
 
-const fromJson = (jsonSrc, errorOwner) => {
-  return (u) => {
+function FromJson(jsonSrc, errorOwner) {
+  return (user) => {
     jsonSrc((json) => {
       try {
-        u(JSON.parse(json));
+        user(JSON.parse(json));
       } catch (error) {
         errorOwner?.(new Error(`Failed to parse JSON: ${error}`));
       }
     });
   };
-};
+}
 
-const toJson = (dataSrc, errorOwner) => {
-  return (u) => {
+function ToJson(dataSrc, errorOwner) {
+  return (user) => {
     dataSrc((data) => {
       try {
-        u(JSON.stringify(data));
+        user(JSON.stringify(data));
       } catch {
         errorOwner?.(new Error("Failed to convert to JSON"));
       }
     });
   };
-};
+}
 
-const first = (baseSrc) => {
-  return (u) => {
-    applied(baseSrc, (a) => a[0])(u);
+function First(baseSrc) {
+  return (user) => {
+    Applied(baseSrc, (a) => a[0])(user);
   };
-};
+}
 
-export { and, bool, branch, branchLazy, concatenated, constant, deadline, deferred, detached, dirty, first, fromJson, hashTable, loading, lock, memo, not, onlyChanged, or, part, path, polling, recordOf, regexpMatch, regexpMatched, regexpReplaced, router, set, shot, task, template, tick, toJson };
+export { And, Bool, Branch, BranchLazy, Concatenated, Constant, Deadline, Deferred, Detached, Dirty, First, FromJson, HashTable, Loading, Lock, Memo, Not, OnlyChanged, Or, Part, Path, Polling, RecordOf, RegexpMatch, RegexpMatched, RegexpReplaced, Router, Set, Shot, Task, Template, Tick, ToJson };
 //# sourceMappingURL=silentium-components.js.map