@gemboss/gem-framework 0.6.0 → 0.9.0

package/dist/plugins/mobile-menu.d.ts

@@ -0,0 +1,9 @@
+// @gemboss/gem-framework/plugins/mobile-menu: 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: "mobile-menu";
+export declare const readyEvent: "gem:menu:ready";
+/** Bind every "mobile-menu" 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/mobile-menu.js

@@ -0,0 +1,51 @@
+// @gemboss/gem-framework/plugins/mobile-menu: the gem-runtime plugin "mobile-menu" 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 = "mobile-menu";
+export const readyEvent = "gem:menu:ready";
+
+function install({ document, window, target, mark, canListen, listen: __gemListen, registerPlugin, registerNoopPlugin }) {
+  registerPlugin('mobile-menu', ({ api }) => {
+    const menus = document.querySelectorAll('[data-gem-mobile-menu], details.gem-shell-header__drawer');
+    let bound = 0;
+    menus.forEach((menu) => {
+      if (!mark(menu, 'mobile-menu')) return;
+      const setMenuA11y = () => {
+        menu.setAttribute && menu.setAttribute('aria-expanded', menu.open ? 'true' : 'false');
+        const panel = menu.querySelector && menu.querySelector('[data-gem-mobile-menu-panel], .gem-shell-header__drawer-panel');
+        if (panel && panel.setAttribute) panel.setAttribute('aria-hidden', menu.open ? 'false' : 'true');
+      };
+      menu.dataset.gemMenuState = menu.open ? 'open' : 'closed';
+      setMenuA11y();
+      if (!canListen(menu)) return;
+      __gemListen(menu, 'toggle', () => {
+        menu.dataset.gemMenuState = menu.open ? 'open' : 'closed';
+        setMenuA11y();
+        if (menu.open) {
+          const panel = menu.querySelector && menu.querySelector('[data-gem-mobile-menu-panel], .gem-shell-header__drawer-panel');
+          const firstFocusable = panel && panel.querySelector && panel.querySelector('a[href], button, select, input, textarea, summary, [tabindex]:not([tabindex="-1"])');
+          if (firstFocusable && firstFocusable.focus) firstFocusable.focus();
+        }
+        api.emit(menu.open ? 'gem:menu:open' : 'gem:menu:close', { source: 'gem-runtime', id: menu.id || undefined });
+      });
+      __gemListen(menu, 'keydown', (event) => {
+        if (event.key !== 'Escape' || !menu.open) return;
+        menu.open = false;
+        menu.dataset.gemMenuState = 'closed';
+        setMenuA11y();
+        const summary = menu.querySelector && menu.querySelector('summary');
+        if (summary && summary.focus) summary.focus();
+      });
+      bound += 1;
+    });
+    api.emit('gem:menu:ready', { source: 'gem-runtime', count: bound });
+  });
+}
+
+/** Bind every "mobile-menu" 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/offer-engine.d.ts

@@ -0,0 +1,9 @@
+// @gemboss/gem-framework/plugins/offer-engine: 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: "offer-engine";
+export declare const readyEvent: "gem:offer:ready";
+/** Bind every "offer-engine" 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/offer-engine.js

@@ -0,0 +1,57 @@
+// @gemboss/gem-framework/plugins/offer-engine: the gem-runtime plugin "offer-engine" 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 = "offer-engine";
+export const readyEvent = "gem:offer:ready";
+
+function install({ document, window, target, mark, canListen, listen: __gemListen, registerPlugin, registerNoopPlugin }) {
+  registerPlugin('offer-engine', ({ api }) => {
+    (function(){
+  document.querySelectorAll('[data-gem-offer-engine]').forEach(function(root){
+    if(root.__gemOffer)return; root.__gemOffer=1;
+    var el=root.querySelector('[data-gem-offer-model]'); if(!el)return;
+    var model; try{model=JSON.parse(el.textContent);}catch(e){return;}
+    var dims=model.dimensions||{}, sel={};
+    Object.keys(dims).forEach(function(d){var o=(dims[d].options||[]),def=o.filter(function(x){return x.default;})[0]||o[0];sel[d]=(model.default_selection&&model.default_selection[d])||(def&&def.id);});
+    function m(w){return Object.keys(w).every(function(k){return sel[k]===w[k];});}
+    function sp(w){return Object.keys(w).length;}
+    function pick(list){return (list||[]).filter(function(r){return m(r.when);}).sort(function(a,b){return sp(b.when)-sp(a.when);})[0];}
+    function gift(g,t){if(!g||t==null)return null;var sym=g.currency_symbol||'$';var rem=Math.max(0,Math.round((g.threshold-t)*100)/100);var unl=rem<=0;var rs=sym+rem.toFixed(2);var pct=g.threshold>0?Math.max(0,Math.min(100,Math.round((t/g.threshold)*100))):100;var tpl=unl?(g.unlocked_text||'\uD83C\uDF81 {label} unlocked!'):(g.locked_text||'Add {remaining} more to unlock {label}');return {unlocked:unl,remaining:rs,remaining_amount:rem,percent:pct,text:tpl.replace('{remaining}',rs).replace('{label}',g.label)};}
+    function render(){
+      var row=pick(model.price_matrix)||{}, plan=pick(model.selling_plan_map);
+      var vis={}; Object.keys(dims).forEach(function(d){vis[d]=true;});
+      (model.conditions||[]).forEach(function(c){vis[c.show]=(sel[c.when_dim]===c.equals);});
+      (model.panels||[]).forEach(function(p){if(p.when)vis[p.id]=(sel[p.when.when_dim]===p.when.equals);});
+      var headline=row.total||row.price||'';
+      var gf=gift(model.gift,row.total_amount);
+      root.querySelectorAll('[data-gem-offer-out]').forEach(function(o){var k=o.getAttribute('data-gem-offer-out');
+        if(k==='price')o.textContent=row.price||'';
+        else if(k==='compare'){o.textContent=row.compare_at||'';o.style.display=row.compare_at?'':'none';}
+        else if(k==='save'){o.textContent=row.save_label||'';o.style.display=row.save_label?'':'none';}
+        else if(k==='gift'){o.textContent=gf?gf.text:'';if(o.classList)o.classList.toggle('unlocked',!!(gf&&gf.unlocked));}
+        else if(k==='cta')o.textContent=(model.cta_template||'Add to cart').replace('{price}',headline).replace('{total}',headline);});
+      root.querySelectorAll('[data-gem-offer-gift]').forEach(function(w){w.style.display=gf?'':'none';if(w.classList)w.classList.toggle('unlocked',!!(gf&&gf.unlocked));});
+      root.querySelectorAll('[data-gem-offer-gift-bar]').forEach(function(b){b.style.width=(gf?gf.percent:0)+'%';});
+      root.querySelectorAll('[data-gem-offer-group]').forEach(function(g){g.style.display=(vis[g.getAttribute('data-gem-offer-group')]===false)?'none':'';});
+      root.querySelectorAll('[data-gem-offer-dim]').forEach(function(b){var d=b.getAttribute('data-gem-offer-dim'),v=b.getAttribute('data-gem-offer-value');if(b.tagName==='OPTION'){b.selected=(sel[d]===v);}else{b.classList.toggle('sel',sel[d]===v);}});
+      var s=root.querySelector('[data-gem-offer-selling-plan]'); if(s)s.value=(plan&&plan.selling_plan_id)||'';
+      var ca=(plan&&plan.cart_attributes)||{};
+      root.querySelectorAll('[data-gem-offer-cart-field]').forEach(function(f){var n=f.getAttribute('data-gem-offer-cart-field');f.value=ca[n]||'';f.disabled=!(n in ca);});
+      root.dispatchEvent(new CustomEvent('gem:offer:change',{bubbles:true,detail:{selection:sel,row:row,selling_plan_id:(plan&&plan.selling_plan_id)||null,cart_attributes:ca,gift:gf}}));
+    }
+    __gemListen(root, 'click',function(e){var b=e.target.closest('[data-gem-offer-dim]');if(!b||b.tagName==='OPTION')return;sel[b.getAttribute('data-gem-offer-dim')]=b.getAttribute('data-gem-offer-value');render();});
+    __gemListen(root, 'change',function(e){var s=e.target.closest('select[data-gem-offer-select]');if(!s)return;var o=s.options[s.selectedIndex];sel[s.getAttribute('data-gem-offer-select')]=o.getAttribute('data-gem-offer-value');render();});
+    render();
+  });
+})();
+    api.emit('gem:offer:ready', { source: 'gem-runtime' });
+  });
+}
+
+/** Bind every "offer-engine" 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, {"selector":"[data-gem-offer-engine]","prop":"__gemOffer"});
+}
+
+export default mount;

package/dist/plugins/predictive-search.d.ts

@@ -0,0 +1,9 @@
+// @gemboss/gem-framework/plugins/predictive-search: 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: "predictive-search";
+export declare const readyEvent: "gem:search:ready";
+/** Bind every "predictive-search" 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/predictive-search.js

@@ -0,0 +1,77 @@
+// @gemboss/gem-framework/plugins/predictive-search: the gem-runtime plugin "predictive-search" 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 = "predictive-search";
+export const readyEvent = "gem:search:ready";
+
+function install({ document, window, target, mark, canListen, listen: __gemListen, registerPlugin, registerNoopPlugin }) {
+  registerPlugin('predictive-search', ({ api }) => {
+    const forms = document.querySelectorAll('[data-gem-predictive-search], [data-gem-search-canvas], form[action*="/search"], form[role="search"]');
+    const toggles = document.querySelectorAll('[data-gem-search-toggle]');
+    const canvas = document.querySelector('[data-gem-search-canvas]');
+    let bound = 0;
+    const setCanvasState = (state, reason = 'api') => {
+      if (!canvas || !canvas.dataset) return false;
+      canvas.dataset.gemSearchCanvasState = state;
+      canvas.setAttribute && canvas.setAttribute('aria-hidden', state === 'open' ? 'false' : 'true');
+      if (state === 'open') {
+        const input = canvas.querySelector && canvas.querySelector('input[type="search"], input[name="q"]');
+        if (input && input.focus) input.focus();
+      }
+      api.emit(state === 'open' ? 'gem:search:open' : 'gem:search:close', { source: 'gem-runtime', reason });
+      return true;
+    };
+    forms.forEach((form) => {
+      if (!mark(form, 'predictive-search')) return;
+      const input = form.querySelector && form.querySelector('input[type="search"], input[name="q"]');
+      const results = form.querySelector && form.querySelector('[data-gem-predictive-search-results]');
+      const setState = (state, value = '') => {
+        if (form.dataset) form.dataset.gemPredictiveSearchState = state;
+        if (results) {
+          results.hidden = state === 'closed';
+          if (results.dataset) results.dataset.gemPredictiveSearchState = state;
+          results.setAttribute && results.setAttribute('aria-hidden', state === 'closed' ? 'true' : 'false');
+          if (state === 'typing') results.textContent = value ? 'Search suggestions for ' + value : 'Start typing to search';
+          if (state === 'empty') results.textContent = 'Start typing to search';
+        }
+      };
+      if (results) {
+        results.hidden = true;
+        results.setAttribute && results.setAttribute('role', 'status');
+        results.setAttribute && results.setAttribute('aria-live', 'polite');
+      }
+      setState('closed');
+      if (canListen(input)) __gemListen(input, 'focus', () => { setState(input.value ? 'typing' : 'empty', input.value || ''); api.emit('gem:search:open', { source: 'gem-runtime', value: input.value || '' }); });
+      const closeOnEscape = (event) => { if (event.key === 'Escape') { event.preventDefault && event.preventDefault(); event.stopPropagation && event.stopPropagation(); setState('closed'); api.emit('gem:search:close', { source: 'gem-runtime', reason: 'escape' }); } };
+      if (canListen(input)) __gemListen(input, 'input', () => { setState(input.value ? 'typing' : 'empty', input.value || ''); api.emit('gem:search:input', { source: 'gem-runtime', value: input.value || '' }); });
+      if (canListen(input)) __gemListen(input, 'keydown', closeOnEscape);
+      if (canListen(form)) __gemListen(form, 'keydown', closeOnEscape);
+      if (canListen(form)) __gemListen(form, 'submit', () => { setState('submit', input && input.value || ''); api.emit('gem:search:submit', { source: 'gem-runtime', value: input && input.value || '' }); });
+      bound += 1;
+    });
+    if (canvas) {
+      canvas.dataset && (canvas.dataset.gemSearchCanvasState = 'closed');
+      canvas.setAttribute && canvas.setAttribute('aria-hidden', 'true');
+      if (mark(canvas, 'search-canvas')) bound += 1;
+      if (canListen(canvas)) __gemListen(canvas, 'keydown', (event) => { if (event.key === 'Escape') setCanvasState('closed', 'escape'); });
+    }
+    toggles.forEach((toggle) => {
+      if (!mark(toggle, 'search-toggle')) return;
+      if (!canListen(toggle)) return;
+      __gemListen(toggle, 'click', (event) => {
+        if (canvas) event.preventDefault && event.preventDefault();
+        setCanvasState('open', 'toggle');
+      });
+      bound += 1;
+    });
+    api.emit('gem:search:ready', { source: 'gem-runtime', count: bound });
+  });
+}
+
+/** Bind every "predictive-search" 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/promo-popup.d.ts

@@ -0,0 +1,9 @@
+// @gemboss/gem-framework/plugins/promo-popup: 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: "promo-popup";
+export declare const readyEvent: "gem:promo-popup:ready";
+/** Bind every "promo-popup" 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/promo-popup.js

@@ -0,0 +1,117 @@
+// @gemboss/gem-framework/plugins/promo-popup: the gem-runtime plugin "promo-popup" 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 = "promo-popup";
+export const readyEvent = "gem:promo-popup:ready";
+
+function install({ document, window, target, mark, canListen, listen: __gemListen, registerPlugin, registerNoopPlugin }) {
+  registerPlugin('promo-popup', ({ api }) => {
+    const popups = document.querySelectorAll('[data-gem-promo-popup]');
+    let bound = 0;
+    const shown = [];
+    const storagePrefix = 'gem:promo-popup-dismissed:';
+    const now = () => Date.now ? Date.now() : new Date().getTime();
+    const readDismissal = (key) => {
+      try { const value = Number(target.localStorage && target.localStorage.getItem(storagePrefix + key) || '0'); return Number.isFinite(value) && value > 0 ? value : 0; }
+      catch { return 0; }
+    };
+    const writeDismissedAt = (key, timestamp) => {
+      try { if (target.localStorage) target.localStorage.setItem(storagePrefix + key, String(timestamp)); }
+      catch { /* storage can be unavailable in private contexts */ }
+    };
+    const isDismissed = (key, windowMs) => {
+      const stored = readDismissal(key);
+      if (!stored) return false;
+      const at = now();
+      if (stored > at) { if (stored - windowMs <= at) writeDismissedAt(key, stored - windowMs); return true; }
+      return at - stored < windowMs;
+    };
+    popups.forEach((popup, index) => {
+      if (!mark(popup, 'promo-popup')) return;
+      const key = popup.id || popup.getAttribute && popup.getAttribute('data-gem-section-library-id') || String(index);
+      const delaySeconds = Number(popup.getAttribute && (popup.getAttribute('data-gem-promo-delay') || '0'));
+      const frequencyDays = Number(popup.getAttribute && (popup.getAttribute('data-gem-promo-frequency-days') || '7'));
+      const windowMs = (Number.isFinite(frequencyDays) ? Math.max(1, frequencyDays) : 7) * 86400000;
+      const dialog = popup.querySelector && popup.querySelector('[data-gem-promo-popup-dialog]');
+      const overlay = popup.querySelector && popup.querySelector('[data-gem-promo-popup-overlay]');
+      const show = (reason) => {
+        popup.hidden = false;
+        if (dialog) dialog.hidden = false;
+        if (overlay) overlay.hidden = false;
+        popup.dataset.gemPromoPopupState = 'open';
+        api.emit('gem:promo-popup:open', { source: 'gem-runtime', id: popup.id || undefined, reason });
+      };
+      const open = (reason = 'timer') => {
+        if (isDismissed(key, windowMs)) { popup.dataset.gemPromoPopupState = 'dismissed'; return false; }
+        show(reason);
+        return true;
+      };
+      const close = (reason = 'dismiss') => {
+        writeDismissedAt(key, now());
+        if (dialog) dialog.hidden = true;
+        if (overlay) overlay.hidden = true;
+        popup.dataset.gemPromoPopupState = 'closed';
+        api.emit('gem:promo-popup:close', { source: 'gem-runtime', id: popup.id || undefined, reason });
+      };
+      popup.querySelectorAll && popup.querySelectorAll('[data-gem-promo-popup-dismiss]').forEach((button) => {
+        if (!canListen(button)) return;
+        __gemListen(button, 'click', (event) => { event.preventDefault && event.preventDefault(); close('dismiss'); });
+      });
+      if (canListen(overlay)) __gemListen(overlay, 'click', () => close('overlay'));
+      popup.dataset.gemPromoPopupState = 'ready';
+      const delay = Math.max(0, Number.isFinite(delaySeconds) ? delaySeconds : 0) * 1000;
+      const trigger = String(popup.getAttribute && popup.getAttribute('data-gem-promo-trigger') || 'delay').trim();
+      const rawPercent = String(popup.getAttribute && popup.getAttribute('data-gem-promo-scroll-percent') || '').trim();
+      const parsedPercent = rawPercent ? Number(rawPercent) : NaN;
+      const scrollPercent = Number.isFinite(parsedPercent) ? Math.min(90, Math.max(10, parsedPercent)) : 50;
+      const canHover = () => { try { return Boolean(target.matchMedia && target.matchMedia('(hover: hover) and (pointer: fine)').matches); } catch { return false; } };
+      const armed = trigger === 'exit_intent' && canHover() ? 'exit_intent' : trigger === 'scroll' ? 'scroll' : 'delay';
+      if (popup.setAttribute) popup.setAttribute('data-gem-promo-armed', armed);
+      let opened = false;
+      const disarm = [];
+      const openOnce = (reason) => { if (opened) return; opened = true; disarm.splice(0).forEach((off) => off()); open(reason); };
+      shown.push((reason) => { opened = true; disarm.splice(0).forEach((off) => off()); if (popup.dataset.gemPromoPopupState !== 'open') show(reason); });
+      if (armed === 'exit_intent') {
+        const onMouseOut = (event) => { if (event.relatedTarget || event.clientY >= 10) return; openOnce('exit_intent'); };
+        if (canListen(document)) {
+          __gemListen(document, 'mouseout', onMouseOut);
+          disarm.push(() => document.removeEventListener && document.removeEventListener('mouseout', onMouseOut));
+        }
+      } else if (armed === 'scroll') {
+        const room = () => Number(document.documentElement && document.documentElement.scrollHeight || 0) - Number(target.innerHeight || 0);
+        const check = () => { const r = room(); if (r > 0 && (Number(target.scrollY || target.pageYOffset || 0) / r) * 100 >= scrollPercent) openOnce('scroll'); };
+        let ticking = false;
+        const onScroll = () => {
+          if (ticking) return;
+          ticking = true;
+          const frame = target.requestAnimationFrame ? (fn) => target.requestAnimationFrame(fn) : (fn) => target.setTimeout && target.setTimeout(fn, 16);
+          frame(() => { ticking = false; check(); });
+        };
+        if (canListen(target)) {
+          __gemListen(target, 'scroll', onScroll, { passive: true });
+          __gemListen(target, 'resize', check);
+          __gemListen(target, 'load', check);
+          disarm.push(() => { if (!target.removeEventListener) return; target.removeEventListener('scroll', onScroll); target.removeEventListener('resize', check); target.removeEventListener('load', check); });
+        }
+        if (target.setTimeout) {
+          const fallback = target.setTimeout(() => { if (room() <= 0) openOnce('timer'); }, delay);
+          disarm.push(() => target.clearTimeout && target.clearTimeout(fallback));
+        }
+        check();
+      } else {
+        target.setTimeout ? target.setTimeout(() => openOnce('timer'), delay) : openOnce('timer');
+      }
+      bound += 1;
+    });
+    api.promoPopup = { open: () => shown.forEach((show) => show('api')) };
+    api.emit('gem:promo-popup:ready', { source: 'gem-runtime', count: bound });
+  });
+}
+
+/** Bind every "promo-popup" 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/quantity-input.d.ts

@@ -0,0 +1,9 @@
+// @gemboss/gem-framework/plugins/quantity-input: 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: "quantity-input";
+export declare const readyEvent: "gem:quantity:ready";
+/** Bind every "quantity-input" 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/quantity-input.js

@@ -0,0 +1,44 @@
+// @gemboss/gem-framework/plugins/quantity-input: the gem-runtime plugin "quantity-input" 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 = "quantity-input";
+export const readyEvent = "gem:quantity:ready";
+
+function install({ document, window, target, mark, canListen, listen: __gemListen, registerPlugin, registerNoopPlugin }) {
+  registerPlugin('quantity-input', ({ api }) => {
+    const controls = document.querySelectorAll('[data-gem-quantity-input], .gem-quantity-input');
+    let bound = 0;
+    const clamp = (value, min, max) => Math.max(min, Math.min(max, value));
+    controls.forEach((control) => {
+      if (!mark(control, 'quantity-input')) return;
+      const input = control.querySelector && control.querySelector('input[type="number"]');
+      if (!input) return;
+      const setValue = (nextValue, reason) => {
+        const min = Number.isFinite(Number(input.min)) ? Number(input.min) : 0;
+        const max = Number.isFinite(Number(input.max)) && input.max !== '' ? Number(input.max) : Number.MAX_SAFE_INTEGER;
+        const value = clamp(Number(nextValue) || min, min, max);
+        input.value = String(value);
+        api.emit('gem:quantity:change', { source: 'gem-runtime', value, reason, name: input.name || undefined });
+      };
+      if (!canListen(control) || !canListen(input)) return;
+      __gemListen(control, 'click', (event) => {
+        const button = event.target && event.target.closest ? event.target.closest('[data-gem-quantity-change]') : null;
+        if (!button) return;
+        event.preventDefault && event.preventDefault();
+        const delta = Number(button.getAttribute('data-gem-quantity-change') || '0');
+        setValue(Number(input.value || 0) + delta, delta > 0 ? 'increase' : 'decrease');
+      });
+      __gemListen(input, 'change', () => setValue(input.value, 'input'));
+      bound += 1;
+    });
+    api.emit('gem:quantity:ready', { source: 'gem-runtime', count: bound });
+  });
+}
+
+/** Bind every "quantity-input" 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/quick-view.d.ts

@@ -0,0 +1,9 @@
+// @gemboss/gem-framework/plugins/quick-view: 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: "quick-view";
+export declare const readyEvent: "gem:quick-view:ready";
+/** Bind every "quick-view" 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/quick-view.js

@@ -0,0 +1,69 @@
+// @gemboss/gem-framework/plugins/quick-view: the gem-runtime plugin "quick-view" 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 = "quick-view";
+export const readyEvent = "gem:quick-view:ready";
+
+function install({ document, window, target, mark, canListen, listen: __gemListen, registerPlugin, registerNoopPlugin }) {
+  registerPlugin('quick-view', ({ api }) => {
+    const triggers = document.querySelectorAll('[data-gem-quick-view], [data-gem-action="quick-view"]');
+    const surface = document.querySelector('[data-gem-quick-view-surface], .gem-quick-view, .gem-modal[data-gem-component="quick-view"]');
+    let bound = 0;
+    const close = (reason = 'close-control') => {
+      if (surface) {
+        surface.dataset.gemQuickViewState = 'closed';
+        surface.removeAttribute && surface.removeAttribute('open');
+        surface.setAttribute && surface.setAttribute('aria-hidden', 'true');
+      }
+      api.emit('gem:quick-view:close', { source: 'gem-runtime', reason });
+    };
+    const openSurface = (detail) => {
+      if (surface) {
+        surface.dataset.gemQuickViewState = 'open';
+        surface.dataset.gemProductHandle = detail.productHandle || '';
+        surface.dataset.gemProductUrl = detail.productUrl || '';
+        surface.setAttribute && surface.setAttribute('open', '');
+        surface.setAttribute && surface.setAttribute('aria-hidden', 'false');
+        surface.setAttribute && surface.setAttribute('role', 'dialog');
+        surface.setAttribute && surface.setAttribute('aria-modal', 'true');
+        const content = surface.querySelector && surface.querySelector('[data-gem-quick-view-content]');
+        if (content && content.textContent !== undefined) content.textContent = 'Quick view for ' + (detail.productHandle || 'product');
+        else if (surface.textContent !== undefined) surface.textContent = 'Quick view for ' + (detail.productHandle || 'product');
+        const closeButton = surface.querySelector && surface.querySelector('[data-gem-quick-view-close]');
+        if (closeButton && closeButton.focus) closeButton.focus();
+      }
+      api.emit('gem:quick-view:open', { source: 'gem-runtime', ...detail, hasSurface: Boolean(surface) });
+    };
+    triggers.forEach((trigger) => {
+      if (!mark(trigger, 'quick-view')) return;
+      if (!canListen(trigger)) return;
+      __gemListen(trigger, 'click', (event) => {
+        const productUrl = trigger.getAttribute && (trigger.getAttribute('data-gem-product-url') || trigger.getAttribute('href'));
+        const productHandle = trigger.getAttribute && trigger.getAttribute('data-gem-product-handle');
+        if (!productUrl && !productHandle) return;
+        event.preventDefault && event.preventDefault();
+        openSurface({ productUrl, productHandle });
+      });
+      bound += 1;
+    });
+    if (surface && mark(surface, 'quick-view-surface')) {
+      surface.dataset.gemQuickViewState = 'closed';
+      surface.setAttribute && surface.setAttribute('aria-hidden', 'true');
+      if (canListen(surface)) __gemListen(surface, 'click', (event) => {
+        const target = event.target;
+        if (target && target.closest && target.closest('[data-gem-quick-view-close]')) close('close-control');
+      });
+      if (canListen(surface)) __gemListen(surface, 'keydown', (event) => { if (event.key === 'Escape') close('escape'); });
+    }
+    api.quickView = { open: (detail = {}) => openSurface({ ...detail }), close };
+    api.emit('gem:quick-view:ready', { source: 'gem-runtime', count: bound, hasSurface: Boolean(surface) });
+  });
+}
+
+/** Bind every "quick-view" 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/recently-viewed.d.ts

@@ -0,0 +1,9 @@
+// @gemboss/gem-framework/plugins/recently-viewed: 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: "recently-viewed";
+export declare const readyEvent: "gem:recently-viewed:ready";
+/** Bind every "recently-viewed" 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/recently-viewed.js

@@ -0,0 +1,71 @@
+// @gemboss/gem-framework/plugins/recently-viewed: the gem-runtime plugin "recently-viewed" 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 = "recently-viewed";
+export const readyEvent = "gem:recently-viewed:ready";
+
+function install({ document, window, target, mark, canListen, listen: __gemListen, registerPlugin, registerNoopPlugin }) {
+  registerPlugin('recently-viewed', ({ api }) => {
+    const storageKey = 'gem:recently-viewed-products';
+    const readItems = () => {
+      try { return JSON.parse(target.localStorage && target.localStorage.getItem(storageKey) || '[]'); }
+      catch { return []; }
+    };
+    const writeItems = (items) => {
+      try { if (target.localStorage) target.localStorage.setItem(storageKey, JSON.stringify(items.slice(0, 12))); }
+      catch { /* storage can be unavailable in private contexts */ }
+    };
+    const escapeHtml = (value) => String(value || '').replace(/[&<>'"]/g, (char) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', "'": '&#39;', '"': '&quot;' }[char]));
+    const renderItem = (item) => {
+      const url = item && item.url ? String(item.url) : '#';
+      const label = item && (item.title || item.handle || item.url) ? String(item.title || item.handle || item.url) : 'Recently viewed product';
+      return '<a class="gem-card gem-recently-viewed__item" href="' + escapeHtml(url) + '"><strong>' + escapeHtml(label) + '</strong></a>';
+    };
+    const current = document.querySelector('[data-gem-current-product], [data-gem-product-handle]');
+    if (current) {
+      const handle = current.getAttribute && current.getAttribute('data-gem-product-handle');
+      const url = current.getAttribute && (current.getAttribute('data-gem-product-url') || current.getAttribute('href'));
+      const title = current.getAttribute && current.getAttribute('data-gem-product-title');
+      if (handle || url) {
+        const nextItem = { handle, url, title, recordedAt: new Date().toISOString() };
+        const items = [nextItem, ...readItems().filter((item) => item && item.handle !== handle && item.url !== url)];
+        writeItems(items);
+        api.emit('gem:recently-viewed:record', { source: 'gem-runtime', handle, url });
+      }
+    }
+    const rails = document.querySelectorAll('[data-gem-recently-viewed], .gem-recently-viewed');
+    let bound = 0;
+    rails.forEach((rail) => {
+      if (!mark(rail, 'recently-viewed')) return;
+      const limit = Number(rail.getAttribute && (rail.getAttribute('data-gem-recently-viewed-limit') || '4'));
+      const items = readItems().slice(0, Number.isFinite(limit) ? limit : 4);
+      const list = rail.querySelector && (rail.querySelector('[data-gem-recently-viewed-list]') || rail);
+      const empty = rail.querySelector && rail.querySelector('[data-gem-recently-viewed-empty]');
+      rail.dataset.gemRecentlyViewedCount = String(items.length);
+      if (items.length > 0) {
+        rail.dataset.gemRecentlyViewedState = 'ready';
+        if (list) {
+          list.hidden = false;
+          if (list.dataset) list.dataset.gemRecentlyViewedCount = String(items.length);
+          if ('innerHTML' in list) list.innerHTML = items.map(renderItem).join('');
+          else if ('textContent' in list) list.textContent = items.map((item) => item && (item.title || item.handle || item.url) || 'Recently viewed product').join(', ');
+        }
+        if (empty) empty.hidden = true;
+      } else {
+        rail.dataset.gemRecentlyViewedState = 'empty';
+        if (empty) empty.hidden = false;
+      }
+      bound += 1;
+    });
+    api.recentlyViewed = { list: readItems };
+    api.emit('gem:recently-viewed:ready', { source: 'gem-runtime', count: bound });
+  });
+}
+
+/** Bind every "recently-viewed" 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/reveal-on-scroll.d.ts

@@ -0,0 +1,9 @@
+// @gemboss/gem-framework/plugins/reveal-on-scroll: 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: "reveal-on-scroll";
+export declare const readyEvent: "gem:reveal:ready";
+/** Bind every "reveal-on-scroll" 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/reveal-on-scroll.js

@@ -0,0 +1,37 @@
+// @gemboss/gem-framework/plugins/reveal-on-scroll: the gem-runtime plugin "reveal-on-scroll" 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 = "reveal-on-scroll";
+export const readyEvent = "gem:reveal:ready";
+
+function install({ document, window, target, mark, canListen, listen: __gemListen, registerPlugin, registerNoopPlugin }) {
+  registerPlugin('reveal-on-scroll', ({ api }) => {
+    const nodes = document.querySelectorAll('[data-gem-reveal], .gem-reveal');
+    let bound = 0;
+    const reveal = (node) => { node.dataset.gemRevealState = 'in'; };
+    if (!target.IntersectionObserver) { nodes.forEach(reveal); api.emit('gem:reveal:ready', { source: 'gem-runtime', count: 0 }); return; }
+    const observer = new target.IntersectionObserver((entries, obs) => {
+      entries.forEach((entry) => {
+        if (!entry.isIntersecting) return;
+        reveal(entry.target);
+        obs.unobserve(entry.target);
+        api.emit('gem:reveal:in', { source: 'gem-runtime', id: entry.target.id || undefined });
+      });
+    }, { threshold: 0.12, rootMargin: '0px 0px -40px 0px' });
+    nodes.forEach((node) => {
+      if (!mark(node, 'reveal-on-scroll')) return;
+      if (!node.dataset.gemRevealState) node.dataset.gemRevealState = 'ready';
+      observer.observe(node);
+      bound += 1;
+    });
+    api.emit('gem:reveal:ready', { source: 'gem-runtime', count: bound });
+  });
+}
+
+/** Bind every "reveal-on-scroll" 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/runtime-slot-loader.d.ts

@@ -0,0 +1,9 @@
+// @gemboss/gem-framework/plugins/runtime-slot-loader: 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: "runtime-slot-loader";
+export declare const readyEvent: "gem:slot:ready";
+/** Bind every "runtime-slot-loader" 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;