@fairfox/polly 0.23.0 → 0.25.0

package/dist/src/actions/index.js

@@ -0,0 +1,525 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/actions/error.ts
+import { signal } from "@preact/signals";
+var errorState = signal([]);
+var nextId = 0;
+function allocId() {
+  nextId += 1;
+  return `polly-err-${nextId}`;
+}
+function setError(message, opts = {}) {
+  const entry = {
+    id: allocId(),
+    message,
+    severity: opts.severity ?? "error",
+    action: opts.action,
+    createdAt: Date.now()
+  };
+  errorState.value = [...errorState.value, entry];
+  return entry.id;
+}
+function clearError(id) {
+  if (id === undefined) {
+    errorState.value = [];
+    return;
+  }
+  errorState.value = errorState.value.filter((e) => e.id !== id);
+}
+function submitError(action, err) {
+  const message = err instanceof Error ? err.message : String(err);
+  return setError(message, { action, severity: "error" });
+}
+// src/actions/overlay.ts
+import { signal as signal2 } from "@preact/signals";
+var stack = signal2([]);
+function overlayStack() {
+  return stack.value;
+}
+function hasOpenOverlay() {
+  return stack.value.length > 0;
+}
+function topOverlay() {
+  const s = stack.value;
+  return s[s.length - 1];
+}
+function pushOverlay(entry) {
+  stack.value = [...stack.value, entry];
+}
+function popOverlay(id) {
+  const s = stack.value;
+  if (s.length === 0)
+    return;
+  if (id === undefined) {
+    const top = s[s.length - 1];
+    stack.value = s.slice(0, -1);
+    return top;
+  }
+  const idx = s.findIndex((e) => e.id === id);
+  if (idx === -1)
+    return;
+  const entry = s[idx];
+  stack.value = [...s.slice(0, idx), ...s.slice(idx + 1)];
+  return entry;
+}
+function closeTopOverlay() {
+  const top = topOverlay();
+  if (!top)
+    return;
+  top.onClose?.();
+  return popOverlay(top.id);
+}
+function resetOverlayStack() {
+  stack.value = [];
+}
+
+// src/actions/event-delegation.ts
+var INTERACTIVE_TAGS = new Set(["BUTTON", "A", "INPUT", "SELECT", "TEXTAREA"]);
+var ACTION_EVENT_TYPES = new Set(["click", "submit", "change", "input"]);
+function parseActionData(element) {
+  const data = {};
+  for (const attr of Array.from(element.attributes)) {
+    if (attr.name.startsWith("data-action-")) {
+      const key = attr.name.replace("data-action-", "").replace(/-([a-z])/g, (_m, letter) => letter.toUpperCase());
+      data[key] = attr.value;
+    }
+  }
+  return data;
+}
+function closeTopOverlay2() {
+  const overlays = document.querySelectorAll("[data-overlay-id]");
+  if (overlays.length === 0)
+    return;
+  const topOverlay2 = overlays[overlays.length - 1];
+  if (!topOverlay2)
+    return;
+  topOverlay2.dispatchEvent(new CustomEvent("overlay:close", {
+    bubbles: true,
+    detail: { id: topOverlay2.getAttribute("data-overlay-id") }
+  }));
+}
+function resolveAction(event) {
+  const target = event.target;
+  if (!(target instanceof Element))
+    return null;
+  const actionElement = target.closest("[data-action]");
+  if (!(actionElement instanceof HTMLElement))
+    return null;
+  if (event.type === "click" && actionElement.tagName === "FORM")
+    return null;
+  const action = actionElement.getAttribute("data-action");
+  if (!action)
+    return null;
+  return {
+    action,
+    element: actionElement,
+    event,
+    data: parseActionData(actionElement)
+  };
+}
+function installEventDelegation(onDispatch, options = {}) {
+  const handleActionEvent = (event) => {
+    const dispatch = resolveAction(event);
+    if (dispatch)
+      onDispatch(dispatch);
+  };
+  const handleKeyDown = (event) => {
+    if (event.key === "Escape") {
+      if (options.onEscape) {
+        options.onEscape();
+      } else {
+        closeTopOverlay();
+        closeTopOverlay2();
+      }
+      return;
+    }
+    if (event.key === "Enter" || event.key === " ") {
+      const target = event.target;
+      if (!(target instanceof Element))
+        return;
+      if (INTERACTIVE_TAGS.has(target.tagName))
+        return;
+      const dispatch = resolveAction(event);
+      if (dispatch) {
+        event.preventDefault();
+        onDispatch(dispatch);
+      }
+    }
+  };
+  const handleMouseDown = (event) => {
+    if (!(event.target instanceof Element))
+      return;
+    const clickedOverlay = event.target.closest("[data-overlay-id]");
+    if (clickedOverlay)
+      return;
+    if (options.onOutsideOverlayClick) {
+      options.onOutsideOverlayClick();
+    } else {
+      closeTopOverlay();
+      closeTopOverlay2();
+    }
+  };
+  for (const eventType of ACTION_EVENT_TYPES) {
+    document.addEventListener(eventType, handleActionEvent);
+  }
+  document.addEventListener("keydown", handleKeyDown);
+  document.addEventListener("mousedown", handleMouseDown);
+  return () => {
+    for (const eventType of ACTION_EVENT_TYPES) {
+      document.removeEventListener(eventType, handleActionEvent);
+    }
+    document.removeEventListener("keydown", handleKeyDown);
+    document.removeEventListener("mousedown", handleMouseDown);
+  };
+}
+// src/actions/form.ts
+import { computed, effect, signal as signal3 } from "@preact/signals";
+function isFormElement(target) {
+  if (!target)
+    return false;
+  if (typeof HTMLFormElement !== "undefined") {
+    return target instanceof HTMLFormElement;
+  }
+  const t = target;
+  return typeof t.tagName === "string" && t.tagName === "FORM";
+}
+function createForm(config) {
+  const fieldKeys = Object.keys(config.initialValues);
+  const fields = {};
+  for (const key of fieldKeys) {
+    fields[key] = signal3(config.initialValues[key]);
+  }
+  const values = computed(() => {
+    const v = {};
+    for (const key of fieldKeys) {
+      v[key] = fields[key].value;
+    }
+    return v;
+  });
+  const isOpen = signal3(false);
+  const isSubmitting = signal3(false);
+  const errors = signal3({});
+  const openParams = signal3({});
+  let getStoresRef = null;
+  let disposeGuardEffect = null;
+  function getStoresOrThrow() {
+    if (!getStoresRef) {
+      throw new Error(`Form "${config.name}" used before bindStores(). Call form.bindStores(() => yourStores) at app init.`);
+    }
+    return getStoresRef();
+  }
+  function resetToInitial() {
+    for (const key of fieldKeys) {
+      fields[key].value = config.initialValues[key];
+    }
+    errors.value = {};
+  }
+  function open(override, params = {}) {
+    resetToInitial();
+    openParams.value = params;
+    if (config.onOpen && getStoresRef) {
+      const onOpenOverride = config.onOpen({ data: params, stores: getStoresOrThrow() }) ?? {};
+      for (const [k, v] of Object.entries(onOpenOverride)) {
+        if (k in fields) {
+          fields[k].value = v;
+        }
+      }
+    }
+    if (override) {
+      for (const [k, v] of Object.entries(override)) {
+        if (k in fields) {
+          fields[k].value = v;
+        }
+      }
+    }
+    isOpen.value = true;
+  }
+  function close() {
+    isOpen.value = false;
+    resetToInitial();
+    openParams.value = {};
+  }
+  async function submit(event) {
+    if (event)
+      event.preventDefault();
+    if (event && isFormElement(event.target)) {
+      const fd = new FormData(event.target);
+      for (const key of fieldKeys) {
+        const raw = fd.get(key);
+        if (raw !== null) {
+          fields[key].value = String(raw);
+        }
+      }
+    }
+    const current = values.value;
+    const validationErrors = config.validate?.(current);
+    if (validationErrors && Object.keys(validationErrors).length > 0) {
+      errors.value = validationErrors;
+      return;
+    }
+    errors.value = {};
+    isSubmitting.value = true;
+    try {
+      await config.onSubmit({
+        values: current,
+        stores: getStoresOrThrow()
+      });
+      close();
+    } catch (err) {
+      submitError(`${config.name}:submit`, err);
+    } finally {
+      isSubmitting.value = false;
+    }
+  }
+  function bindStores(getStores) {
+    getStoresRef = getStores;
+    disposeGuardEffect?.();
+    const guardFn = config.guard;
+    if (guardFn) {
+      disposeGuardEffect = effect(() => {
+        if (!isOpen.value)
+          return;
+        if (!guardFn({ stores: getStores() }))
+          close();
+      });
+    }
+  }
+  const actions = {
+    [`${config.name}:open`]: ({ data }) => {
+      open(undefined, data);
+    },
+    [`${config.name}:close`]: () => {
+      close();
+    },
+    [`${config.name}:submit`]: async ({ event }) => {
+      await submit(event);
+    }
+  };
+  return {
+    name: config.name,
+    isOpen,
+    values,
+    fields,
+    errors,
+    isSubmitting,
+    openParams,
+    open,
+    close,
+    submit,
+    bindStores,
+    actions
+  };
+}
+function createFormSet(forms) {
+  const merged = {};
+  for (const form of forms) {
+    Object.assign(merged, form.actions);
+  }
+  const openForm = computed(() => {
+    for (const form of forms) {
+      if (form.isOpen.value)
+        return form.name;
+    }
+    return null;
+  });
+  return {
+    actions: merged,
+    openForm,
+    closeAll() {
+      for (const form of forms)
+        form.close();
+    },
+    bindStores(getStores) {
+      for (const form of forms)
+        form.bindStores(getStores);
+    }
+  };
+}
+// src/actions/store.tsx
+import { createContext } from "preact";
+import { useContext } from "preact/hooks";
+import { jsxDEV } from "preact/jsx-dev-runtime";
+function createStore(init) {
+  return init;
+}
+var StoreContext = createContext(null);
+function StoreProvider({ children, stores }) {
+  return /* @__PURE__ */ jsxDEV(StoreContext.Provider, {
+    value: stores,
+    children
+  }, undefined, false, undefined, this);
+}
+function useStores() {
+  const ctx = useContext(StoreContext);
+  if (ctx === null) {
+    throw new Error("useStores must be used within a StoreProvider");
+  }
+  return ctx;
+}
+// src/actions/testing.ts
+function createMockElement(attrs = {}, tagName = "DIV") {
+  const attrMap = new Map(Object.entries(attrs));
+  const el = {
+    tagName,
+    nodeType: 1,
+    getAttribute: (name) => attrMap.get(name) ?? null,
+    setAttribute: (name, value) => {
+      attrMap.set(name, value);
+    },
+    hasAttribute: (name) => attrMap.has(name),
+    removeAttribute: (name) => {
+      attrMap.delete(name);
+    },
+    attributes: Array.from(attrMap.entries()).map(([name, value]) => ({
+      name,
+      value
+    }))
+  };
+  return el;
+}
+function createMockSubmitEvent(form) {
+  let target;
+  if (typeof HTMLFormElement !== "undefined" && form instanceof HTMLFormElement) {
+    target = form;
+  } else {
+    target = createMockFormElement(form);
+  }
+  let defaultPrevented = false;
+  return {
+    type: "submit",
+    target,
+    currentTarget: target,
+    preventDefault() {
+      defaultPrevented = true;
+    },
+    stopPropagation() {},
+    get defaultPrevented() {
+      return defaultPrevented;
+    }
+  };
+}
+function createMockFormElement(fields) {
+  return {
+    nodeType: 1,
+    tagName: "FORM",
+    elements: Object.entries(fields).map(([name, value]) => ({
+      name,
+      value
+    }))
+  };
+}
+function createMockStores(partial = {}) {
+  return partial;
+}
+async function runAction(registry, action, ctx) {
+  const handler = registry[action];
+  if (!handler) {
+    throw new Error(`No handler registered for action "${action}"`);
+  }
+  const fullCtx = {
+    stores: ctx.stores,
+    event: ctx.event ?? new Event("click"),
+    element: ctx.element ?? createMockElement(),
+    data: ctx.data ?? {}
+  };
+  await handler(fullCtx);
+}
+export {
+  useStores,
+  topOverlay,
+  submitError,
+  setError,
+  runAction,
+  resolveAction,
+  resetOverlayStack,
+  pushOverlay,
+  popOverlay,
+  parseActionData,
+  overlayStack,
+  installEventDelegation,
+  hasOpenOverlay,
+  errorState,
+  createStore,
+  createMockSubmitEvent,
+  createMockStores,
+  createMockElement,
+  createFormSet,
+  createForm,
+  closeTopOverlay2 as closeTopOverlayViaDom,
+  closeTopOverlay,
+  clearError,
+  StoreProvider,
+  INTERACTIVE_TAGS,
+  ACTION_EVENT_TYPES
+};
+
+//# debugId=EEBB85AB8D494BC664756E2164756E21

package/dist/src/actions/index.js.map

@@ -0,0 +1,15 @@
+{
+  "version": 3,
+  "sources": ["../src/actions/error.ts", "../src/actions/overlay.ts", "../src/actions/event-delegation.ts", "../src/actions/form.ts", "../src/actions/store.tsx", "../src/actions/testing.ts"],
+  "sourcesContent": [
+    "/**\n * Global error surface for action handlers.\n *\n * Actions that fail set the errorState signal via `submitError`; a `<Toast>`\n * component consumes that signal and renders a dismissable message. Handlers\n * that catch expected failures (validation, quota) may call `setError` directly.\n */\n\nimport { signal } from \"@preact/signals\";\n\nexport type ErrorSeverity = \"error\" | \"warning\" | \"info\";\n\nexport type ErrorEntry = {\n  id: string;\n  message: string;\n  severity: ErrorSeverity;\n  action?: string;\n  createdAt: number;\n};\n\nexport const errorState = signal<ErrorEntry[]>([]);\n\nlet nextId = 0;\nfunction allocId(): string {\n  nextId += 1;\n  return `polly-err-${nextId}`;\n}\n\nexport function setError(\n  message: string,\n  opts: { severity?: ErrorSeverity; action?: string } = {}\n): string {\n  const entry: ErrorEntry = {\n    id: allocId(),\n    message,\n    severity: opts.severity ?? \"error\",\n    action: opts.action,\n    createdAt: Date.now(),\n  };\n  errorState.value = [...errorState.value, entry];\n  return entry.id;\n}\n\nexport function clearError(id?: string): void {\n  if (id === undefined) {\n    errorState.value = [];\n    return;\n  }\n  errorState.value = errorState.value.filter((e) => e.id !== id);\n}\n\n/**\n * Convenience wrapper for an action's catch block.\n * Logs the action name + error and surfaces a user-visible message.\n */\nexport function submitError(action: string, err: unknown): string {\n  const message = err instanceof Error ? err.message : String(err);\n  return setError(message, { action, severity: \"error\" });\n}\n",
+    "/**\n * Overlay registry.\n *\n * Tracks the stack of open overlays (modals, popovers, confirm dialogs) so\n * Escape can close the topmost and `data-overlay-id`-based DOM scans have\n * a mirror in memory. Each entry stores an id plus an optional close\n * callback; `closeTopOverlay` invokes the callback and pops the entry.\n */\n\nimport { signal } from \"@preact/signals\";\n\nexport type OverlayEntry = {\n  id: string;\n  onClose?: () => void;\n};\n\nconst stack = signal<OverlayEntry[]>([]);\n\n/** Current overlay stack as a read-only snapshot. */\nexport function overlayStack(): readonly OverlayEntry[] {\n  return stack.value;\n}\n\n/** Is any overlay currently open? */\nexport function hasOpenOverlay(): boolean {\n  return stack.value.length > 0;\n}\n\n/** The top of the stack, or undefined if empty. */\nexport function topOverlay(): OverlayEntry | undefined {\n  const s = stack.value;\n  return s[s.length - 1];\n}\n\n/** Push an overlay onto the stack. Returns the popped entry when closed. */\nexport function pushOverlay(entry: OverlayEntry): void {\n  stack.value = [...stack.value, entry];\n}\n\n/** Pop a specific overlay by id (or the top if no id given). */\nexport function popOverlay(id?: string): OverlayEntry | undefined {\n  const s = stack.value;\n  if (s.length === 0) return undefined;\n  if (id === undefined) {\n    const top = s[s.length - 1];\n    stack.value = s.slice(0, -1);\n    return top;\n  }\n  const idx = s.findIndex((e) => e.id === id);\n  if (idx === -1) return undefined;\n  const entry = s[idx];\n  stack.value = [...s.slice(0, idx), ...s.slice(idx + 1)];\n  return entry;\n}\n\n/** Close the top overlay by calling its onClose and popping it. */\nexport function closeTopOverlay(): OverlayEntry | undefined {\n  const top = topOverlay();\n  if (!top) return undefined;\n  top.onClose?.();\n  return popOverlay(top.id);\n}\n\n/** Reset the stack. Intended for tests. */\nexport function resetOverlayStack(): void {\n  stack.value = [];\n}\n",
+    "/**\n * Event delegation core.\n *\n * One document listener dispatches `data-action` events to typed handlers.\n * Walks up the DOM with `closest('[data-action]')`, parses `data-action-*`\n * attributes into a camelCase object, and hands the dispatch to the caller.\n *\n * Forms are skipped on click — a `<form data-action=\"...\">` responds to\n * submit only, so clicks on form children don't bubble into its action.\n * Escape closes the topmost overlay by calling the overlay registry.\n * Enter/Space on non-interactive elements with `data-action` fire the\n * action (Space is prevented to stop page scroll). Click outside any\n * `[data-overlay-id]` element also pops the top overlay.\n */\n\nimport { closeTopOverlay as closeTopRegistryOverlay } from \"./overlay.ts\";\n\n/** Elements that natively fire click on Enter/Space. */\nexport const INTERACTIVE_TAGS = new Set([\"BUTTON\", \"A\", \"INPUT\", \"SELECT\", \"TEXTAREA\"]);\n\n/** Event types that may trigger a data-action dispatch. */\nexport const ACTION_EVENT_TYPES = new Set([\"click\", \"submit\", \"change\", \"input\"]);\n\n/** Parsed action dispatch — what the runtime resolves before invoking a handler. */\nexport type ActionDispatch = {\n  action: string;\n  element: HTMLElement;\n  event: Event;\n  data: Record<string, string>;\n};\n\n/**\n * Parse `data-action-*` attributes into camelCase key-value pairs.\n *\n * `data-action-text-set-id=\"42\"` becomes `{ textSetId: \"42\" }`.\n */\nexport function parseActionData(element: HTMLElement): Record<string, string> {\n  const data: Record<string, string> = {};\n  for (const attr of Array.from(element.attributes)) {\n    if (attr.name.startsWith(\"data-action-\")) {\n      const key = attr.name\n        .replace(\"data-action-\", \"\")\n        .replace(/-([a-z])/g, (_m: string, letter: string) => letter.toUpperCase());\n      data[key] = attr.value;\n    }\n  }\n  return data;\n}\n\n/**\n * Close the topmost overlay by dispatching `overlay:close` on its element.\n * Overlays mark themselves with `data-overlay-id`.\n */\nexport function closeTopOverlay(): void {\n  const overlays = document.querySelectorAll(\"[data-overlay-id]\");\n  if (overlays.length === 0) return;\n  const topOverlay = overlays[overlays.length - 1];\n  if (!topOverlay) return;\n  topOverlay.dispatchEvent(\n    new CustomEvent(\"overlay:close\", {\n      bubbles: true,\n      detail: { id: topOverlay.getAttribute(\"data-overlay-id\") },\n    })\n  );\n}\n\n/**\n * Resolve a DOM event to an ActionDispatch, or null if no data-action matches.\n */\nexport function resolveAction(event: Event): ActionDispatch | null {\n  const target = event.target;\n  if (!(target instanceof Element)) return null;\n  const actionElement = target.closest(\"[data-action]\");\n  if (!(actionElement instanceof HTMLElement)) return null;\n  if (event.type === \"click\" && actionElement.tagName === \"FORM\") return null;\n  const action = actionElement.getAttribute(\"data-action\");\n  if (!action) return null;\n  return {\n    action,\n    element: actionElement,\n    event,\n    data: parseActionData(actionElement),\n  };\n}\n\n/**\n * Install document-level listeners for the delegation system.\n * Returns a cleanup function that removes every listener it installed.\n */\nexport function installEventDelegation(\n  onDispatch: (dispatch: ActionDispatch) => void,\n  options: { onEscape?: () => void; onOutsideOverlayClick?: () => void } = {}\n): () => void {\n  const handleActionEvent = (event: Event) => {\n    const dispatch = resolveAction(event);\n    if (dispatch) onDispatch(dispatch);\n  };\n\n  const handleKeyDown = (event: KeyboardEvent) => {\n    if (event.key === \"Escape\") {\n      if (options.onEscape) {\n        options.onEscape();\n      } else {\n        closeTopRegistryOverlay();\n        closeTopOverlay();\n      }\n      return;\n    }\n    if (event.key === \"Enter\" || event.key === \" \") {\n      const target = event.target;\n      if (!(target instanceof Element)) return;\n      if (INTERACTIVE_TAGS.has(target.tagName)) return;\n      const dispatch = resolveAction(event);\n      if (dispatch) {\n        event.preventDefault();\n        onDispatch(dispatch);\n      }\n    }\n  };\n\n  const handleMouseDown = (event: MouseEvent) => {\n    if (!(event.target instanceof Element)) return;\n    const clickedOverlay = event.target.closest(\"[data-overlay-id]\");\n    if (clickedOverlay) return;\n    if (options.onOutsideOverlayClick) {\n      options.onOutsideOverlayClick();\n    } else {\n      closeTopRegistryOverlay();\n      closeTopOverlay();\n    }\n  };\n\n  for (const eventType of ACTION_EVENT_TYPES) {\n    document.addEventListener(eventType, handleActionEvent);\n  }\n  document.addEventListener(\"keydown\", handleKeyDown);\n  document.addEventListener(\"mousedown\", handleMouseDown);\n\n  return () => {\n    for (const eventType of ACTION_EVENT_TYPES) {\n      document.removeEventListener(eventType, handleActionEvent);\n    }\n    document.removeEventListener(\"keydown\", handleKeyDown);\n    document.removeEventListener(\"mousedown\", handleMouseDown);\n  };\n}\n",
+    "/**\n * Form primitive.\n *\n * `createForm` returns a typed form store: per-field signals, an aggregated\n * values signal, open/close/submit methods, and three auto-registered action\n * handlers (`{name}:open`, `{name}:close`, `{name}:submit`) that callers spread\n * into their global action registry.\n *\n * Lifecycle:\n *   open  → resets fields to initialValues, applies onOpen overrides,\n *           sets isOpen = true, records data-action-* data in openParams\n *   typing → uncontrolled inputs keep their own state; controlled inputs\n *           write fields.X.value directly\n *   submit → reads FormData from the form element, merges into fields,\n *           runs optional validate, calls user onSubmit with final values,\n *           closes on success, sets errorState on failure\n *   close  → resets and sets isOpen = false\n *   guard  → autonomous effect; if guard() returns false while open, close()\n */\n\nimport { computed, effect, type ReadonlySignal, type Signal, signal } from \"@preact/signals\";\nimport { submitError } from \"./error.ts\";\nimport type { ActionRegistry } from \"./registry.ts\";\n\nfunction isFormElement(target: EventTarget | null): target is HTMLFormElement {\n  if (!target) return false;\n  if (typeof HTMLFormElement !== \"undefined\") {\n    return target instanceof HTMLFormElement;\n  }\n  const t = target as unknown as { tagName?: unknown };\n  return typeof t.tagName === \"string\" && t.tagName === \"FORM\";\n}\n\nexport type FormOpenContext<TStores> = {\n  data: Record<string, string>;\n  stores: TStores;\n};\n\nexport type FormSubmitContext<TValues, TStores> = {\n  values: TValues;\n  stores: TStores;\n};\n\nexport type FormConfig<TValues extends Record<string, string>, TStores> = {\n  /** Used as action namespace: `{name}:open`, `{name}:close`, `{name}:submit`. */\n  name: string;\n  initialValues: TValues;\n  onSubmit: (ctx: FormSubmitContext<TValues, TStores>) => void | Promise<void>;\n  /** Invoked on open; return partial overrides to pre-populate fields. */\n  onOpen?: (ctx: FormOpenContext<TStores>) => Partial<TValues> | undefined;\n  /** Returns false while open → form auto-closes (entity-deletion guard). */\n  guard?: (ctx: { stores: TStores }) => boolean;\n  /** Synchronous validation. Returning keys blocks submit. */\n  validate?: (values: TValues) => Partial<Record<keyof TValues, string>> | null;\n};\n\nexport type FormStore<TValues extends Record<string, string>, TStores> = {\n  readonly name: string;\n  readonly isOpen: ReadonlySignal<boolean>;\n  readonly values: ReadonlySignal<TValues>;\n  readonly fields: { [K in keyof TValues]: Signal<TValues[K]> };\n  readonly errors: ReadonlySignal<Partial<Record<keyof TValues, string>>>;\n  readonly isSubmitting: ReadonlySignal<boolean>;\n  readonly openParams: ReadonlySignal<Record<string, string>>;\n  open(override?: Partial<TValues>, params?: Record<string, string>): void;\n  close(): void;\n  submit(event?: Event): Promise<void>;\n  /** Late-binds stores; required before guard/onOpen/onSubmit can access stores. */\n  bindStores(getStores: () => TStores): void;\n  /** Action handler entries. Spread into the user's ActionRegistry. */\n  actions: ActionRegistry<TStores>;\n};\n\nexport function createForm<TValues extends Record<string, string>, TStores>(\n  config: FormConfig<TValues, TStores>\n): FormStore<TValues, TStores> {\n  const fieldKeys = Object.keys(config.initialValues) as unknown as (keyof TValues)[];\n\n  const fields = {} as unknown as { [K in keyof TValues]: Signal<TValues[K]> };\n  for (const key of fieldKeys) {\n    fields[key] = signal(config.initialValues[key]);\n  }\n\n  const values = computed<TValues>(() => {\n    const v = {} as unknown as TValues;\n    for (const key of fieldKeys) {\n      v[key] = fields[key].value;\n    }\n    return v;\n  });\n\n  const isOpen = signal(false);\n  const isSubmitting = signal(false);\n  const errors = signal<Partial<Record<keyof TValues, string>>>({});\n  const openParams = signal<Record<string, string>>({});\n\n  let getStoresRef: (() => TStores) | null = null;\n  let disposeGuardEffect: (() => void) | null = null;\n\n  function getStoresOrThrow(): TStores {\n    if (!getStoresRef) {\n      throw new Error(\n        `Form \"${config.name}\" used before bindStores(). Call form.bindStores(() => yourStores) at app init.`\n      );\n    }\n    return getStoresRef();\n  }\n\n  function resetToInitial(): void {\n    for (const key of fieldKeys) {\n      fields[key].value = config.initialValues[key];\n    }\n    errors.value = {};\n  }\n\n  // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: open applies two layers of overrides plus optional onOpen — branchy by design.\n  function open(override?: Partial<TValues>, params: Record<string, string> = {}): void {\n    resetToInitial();\n    openParams.value = params;\n    if (config.onOpen && getStoresRef) {\n      const onOpenOverride = config.onOpen({ data: params, stores: getStoresOrThrow() }) ?? {};\n      for (const [k, v] of Object.entries(onOpenOverride)) {\n        if (k in fields) {\n          fields[k as keyof TValues].value = v as TValues[keyof TValues];\n        }\n      }\n    }\n    if (override) {\n      for (const [k, v] of Object.entries(override)) {\n        if (k in fields) {\n          fields[k as keyof TValues].value = v as TValues[keyof TValues];\n        }\n      }\n    }\n    isOpen.value = true;\n  }\n\n  function close(): void {\n    isOpen.value = false;\n    resetToInitial();\n    openParams.value = {};\n  }\n\n  // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: submit funnels FormData, validate, onSubmit, errorState, and close — one-path-per-stage by design.\n  async function submit(event?: Event): Promise<void> {\n    if (event) event.preventDefault();\n    if (event && isFormElement(event.target)) {\n      const fd = new FormData(event.target);\n      for (const key of fieldKeys) {\n        const raw = fd.get(key as unknown as string);\n        if (raw !== null) {\n          fields[key].value = String(raw) as unknown as TValues[typeof key];\n        }\n      }\n    }\n    const current = values.value;\n    const validationErrors = config.validate?.(current);\n    if (validationErrors && Object.keys(validationErrors).length > 0) {\n      errors.value = validationErrors;\n      return;\n    }\n    errors.value = {};\n    isSubmitting.value = true;\n    try {\n      await config.onSubmit({\n        values: current,\n        stores: getStoresOrThrow(),\n      });\n      close();\n    } catch (err) {\n      submitError(`${config.name}:submit`, err);\n    } finally {\n      isSubmitting.value = false;\n    }\n  }\n\n  function bindStores(getStores: () => TStores): void {\n    getStoresRef = getStores;\n    disposeGuardEffect?.();\n    const guardFn = config.guard;\n    if (guardFn) {\n      disposeGuardEffect = effect(() => {\n        if (!isOpen.value) return;\n        if (!guardFn({ stores: getStores() })) close();\n      });\n    }\n  }\n\n  const actions: ActionRegistry<TStores> = {\n    [`${config.name}:open`]: ({ data }) => {\n      open(undefined, data);\n    },\n    [`${config.name}:close`]: () => {\n      close();\n    },\n    [`${config.name}:submit`]: async ({ event }) => {\n      await submit(event);\n    },\n  };\n\n  return {\n    name: config.name,\n    isOpen,\n    values,\n    fields,\n    errors,\n    isSubmitting,\n    openParams,\n    open,\n    close,\n    submit,\n    bindStores,\n    actions,\n  };\n}\n\n/**\n * Compose many forms into a single set: merged actions, closeAll, openForm signal.\n */\nexport type FormSet<TStores> = {\n  actions: ActionRegistry<TStores>;\n  openForm: ReadonlySignal<string | null>;\n  closeAll(): void;\n  bindStores(getStores: () => TStores): void;\n};\n\nexport function createFormSet<TStores>(\n  forms: readonly FormStore<Record<string, string>, TStores>[]\n): FormSet<TStores> {\n  const merged: ActionRegistry<TStores> = {};\n  for (const form of forms) {\n    Object.assign(merged, form.actions);\n  }\n\n  const openForm = computed<string | null>(() => {\n    for (const form of forms) {\n      if (form.isOpen.value) return form.name;\n    }\n    return null;\n  });\n\n  return {\n    actions: merged,\n    openForm,\n    closeAll() {\n      for (const form of forms) form.close();\n    },\n    bindStores(getStores) {\n      for (const form of forms) form.bindStores(getStores);\n    },\n  };\n}\n",
+    "/**\n * Store base + Preact context.\n *\n * `createStore` is a thin convention-enforcer: a typed bag of signals\n * plus methods. Apps use it to define domain stores whose only public\n * mutation surface is named methods (actions call them; components read\n * signals and dispatch actions). No cleverness — a named pattern more\n * than a library.\n *\n * `StoreProvider` + `useStores` wire the stores bag into Preact context\n * so components and the delegation runtime can reach it via a single hook.\n */\n\nimport type { ComponentChildren } from \"preact\";\nimport { createContext } from \"preact\";\nimport { useContext } from \"preact/hooks\";\n\n/**\n * Identity helper; exists so domain stores have a canonical creation\n * call even though the bag itself is a plain object. Centralising here\n * lets us hang additional behaviour off the call site later (debug\n * instrumentation, devtools) without a migration.\n */\nexport function createStore<T extends object>(init: T): T {\n  return init;\n}\n\nconst StoreContext = createContext<unknown>(null);\n\nexport type StoreProviderProps<TStores> = {\n  children: ComponentChildren;\n  stores: TStores;\n};\n\nexport function StoreProvider<TStores>({ children, stores }: StoreProviderProps<TStores>) {\n  return <StoreContext.Provider value={stores}>{children}</StoreContext.Provider>;\n}\n\nexport function useStores<TStores>(): TStores {\n  const ctx = useContext(StoreContext) as unknown as TStores | null;\n  if (ctx === null) {\n    throw new Error(\"useStores must be used within a StoreProvider\");\n  }\n  return ctx;\n}\n",
+    "/**\n * Testing helpers for action handlers.\n *\n * Handlers are plain functions taking an ActionContext; these helpers\n * build the context pieces without jsdom. For full-DOM tests use the\n * browser harness at `@fairfox/polly/test/browser`.\n */\n\nimport type { ActionContext, ActionHandler, ActionRegistry } from \"./registry.ts\";\n\n/**\n * Build a mock element that satisfies ActionContext.element.\n * Only the surface a handler is likely to touch is populated.\n */\nexport function createMockElement(\n  attrs: Record<string, string> = {},\n  tagName = \"DIV\"\n): HTMLElement {\n  const attrMap = new Map(Object.entries(attrs));\n  const el = {\n    tagName,\n    nodeType: 1,\n    getAttribute: (name: string) => attrMap.get(name) ?? null,\n    setAttribute: (name: string, value: string) => {\n      attrMap.set(name, value);\n    },\n    hasAttribute: (name: string) => attrMap.has(name),\n    removeAttribute: (name: string) => {\n      attrMap.delete(name);\n    },\n    attributes: Array.from(attrMap.entries()).map(([name, value]) => ({\n      name,\n      value,\n    })),\n  } as unknown as HTMLElement;\n  return el;\n}\n\n/** Build a minimal submit-like event wrapping a `<form>` FormData payload. */\nexport function createMockSubmitEvent(form: HTMLFormElement | Record<string, string>): Event {\n  let target: HTMLFormElement;\n  if (typeof HTMLFormElement !== \"undefined\" && form instanceof HTMLFormElement) {\n    target = form;\n  } else {\n    target = createMockFormElement(form as unknown as Record<string, string>);\n  }\n  let defaultPrevented = false;\n  return {\n    type: \"submit\",\n    target,\n    currentTarget: target,\n    preventDefault() {\n      defaultPrevented = true;\n    },\n    stopPropagation() {\n      /* noop */\n    },\n    get defaultPrevented() {\n      return defaultPrevented;\n    },\n  } as unknown as Event;\n}\n\nfunction createMockFormElement(fields: Record<string, string>): HTMLFormElement {\n  return {\n    nodeType: 1,\n    tagName: \"FORM\",\n    elements: Object.entries(fields).map(([name, value]) => ({\n      name,\n      value,\n    })),\n  } as unknown as HTMLFormElement;\n}\n\n/**\n * Shallow-merged partial stores. Callers typically pass signal-backed fakes.\n */\nexport function createMockStores<TStores extends object>(partial: Partial<TStores> = {}): TStores {\n  return partial as unknown as TStores;\n}\n\n/**\n * Run a handler in isolation. Useful for unit-testing action logic without\n * wiring the full document event delegation.\n */\nexport async function runAction<TStores>(\n  registry: ActionRegistry<TStores>,\n  action: string,\n  ctx: Partial<ActionContext<TStores>> & { stores: TStores }\n): Promise<void> {\n  const handler: ActionHandler<TStores> | undefined = registry[action];\n  if (!handler) {\n    throw new Error(`No handler registered for action \"${action}\"`);\n  }\n  const fullCtx: ActionContext<TStores> = {\n    stores: ctx.stores,\n    event: ctx.event ?? new Event(\"click\"),\n    element: ctx.element ?? createMockElement(),\n    data: ctx.data ?? {},\n  };\n  await handler(fullCtx);\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "EEBB85AB8D494BC664756E2164756E21",
+  "names": []
+}

package/dist/src/actions/overlay.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Overlay registry.
+ *
+ * Tracks the stack of open overlays (modals, popovers, confirm dialogs) so
+ * Escape can close the topmost and `data-overlay-id`-based DOM scans have
+ * a mirror in memory. Each entry stores an id plus an optional close
+ * callback; `closeTopOverlay` invokes the callback and pops the entry.
+ */
+export type OverlayEntry = {
+    id: string;
+    onClose?: () => void;
+};
+/** Current overlay stack as a read-only snapshot. */
+export declare function overlayStack(): readonly OverlayEntry[];
+/** Is any overlay currently open? */
+export declare function hasOpenOverlay(): boolean;
+/** The top of the stack, or undefined if empty. */
+export declare function topOverlay(): OverlayEntry | undefined;
+/** Push an overlay onto the stack. Returns the popped entry when closed. */
+export declare function pushOverlay(entry: OverlayEntry): void;
+/** Pop a specific overlay by id (or the top if no id given). */
+export declare function popOverlay(id?: string): OverlayEntry | undefined;
+/** Close the top overlay by calling its onClose and popping it. */
+export declare function closeTopOverlay(): OverlayEntry | undefined;
+/** Reset the stack. Intended for tests. */
+export declare function resetOverlayStack(): void;

package/dist/src/actions/registry.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Action registry types.
+ *
+ * An action registry is a plain object mapping action names to handlers.
+ * Handlers receive a typed context with the app's stores, the DOM event,
+ * the element carrying `data-action`, and parsed `data-action-*` data.
+ * Handlers return void or a Promise for async work.
+ *
+ * Users compose registries by spreading partial registries (e.g. from
+ * `createForm`) into one central object:
+ *
+ *   const ACTION_REGISTRY: ActionRegistry<RootStore> = {
+ *     ...teamForm.actions,
+ *     ...projectForm.actions,
+ *     'app:theme:toggle': ({ stores }) => { ... },
+ *   }
+ */
+export type ActionContext<TStores> = {
+    stores: TStores;
+    event: Event;
+    element: HTMLElement;
+    data: Record<string, string>;
+};
+export type ActionHandler<TStores> = (ctx: ActionContext<TStores>) => void | Promise<void>;
+export type ActionRegistry<TStores> = Record<string, ActionHandler<TStores>>;

package/dist/src/actions/store.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Store base + Preact context.
+ *
+ * `createStore` is a thin convention-enforcer: a typed bag of signals
+ * plus methods. Apps use it to define domain stores whose only public
+ * mutation surface is named methods (actions call them; components read
+ * signals and dispatch actions). No cleverness — a named pattern more
+ * than a library.
+ *
+ * `StoreProvider` + `useStores` wire the stores bag into Preact context
+ * so components and the delegation runtime can reach it via a single hook.
+ */
+import type { ComponentChildren } from "preact";
+/**
+ * Identity helper; exists so domain stores have a canonical creation
+ * call even though the bag itself is a plain object. Centralising here
+ * lets us hang additional behaviour off the call site later (debug
+ * instrumentation, devtools) without a migration.
+ */
+export declare function createStore<T extends object>(init: T): T;
+export type StoreProviderProps<TStores> = {
+    children: ComponentChildren;
+    stores: TStores;
+};
+export declare function StoreProvider<TStores>({ children, stores }: StoreProviderProps<TStores>): import("preact").JSX.Element;
+export declare function useStores<TStores>(): TStores;