silentium-components 0.0.65 → 0.0.67

package/dist/silentium-components.cjs

@@ -2,12 +2,12 @@
 
 var silentium = require('silentium');
 
-const branch = (conditionSrc, leftSrc, rightSrc) => {
-  return (u) => {
-    const leftSync = silentium.primitive(leftSrc);
+function Branch(conditionSrc, leftSrc, rightSrc) {
+  return (user) => {
+    const leftSync = silentium.Primitive(leftSrc);
     let rightSync;
     if (rightSrc !== void 0) {
-      rightSync = silentium.primitive(rightSrc);
+      rightSync = silentium.Primitive(rightSrc);
     }
     conditionSrc((v) => {
       let result = null;
@@ -17,18 +17,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) {
@@ -37,27 +37,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 = silentium.shared(baseSrc, true);
+    const s = silentium.Shared(baseSrc, true);
     timeoutSrc((timeout) => {
       if (timerHead) {
         clearTimeout(timerHead);
@@ -70,52 +70,52 @@ const deadline = (error, baseSrc, timeoutSrc) => {
         timeoutReached = true;
         error(new Error("Timeout reached in Deadline class"));
       }, timeout);
-      const f = silentium.filtered(s.event, () => !timeoutReached);
-      f(u);
+      const f = silentium.Filtered(s.event, () => !timeoutReached);
+      f(user);
       s.event(() => {
         timeoutReached = true;
       });
     });
   };
-};
+}
 
-const deferred = (baseSrc, triggerSrc) => {
-  return (u) => {
-    const baseSync = silentium.primitive(baseSrc);
+function Deferred(baseSrc, triggerSrc) {
+  return (user) => {
+    const baseSync = silentium.Primitive(baseSrc);
     triggerSrc(() => {
       const value = baseSync.primitive();
       if (silentium.isFilled(value)) {
-        u(value);
+        user(value);
       }
     });
   };
-};
+}
 
-const detached = (baseSrc) => {
-  return function Detached(user) {
-    const v = silentium.primitive(baseSrc).primitive();
+function Detached(baseSrc) {
+  return function Detached2(user) {
+    const v = silentium.Primitive(baseSrc).primitive();
     if (silentium.isFilled(v)) {
       user(v);
     }
   };
-};
+}
 
-const dirty = (baseEntitySource, alwaysKeep = [], excludeKeys = [], cloneFn) => {
-  const comparingSrc = silentium.late();
+function Dirty(baseEntitySource, alwaysKeep = [], excludeKeys = [], cloneFn) {
+  const comparingSrc = silentium.Late();
   if (cloneFn === void 0) {
     cloneFn = (value) => JSON.parse(JSON.stringify(value));
   }
   return {
-    event: (u) => {
-      const comparingDetached = silentium.applied(comparingSrc.event, cloneFn);
-      silentium.all(
+    event: (user) => {
+      const comparingDetached = silentium.Applied(comparingSrc.event, cloneFn);
+      silentium.All(
         comparingDetached,
         baseEntitySource
       )(([comparing, base]) => {
         if (!comparing) {
           return;
         }
-        u(
+        user(
           Object.fromEntries(
             Object.entries(comparing).filter(([key, value]) => {
               if (alwaysKeep.includes(key)) {
@@ -134,57 +134,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 = silentium.filtered(baseSrc, () => !locked);
-    i(u);
+    const i = silentium.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 = silentium.primitive(baseSrc.event);
-  const keySync = silentium.primitive(keySrc);
+function Part(baseSrc, keySrc) {
+  const baseSync = silentium.Primitive(baseSrc.event);
+  const keySync = silentium.Primitive(keySrc);
   return {
-    event: (u) => {
-      silentium.all(
+    event: (user) => {
+      silentium.All(
         baseSrc.event,
         keySrc
       )(([base, key]) => {
@@ -194,7 +194,7 @@ const part = (baseSrc, keySrc) => {
           value = value[keyChunk];
         });
         if (value !== void 0 && value !== base) {
-          u(value);
+          user(value);
         }
       });
     },
@@ -208,11 +208,11 @@ const part = (baseSrc, keySrc) => {
       }
     }
   };
-};
+}
 
-const path = (baseSrc, keySrc) => {
-  return (u) => {
-    silentium.all(
+function Path(baseSrc, keySrc) {
+  return (user) => {
+    silentium.All(
       baseSrc,
       keySrc
     )(([base, key]) => {
@@ -222,36 +222,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 = silentium.primitive(targetSrc);
+function Shot(targetSrc, triggerSrc) {
+  return (user) => {
+    const targetSync = silentium.Primitive(targetSrc);
     triggerSrc(() => {
       const value = targetSync.primitive();
       if (silentium.isFilled(value)) {
-        u(value);
+        user(value);
       }
     });
   };
-};
+}
 
-const task = (baseSrc, delay = 0) => {
-  return (u) => {
+function Task(baseSrc, delay = 0) {
+  return (user) => {
     let prevTimer = null;
-    silentium.executorApplied(baseSrc, (fn) => {
+    silentium.ExecutorApplied(baseSrc, (fn) => {
       return (v) => {
         if (prevTimer) {
           clearTimeout(prevTimer);
@@ -260,12 +260,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 = () => {
@@ -273,7 +273,7 @@ const tick = (baseSrc) => {
       queueMicrotask(() => {
         microtaskScheduled = false;
         if (lastValue !== null) {
-          u(lastValue);
+          user(lastValue);
           lastValue = null;
         }
       });
@@ -285,52 +285,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);
-    silentium.all(...Object.values(recordSrc))((entries) => {
+    silentium.All(...Object.values(recordSrc))((entries) => {
       const record = {};
       entries.forEach((entry, index) => {
         record[keys[index]] = entry;
       });
-      u(record);
+      user(record);
     });
   };
-};
+}
 
-const concatenated = (sources, joinPartSrc = silentium.of("")) => {
-  return (u) => {
-    silentium.all(
+function Concatenated(sources, joinPartSrc = silentium.Of("")) {
+  return (user) => {
+    silentium.All(
       joinPartSrc,
       ...sources
     )(([joinPart, ...strings]) => {
-      u(strings.join(joinPart));
+      user(strings.join(joinPart));
     });
   };
-};
+}
 
-const template = (theSrc = silentium.of(""), placesSrc = silentium.of({})) => {
+function Template(theSrc = silentium.Of(""), placesSrc = silentium.Of({})) {
   let placesCounter = 0;
   const vars = {
-    $TPL: silentium.of("$TPL")
+    $TPL: silentium.Of("$TPL")
   };
   const destructors = [];
   return {
-    value: (u) => {
-      const varsSrc = recordOf(vars);
-      silentium.applied(silentium.all(theSrc, placesSrc, varsSrc), ([base, rules, vars2]) => {
+    value: (user) => {
+      const varsSrc = RecordOf(vars);
+      silentium.Applied(silentium.All(theSrc, placesSrc, varsSrc), ([base, rules, vars2]) => {
         Object.entries(rules).forEach(([ph, val]) => {
           base = base.replaceAll(ph, String(val));
         });
@@ -338,221 +338,221 @@ const template = (theSrc = silentium.of(""), placesSrc = silentium.of({})) => {
           base = base.replaceAll(ph, String(val));
         });
         return base;
-      })(u);
+      })(user);
     },
     template: (value) => {
-      theSrc = silentium.of(value);
+      theSrc = silentium.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] = silentium.destructor(src, (d) => {
+      vars[varName] = silentium.Destructor(src, (d) => {
         destructors.push(d);
-      }).value;
+      }).event;
       return varName;
     },
     destroy() {
       destructors.forEach((d) => d());
     }
   };
-};
+}
 
-const regexpMatched = (patternSrc, valueSrc, flagsSrc = silentium.of("")) => {
-  return (u) => {
-    silentium.all(
+function RegexpMatched(patternSrc, valueSrc, flagsSrc = silentium.Of("")) {
+  return (user) => {
+    silentium.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 = silentium.of("")) => {
-  return (u) => {
-    silentium.all(
+function RegexpReplaced(valueSrc, patternSrc, replaceValueSrc, flagsSrc = silentium.Of("")) {
+  return (user) => {
+    silentium.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 = silentium.of("")) => {
-  return (u) => {
-    silentium.all(
+function RegexpMatch(patternSrc, valueSrc, flagsSrc = silentium.Of("")) {
+  return (user) => {
+    silentium.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) => {
-    silentium.all(
+function Set(baseSrc, keySrc, valueSrc) {
+  return (user) => {
+    silentium.All(
       baseSrc,
       keySrc,
       valueSrc
     )(([base, key, value]) => {
       base[key] = value;
-      u(base);
+      user(base);
     });
   };
-};
+}
 
-const emptySrc = () => silentium.of(false);
-const router = (urlSrc, routesSrc, defaultSrc) => {
-  return (u) => {
+const emptySrc = () => silentium.Of(false);
+function Router(urlSrc, routesSrc, defaultSrc) {
+  return (user) => {
     const destructors = [];
     const destroyAllData = () => {
       destructors.forEach((d) => d());
       destructors.length = 0;
     };
-    silentium.all(
+    silentium.All(
       routesSrc,
       urlSrc
     )(([routes, url]) => {
       destroyAllData();
-      const instance = silentium.all(
+      const instance = silentium.All(
         defaultSrc(),
-        silentium.all(
+        silentium.All(
           ...routes.map(
-            (r) => silentium.destructor(
-              branchLazy(
-                regexpMatched(
-                  silentium.of(r.pattern),
-                  silentium.of(url),
-                  r.patternFlags ? silentium.of(r.patternFlags) : void 0
+            (r) => silentium.Destructor(
+              BranchLazy(
+                RegexpMatched(
+                  silentium.Of(r.pattern),
+                  silentium.Of(url),
+                  r.patternFlags ? silentium.Of(r.patternFlags) : void 0
                 ),
                 r.template,
                 emptySrc
               ),
               (d) => destructors.push(d)
-            ).value
+            ).event
           )
         )
       );
-      silentium.applied(instance, (r) => {
+      silentium.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) => {
-    silentium.all(
+function And(oneSrc, twoSrc) {
+  return (user) => {
+    silentium.All(
       oneSrc,
       twoSrc
     )(([one, two]) => {
-      u(one && two);
+      user(one && two);
     });
   };
-};
+}
 
-const or = (oneSrc, twoSrc) => {
-  return (u) => {
-    silentium.all(
+function Or(oneSrc, twoSrc) {
+  return (user) => {
+    silentium.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) => {
-    silentium.applied(baseSrc, Boolean)(u);
+function Bool(baseSrc) {
+  return (user) => {
+    silentium.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) => {
-    silentium.applied(baseSrc, (a) => a[0])(u);
-  };
-};
-
-exports.and = and;
-exports.bool = bool;
-exports.branch = branch;
-exports.branchLazy = branchLazy;
-exports.concatenated = concatenated;
-exports.constant = constant;
-exports.deadline = deadline;
-exports.deferred = deferred;
-exports.detached = detached;
-exports.dirty = dirty;
-exports.first = first;
-exports.fromJson = fromJson;
-exports.hashTable = hashTable;
-exports.loading = loading;
-exports.lock = lock;
-exports.memo = memo;
-exports.not = not;
-exports.onlyChanged = onlyChanged;
-exports.or = or;
-exports.part = part;
-exports.path = path;
-exports.polling = polling;
-exports.recordOf = recordOf;
-exports.regexpMatch = regexpMatch;
-exports.regexpMatched = regexpMatched;
-exports.regexpReplaced = regexpReplaced;
-exports.router = router;
-exports.set = set;
-exports.shot = shot;
-exports.task = task;
-exports.template = template;
-exports.tick = tick;
-exports.toJson = toJson;
+}
+
+function First(baseSrc) {
+  return (user) => {
+    silentium.Applied(baseSrc, (a) => a[0])(user);
+  };
+}
+
+exports.And = And;
+exports.Bool = Bool;
+exports.Branch = Branch;
+exports.BranchLazy = BranchLazy;
+exports.Concatenated = Concatenated;
+exports.Constant = Constant;
+exports.Deadline = Deadline;
+exports.Deferred = Deferred;
+exports.Detached = Detached;
+exports.Dirty = Dirty;
+exports.First = First;
+exports.FromJson = FromJson;
+exports.HashTable = HashTable;
+exports.Loading = Loading;
+exports.Lock = Lock;
+exports.Memo = Memo;
+exports.Not = Not;
+exports.OnlyChanged = OnlyChanged;
+exports.Or = Or;
+exports.Part = Part;
+exports.Path = Path;
+exports.Polling = Polling;
+exports.RecordOf = RecordOf;
+exports.RegexpMatch = RegexpMatch;
+exports.RegexpMatched = RegexpMatched;
+exports.RegexpReplaced = RegexpReplaced;
+exports.Router = Router;
+exports.Set = Set;
+exports.Shot = Shot;
+exports.Task = Task;
+exports.Template = Template;
+exports.Tick = Tick;
+exports.ToJson = ToJson;
 //# sourceMappingURL=silentium-components.cjs.map