silentium-components 0.0.4 → 0.0.6

package/CHANGELOG.md

@@ -2,6 +2,28 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+### [0.0.6](https://github.com/silentium-lab/silentium-components/compare/v0.0.5...v0.0.6) (2025-05-02)
+
+
+### Features
+
+* **1-issue:** done deadline class ([1f4b785](https://github.com/silentium-lab/silentium-components/commit/1f4b785c6dc4241e71f8ec5fd2b4782f02adc58f))
+* **1-issue:** moving to procedures ([83e85a9](https://github.com/silentium-lab/silentium-components/commit/83e85a9da06dbf8aece637801f1a116e016d2492))
+* **main:** deadline to procedures ([087d4e6](https://github.com/silentium-lab/silentium-components/commit/087d4e689cd940c72364310b67f5da406055a0bc))
+* **main:** deps updated ([6140111](https://github.com/silentium-lab/silentium-components/commit/61401111ef0e7bb7530aaa489f8210b56462fd4e))
+* **main:** dirty to procedure ([c4291ca](https://github.com/silentium-lab/silentium-components/commit/c4291ca2aa3d499d8c4087b92798aff899530ff8))
+* **main:** hashtable path and loading moved to procedures ([4edde10](https://github.com/silentium-lab/silentium-components/commit/4edde1001ab75dd9cbd1076fc16e7175ea9acafb))
+* **main:** remove unneeded classes ([aafea7a](https://github.com/silentium-lab/silentium-components/commit/aafea7a7719d2b0561cff45edaa9e9efb01abbf2))
+* **main:** router done ([c9f0648](https://github.com/silentium-lab/silentium-components/commit/c9f06482987c9421ae9c98165cf3f44af36edeaf))
+
+### [0.0.5](https://github.com/silentium-lab/silentium-components/compare/v0.0.4...v0.0.5) (2025-04-19)
+
+
+### Features
+
+* **main:** fix source changeable renaming ([66fe284](https://github.com/silentium-lab/silentium-components/commit/66fe28421a4f6c0331c7eee8470cb2ccedb0c79e))
+* **main:** release ([6f7d7d3](https://github.com/silentium-lab/silentium-components/commit/6f7d7d36590dc7e7fa4d65f3d56e00bc23cd79b3))
+
 ### [0.0.4](https://github.com/silentium-lab/silentium-components/compare/v0.0.3...v0.0.4) (2025-04-17)
 
 

package/dist/silentium-components.cjs

@@ -1,498 +1,149 @@
 'use strict';
 
 var silentium = require('silentium');
-var silentiumWebApi = require('silentium-web-api');
 
-class PageFetchTransport {
-  constructor(basePath, template) {
-    this.basePath = basePath;
-    this.template = template;
-  }
-  content(guest) {
-    fetch(this.basePath + "/" + this.template).then((result) => {
-      return result.text();
-    }).then((result) => {
-      silentium.give(result, guest);
-    });
-  }
-}
-
-class Navigation {
-  constructor(loading, basePath, currentPage, display, pageTransport) {
-    this.loading = loading;
-    this.basePath = basePath;
-    this.currentPage = currentPage;
-    this.display = display;
-    this.pageTransport = pageTransport;
-  }
-  routes(routes) {
-    const defaultRoute = routes.find((route) => route.default);
-    const all = new silentium.SourceAll();
-    silentium.value(this.basePath, new silentium.Patron(all.guestKey("basePath")));
-    silentium.value(this.currentPage, new silentium.Patron(all.guestKey("currentPage")));
-    all.value(
-      new silentium.Patron(({ basePath, currentPage }) => {
-        const urlWithoutBasePath = currentPage.replace(basePath, "");
-        const routeMatchedToAlias = routes.find(
-          (route2) => route2.aliases && (route2.aliases.includes(currentPage) || route2.aliases.includes(urlWithoutBasePath))
-        );
-        if (routeMatchedToAlias) {
-          const correctUrl = basePath + routeMatchedToAlias.url;
-          if (correctUrl !== currentPage) {
-            silentium.give(correctUrl, this.currentPage);
-            return;
-          }
+const groupActiveClass = (activeClassSrc, activeElementSrc, groupElementsSrc) => {
+  silentium.value(
+    silentium.sourceAll([activeClassSrc, activeElementSrc, groupElementsSrc]),
+    silentium.patron(([activeClass, activeElement, groupElements]) => {
+      groupElements.forEach((el) => {
+        if (el.classList) {
+          el.classList.remove(activeClass);
         }
-        let route = routes.find((route2) => {
-          if (route2.url.indexOf("*") >= 0) {
-            const regexp = new RegExp(
-              route2.url.replaceAll("*", ".*").replaceAll("/", "/")
-            );
-            return regexp.test(urlWithoutBasePath);
-          }
-          return route2.url.replaceAll("*", "") === urlWithoutBasePath;
-        });
-        if (!route && defaultRoute) {
-          route = defaultRoute;
-        }
-        if (route) {
-          const basePathWithoutHash = basePath.replace("/#", "").replace("#", "").replace(/[^/]+\.html$/, "");
-          silentium.give(true, this.loading);
-          this.pageTransport.get(basePathWithoutHash, route.template).content((templateContent) => {
-            this.display.display(templateContent);
-            route.page.mounted();
-            silentium.give(false, this.loading);
-          });
-        } else {
-          throw new Error("No matching route in Navigation");
-        }
-      })
-    );
-  }
-}
-
-class RouteDisplay {
-  constructor(selector) {
-    this.selector = selector;
-  }
-  display(content) {
-    const contentEl = document.querySelector(this.selector);
-    if (contentEl) {
-      contentEl.innerHTML = content;
-    }
-  }
-}
-
-var __defProp$3 = Object.defineProperty;
-var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$3 = (obj, key, value) => __defNormalProp$3(obj, key + "" , value);
-class CurrentPage {
-  constructor() {
-    __publicField$3(this, "source");
-    const correctUrl = location.href.replace(location.origin, "");
-    this.source = new silentium.SourceWithPool(correctUrl);
-  }
-  give(value) {
-    this.source.give(value);
-    return this;
-  }
-  value(guest) {
-    this.source.value(guest);
-    return guest;
-  }
-  pool() {
-    return this.source.pool();
-  }
-}
-
-class Input {
-  constructor(source, selector) {
-    this.source = source;
-    const el = document.querySelector(selector);
-    this.source.value(
-      new silentium.Patron((value) => {
-        el.value = String(value);
-      })
-    );
-    el.addEventListener("keyup", () => {
-      this.give(el.value);
-    });
-    el.addEventListener("change", () => {
-      this.give(el.value);
-    });
-  }
-  value(guest) {
-    this.source.value(guest);
-    return this;
-  }
-  give(value) {
-    this.source.give(value);
-    return this;
-  }
-  pool() {
-    return this.source.pool();
-  }
-}
-
-class Visible {
-  constructor(selector) {
-    this.selector = selector;
-  }
-  give(isVisible) {
-    const el = document.querySelector(this.selector);
-    if (el) {
-      el.style.display = isVisible ? "block" : "none";
-    }
-    return this;
-  }
-}
-
-class Text {
-  constructor(selector) {
-    this.selector = selector;
-  }
-  give(value) {
-    const element = document.querySelector(this.selector);
-    if (element) {
-      element.innerText = String(value);
-    }
-    return this;
-  }
-}
-
-class Link {
-  constructor(linkSource, basePath) {
-    this.linkSource = linkSource;
-    this.basePath = basePath;
-  }
-  watchClick(selector, subselector) {
-    const wrapperEl = document.querySelectorAll(selector);
-    if (wrapperEl.length) {
-      wrapperEl.forEach((theElement) => {
-        theElement.addEventListener("click", (e) => {
-          if (subselector) {
-            theElement.querySelectorAll(subselector).forEach((theSubElement) => {
-              if (e?.target === theSubElement || e?.currentTarget === theSubElement) {
-                this.handleClick({
-                  preventDefault: e.preventDefault.bind(e),
-                  target: theSubElement
-                });
-              }
-            });
-          } else {
-            this.handleClick(e);
-          }
-        });
       });
-    } else {
-      throw new Error(`Link wrapper not found for selector ${selector}`);
-    }
-  }
-  handleClick(e) {
-    let href = e?.target?.getAttribute("href");
-    if (!href) {
-      href = e?.currentTarget?.getAttribute("href");
-    }
-    if (href && href.indexOf("http") !== 0) {
-      e.preventDefault();
-      silentium.value(this.basePath, (basePath) => {
-        this.linkSource.give(basePath + href);
-      });
-    }
-  }
-}
-
-class ComputedElement {
-  constructor(sources, selectorTemplate) {
-    this.sources = sources;
-    this.selectorTemplate = selectorTemplate;
-  }
-  element(guest) {
-    const chain = new silentium.SourceAll();
-    this.sources.forEach((source) => {
-      source.source.value(
-        new silentium.GuestCast(guest, chain.guestKey(source.placeholder))
-      );
-    });
-    chain.value(
-      new silentium.GuestCast(
-        guest,
-        (placeholders) => {
-          let selectorTemplate = this.selectorTemplate;
-          Object.entries(placeholders).map((entry) => {
-            selectorTemplate = selectorTemplate.replaceAll(entry[0], entry[1]);
-          });
-          const element = document.querySelector(
-            selectorTemplate
-          );
-          if (element) {
-            silentium.give(element, guest);
+      activeElement.classList.add(activeClass);
+    })
+  );
+  return groupElementsSrc;
+};
+
+const dirty = (baseEntitySource, becomePatronAuto = false, alwaysKeep = [], excludeKeys = []) => {
+  const comparingSrc = silentium.sourceOf();
+  const all = silentium.sourceAll([comparingSrc, baseEntitySource]);
+  const result = {
+    give(value2) {
+      silentium.give(JSON.parse(JSON.stringify(value2)), comparingSrc);
+      return result;
+    },
+    value(guest) {
+      silentium.value(
+        all,
+        silentium.guestCast(guest, ([comparing, base]) => {
+          if (!comparing) {
+            return;
           }
-        }
-      )
-    );
-  }
-}
-
-class GroupActiveClass {
-  constructor(activeClass, groupSelector, document) {
-    this.activeClass = activeClass;
-    this.groupSelector = groupSelector;
-    this.document = document;
-  }
-  give(element) {
-    silentium.value(
-      this.document,
-      new silentium.PatronOnce((document) => {
-        document.querySelectorAll(this.groupSelector).forEach((el) => {
-          el.classList.remove(this.activeClass);
-        });
-        element.classList.add(this.activeClass);
-      })
-    );
-    return this;
-  }
-}
-
-class Router {
-  constructor(loaderSelector, navigationResultSelector, menuSelector) {
-    this.loaderSelector = loaderSelector;
-    this.navigationResultSelector = navigationResultSelector;
-    this.menuSelector = menuSelector;
-  }
-  routes(routes, currentPage, basePathSource, afterPageLoaded) {
-    if (!currentPage) {
-      currentPage = new CurrentPage();
-    }
-    currentPage.value(new silentium.Patron(new silentiumWebApi.HistoryNewPage()));
-    const [basePath] = location.href.replace(location.origin, "").split("#");
-    if (!basePathSource) {
-      basePathSource = new silentium.SourceWithPool(
-        `${basePath}#`.replace("index.html", "").replace("//", "/")
-      );
-    }
-    const pageLoading = new silentium.SourceWithPool(false);
-    pageLoading.value(new silentium.Patron(new Visible(this.loaderSelector)));
-    const historyPoppedPage = new silentiumWebApi.HistoryPoppedPage(currentPage);
-    historyPoppedPage.watchPop();
-    const navigation = new Navigation(
-      pageLoading,
-      basePathSource,
-      currentPage,
-      new RouteDisplay(this.navigationResultSelector),
-      new silentium.PrivateClass(PageFetchTransport)
-    );
-    navigation.routes(routes);
-    const link = new Link(currentPage, basePathSource);
-    link.watchClick(this.menuSelector);
-    const urlChain = new silentium.SourceAll();
-    basePathSource.value(new silentium.Patron(urlChain.guestKey("basePath")));
-    currentPage.value(new silentium.Patron(urlChain.guestKey("page")));
-    const url = new silentium.Source((guest) => {
-      urlChain.value(
-        new silentium.GuestCast(guest, ({ basePath: basePath2, page }) => {
-          silentium.give(page.replace(basePath2, ""), guest);
+          silentium.give(
+            Object.fromEntries(
+              Object.entries(comparing).filter(([key, value2]) => {
+                if (alwaysKeep.includes(key)) {
+                  return true;
+                }
+                if (excludeKeys.includes(key)) {
+                  return false;
+                }
+                return value2 !== base[key];
+              })
+            ),
+            guest
+          );
         })
       );
-    });
-    const activeLink = new ComputedElement(
-      [{ source: url, placeholder: "{url}" }],
-      `${this.menuSelector} a[href="{url}"]`
-    );
-    activeLink.element(
-      new silentium.Patron(
-        new GroupActiveClass(
-          "active",
-          `${this.menuSelector} a`,
-          silentium.sourceOf(document)
-        )
-      )
-    );
-    pageLoading.value(
-      new silentium.Patron((isInLoading) => {
-        if (isInLoading) {
-          return;
-        }
-        if (afterPageLoaded) {
-          afterPageLoaded();
-        }
-        const divDestination = document.querySelector(
-          this.navigationResultSelector
-        );
-        if (divDestination) {
-          divDestination.querySelectorAll("script").forEach((x) => {
-            const sc = document.createElement("script");
-            sc.setAttribute("type", "module");
-            sc.appendChild(document.createTextNode(x.innerText));
-            divDestination.appendChild(sc);
-          });
-        }
-      })
-    );
-  }
-}
-
-class Page {
-  constructor(title) {
-    this.title = title;
-  }
-  mounted() {
-    document.title = this.title;
-  }
-}
-
-class EntryPointPage {
-  constructor(title, entryPointUrl) {
-    this.title = title;
-    this.entryPointUrl = entryPointUrl;
-  }
-  mounted() {
-    document.title = this.title;
-    import(this.entryPointUrl).then((module) => {
-      if (module.main) {
-        module.main();
-      }
-    });
-  }
-}
-
-var __defProp$2 = Object.defineProperty;
-var __defNormalProp$2 = (obj, key, value2) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value: value2 }) : obj[key] = value2;
-var __publicField$2 = (obj, key, value2) => __defNormalProp$2(obj, typeof key !== "symbol" ? key + "" : key, value2);
-class Dirty {
-  constructor(baseEntitySource, alwaysKeep = [], excludeKeys = [], becomePatronAuto = false) {
-    this.alwaysKeep = alwaysKeep;
-    this.excludeKeys = excludeKeys;
-    __publicField$2(this, "comparingSource", new silentium.SourceWithPool());
-    __publicField$2(this, "all", new silentium.SourceAll());
-    this.comparingSource.value(new silentium.Patron(this.all.guestKey("comparing")));
-    silentium.value(baseEntitySource, new silentium.Patron(this.all.guestKey("base")));
-    if (becomePatronAuto) {
-      silentium.value(baseEntitySource, new silentium.PatronOnce(this));
+      return result;
     }
-  }
-  give(value2) {
-    silentium.give(JSON.parse(JSON.stringify(value2)), this.comparingSource);
-    return this;
-  }
-  value(guest) {
-    this.all.value(
-      new silentium.GuestCast(guest, ({ comparing, base }) => {
-        if (!comparing) {
-          return;
-        }
-        silentium.give(
-          Object.fromEntries(
-            Object.entries(comparing).filter(([key, value2]) => {
-              if (this.alwaysKeep.includes(key)) {
-                return true;
-              }
-              if (this.excludeKeys.includes(key)) {
-                return false;
-              }
-              return value2 !== base[key];
-            })
-          ),
-          guest
-        );
-      })
-    );
-    return this;
-  }
-}
-
-var __defProp$1 = Object.defineProperty;
-var __defNormalProp$1 = (obj, key, value2) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value: value2 }) : obj[key] = value2;
-var __publicField$1 = (obj, key, value2) => __defNormalProp$1(obj, key + "" , value2);
-class Loading {
-  constructor(loadingStartSource, loadingFinishSource) {
-    this.loadingStartSource = loadingStartSource;
-    this.loadingFinishSource = loadingFinishSource;
-    __publicField$1(this, "loadingSource", new silentium.SourceWithPool());
-  }
-  value(guest) {
-    silentium.value(
-      this.loadingStartSource,
-      new silentium.GuestCast(guest, () => {
-        this.loadingSource.give(true);
-      })
-    );
+  };
+  if (becomePatronAuto) {
+    silentium.value(baseEntitySource, silentium.patronOnce(result));
+  }
+  return result;
+};
+
+const loading = (loadingStartSource, loadingFinishSource) => {
+  const loadingSrc = silentium.sourceOf();
+  silentium.subSourceMany(loadingSrc, [loadingStartSource, loadingFinishSource]);
+  silentium.value(
+    loadingStartSource,
+    silentium.patron(() => {
+      loadingSrc.give(true);
+    })
+  );
+  silentium.value(
+    loadingFinishSource,
+    silentium.patron(() => {
+      loadingSrc.give(false);
+    })
+  );
+  return loadingSrc.value;
+};
+
+const path = (baseSrc, keySrc) => {
+  const pathSrc = silentium.sourceOf();
+  silentium.subSourceMany(pathSrc, [baseSrc, keySrc]);
+  silentium.value(
+    silentium.sourceAll([baseSrc, keySrc]),
+    silentium.patron(([base, key]) => {
+      const keyChunks = key.split(".");
+      let value2 = base;
+      keyChunks.forEach((keyChunk) => {
+        value2 = value2[keyChunk];
+      });
+      if (value2 !== void 0 && value2 !== base) {
+        silentium.give(value2, pathSrc);
+      }
+    })
+  );
+  return pathSrc.value;
+};
+
+const deadline = (error, baseSrc, timeoutSrc) => {
+  let timerHead = null;
+  return (g) => {
     silentium.value(
-      this.loadingFinishSource,
-      new silentium.GuestCast(guest, () => {
-        this.loadingSource.give(false);
-      })
-    );
-    this.loadingSource.value(guest);
-    return this;
-  }
-}
-
-class Touched {
-}
-
-class Path {
-  constructor(baseSource, keyType) {
-    this.baseSource = baseSource;
-    this.keyType = keyType;
-  }
-  value(guest) {
-    const all = new silentium.SourceAll(["base", "key"]);
-    silentium.value(this.baseSource, new silentium.GuestCast(guest, all.guestKey("base")));
-    silentium.value(this.keyType, new silentium.GuestCast(guest, all.guestKey("key")));
-    all.value(
-      new silentium.GuestCast(guest, ({ base, key }) => {
-        const keyChunks = key.split(".");
-        let value2 = base;
-        keyChunks.forEach((keyChunk) => {
-          value2 = value2[keyChunk];
-        });
-        if (value2 !== void 0 && value2 !== base) {
-          silentium.give(value2, guest);
+      timeoutSrc,
+      silentium.guestCast(g, (timeout) => {
+        if (timerHead) {
+          clearTimeout(timerHead);
         }
+        let timeoutReached = false;
+        timerHead = setTimeout(() => {
+          if (timeoutReached) {
+            return;
+          }
+          timeoutReached = true;
+          silentium.give(new Error("Timeout reached in Deadline class"), error);
+        }, timeout);
+        silentium.value(
+          silentium.sourceFiltered(baseSrc, () => !timeoutReached),
+          g
+        );
+        silentium.value(
+          baseSrc,
+          silentium.patronOnce(() => {
+            timeoutReached = true;
+          })
+        );
       })
     );
-    return this;
-  }
-}
-
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value2) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value: value2 }) : obj[key] = value2;
-var __publicField = (obj, key, value2) => __defNormalProp(obj, key + "" , value2);
-class HashTable {
-  constructor(baseSource) {
-    __publicField(this, "source", new silentium.SourceWithPool({}));
-    silentium.value(
-      baseSource,
-      new silentium.Patron(([key, value2]) => {
-        this.source.value((lastRecord) => {
-          lastRecord[key] = value2;
-        });
-      })
-    );
-  }
-  value(guest) {
-    silentium.value(this.source, guest);
-    return this;
-  }
-}
-
-exports.ComputedElement = ComputedElement;
-exports.CurrentPage = CurrentPage;
-exports.Dirty = Dirty;
-exports.EntryPointPage = EntryPointPage;
-exports.GroupActiveClass = GroupActiveClass;
-exports.HashTable = HashTable;
-exports.Input = Input;
-exports.Link = Link;
-exports.Loading = Loading;
-exports.Navigation = Navigation;
-exports.Page = Page;
-exports.PageFetchTransport = PageFetchTransport;
-exports.Path = Path;
-exports.RouteDisplay = RouteDisplay;
-exports.Router = Router;
-exports.Text = Text;
-exports.Touched = Touched;
-exports.Visible = Visible;
+  };
+};
+
+const hashTable = (baseSource) => {
+  const result = silentium.sourceOf({});
+  silentium.subSource(result, baseSource);
+  silentium.value(
+    baseSource,
+    silentium.patron(([key, value2]) => {
+      result.value((lastRecord) => {
+        lastRecord[key] = value2;
+      });
+    })
+  );
+  return result.value;
+};
+
+exports.deadline = deadline;
+exports.dirty = dirty;
+exports.groupActiveClass = groupActiveClass;
+exports.hashTable = hashTable;
+exports.loading = loading;
+exports.path = path;
 //# sourceMappingURL=silentium-components.cjs.map