@gemboss/gem-framework 0.5.2 → 0.9.0

package/dist/plugins/before_after.d.ts

@@ -0,0 +1,9 @@
+// @gemboss/gem-framework/plugins/before_after: types of the ES module next to this file. Generated; do not edit here.
+import type { MountOptions, Unmount } from "../runtime-core.js";
+
+export type { MountOptions, Unmount };
+export declare const key: "before_after";
+export declare const readyEvent: "gem:before-after:ready";
+/** Bind every "before_after" hook inside root (default: the whole document). Returns unmount(). Mounting the same root twice binds once. */
+export declare function mount(root?: ParentNode | null, options?: MountOptions): Unmount;
+export default mount;

package/dist/plugins/before_after.js

@@ -0,0 +1,37 @@
+// @gemboss/gem-framework/plugins/before_after: the gem-runtime plugin "before_after" as an ES module. Generated from
+// packages/gem-framework/src/runtime.ts, the same lines gem-runtime.js carries; do not edit here.
+import { mountPlugin } from "../runtime-core.js";
+
+export const key = "before_after";
+export const readyEvent = "gem:before-after:ready";
+
+function install({ document, window, target, mark, canListen, listen: __gemListen, registerPlugin, registerNoopPlugin }) {
+  registerPlugin('before_after', ({ api }) => {
+    const frames = document.querySelectorAll('[data-gem-before-after-frame], .gem-before-after__frame');
+    let bound = 0;
+    const clamp = (value) => Math.max(0, Math.min(100, Number.isFinite(value) ? value : 50));
+    frames.forEach((frame) => {
+      if (!mark(frame, 'before_after')) return;
+      const range = frame.querySelector && frame.querySelector('[data-gem-before-after-range], input[type="range"]');
+      const setPosition = (value, reason = 'init') => {
+        const position = clamp(Number(value));
+        if (frame.style && frame.style.setProperty) frame.style.setProperty('--gem-before-after-position', position + '%');
+        frame.dataset.gemBeforeAfterPosition = String(position);
+        if (range && range.value !== undefined) range.value = String(position);
+        api.emit('gem:before-after:change', { source: 'gem-runtime', position, reason, id: frame.id || undefined });
+      };
+      const initial = range && range.value !== undefined ? range.value : frame.getAttribute && frame.getAttribute('data-gem-before-after-position');
+      setPosition(initial || 50);
+      if (canListen(range)) __gemListen(range, 'input', () => setPosition(range.value, 'input'));
+      bound += 1;
+    });
+    api.emit('gem:before-after:ready', { source: 'gem-runtime', count: bound });
+  });
+}
+
+/** Bind every "before_after" hook inside root (default: the whole document). Returns unmount(). Mounting the same root twice binds once. */
+export function mount(root, options) {
+  return mountPlugin(key, install, root, options);
+}
+
+export default mount;

package/dist/plugins/carousel.d.ts

@@ -0,0 +1,9 @@
+// @gemboss/gem-framework/plugins/carousel: types of the ES module next to this file. Generated; do not edit here.
+import type { MountOptions, Unmount } from "../runtime-core.js";
+
+export type { MountOptions, Unmount };
+export declare const key: "carousel";
+export declare const readyEvent: "gem:carousel:ready";
+/** Bind every "carousel" hook inside root (default: the whole document). Returns unmount(). Mounting the same root twice binds once. */
+export declare function mount(root?: ParentNode | null, options?: MountOptions): Unmount;
+export default mount;

package/dist/plugins/carousel.js

@@ -0,0 +1,49 @@
+// @gemboss/gem-framework/plugins/carousel: the gem-runtime plugin "carousel" as an ES module. Generated from
+// packages/gem-framework/src/runtime.ts, the same lines gem-runtime.js carries; do not edit here.
+import { mountPlugin } from "../runtime-core.js";
+
+export const key = "carousel";
+export const readyEvent = "gem:carousel:ready";
+
+function install({ document, window, target, mark, canListen, listen: __gemListen, registerPlugin, registerNoopPlugin }) {
+  registerPlugin('carousel', ({ api }) => {
+    const carousels = document.querySelectorAll('[data-gem-carousel], .gem-carousel');
+    let bound = 0;
+    carousels.forEach((carousel) => {
+      if (!mark(carousel, 'carousel')) return;
+      const viewport = carousel.querySelector && (carousel.querySelector('[data-gem-carousel-viewport]') || carousel.querySelector('.gem-carousel__viewport'));
+      const slides = carousel.querySelectorAll('[data-gem-carousel-slide], .gem-carousel__slide');
+      const previous = carousel.querySelector && carousel.querySelector('[data-gem-carousel-prev]');
+      const next = carousel.querySelector && carousel.querySelector('[data-gem-carousel-next]');
+      const slideCount = slides.length || 0;
+      const currentIndex = () => {
+        if (!viewport || !slideCount) return 0;
+        const width = Number(viewport.clientWidth || viewport.offsetWidth || 1);
+        return Math.max(0, Math.min(slideCount - 1, Math.round(Number(viewport.scrollLeft || 0) / width)));
+      };
+      const setIndex = (index, reason = 'api') => {
+        const nextIndex = Math.max(0, Math.min(slideCount - 1, Number.isFinite(index) ? index : 0));
+        carousel.dataset.gemCarouselIndex = String(nextIndex);
+        carousel.dataset.gemCarouselCount = String(slideCount);
+        if (viewport && viewport.scrollTo) viewport.scrollTo({ left: Number(viewport.clientWidth || viewport.offsetWidth || 0) * nextIndex, behavior: 'smooth' });
+        api.emit('gem:carousel:change', { source: 'gem-runtime', id: carousel.id || undefined, index: nextIndex, count: slideCount, reason });
+      };
+      slides.forEach((slide, index) => { if (slide.dataset) slide.dataset.gemCarouselIndex = String(index); });
+      carousel.dataset.gemCarouselState = slideCount > 1 ? 'ready' : 'single';
+      carousel.dataset.gemCarouselCount = String(slideCount);
+      carousel.dataset.gemCarouselIndex = String(currentIndex());
+      if (canListen(previous)) __gemListen(previous, 'click', (event) => { event.preventDefault && event.preventDefault(); setIndex(currentIndex() - 1, 'previous'); });
+      if (canListen(next)) __gemListen(next, 'click', (event) => { event.preventDefault && event.preventDefault(); setIndex(currentIndex() + 1, 'next'); });
+      if (canListen(viewport)) __gemListen(viewport, 'scroll', () => { carousel.dataset.gemCarouselIndex = String(currentIndex()); }, { passive: true });
+      bound += 1;
+    });
+    api.emit('gem:carousel:ready', { source: 'gem-runtime', count: bound });
+  });
+}
+
+/** Bind every "carousel" hook inside root (default: the whole document). Returns unmount(). Mounting the same root twice binds once. */
+export function mount(root, options) {
+  return mountPlugin(key, install, root, options);
+}
+
+export default mount;

package/dist/plugins/cart-drawer.d.ts

@@ -0,0 +1,9 @@
+// @gemboss/gem-framework/plugins/cart-drawer: types of the ES module next to this file. Generated; do not edit here.
+import type { MountOptions, Unmount } from "../runtime-core.js";
+
+export type { MountOptions, Unmount };
+export declare const key: "cart-drawer";
+export declare const readyEvent: "gem:cart:ready";
+/** Bind every "cart-drawer" hook inside root (default: the whole document). Returns unmount(). Mounting the same root twice binds once. */
+export declare function mount(root?: ParentNode | null, options?: MountOptions): Unmount;
+export default mount;

package/dist/plugins/cart-drawer.js

@@ -0,0 +1,69 @@
+// @gemboss/gem-framework/plugins/cart-drawer: the gem-runtime plugin "cart-drawer" as an ES module. Generated from
+// packages/gem-framework/src/runtime.ts, the same lines gem-runtime.js carries; do not edit here.
+import { mountPlugin } from "../runtime-core.js";
+
+export const key = "cart-drawer";
+export const readyEvent = "gem:cart:ready";
+
+function install({ document, window, target, mark, canListen, listen: __gemListen, registerPlugin, registerNoopPlugin }) {
+  registerPlugin('cart-drawer', ({ api }) => {
+    const drawers = document.querySelectorAll('[data-gem-cart-drawer], [data-gem-cart-canvas], .gem-cart-drawer');
+    const cartLinks = document.querySelectorAll('[data-gem-cart-drawer-trigger], [data-gem-cart-toggle], a[href*="/cart"]');
+    const cartForms = document.querySelectorAll('form[action*="/cart/add"], form[action*="/cart"]');
+    const drawer = drawers[0];
+    const setDrawerA11y = (isOpen) => {
+      if (!drawer) return;
+      drawer.setAttribute && drawer.setAttribute('aria-expanded', isOpen ? 'true' : 'false');
+      const panel = drawer.querySelector && drawer.querySelector('[data-gem-cart-canvas-panel], .gem-cart-drawer__panel');
+      if (panel && panel.setAttribute) panel.setAttribute('aria-hidden', isOpen ? 'false' : 'true');
+    };
+    const openDrawer = (reason, href) => {
+      if (drawer && drawer.tagName === 'DETAILS') drawer.open = true;
+      if (drawer && drawer.dataset) drawer.dataset.gemCartDrawerState = 'open';
+      setDrawerA11y(true);
+      api.emit('gem:cart:open', { source: 'gem-runtime', reason, href });
+    };
+    const closeDrawer = (reason) => {
+      if (drawer && drawer.tagName === 'DETAILS') drawer.open = false;
+      if (drawer && drawer.dataset) drawer.dataset.gemCartDrawerState = 'closed';
+      setDrawerA11y(false);
+      api.emit('gem:cart:close', { source: 'gem-runtime', reason });
+    };
+    let bound = 0;
+    drawers.forEach((drawer) => {
+      if (!mark(drawer, 'cart-drawer')) return;
+      drawer.dataset.gemCartDrawerState = drawer.hasAttribute('open') ? 'open' : 'ready';
+      setDrawerA11y(drawer.hasAttribute('open'));
+      drawer.querySelectorAll('[data-gem-cart-drawer-close], [data-gem-cart-canvas-close]').forEach((control) => { if (!canListen(control)) return; __gemListen(control, 'click', (event) => {
+        event.preventDefault && event.preventDefault();
+        closeDrawer('close-control');
+      }); });
+      if (canListen(drawer)) __gemListen(drawer, 'toggle', () => { drawer.dataset.gemCartDrawerState = drawer.hasAttribute('open') ? 'open' : 'closed'; });
+      bound += 1;
+    });
+    cartLinks.forEach((link) => {
+      if (!mark(link, 'cart-link')) return;
+      if (!canListen(link)) return;
+      __gemListen(link, 'click', (event) => {
+        if (drawer && (link.hasAttribute('data-gem-cart-drawer-trigger') || link.hasAttribute('data-gem-cart-toggle'))) event.preventDefault && event.preventDefault();
+        openDrawer('cart-link', link.href || undefined);
+      });
+      bound += 1;
+    });
+    if (canListen(document)) __gemListen(document, 'keydown', (event) => { if (event.key === 'Escape' && drawer && drawer.hasAttribute('open')) closeDrawer('escape'); });
+    cartForms.forEach((form) => {
+      if (!mark(form, 'cart-form')) return;
+      if (!canListen(form)) return;
+      __gemListen(form, 'submit', () => api.emit('gem:cart:submit', { source: 'gem-runtime', action: form.getAttribute('action') || undefined }));
+      bound += 1;
+    });
+    api.emit('gem:cart:ready', { source: 'gem-runtime', count: bound });
+  });
+}
+
+/** Bind every "cart-drawer" hook inside root (default: the whole document). Returns unmount(). Mounting the same root twice binds once. */
+export function mount(root, options) {
+  return mountPlugin(key, install, root, options);
+}
+
+export default mount;

package/dist/plugins/context-adapter.d.ts

@@ -0,0 +1,9 @@
+// @gemboss/gem-framework/plugins/context-adapter: types of the ES module next to this file. Generated; do not edit here.
+import type { MountOptions, Unmount } from "../runtime-core.js";
+
+export type { MountOptions, Unmount };
+export declare const key: "context-adapter";
+export declare const readyEvent: "gem:context:ready";
+/** Bind every "context-adapter" hook inside root (default: the whole document). Returns unmount(). Mounting the same root twice binds once. */
+export declare function mount(root?: ParentNode | null, options?: MountOptions): Unmount;
+export default mount;

package/dist/plugins/context-adapter.js

@@ -0,0 +1,17 @@
+// @gemboss/gem-framework/plugins/context-adapter: the gem-runtime plugin "context-adapter" as an ES module. Generated from
+// packages/gem-framework/src/runtime.ts, the same lines gem-runtime.js carries; do not edit here.
+import { mountPlugin } from "../runtime-core.js";
+
+export const key = "context-adapter";
+export const readyEvent = "gem:context:ready";
+
+function install({ document, window, target, mark, canListen, listen: __gemListen, registerPlugin, registerNoopPlugin }) {
+  registerNoopPlugin("context-adapter", "gem:context:ready");
+}
+
+/** Bind every "context-adapter" hook inside root (default: the whole document). Returns unmount(). Mounting the same root twice binds once. */
+export function mount(root, options) {
+  return mountPlugin(key, install, root, options);
+}
+
+export default mount;

package/dist/plugins/countdown.d.ts

@@ -0,0 +1,9 @@
+// @gemboss/gem-framework/plugins/countdown: types of the ES module next to this file. Generated; do not edit here.
+import type { MountOptions, Unmount } from "../runtime-core.js";
+
+export type { MountOptions, Unmount };
+export declare const key: "countdown";
+export declare const readyEvent: "gem:countdown:ready";
+/** Bind every "countdown" hook inside root (default: the whole document). Returns unmount(). Mounting the same root twice binds once. */
+export declare function mount(root?: ParentNode | null, options?: MountOptions): Unmount;
+export default mount;

package/dist/plugins/countdown.js

@@ -0,0 +1,164 @@
+// @gemboss/gem-framework/plugins/countdown: the gem-runtime plugin "countdown" as an ES module. Generated from
+// packages/gem-framework/src/runtime.ts, the same lines gem-runtime.js carries; do not edit here.
+import { mountPlugin } from "../runtime-core.js";
+
+export const key = "countdown";
+export const readyEvent = "gem:countdown:ready";
+
+function install({ document, window, target, mark, canListen, listen: __gemListen, registerPlugin, registerNoopPlugin }) {
+  registerPlugin('countdown', ({ api }) => {
+    const timers = document.querySelectorAll('[data-gem-countdown], .gem-countdown');
+    let bound = 0;
+    const pad = (value) => String(Math.max(0, value)).padStart(2, '0');
+    const COUNTDOWN_ISO = /^(\d{4})-(\d{2})-(\d{2})(?:[T ](\d{2}):(\d{2})(?::(\d{2})(?:\.\d+)?)?(Z|[+-]\d{2}:?\d{2})?)?$/i;
+    const countdownEnd = (value) => {
+      if (typeof value !== 'string') return NaN;
+      const raw = value.trim();
+      const m = COUNTDOWN_ISO.exec(raw);
+      if (!m) return NaN;
+      const y = Number(m[1]), mo = Number(m[2]), d = Number(m[3]);
+      const day = new Date(Date.UTC(y, mo - 1, d));
+      if (day.getUTCFullYear() !== y || day.getUTCMonth() !== mo - 1 || day.getUTCDate() !== d) return NaN;
+      if (m[4] === undefined) return Date.parse(m[1] + '-' + m[2] + '-' + m[3] + 'T23:59:59Z');
+      const iso = m[1] + '-' + m[2] + '-' + m[3] + 'T' + raw.slice(11);
+      return Date.parse(m[7] ? iso : iso + 'Z');
+    };
+    const write = (timer, selector, value) => {
+      const targetNode = timer.querySelector && timer.querySelector(selector);
+      if (targetNode) targetNode.textContent = pad(value);
+    };
+    const clockText = (s) => {
+      const h = Math.floor(s / 3600), m = Math.floor((s % 3600) / 60), sec = s % 60;
+      return (h ? h + ':' + pad(m) : String(m)) + ':' + pad(sec);
+    };
+    const bindDuration = (timer, total) => {
+      const scope = (timer.closest && timer.closest('[data-gem-section-id]')) || document;
+      const mode = String(timer.getAttribute('data-gem-countdown-start') || 'mount').trim() || 'mount';
+      const stopEvent = String(timer.getAttribute('data-gem-countdown-stop') || '').trim();
+      let left = total * 1000;
+      let endAt = 0;
+      let handle = null;
+      let state = 'idle';
+      let started = false;
+      let observer = null;
+      const release = () => { if (observer) { observer.disconnect(); observer = null; } };
+      const detail = () => ({ source: 'gem-runtime', id: timer.id || undefined, mode: 'duration', duration: total, remainingSeconds: Math.max(0, Math.ceil(left / 1000)) });
+      const render = () => {
+        const s = Math.max(0, Math.ceil(left / 1000));
+        timer.dataset.gemCountdownState = state;
+        timer.dataset.gemCountdownRemainingSeconds = String(s);
+        write(timer, '[data-gem-countdown-days]', Math.floor(s / 86400));
+        write(timer, '[data-gem-countdown-hours]', Math.floor((s % 86400) / 3600));
+        write(timer, '[data-gem-countdown-minutes]', Math.floor((s % 3600) / 60));
+        write(timer, '[data-gem-countdown-seconds]', s % 60);
+        const readout = timer.querySelector && timer.querySelector('[data-gem-countdown-clock]');
+        if (readout) readout.textContent = clockText(s);
+      };
+      const halt = () => { if (handle !== null && target.clearInterval) target.clearInterval(handle); handle = null; };
+      const finish = () => {
+        halt();
+        release();
+        left = 0;
+        state = 'complete';
+        render();
+        timer.setAttribute('data-gem-countdown-ended', 'true');
+        if (timer.dispatchEvent && timer.isConnected !== false) {
+          timer.dispatchEvent(new CustomEvent('gem:countdown:complete', { bubbles: true, detail: detail() }));
+          for (const callback of api.listeners['gem:countdown:complete'] || []) callback(detail());
+        } else api.emit('gem:countdown:complete', detail());
+      };
+      const tick = () => { left = endAt - Date.now(); if (left <= 0) finish(); else render(); };
+      const run = () => {
+        if (state === 'running' || state === 'complete' || state === 'stopped') return;
+        state = 'running';
+        endAt = Date.now() + left;
+        render();
+        if (target.setInterval) handle = target.setInterval(tick, 250);
+        if (!started) { started = true; api.emit('gem:countdown:start', detail()); }
+      };
+      const pause = (next) => {
+        if (state === 'running') { left = Math.max(0, endAt - Date.now()); halt(); }
+        if (state === 'complete' || state === 'stopped') return;
+        state = next;
+        if (next === 'stopped') release();
+        render();
+      };
+      render();
+      if (stopEvent && canListen(scope)) __gemListen(scope, stopEvent, () => pause('stopped'));
+      if (mode === 'visible' && target.IntersectionObserver) {
+        observer = new target.IntersectionObserver((entries) => {
+          for (const entry of entries) entry.isIntersecting ? run() : pause('paused');
+        });
+        observer.observe(timer);
+      } else if (mode === 'mount' || mode === 'visible') run();
+      else if (canListen(scope)) __gemListen(scope, mode, run);
+    };
+    timers.forEach((timer) => {
+      if (!mark(timer, 'countdown')) return;
+      const duration = Number(timer.getAttribute && timer.getAttribute('data-gem-countdown-duration'));
+      if (Number.isFinite(duration) && duration > 0) {
+        bindDuration(timer, Math.min(Math.round(duration), 86400));
+        bound += 1;
+        return;
+      }
+      const targetTime = countdownEnd(timer.getAttribute && timer.getAttribute('data-gem-countdown-target'));
+      const section = timer.closest ? timer.closest('[data-gem-section-id]') : null;
+      const band = section && section.hasAttribute && section.hasAttribute('data-gem-countdown-end') ? section : null;
+      const hasSecondsCell = Boolean(timer.querySelector && (timer.querySelector('[data-gem-cd-secs]') || timer.querySelector('[data-gem-countdown-seconds]')));
+      let handle = null;
+      let announced = '';
+      const update = () => {
+        if (!Number.isFinite(targetTime)) {
+          timer.dataset.gemCountdownState = 'invalid';
+          return;
+        }
+        const ms = targetTime - Date.now();
+        const remainingSeconds = Math.max(0, Math.floor(ms / 1000));
+        const days = Math.floor(remainingSeconds / 86400);
+        const hours = Math.floor((remainingSeconds % 86400) / 3600);
+        const minutes = Math.floor((remainingSeconds % 3600) / 60);
+        const seconds = remainingSeconds % 60;
+        timer.dataset.gemCountdownState = ms > 0 ? 'running' : 'complete';
+        timer.dataset.gemCountdownRemainingSeconds = String(remainingSeconds);
+        write(timer, '[data-gem-countdown-days]', days);
+        write(timer, '[data-gem-countdown-hours]', hours);
+        write(timer, '[data-gem-countdown-minutes]', minutes);
+        write(timer, '[data-gem-countdown-seconds]', seconds);
+        write(timer, '[data-gem-cd-days]', days);
+        write(timer, '[data-gem-cd-hours]', hours);
+        write(timer, '[data-gem-cd-mins]', minutes);
+        write(timer, '[data-gem-cd-secs]', seconds);
+        if (ms <= 0) {
+          if (band) band.setAttribute('data-gem-countdown-ended', 'true');
+          if (timer.setAttribute && !(timer.hasAttribute && timer.hasAttribute('data-gem-section-id'))) timer.setAttribute('data-gem-countdown-ended', 'true');
+          if (handle !== null && target.clearInterval) { target.clearInterval(handle); handle = null; }
+        }
+        const event = ms > 0 ? 'gem:countdown:start' : 'gem:countdown:complete';
+        if (event === announced && (event === 'gem:countdown:complete' || hasSecondsCell)) return;
+        announced = event;
+        api.emit(event, { source: 'gem-runtime', id: timer.id || undefined, remainingSeconds });
+      };
+      const onTheMinute = () => {
+        const ms = targetTime - Date.now();
+        if (!(ms > 0) || !target.setTimeout) return;
+        target.setTimeout(() => { update(); onTheMinute(); }, Math.min((ms % 60000) + 5, ms));
+      };
+      update();
+      if (Number.isFinite(targetTime) && targetTime - Date.now() > 0) {
+        if (!hasSecondsCell) onTheMinute();
+        else if (target.setInterval) handle = target.setInterval(update, 1000);
+      }
+      const left = targetTime - Date.now();
+      if (target.setTimeout && Number.isFinite(left) && left > 0 && left < 2147483647) target.setTimeout(update, left);
+      bound += 1;
+    });
+    api.emit('gem:countdown:ready', { source: 'gem-runtime', count: bound });
+  });
+}
+
+/** Bind every "countdown" hook inside root (default: the whole document). Returns unmount(). Mounting the same root twice binds once. */
+export function mount(root, options) {
+  return mountPlugin(key, install, root, options);
+}
+
+export default mount;

package/dist/plugins/disclosure.d.ts

@@ -0,0 +1,9 @@
+// @gemboss/gem-framework/plugins/disclosure: types of the ES module next to this file. Generated; do not edit here.
+import type { MountOptions, Unmount } from "../runtime-core.js";
+
+export type { MountOptions, Unmount };
+export declare const key: "disclosure";
+export declare const readyEvent: "gem:disclosure:ready";
+/** Bind every "disclosure" hook inside root (default: the whole document). Returns unmount(). Mounting the same root twice binds once. */
+export declare function mount(root?: ParentNode | null, options?: MountOptions): Unmount;
+export default mount;

package/dist/plugins/disclosure.js

@@ -0,0 +1,40 @@
+// @gemboss/gem-framework/plugins/disclosure: the gem-runtime plugin "disclosure" as an ES module. Generated from
+// packages/gem-framework/src/runtime.ts, the same lines gem-runtime.js carries; do not edit here.
+import { mountPlugin } from "../runtime-core.js";
+
+export const key = "disclosure";
+export const readyEvent = "gem:disclosure:ready";
+
+function install({ document, window, target, mark, canListen, listen: __gemListen, registerPlugin, registerNoopPlugin }) {
+  registerPlugin('disclosure', ({ api }) => {
+    const items = document.querySelectorAll('details[data-gem-disclosure], .gem-accordion details, .gem-tabs details, .gem-footer-shell details, [data-gem-footer-shell] details');
+    let bound = 0;
+    items.forEach((item) => {
+      if (!mark(item, 'disclosure')) return;
+      item.dataset.gemDisclosureState = item.open ? 'open' : 'closed';
+      if (!canListen(item)) return;
+      __gemListen(item, 'toggle', () => {
+        item.dataset.gemDisclosureState = item.open ? 'open' : 'closed';
+        api.emit(item.open ? 'gem:disclosure:open' : 'gem:disclosure:close', { source: 'gem-runtime', id: item.id || undefined });
+      });
+      __gemListen(item, 'keydown', (event) => {
+        if (event.key !== 'Escape' || !item.open) return;
+        event.preventDefault && event.preventDefault();
+        item.open = false;
+        item.dataset.gemDisclosureState = 'closed';
+        const summary = item.querySelector && item.querySelector('summary');
+        if (summary && summary.focus) summary.focus();
+        api.emit('gem:disclosure:close', { source: 'gem-runtime', id: item.id || undefined, reason: 'escape' });
+      });
+      bound += 1;
+    });
+    api.emit('gem:disclosure:ready', { source: 'gem-runtime', count: bound });
+  });
+}
+
+/** Bind every "disclosure" hook inside root (default: the whole document). Returns unmount(). Mounting the same root twice binds once. */
+export function mount(root, options) {
+  return mountPlugin(key, install, root, options);
+}
+
+export default mount;

package/dist/plugins/hero-slideshow.d.ts

@@ -0,0 +1,9 @@
+// @gemboss/gem-framework/plugins/hero-slideshow: types of the ES module next to this file. Generated; do not edit here.
+import type { MountOptions, Unmount } from "../runtime-core.js";
+
+export type { MountOptions, Unmount };
+export declare const key: "hero-slideshow";
+export declare const readyEvent: "gem:hero-slideshow:ready";
+/** Bind every "hero-slideshow" hook inside root (default: the whole document). Returns unmount(). Mounting the same root twice binds once. */
+export declare function mount(root?: ParentNode | null, options?: MountOptions): Unmount;
+export default mount;

package/dist/plugins/hero-slideshow.js

@@ -0,0 +1,57 @@
+// @gemboss/gem-framework/plugins/hero-slideshow: the gem-runtime plugin "hero-slideshow" as an ES module. Generated from
+// packages/gem-framework/src/runtime.ts, the same lines gem-runtime.js carries; do not edit here.
+import { mountPlugin } from "../runtime-core.js";
+
+export const key = "hero-slideshow";
+export const readyEvent = "gem:hero-slideshow:ready";
+
+function install({ document, window, target, mark, canListen, listen: __gemListen, registerPlugin, registerNoopPlugin }) {
+  registerPlugin('hero-slideshow', ({ api }) => {
+    const roots = document.querySelectorAll('[data-gem-hero-slideshow]');
+    let bound = 0;
+    roots.forEach((root) => {
+      if (!mark(root, 'hero-slideshow')) return;
+      const slides = Array.prototype.slice.call(root.querySelectorAll('[data-gem-hero-slide]'));
+      if (slides.length < 2) return;
+      const dots = Array.prototype.slice.call(root.querySelectorAll('[data-gem-hero-dot]'));
+      const previous = root.querySelector && root.querySelector('[data-gem-hero-prev]');
+      const next = root.querySelector && root.querySelector('[data-gem-hero-next]');
+      const pause = root.querySelector && root.querySelector('[data-gem-hero-pause]');
+      const reduce = window.matchMedia && window.matchMedia('(prefers-reduced-motion: reduce)').matches;
+      const autoplay = !!(root.dataset && root.dataset.autoplay === 'true') && !reduce;
+      const interval = Math.max(Number((root.dataset && root.dataset.autoplayInterval) || 6000), 4000);
+      let active = 0;
+      for (let i = 0; i < slides.length; i += 1) { if ((slides[i].className || '').indexOf('gem-hero-slideshow__slide--active') > -1) { active = i; break; } }
+      let timer = null; let paused = false;
+      const show = (index) => {
+        active = (index + slides.length) % slides.length;
+        slides.forEach((s, i) => { const on = i === active; if (s.classList) s.classList.toggle('gem-hero-slideshow__slide--active', on); s.hidden = !on; });
+        dots.forEach((d, i) => { const on = i === active; if (d.classList) d.classList.toggle('gem-hero-slideshow__dot--active', on); if (d.setAttribute) { d.setAttribute('aria-selected', String(on)); d.setAttribute('tabindex', on ? '0' : '-1'); } });
+        api.emit('gem:hero-slideshow:change', { source: 'gem-runtime', id: root.id || undefined, index: active, count: slides.length });
+      };
+      const stop = () => { if (timer) { window.clearInterval(timer); timer = null; } };
+      const start = () => { stop(); if (autoplay && !paused) timer = window.setInterval(() => { show(active + 1); }, interval); };
+      if (canListen(previous)) __gemListen(previous, 'click', (e) => { if (e.preventDefault) e.preventDefault(); show(active - 1); start(); });
+      if (canListen(next)) __gemListen(next, 'click', (e) => { if (e.preventDefault) e.preventDefault(); show(active + 1); start(); });
+      dots.forEach((d, i) => { if (canListen(d)) __gemListen(d, 'click', () => { show(Number((d.dataset && d.dataset.slideIndex) || i)); start(); }); });
+      const focusDot = (i) => { const n = dots.length; if (!n) return; const k = ((i % n) + n) % n; show(k); start(); if (dots[k].focus) dots[k].focus(); };
+      dots.forEach((d, i) => { if (canListen(d)) __gemListen(d, 'keydown', (e) => {
+        const k = e.key;
+        if (k === 'ArrowRight' || k === 'ArrowDown') { if (e.preventDefault) e.preventDefault(); focusDot(i + 1); }
+        else if (k === 'ArrowLeft' || k === 'ArrowUp') { if (e.preventDefault) e.preventDefault(); focusDot(i - 1); }
+        else if (k === 'Home') { if (e.preventDefault) e.preventDefault(); focusDot(0); }
+        else if (k === 'End') { if (e.preventDefault) e.preventDefault(); focusDot(dots.length - 1); }
+      }); });
+      if (canListen(pause)) __gemListen(pause, 'click', () => { paused = !paused; if (pause.setAttribute) pause.setAttribute('aria-pressed', String(paused)); start(); });
+      show(active); start(); bound += 1;
+    });
+    api.emit('gem:hero-slideshow:ready', { source: 'gem-runtime', count: bound });
+  });
+}
+
+/** Bind every "hero-slideshow" hook inside root (default: the whole document). Returns unmount(). Mounting the same root twice binds once. */
+export function mount(root, options) {
+  return mountPlugin(key, install, root, options);
+}
+
+export default mount;

package/dist/plugins/localization.d.ts

@@ -0,0 +1,9 @@
+// @gemboss/gem-framework/plugins/localization: types of the ES module next to this file. Generated; do not edit here.
+import type { MountOptions, Unmount } from "../runtime-core.js";
+
+export type { MountOptions, Unmount };
+export declare const key: "localization";
+export declare const readyEvent: "gem:localization:ready";
+/** Bind every "localization" hook inside root (default: the whole document). Returns unmount(). Mounting the same root twice binds once. */
+export declare function mount(root?: ParentNode | null, options?: MountOptions): Unmount;
+export default mount;

package/dist/plugins/localization.js

@@ -0,0 +1,37 @@
+// @gemboss/gem-framework/plugins/localization: the gem-runtime plugin "localization" as an ES module. Generated from
+// packages/gem-framework/src/runtime.ts, the same lines gem-runtime.js carries; do not edit here.
+import { mountPlugin } from "../runtime-core.js";
+
+export const key = "localization";
+export const readyEvent = "gem:localization:ready";
+
+function install({ document, window, target, mark, canListen, listen: __gemListen, registerPlugin, registerNoopPlugin }) {
+  registerPlugin('localization', ({ api }) => {
+    const forms = document.querySelectorAll('form[action*="/localization"], form[action*="localization"], [data-gem-footer-localization], [data-gem-header-localization], .gem-navigation-shell__localization, .gem-shell-footer__localization, .gem-shell-header__localization-form');
+    let bound = 0;
+    forms.forEach((form) => {
+      if (!mark(form, 'localization')) return;
+      form.dataset && (form.dataset.gemLocalizationState = 'ready');
+      form.querySelectorAll && form.querySelectorAll('select[name="country_code"], select[name="locale_code"]').forEach((select) => {
+        if (!canListen(select)) return;
+        __gemListen(select, 'change', () => {
+          form.dataset && (form.dataset.gemLocalizationState = 'changed');
+          api.emit('gem:localization:change', { source: 'gem-runtime', name: select.name || undefined, value: select.value || undefined });
+        });
+      });
+      canListen(form) && __gemListen(form, 'submit', () => {
+        form.dataset && (form.dataset.gemLocalizationState = 'submit');
+        api.emit('gem:localization:submit', { source: 'gem-runtime' });
+      });
+      bound += 1;
+    });
+    api.emit('gem:localization:ready', { source: 'gem-runtime', count: bound });
+  });
+}
+
+/** Bind every "localization" hook inside root (default: the whole document). Returns unmount(). Mounting the same root twice binds once. */
+export function mount(root, options) {
+  return mountPlugin(key, install, root, options);
+}
+
+export default mount;

package/dist/plugins/media-gallery.d.ts

@@ -0,0 +1,9 @@
+// @gemboss/gem-framework/plugins/media-gallery: types of the ES module next to this file. Generated; do not edit here.
+import type { MountOptions, Unmount } from "../runtime-core.js";
+
+export type { MountOptions, Unmount };
+export declare const key: "media-gallery";
+export declare const readyEvent: "gem:media:ready";
+/** Bind every "media-gallery" hook inside root (default: the whole document). Returns unmount(). Mounting the same root twice binds once. */
+export declare function mount(root?: ParentNode | null, options?: MountOptions): Unmount;
+export default mount;

package/dist/plugins/media-gallery.js

@@ -0,0 +1,57 @@
+// @gemboss/gem-framework/plugins/media-gallery: the gem-runtime plugin "media-gallery" as an ES module. Generated from
+// packages/gem-framework/src/runtime.ts, the same lines gem-runtime.js carries; do not edit here.
+import { mountPlugin } from "../runtime-core.js";
+
+export const key = "media-gallery";
+export const readyEvent = "gem:media:ready";
+
+function install({ document, window, target, mark, canListen, listen: __gemListen, registerPlugin, registerNoopPlugin }) {
+  registerPlugin('media-gallery', ({ api }) => {
+    const galleries = document.querySelectorAll('[data-gem-media-gallery], .gem-media-gallery, .gem-product-media-gallery');
+    let bound = 0;
+    galleries.forEach((gallery) => {
+      if (!mark(gallery, 'media-gallery')) return;
+      const items = gallery.querySelectorAll('[data-gem-media-item], img, video, model-viewer');
+      const thumbControls = gallery.querySelectorAll('[data-gem-media-thumb]');
+      const controls = thumbControls.length ? thumbControls : items;
+      gallery.dataset.gemMediaState = 'ready';
+      items.forEach((item, index) => {
+        if (!item.dataset) return;
+        item.dataset.gemMediaIndex = String(index);
+      });
+      const activate = (target, reason = 'click') => {
+        if (!target) return;
+        const index = target.dataset && target.dataset.gemMediaIndex ? Number(target.dataset.gemMediaIndex) : undefined;
+        if (!Number.isFinite(index)) return;
+        controls.forEach((control) => {
+          const isActive = control.dataset && Number(control.dataset.gemMediaIndex) === index;
+          if (isActive) control.setAttribute('aria-current', 'true'); else control.removeAttribute('aria-current');
+          if (control.dataset) control.dataset.gemMediaActive = isActive ? 'true' : 'false';
+        });
+        gallery.dataset.gemMediaActiveIndex = String(index);
+        api.emit('gem:media:change', { source: 'gem-runtime', index, galleryId: gallery.id || undefined, reason });
+      };
+      const firstActive = gallery.querySelector('[aria-current="true"], [data-gem-media-thumb]');
+      if (firstActive) activate(firstActive, 'init');
+      if (canListen(gallery)) __gemListen(gallery, 'click', (event) => {
+        const target = event.target && event.target.closest ? event.target.closest('[data-gem-media-item], img, video, model-viewer') : null;
+        if (!target) return;
+        activate(target, 'click');
+      });
+      controls.forEach((control) => { if (!canListen(control)) return; __gemListen(control, 'keydown', (event) => {
+        if (!['Enter', ' '].includes(event.key)) return;
+        event.preventDefault && event.preventDefault();
+        activate(control, 'keyboard');
+      }); });
+      bound += 1;
+    });
+    api.emit('gem:media:ready', { source: 'gem-runtime', count: bound });
+  });
+}
+
+/** Bind every "media-gallery" hook inside root (default: the whole document). Returns unmount(). Mounting the same root twice binds once. */
+export function mount(root, options) {
+  return mountPlugin(key, install, root, options);
+}
+
+export default mount;