attaform 0.27.6 → 0.29.0

package/dist/shared/attaform.Cvao8bW5.mjs

@@ -0,0 +1,358 @@
+import { m as mapSegmentKeys, f as pathsEqual, i as isPathPrefix } from './attaform.CZYt_5N_.mjs';
+
+const DEFAULT_FIELD_VALIDATION_DEBOUNCE_MS = 0;
+const DEFAULT_HISTORY_MAX_SNAPSHOTS = 128;
+const RESERVED_KEY_PREFIX = "__atta:";
+const ANONYMOUS_FORM_KEY_PREFIX = `${RESERVED_KEY_PREFIX}anon:`;
+const ANONYMOUS_WIZARD_KEY_PREFIX = `${RESERVED_KEY_PREFIX}anon-wizard:`;
+const DEFAULT_MAX_RECURSION_DEPTH = 64;
+function normalizeNumericOption(config) {
+  const { value, source, allowInfinity, min, defaultValue } = config;
+  if (allowInfinity && value === Infinity) return Infinity;
+  if (typeof value !== "number" || Number.isNaN(value) || value === Infinity || value === -Infinity) {
+    return defaultValue;
+  }
+  return Math.max(min, Math.floor(value));
+}
+function pickDefined(bag) {
+  const out = {};
+  for (const key of Object.keys(bag)) {
+    if (bag[key] !== void 0) out[key] = bag[key];
+  }
+  return out;
+}
+
+function callConsumerSchemaFn(fn, fallback, site) {
+  try {
+    return fn();
+  } catch (err) {
+    return fallback;
+  }
+}
+function readConsumerProp(obj, key) {
+  try {
+    return obj[key];
+  } catch {
+    return void 0;
+  }
+}
+function consumerKeys(obj) {
+  try {
+    return Object.keys(obj);
+  } catch {
+    return [];
+  }
+}
+function readConsumerIndex(arr, i) {
+  try {
+    return arr[i];
+  } catch {
+    return void 0;
+  }
+}
+function consumerSymbolKeys(obj) {
+  try {
+    return Object.getOwnPropertySymbols(obj);
+  } catch {
+    return [];
+  }
+}
+function consumerHas(obj, key) {
+  try {
+    return key in obj;
+  } catch {
+    return false;
+  }
+}
+
+function safeAssign(target, key, value) {
+  if (key === "__proto__") {
+    Object.defineProperty(target, key, {
+      value,
+      writable: true,
+      enumerable: true,
+      configurable: true
+    });
+    return;
+  }
+  target[key] = value;
+}
+function isShadowedKey(key) {
+  return key in Object.prototype;
+}
+function safeOwnRead(target, key) {
+  if (isShadowedKey(key)) {
+    const desc = Object.getOwnPropertyDescriptor(target, key);
+    if (desc === void 0) return void 0;
+    return "value" in desc ? desc.value : readConsumerProp(target, key);
+  }
+  return readConsumerProp(target, key);
+}
+function safeOwnHas(target, key) {
+  try {
+    return Object.prototype.hasOwnProperty.call(target, key);
+  } catch {
+    return false;
+  }
+}
+function spreadConsumerRecord(src) {
+  try {
+    return { ...src };
+  } catch {
+    const out = {};
+    for (const key of Object.keys(src)) {
+      safeAssign(out, key, readConsumerProp(src, key));
+    }
+    return out;
+  }
+}
+function copyConsumerArray(src) {
+  try {
+    return src.slice();
+  } catch {
+    const out = new Array(src.length);
+    for (let i = 0; i < src.length; i++) out[i] = readConsumerIndex(src, i);
+    return out;
+  }
+}
+
+function isDescendable(value) {
+  if (value === null || typeof value !== "object") return false;
+  if (Array.isArray(value)) return true;
+  if (value instanceof Map) return mapSegmentKeys(value) !== null;
+  const proto = Object.getPrototypeOf(value);
+  return proto === null || proto === Object.prototype;
+}
+function appendSegment(prefix, segment) {
+  const next = new Array(prefix.length + 1);
+  for (let i = 0; i < prefix.length; i++) {
+    const s = prefix[i];
+    next[i] = s;
+  }
+  next[prefix.length] = segment;
+  return next;
+}
+function diffAndApply(oldValue, newValue, prefix, visit) {
+  if (Object.is(oldValue, newValue)) return;
+  const oldIsDescendable = isDescendable(oldValue);
+  const newIsDescendable = isDescendable(newValue);
+  if (oldValue === void 0 && newIsDescendable) {
+    walkNewDescendable(newValue, prefix, visit);
+    return;
+  }
+  if (oldIsDescendable && newValue === void 0) {
+    walkOldDescendable(oldValue, prefix, visit);
+    return;
+  }
+  if (oldIsDescendable && newIsDescendable) {
+    const oldIsMap = oldValue instanceof Map;
+    const newIsMap = newValue instanceof Map;
+    if (oldIsMap && newIsMap) {
+      diffMapsLockstep(oldValue, newValue, prefix, visit);
+      return;
+    }
+    if (oldIsMap !== newIsMap) {
+      visit({ kind: "changed", path: prefix, oldValue, newValue });
+      return;
+    }
+    const oldIsArray = Array.isArray(oldValue);
+    const newIsArray = Array.isArray(newValue);
+    if (oldIsArray && newIsArray) {
+      diffArraysLockstep(oldValue, newValue, prefix, visit);
+      return;
+    }
+    if (!oldIsArray && !newIsArray) {
+      diffObjectsLockstep(
+        oldValue,
+        newValue,
+        prefix,
+        visit
+      );
+      return;
+    }
+    visit({ kind: "changed", path: prefix, oldValue, newValue });
+    return;
+  }
+  if (oldIsDescendable && !newIsDescendable) {
+    visit({ kind: "changed", path: prefix, oldValue, newValue });
+    return;
+  }
+  if (!oldIsDescendable && newIsDescendable) {
+    visit({ kind: "changed", path: prefix, oldValue, newValue });
+    return;
+  }
+  if (oldValue === void 0) {
+    visit({ kind: "added", path: prefix, newValue });
+    return;
+  }
+  if (newValue === void 0) {
+    visit({ kind: "removed", path: prefix, oldValue });
+    return;
+  }
+  visit({ kind: "changed", path: prefix, oldValue, newValue });
+}
+function walkNewDescendable(newValue, prefix, visit) {
+  if (Array.isArray(newValue)) {
+    for (let i = 0; i < newValue.length; i++) {
+      diffAndApply(void 0, readConsumerIndex(newValue, i), appendSegment(prefix, i), visit);
+    }
+  } else if (newValue instanceof Map) {
+    for (const [key, entry] of newValue) {
+      diffAndApply(void 0, entry, appendSegment(prefix, key), visit);
+    }
+  } else {
+    const rec = newValue;
+    for (const k of consumerKeys(rec)) {
+      diffAndApply(void 0, readConsumerProp(rec, k), appendSegment(prefix, k), visit);
+    }
+  }
+}
+function walkOldDescendable(oldValue, prefix, visit) {
+  if (Array.isArray(oldValue)) {
+    for (let i = 0; i < oldValue.length; i++) {
+      diffAndApply(readConsumerIndex(oldValue, i), void 0, appendSegment(prefix, i), visit);
+    }
+  } else if (oldValue instanceof Map) {
+    for (const [key, entry] of oldValue) {
+      diffAndApply(entry, void 0, appendSegment(prefix, key), visit);
+    }
+  } else {
+    const rec = oldValue;
+    for (const k of consumerKeys(rec)) {
+      diffAndApply(readConsumerProp(rec, k), void 0, appendSegment(prefix, k), visit);
+    }
+  }
+}
+function diffMapsLockstep(oldMap, newMap, prefix, visit) {
+  for (const [key, entry] of newMap) {
+    diffAndApply(oldMap.get(key), entry, appendSegment(prefix, key), visit);
+  }
+  for (const [key, entry] of oldMap) {
+    if (newMap.has(key)) continue;
+    diffAndApply(entry, void 0, appendSegment(prefix, key), visit);
+  }
+}
+function diffArraysLockstep(oldArr, newArr, prefix, visit) {
+  const max = Math.max(oldArr.length, newArr.length);
+  for (let i = 0; i < max; i++) {
+    diffAndApply(
+      readConsumerIndex(oldArr, i),
+      readConsumerIndex(newArr, i),
+      appendSegment(prefix, i),
+      visit
+    );
+  }
+}
+function diffObjectsLockstep(oldRec, newRec, prefix, visit) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const k of consumerKeys(oldRec)) {
+    seen.add(k);
+    diffAndApply(
+      readConsumerProp(oldRec, k),
+      readConsumerProp(newRec, k),
+      appendSegment(prefix, k),
+      visit
+    );
+  }
+  for (const k of consumerKeys(newRec)) {
+    if (seen.has(k)) continue;
+    diffAndApply(
+      readConsumerProp(oldRec, k),
+      readConsumerProp(newRec, k),
+      appendSegment(prefix, k),
+      visit
+    );
+  }
+}
+function applyChangedKeys(target, source, arrayOpPath, currentPath, patches) {
+  if (!isDescendable(target) || !isDescendable(source)) return false;
+  if (target instanceof Map || source instanceof Map) return false;
+  const targetIsArray = Array.isArray(target);
+  const sourceIsArray = Array.isArray(source);
+  if (targetIsArray !== sourceIsArray) return false;
+  const depth = currentPath.length;
+  const changedFirstSegments = /* @__PURE__ */ new Set();
+  for (const patch of patches) {
+    if (patch.path.length === depth) return false;
+    changedFirstSegments.add(patch.path[depth]);
+  }
+  if (targetIsArray) {
+    const t = target;
+    const s = source;
+    if (arrayOpPath === null || pathsEqual(currentPath, arrayOpPath)) {
+      if (t.length > s.length) t.length = s.length;
+      for (const idx of changedFirstSegments) {
+        const i = typeof idx === "number" ? idx : Number(idx);
+        if (i >= s.length) continue;
+        t[i] = s[i];
+      }
+    } else {
+      for (const idx of changedFirstSegments) {
+        const i = typeof idx === "number" ? idx : Number(idx);
+        if (i >= s.length) continue;
+        const childPath = appendSegment(currentPath, i);
+        const curEl = t[i];
+        const nextEl = s[i];
+        if (isPathPrefix(childPath, arrayOpPath) && isDescendable(curEl) && isDescendable(nextEl) && applyChangedKeys(
+          curEl,
+          nextEl,
+          arrayOpPath,
+          childPath,
+          patches.filter((p) => isPathPrefix(childPath, p.path))
+        )) {
+          continue;
+        }
+        t[i] = nextEl;
+      }
+    }
+  } else {
+    const t = target;
+    const s = source;
+    const sourceKeys = new Set(Object.keys(s));
+    for (const k of Object.keys(t)) {
+      if (!sourceKeys.has(k)) delete t[k];
+    }
+    for (const k of changedFirstSegments) {
+      const key = String(k);
+      const nextVal = safeOwnRead(s, key);
+      if (arrayOpPath !== null) {
+        const curVal = safeOwnRead(t, key);
+        const childPath = appendSegment(currentPath, key);
+        if (isDescendable(curVal) && isDescendable(nextVal) && applyChangedKeys(
+          curVal,
+          nextVal,
+          arrayOpPath,
+          childPath,
+          patches.filter((p) => isPathPrefix(childPath, p.path))
+        )) {
+          continue;
+        }
+      }
+      safeAssign(t, key, nextVal);
+    }
+  }
+  return true;
+}
+function structuralSnapshot(value) {
+  if (!isDescendable(value)) return value;
+  if (value instanceof Map) {
+    const out2 = /* @__PURE__ */ new Map();
+    for (const [k, v] of value) out2.set(k, structuralSnapshot(v));
+    return out2;
+  }
+  if (Array.isArray(value)) {
+    const out2 = new Array(value.length);
+    for (let i = 0; i < value.length; i++) {
+      out2[i] = structuralSnapshot(value[i]);
+    }
+    return out2;
+  }
+  const src = value;
+  const out = {};
+  for (const k of Object.keys(src)) {
+    safeAssign(out, k, structuralSnapshot(safeOwnRead(src, k)));
+  }
+  return out;
+}
+
+export { ANONYMOUS_FORM_KEY_PREFIX as A, DEFAULT_HISTORY_MAX_SNAPSHOTS as D, RESERVED_KEY_PREFIX as R, safeOwnRead as a, safeAssign as b, callConsumerSchemaFn as c, consumerHas as d, safeOwnHas as e, spreadConsumerRecord as f, copyConsumerArray as g, consumerKeys as h, isShadowedKey as i, readConsumerProp as j, diffAndApply as k, DEFAULT_FIELD_VALIDATION_DEBOUNCE_MS as l, consumerSymbolKeys as m, normalizeNumericOption as n, applyChangedKeys as o, pickDefined as p, DEFAULT_MAX_RECURSION_DEPTH as q, readConsumerIndex as r, structuralSnapshot as s, ANONYMOUS_WIZARD_KEY_PREFIX as t };

package/dist/shared/attaform.D0x-qSXm.mjs

@@ -0,0 +1,197 @@
+import { c as RegistryNotInstalledError, O as OutsideSetupError, g as pathKeyToDotted } from './attaform.CZYt_5N_.mjs';
+import { shallowReactive, getCurrentInstance, inject } from 'vue';
+
+function detectSSR(options = {}) {
+  if (options.ssr !== void 0) return options.ssr;
+  return typeof window === "undefined" && typeof document === "undefined";
+}
+
+const kAttaformRegistry = /* @__PURE__ */ Symbol.for("attaform:registry");
+const kAttaformAncestorWizard = /* @__PURE__ */ Symbol.for(
+  "attaform:ancestor-wizard"
+);
+const kAttaformWizardActiveStepResolver = /* @__PURE__ */ Symbol.for(
+  "attaform:wizard-active-step-resolver"
+);
+const kFormContext = /* @__PURE__ */ Symbol.for("attaform:form-context");
+const kFormInstanceId = /* @__PURE__ */ Symbol.for("attaform:form-instance-id");
+function createRegistry(options = {}) {
+  const ssr = detectSSR(options);
+  const defaults = Object.freeze({ ...options.defaults ?? {} });
+  const forms = shallowReactive(/* @__PURE__ */ new Map());
+  const wizards = shallowReactive(/* @__PURE__ */ new Map());
+  const pendingHydration = shallowReactive(/* @__PURE__ */ new Map());
+  const consumers = /* @__PURE__ */ new Map();
+  const pendingEvictions = /* @__PURE__ */ new Map();
+  function cancelPendingEviction(key) {
+    const pending = pendingEvictions.get(key);
+    if (pending === void 0) return;
+    pending.cancelled = true;
+    pendingEvictions.delete(key);
+  }
+  function trackConsumer(key) {
+    cancelPendingEviction(key);
+    consumers.set(key, (consumers.get(key) ?? 0) + 1);
+    let disposed = false;
+    return () => {
+      if (disposed) return;
+      disposed = true;
+      const remaining = (consumers.get(key) ?? 1) - 1;
+      if (remaining > 0) {
+        consumers.set(key, remaining);
+        return;
+      }
+      consumers.delete(key);
+      const token = { cancelled: false };
+      pendingEvictions.set(key, token);
+      queueMicrotask(() => {
+        if (token.cancelled) return;
+        if (pendingEvictions.get(key) !== token) return;
+        pendingEvictions.delete(key);
+        const state = forms.get(key);
+        forms.delete(key);
+        if (state === void 0) return;
+        state.dispose();
+      });
+    };
+  }
+  const wizardConsumers = /* @__PURE__ */ new Map();
+  const pendingWizardEvictions = /* @__PURE__ */ new Map();
+  function cancelPendingWizardEviction(key) {
+    const pending = pendingWizardEvictions.get(key);
+    if (pending === void 0) return;
+    pending.cancelled = true;
+    pendingWizardEvictions.delete(key);
+  }
+  function trackWizardConsumer(key) {
+    cancelPendingWizardEviction(key);
+    wizardConsumers.set(key, (wizardConsumers.get(key) ?? 0) + 1);
+    let disposed = false;
+    return () => {
+      if (disposed) return;
+      disposed = true;
+      const remaining = (wizardConsumers.get(key) ?? 1) - 1;
+      if (remaining > 0) {
+        wizardConsumers.set(key, remaining);
+        return;
+      }
+      wizardConsumers.delete(key);
+      const token = { cancelled: false };
+      pendingWizardEvictions.set(key, token);
+      queueMicrotask(() => {
+        if (token.cancelled) return;
+        if (pendingWizardEvictions.get(key) !== token) return;
+        pendingWizardEvictions.delete(key);
+        wizards.delete(key);
+      });
+    };
+  }
+  const prefetchEnqueued = /* @__PURE__ */ new Set();
+  const prefetchSkipped = /* @__PURE__ */ new Set();
+  function enqueuePrefetch(key) {
+    prefetchEnqueued.add(key);
+  }
+  function skipPrefetch(key) {
+    prefetchSkipped.add(key);
+  }
+  function shouldPrefetch(key) {
+    return prefetchEnqueued.has(key) && !prefetchSkipped.has(key);
+  }
+  return {
+    forms,
+    wizards,
+    pendingHydration,
+    ssr,
+    defaults,
+    trackConsumer,
+    trackWizardConsumer,
+    enqueuePrefetch,
+    skipPrefetch,
+    shouldPrefetch
+  };
+}
+function useRegistry() {
+  const instance = getCurrentInstance();
+  if (instance === null) {
+    throw new OutsideSetupError();
+  }
+  const registry = inject(kAttaformRegistry, null);
+  if (registry === null) {
+    throw new RegistryNotInstalledError();
+  }
+  return registry;
+}
+function getRegistryFromApp(app) {
+  const registry = app._attaform;
+  if (registry === void 0) {
+    throw new RegistryNotInstalledError();
+  }
+  return registry;
+}
+function attachRegistryToApp(app, registry) {
+  app.provide(kAttaformRegistry, registry);
+  app._attaform = registry;
+}
+
+function installAttaformOnApp(app, options, source) {
+  if (app._attaform !== void 0) {
+    return app._attaform;
+  }
+  const registry = createRegistry(options);
+  attachRegistryToApp(app, registry);
+  return registry;
+}
+function ensureAttaformInstalled(app) {
+  return installAttaformOnApp(app, {});
+}
+function createAttaform(options = {}) {
+  const plugin = {
+    install(app) {
+      installAttaformOnApp(app, options);
+    }
+  };
+  return plugin;
+}
+
+const ATTAFORM_STATE_VERSION = 1;
+function renderAttaformState(app) {
+  const registry = getRegistryFromApp(app);
+  const forms = [];
+  for (const [key, state] of registry.forms) {
+    const transientList = [];
+    for (const pk of state.blankPaths) {
+      const d = pathKeyToDotted(pk);
+      if (d !== null) transientList.push(d);
+    }
+    forms.push([
+      key,
+      {
+        form: state.form.value,
+        // The wire shape stays two per-source arrays; the tagged store
+        // splits at the boundary and the client replays each side into
+        // its cell half.
+        schemaErrors: [...state.errorCells.entries()].filter(([, cell]) => cell.schema.length > 0).map(([key2, cell]) => [key2, cell.schema]),
+        userErrors: [...state.errorCells.entries()].filter(([, cell]) => cell.user.length > 0).map(([key2, cell]) => [key2, cell.user]),
+        fields: Array.from(state.fields.entries()),
+        ...transientList.length > 0 ? { blankPaths: transientList } : {}
+      }
+    ]);
+  }
+  return { v: ATTAFORM_STATE_VERSION, forms };
+}
+function hydrateAttaformState(app, payload) {
+  if (!isHydratableEnvelope(payload)) {
+    return;
+  }
+  const registry = getRegistryFromApp(app);
+  for (const [key, data] of payload.forms) {
+    registry.pendingHydration.set(key, data);
+  }
+}
+function isHydratableEnvelope(payload) {
+  return payload !== null && typeof payload === "object" && "v" in payload && payload.v === ATTAFORM_STATE_VERSION && "forms" in payload && Array.isArray(payload.forms);
+}
+
+const DEVTOOLS_WINDOW_KEY = "__attaform_devtools__";
+
+export { DEVTOOLS_WINDOW_KEY as D, createRegistry as a, kAttaformWizardActiveStepResolver as b, createAttaform as c, kFormContext as d, ensureAttaformInstalled as e, kFormInstanceId as f, getRegistryFromApp as g, hydrateAttaformState as h, kAttaformAncestorWizard as i, kAttaformRegistry as k, renderAttaformState as r, useRegistry as u };