attaform 0.27.5 → 0.28.0

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

@@ -0,0 +1,197 @@
+class AttaformError extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = new.target.name;
+  }
+}
+class InvalidPathError extends AttaformError {
+}
+class InvalidUseFormConfigError extends AttaformError {
+  constructor() {
+    super(
+      "[attaform] useForm received an invalid configuration (a schema directly, no argument, or no `schema` field). Pass it as `useForm({ schema })` \u2014 the schema is one of several configuration options. See https://attaform.dev/docs/reading-the-form/the-form for the full configuration shape." 
+    );
+  }
+}
+class SubmitErrorHandlerError extends AttaformError {
+}
+function toError(value) {
+  if (value instanceof Error) return value;
+  const message = typeof value === "string" && value.length > 0 ? value : `Submit callback threw a non-Error value (${typeof value})`;
+  return new Error(message, { cause: value });
+}
+function normalizeErrorInput(item, scope, defaultCode) {
+  if (item instanceof Error) {
+    return {
+      message: item.message.length > 0 ? item.message : "Unknown error",
+      path: scope !== void 0 ? [...scope] : [],
+      code: defaultCode
+    };
+  }
+  const entry = {
+    message: typeof item.message === "string" && item.message.length > 0 ? item.message : "Unknown error",
+    path: scope !== void 0 ? [...scope] : Array.isArray(item.path) ? [...item.path] : [],
+    code: typeof item.code === "string" && item.code.length > 0 ? item.code : defaultCode
+  };
+  if (item.data !== void 0) entry.data = item.data;
+  return entry;
+}
+function normalizeErrorInputs(input, scope, defaultCode) {
+  const items = Array.isArray(input) ? input : [input];
+  return items.map((item) => normalizeErrorInput(item, scope, defaultCode));
+}
+function* cellEntriesFor(cells, side) {
+  for (const [key, cell] of cells) {
+    const list = cell[side];
+    if (list.length > 0) yield [key, list];
+  }
+}
+class RegistryNotInstalledError extends AttaformError {
+  constructor() {
+    super(
+      "[attaform] No registry attached to this Vue app. Component-level useForm / injectForm / useRegister auto-install the registry, but SSR helpers (renderAttaformState, hydrateAttaformState) run outside setup and require an explicit `app.use(createAttaform())` at server-render time. Add it to your SSR entry, before `renderToString`." 
+    );
+  }
+}
+class OutsideSetupError extends AttaformError {
+  constructor() {
+    super(
+      "[attaform] useForm / injectForm called outside Vue setup(). Move into setup or mount a child component to trigger from an event." 
+    );
+  }
+}
+class ReservedFormKeyError extends AttaformError {
+  constructor(key) {
+    super(
+      `[attaform] Form key "${key}" uses the reserved "__atta:" namespace. Use a different prefix \u2014 "__atta:" is for library-internal synthetic keys (anonymous useForm() calls without an explicit key).` 
+    );
+  }
+}
+function groupErrorsByKey(entries) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const raw of entries) {
+    const { key } = canonicalizePath(raw.path);
+    const list = grouped.get(key);
+    if (list === void 0) grouped.set(key, [raw]);
+    else list.push(raw);
+  }
+  return grouped;
+}
+
+const INTEGER_SEGMENT = /^(?:0|[1-9]\d*)$/;
+function normalizeSegment(raw) {
+  if (typeof raw === "number") {
+    if (!Number.isInteger(raw) || raw < 0) {
+      throw new InvalidPathError(
+        `Path segments must be non-negative integers when numeric; got ${String(raw)}` 
+      );
+    }
+    return raw;
+  }
+  if (INTEGER_SEGMENT.test(raw)) return Number(raw);
+  return raw;
+}
+function parseDottedPath(path) {
+  if (path.length === 0) return [""];
+  const rawSegments = path.split(".");
+  const segments = [];
+  for (const raw of rawSegments) {
+    if (raw.length === 0) {
+      throw new InvalidPathError(
+        `Path '${path}' has an empty segment; use the array form for empty keys.` 
+      );
+    }
+    segments.push(normalizeSegment(raw));
+  }
+  return segments;
+}
+const CANONICAL_STRING_CACHE_MAX = 128;
+const canonicalStringCache = /* @__PURE__ */ new Map();
+const PATHKEY_TO_SEGMENTS_MAX = 4096;
+const pathKeyToSegments = /* @__PURE__ */ new Map();
+function rememberSegmentsForPathKey(key, segments) {
+  if (!pathKeyToSegments.has(key) && pathKeyToSegments.size >= PATHKEY_TO_SEGMENTS_MAX) {
+    const oldest = pathKeyToSegments.keys().next().value;
+    if (oldest !== void 0) pathKeyToSegments.delete(oldest);
+  }
+  pathKeyToSegments.set(key, segments);
+}
+function segmentsForPathKey(key) {
+  const cached = pathKeyToSegments.get(key);
+  if (cached !== void 0) return cached;
+  let parsed;
+  try {
+    parsed = JSON.parse(key);
+  } catch {
+    return null;
+  }
+  if (!Array.isArray(parsed)) return null;
+  const segments = [];
+  for (const raw of parsed) {
+    if (typeof raw !== "string" && typeof raw !== "number") return null;
+    segments.push(normalizeSegment(raw));
+  }
+  rememberSegmentsForPathKey(key, segments);
+  return segments;
+}
+function canonicalizePath(input) {
+  if (typeof input === "string") {
+    const cached = canonicalStringCache.get(input);
+    if (cached !== void 0) return cached;
+    const segments = parseDottedPath(input);
+    const key = JSON.stringify(segments);
+    const entry = { segments, key };
+    if (canonicalStringCache.size >= CANONICAL_STRING_CACHE_MAX) {
+      const oldest = canonicalStringCache.keys().next().value;
+      if (oldest !== void 0) canonicalStringCache.delete(oldest);
+    }
+    canonicalStringCache.set(input, entry);
+    rememberSegmentsForPathKey(key, segments);
+    return entry;
+  }
+  return keyForSegments(input);
+}
+function keyForSegments(input) {
+  const segments = Array.from(input).map(normalizeSegment);
+  const key = JSON.stringify(segments);
+  rememberSegmentsForPathKey(key, segments);
+  return { segments, key };
+}
+function segmentsToDotted(segments) {
+  return segments.join(".");
+}
+function pathKeyToDotted(key) {
+  const segments = segmentsForPathKey(key);
+  if (segments === null) return null;
+  return segmentsToDotted(segments);
+}
+function coerceToPathKey(input) {
+  if (input.length > 0 && input.charCodeAt(0) === 91) {
+    try {
+      const parsed = JSON.parse(input);
+      if (Array.isArray(parsed) && parsed.every((s) => typeof s === "string" || typeof s === "number")) {
+        return input;
+      }
+    } catch {
+    }
+  }
+  return canonicalizePath(input).key;
+}
+const ROOT_PATH = Object.freeze([]);
+const ROOT_PATH_KEY = "[]";
+function isPathPrefix(prefix, path) {
+  if (path.length < prefix.length) return false;
+  for (let i = 0; i < prefix.length; i++) {
+    if (path[i] !== prefix[i]) return false;
+  }
+  return true;
+}
+function pathsEqual(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) return false;
+  }
+  return true;
+}
+
+export { AttaformError as A, InvalidPathError as I, OutsideSetupError as O, ROOT_PATH as R, SubmitErrorHandlerError as S, InvalidUseFormConfigError as a, ROOT_PATH_KEY as b, RegistryNotInstalledError as c, ReservedFormKeyError as d, canonicalizePath as e, pathsEqual as f, pathKeyToDotted as g, cellEntriesFor as h, isPathPrefix as i, groupErrorsByKey as j, keyForSegments as k, normalizeErrorInputs as l, coerceToPathKey as m, normalizeErrorInput as n, parseDottedPath as p, segmentsForPathKey as s, toError as t };