attaform 0.27.6 → 0.29.0

package/dist/dev/shared/attaform-dev.DD5m2W51.mjs

@@ -0,0 +1,220 @@
+import { c as RegistryNotInstalledError, O as OutsideSetupError, g as pathKeyToDotted } from './attaform-dev.A-TpJW0B.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) {
+    if (source === "explicit") {
+      console.warn(
+        "[attaform] createAttaform() install was called twice on the same app; the second call is a no-op. Likely cause: registering the plugin via both the Nuxt module AND a manual `app.use(...)`."
+      );
+    }
+    return app._attaform;
+  }
+  const registry = createRegistry(options);
+  attachRegistryToApp(app, registry);
+  if (options.devtools !== false && !registry.ssr) {
+    void (async () => {
+      try {
+        const { setupAttaformDevtools } = await import('../chunks/devtools.mjs');
+        await setupAttaformDevtools(app, registry);
+      } catch {
+      }
+    })();
+  }
+  return registry;
+}
+function ensureAttaformInstalled(app) {
+  return installAttaformOnApp(app, {}, "lazy");
+}
+function createAttaform(options = {}) {
+  const plugin = {
+    install(app) {
+      installAttaformOnApp(app, options, "explicit");
+    }
+  };
+  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)) {
+    {
+      let got = payload;
+      if (payload !== null && typeof payload === "object") {
+        got = "v" in payload ? payload.v : void 0;
+      }
+      console.warn(
+        `[attaform] hydrateAttaformState: payload version mismatch (expected ${ATTAFORM_STATE_VERSION}, got ${String(got)}). Skipping hydration \u2014 forms will construct fresh. This usually means the SSR bundle is on a different attaform version than the client (rolling deploy / stale cache).`
+      );
+    }
+    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 };