@vanduo-oss/framework 1.3.3 → 1.3.5

package/dist/vanduo.esm.js

@@ -1,4 +1,4 @@
-/*! Vanduo v1.3.3 | Built: 2026-04-10T21:45:12.664Z | git:281f4f6 | development */
+/*! Vanduo v1.3.5 | Built: 2026-04-15T18:39:53.955Z | git:3ca4f62 | development */
 
 // js/utils/lifecycle.js
 (function() {
@@ -107,7 +107,7 @@
 // js/vanduo.js
 (function() {
   "use strict";
-  const VANDUO_VERSION = true ? "1.3.3" : "0.0.0-dev";
+  const VANDUO_VERSION = true ? "1.3.5" : "0.0.0-dev";
   const Vanduo2 = {
     version: VANDUO_VERSION,
     components: {},
@@ -2157,6 +2157,31 @@
         this.initNavbar(navbar);
       });
     },
+    /**
+     * Initialize scroll-aware glass/transparent behaviour for a navbar.
+     * Adds/removes `.vd-navbar-scrolled` when the page scrolls past a threshold.
+     * Threshold: `data-scroll-threshold` attribute (px) or the navbar's own height.
+     * @param {HTMLElement} navbar - Navbar element
+     * @returns {Function|null} Cleanup function, or null if not applicable
+     */
+    initScrollWatcher: function(navbar) {
+      const isGlass = navbar.classList.contains("vd-navbar-glass");
+      const isTransparent = navbar.classList.contains("vd-navbar-transparent");
+      if (!isGlass && !isTransparent) {
+        return null;
+      }
+      const getThreshold = () => {
+        const attr = parseInt(navbar.dataset.scrollThreshold, 10);
+        return isNaN(attr) ? navbar.offsetHeight || 60 : attr;
+      };
+      const onScroll = () => {
+        const scrolled = window.scrollY > getThreshold();
+        navbar.classList.toggle("vd-navbar-scrolled", scrolled);
+      };
+      onScroll();
+      window.addEventListener("scroll", onScroll, { passive: true });
+      return () => window.removeEventListener("scroll", onScroll);
+    },
     /**
      * Initialize a single navbar
      * @param {HTMLElement} navbar - Navbar element
@@ -2165,10 +2190,17 @@
       const toggle = navbar.querySelector(".vd-navbar-toggle, .vd-navbar-burger");
       const menu = navbar.querySelector(".vd-navbar-menu");
       const overlay = navbar.querySelector(".vd-navbar-overlay") || this.createOverlay(navbar);
+      const cleanupFunctions = [];
+      const scrollWatcherCleanup = this.initScrollWatcher(navbar);
+      if (scrollWatcherCleanup) {
+        cleanupFunctions.push(scrollWatcherCleanup);
+      }
       if (!toggle || !menu) {
+        if (cleanupFunctions.length) {
+          this.instances.set(navbar, { toggle: null, menu: null, overlay: null, cleanup: cleanupFunctions });
+        }
         return;
       }
-      const cleanupFunctions = [];
       const toggleClickHandler = (e) => {
         e.preventDefault();
         e.stopPropagation();
@@ -6479,6 +6511,178 @@
   window.VanduoLazyLoad = VanduoLazyLoad;
 })();
 
+// js/components/glass.js
+(function() {
+  "use strict";
+  const GlassScroll = {
+    /** @type {Map<Element, IntersectionObserver>} */
+    observers: /* @__PURE__ */ new Map(),
+    init: function() {
+      document.querySelectorAll("[data-glass-scroll]").forEach((el) => {
+        if (this.observers.has(el)) return;
+        this.initElement(el);
+      });
+    },
+    /**
+     * Wire up a single scroll-activated glass element.
+     * @param {HTMLElement} el
+     */
+    initElement: function(el) {
+      const sentinelSelector = el.dataset.glassSentinel;
+      let sentinel;
+      if (sentinelSelector) {
+        sentinel = document.querySelector(sentinelSelector);
+      }
+      if (!sentinel) {
+        sentinel = el.previousElementSibling;
+      }
+      if (!sentinel) {
+        el.classList.add("is-glass-active");
+        return;
+      }
+      const observer = new IntersectionObserver(
+        (entries) => {
+          entries.forEach((entry) => {
+            el.classList.toggle("is-glass-active", !entry.isIntersecting);
+          });
+        },
+        { threshold: 0, rootMargin: "0px" }
+      );
+      observer.observe(sentinel);
+      this.observers.set(el, observer);
+    },
+    /**
+     * Disconnect and remove a single element's observer.
+     * @param {HTMLElement} el
+     */
+    destroy: function(el) {
+      const observer = this.observers.get(el);
+      if (observer) {
+        observer.disconnect();
+        this.observers.delete(el);
+      }
+    },
+    destroyAll: function() {
+      this.observers.forEach((observer, el) => this.destroy(el));
+    }
+  };
+  if (typeof window.Vanduo !== "undefined") {
+    window.Vanduo.register("glassScroll", GlassScroll);
+  }
+  window.VanduoGlassScroll = GlassScroll;
+})();
+
+// js/components/morph.js
+(function() {
+  "use strict";
+  const MORPH_DURATION_MS = 750;
+  const Morph = {
+    instances: /* @__PURE__ */ new Map(),
+    init: function() {
+      const elements = document.querySelectorAll(".vd-morph, [data-vd-morph]");
+      elements.forEach(function(el) {
+        if (Morph.instances.has(el)) return;
+        if (el.getAttribute("data-vd-morph") === "manual") return;
+        Morph.initInstance(el);
+      });
+    },
+    initInstance: function(el) {
+      Morph._ensureLayers(el);
+      const cleanup = [];
+      let morphing = false;
+      const handleClick = function(e) {
+        if (morphing) return;
+        Morph._runMorph(el, e, function() {
+          morphing = false;
+        });
+        morphing = true;
+      };
+      el.addEventListener("click", handleClick);
+      cleanup.push(function() {
+        el.removeEventListener("click", handleClick);
+      });
+      this.instances.set(el, { cleanup });
+    },
+    morph: function(el) {
+      if (!el) return;
+      if (!this.instances.has(el)) this.initInstance(el);
+      this._runMorph(el, null, null);
+    },
+    destroy: function(el) {
+      const instance = this.instances.get(el);
+      if (!instance) return;
+      instance.cleanup.forEach(function(fn) {
+        fn();
+      });
+      this.instances.delete(el);
+    },
+    destroyAll: function() {
+      this.instances.forEach(function(_, el) {
+        Morph.destroy(el);
+      });
+    },
+    /* ── Internal helpers ── */
+    _ensureLayers: function(el) {
+      if (!el.querySelector(".vd-morph-wave")) {
+        const wave = document.createElement("span");
+        wave.className = "vd-morph-wave";
+        wave.setAttribute("aria-hidden", "true");
+        el.insertBefore(wave, el.firstChild);
+      }
+      if (!el.querySelector(".vd-morph-shine")) {
+        const shine = document.createElement("span");
+        shine.className = "vd-morph-shine";
+        shine.setAttribute("aria-hidden", "true");
+        const waveEl = el.querySelector(".vd-morph-wave");
+        if (waveEl && waveEl.nextSibling) {
+          el.insertBefore(shine, waveEl.nextSibling);
+        } else {
+          el.insertBefore(shine, el.firstChild);
+        }
+      }
+    },
+    _runMorph: function(el, pointerEvent, onComplete) {
+      const wave = el.querySelector(".vd-morph-wave");
+      if (wave) {
+        const rect = el.getBoundingClientRect();
+        const cx = rect.left + rect.width / 2;
+        const cy = rect.top + rect.height / 2;
+        const px = pointerEvent ? pointerEvent.clientX || cx : cx;
+        const py = pointerEvent ? pointerEvent.clientY || cy : cy;
+        wave.style.left = px - rect.left + "px";
+        wave.style.top = py - rect.top + "px";
+      }
+      el.classList.add("is-morphing");
+      let duration = MORPH_DURATION_MS;
+      const custom = getComputedStyle(el).getPropertyValue("--morph-duration");
+      if (custom) {
+        const parsed = parseFloat(custom);
+        if (!isNaN(parsed)) duration = parsed * (custom.indexOf("ms") !== -1 ? 1 : 1e3);
+      }
+      setTimeout(function() {
+        el.classList.remove("is-morphing");
+        const current = el.querySelector(".vd-morph-current");
+        const next = el.querySelector(".vd-morph-next");
+        if (current && next) {
+          current.classList.remove("vd-morph-current");
+          current.classList.add("vd-morph-next");
+          next.classList.remove("vd-morph-next");
+          next.classList.add("vd-morph-current");
+        }
+        el.classList.add("morph-done");
+        setTimeout(function() {
+          el.classList.remove("morph-done");
+        }, 350);
+        if (typeof onComplete === "function") onComplete();
+      }, duration);
+    }
+  };
+  if (typeof window.Vanduo !== "undefined") {
+    window.Vanduo.register("morph", Morph);
+  }
+  window.VanduoMorph = Morph;
+})();
+
 // js/components/flow.js
 (function() {
   "use strict";