@elabs-ai/components-ui 4.1.0 → 5.0.0

package/dist/chunk-GAI4NEPU.js

@@ -0,0 +1,151 @@
+"use client";
+import {
+  mediaTypeFromName,
+  resolveFileKind
+} from "./chunk-IRUZDWJ3.js";
+
+// src/lib/file-source.ts
+function nameFromUrl(url) {
+  try {
+    const parsed = new URL(url, "http://localhost");
+    const last = parsed.pathname.split("/").filter(Boolean).pop();
+    return last ? decodeURIComponent(last) : "file";
+  } catch {
+    const stripped = url.split(/[?#]/)[0] ?? "";
+    const last = stripped.split("/").filter(Boolean).pop();
+    return last && last.length > 0 ? last : "file";
+  }
+}
+function blobToArrayBuffer(blob) {
+  if (typeof blob.arrayBuffer === "function") return blob.arrayBuffer();
+  if (typeof FileReader !== "function") {
+    return Promise.reject(
+      new Error("Cannot read file bytes: no Blob.arrayBuffer and no FileReader.")
+    );
+  }
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => resolve(reader.result);
+    reader.onerror = () => reject(reader.error ?? new Error("Could not read the file."));
+    reader.readAsArrayBuffer(blob);
+  });
+}
+function identify(source) {
+  switch (source.kind) {
+    case "file":
+      return { name: source.file.name || "file", declaredMediaType: source.file.type };
+    case "blob":
+      return { name: source.name, declaredMediaType: source.mediaType ?? source.blob.type };
+    case "buffer":
+      return { name: source.name, declaredMediaType: source.mediaType };
+    case "text":
+      return {
+        name: source.name,
+        declaredMediaType: source.mediaType ?? mediaTypeFromName(source.name) ?? "text/plain"
+      };
+    case "url":
+      return { name: source.name ?? nameFromUrl(source.url), declaredMediaType: source.mediaType };
+  }
+}
+function knownSize(source) {
+  switch (source.kind) {
+    case "file":
+      return source.file.size;
+    case "blob":
+      return source.blob.size;
+    case "buffer":
+      return source.buffer.byteLength;
+    // `text` would need an encode pass, `url` a fetch — neither is free, so we
+    // report "unknown" rather than doing work a caller may not want.
+    default:
+      return void 0;
+  }
+}
+function assertNotAborted(signal) {
+  if (signal?.aborted) throw signal.reason instanceof Error ? signal.reason : new Error("Aborted");
+}
+function normalizeFileSource(source) {
+  const { name, declaredMediaType } = identify(source);
+  const kind = resolveFileKind(name, declaredMediaType);
+  const alt = "alt" in source ? source.alt : void 0;
+  let bytesPromise;
+  let textPromise;
+  let objectUrl;
+  async function readBytes(signal) {
+    assertNotAborted(signal);
+    switch (source.kind) {
+      case "file":
+        return blobToArrayBuffer(source.file);
+      case "blob":
+        return blobToArrayBuffer(source.blob);
+      case "buffer":
+        return source.buffer;
+      case "text":
+        return new TextEncoder().encode(source.text).buffer;
+      case "url": {
+        const res = await fetch(source.url, {
+          ...source.init,
+          signal: signal ?? source.init?.signal
+        });
+        if (!res.ok) {
+          throw new Error(`Could not read "${name}": the server responded ${res.status}.`);
+        }
+        return res.arrayBuffer();
+      }
+    }
+  }
+  async function blobOf(signal) {
+    if (source.kind === "file") return source.file;
+    if (source.kind === "blob") return source.blob;
+    const buffer = await bytes(signal);
+    return new Blob([buffer], { type: kind.mediaType });
+  }
+  function bytes(signal) {
+    bytesPromise ??= readBytes(signal).catch((error) => {
+      bytesPromise = void 0;
+      throw error;
+    });
+    return bytesPromise;
+  }
+  function text(signal) {
+    if (source.kind === "text") return Promise.resolve(source.text);
+    textPromise ??= bytes(signal).then((buffer) => new TextDecoder().decode(buffer)).catch((error) => {
+      textPromise = void 0;
+      throw error;
+    });
+    return textPromise;
+  }
+  async function url(signal) {
+    if (source.kind === "url" && !source.init) return source.url;
+    if (objectUrl) return objectUrl;
+    if (typeof URL === "undefined" || typeof URL.createObjectURL !== "function") {
+      throw new Error(
+        `Could not create a URL for "${name}": no object-URL support in this environment.`
+      );
+    }
+    objectUrl = URL.createObjectURL(await blobOf(signal));
+    return objectUrl;
+  }
+  function revoke() {
+    if (!objectUrl) return;
+    URL.revokeObjectURL(objectUrl);
+    objectUrl = void 0;
+  }
+  return {
+    name,
+    mediaType: kind.mediaType,
+    category: kind.category,
+    extension: kind.extension,
+    alt,
+    size: knownSize(source),
+    bytes,
+    text,
+    url,
+    revoke
+  };
+}
+
+export {
+  normalizeFileSource
+};
+//# sourceMappingURL=chunk-GAI4NEPU.js.map

package/dist/chunk-GAI4NEPU.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/lib/file-source.ts"],"sourcesContent":["/**\n * One input model for \"a file\", whatever the app happens to be holding.\n *\n * The library previously had three: a `File` (upload), a `string` of content\n * (chat assets), and a bare URL (attachments) — so every surface that wanted to\n * render a file first had to guess which of the three it had. {@link FileSource}\n * is the union all of them collapse into, and {@link normalizeFileSource} turns\n * any member into one uniform reader.\n *\n * Two things this fixes beyond the merge:\n *\n * - **Authenticated remote files work.** The `url` variant carries\n *   `init?: RequestInit`, so headers, credentials and an abort signal reach the\n *   fetch. A viewer that can only take a naked URL cannot open anything behind\n *   auth, which is most enterprise content.\n * - **Alt text has a home.** Every binary variant takes `alt`, so an image or a\n *   rendered page can be described without a parallel prop channel.\n *\n * Pure DOM/platform mechanics: no React, no other deps. SSR-safe to import;\n * only {@link ResolvedFileSource.url} needs a browser, and it says so.\n */\n\nimport { type FileCategory, mediaTypeFromName, resolveFileKind } from \"./file-kind\";\n\n/** Any file the library can be handed. Discriminated on `kind`. */\nexport type FileSource =\n  /** A user-picked file. Name and MIME come from the platform. */\n  | { kind: \"file\"; file: File; alt?: string }\n  /** In-memory bytes that already have a `Blob` wrapper (a generated export, a decoded attachment). */\n  | { kind: \"blob\"; blob: Blob; name: string; mediaType?: string; alt?: string }\n  /**\n   * A remote file. `init` is passed straight to `fetch` — this is how auth\n   * headers, `credentials` and an `AbortSignal` reach the request.\n   */\n  | {\n      kind: \"url\";\n      url: string;\n      name?: string;\n      mediaType?: string;\n      alt?: string;\n      init?: RequestInit;\n    }\n  /** Raw bytes with no wrapper (a worker result, a WASM output). */\n  | { kind: \"buffer\"; buffer: ArrayBuffer; name: string; mediaType: string; alt?: string }\n  /** Content the app already has as a string (an agent's markdown, a code snippet). */\n  | { kind: \"text\"; text: string; name: string; mediaType?: string };\n\n/**\n * A {@link FileSource} with its identity resolved and its bytes reachable the\n * same way regardless of where they came from.\n *\n * Reads are memoized on success, so `text()` after `bytes()` costs nothing and a\n * remote file is fetched once. A failed read is NOT cached — a retry re-runs it.\n */\nexport interface ResolvedFileSource {\n  /** Display name, always non-empty. Derived from the URL path when the caller gave none. */\n  readonly name: string;\n  /** Best-known MIME, resolved from the declared type then the extension. */\n  readonly mediaType: string;\n  /** Coarse shape, for icons/labels/fallbacks. Not a renderer routing key. */\n  readonly category: FileCategory;\n  /** Lowercased extension without the dot, or `\"\"`. */\n  readonly extension: string;\n  /** Author-supplied description, for images and rendered pages. */\n  readonly alt?: string;\n  /** Byte length when known up front. `undefined` for `text` and un-fetched `url` sources. */\n  readonly size?: number;\n\n  /** The full contents as bytes. */\n  bytes(signal?: AbortSignal): Promise<ArrayBuffer>;\n  /** The full contents decoded as UTF-8. */\n  text(signal?: AbortSignal): Promise<string>;\n  /**\n   * A URL usable as an `<img>`/`<video>`/`<iframe>` src.\n   *\n   * A public `url` source returns its own URL unchanged, so the browser streams\n   * it and no full read happens. Every other source (and any `url` source with\n   * an `init`, which the element could not replay) mints an object URL — release\n   * it with {@link revoke}. Browser only: rejects where `URL.createObjectURL`\n   * does not exist.\n   */\n  url(signal?: AbortSignal): Promise<string>;\n  /** Release any object URL this reader minted. Idempotent; safe to call unconditionally. */\n  revoke(): void;\n}\n\n/** Best-effort filename from a URL path. Never empty. */\nfunction nameFromUrl(url: string): string {\n  try {\n    // A relative URL still needs a base to parse; the base is never used.\n    const parsed = new URL(url, \"http://localhost\");\n    const last = parsed.pathname.split(\"/\").filter(Boolean).pop();\n    return last ? decodeURIComponent(last) : \"file\";\n  } catch {\n    // Unparseable: strip the query/hash by hand rather than give up. Note this\n    // runs ONLY on a parse failure — running it as a fallback for an empty\n    // pathname would return the host (\"x.test\" for \"https://x.test/\").\n    const stripped = url.split(/[?#]/)[0] ?? \"\";\n    const last = stripped.split(\"/\").filter(Boolean).pop();\n    return last && last.length > 0 ? last : \"file\";\n  }\n}\n\n/**\n * `Blob`/`File` → bytes, feature-detecting `Blob.prototype.arrayBuffer`.\n *\n * jsdom does not implement it (nor `Blob.prototype.text`), and this module is\n * reached from every downstream package's jsdom tests — so per the note in\n * `packages/ui/vitest.setup.ts`, the detection lives HERE rather than in a stub\n * that would only fix this package's own suite. `FileReader` is the fallback:\n * jsdom implements it, and it is the pre-2020 browser path anyway.\n */\nfunction blobToArrayBuffer(blob: Blob): Promise<ArrayBuffer> {\n  if (typeof blob.arrayBuffer === \"function\") return blob.arrayBuffer();\n\n  if (typeof FileReader !== \"function\") {\n    return Promise.reject(\n      new Error(\"Cannot read file bytes: no Blob.arrayBuffer and no FileReader.\"),\n    );\n  }\n  return new Promise<ArrayBuffer>((resolve, reject) => {\n    const reader = new FileReader();\n    reader.onload = () => resolve(reader.result as ArrayBuffer);\n    reader.onerror = () => reject(reader.error ?? new Error(\"Could not read the file.\"));\n    reader.readAsArrayBuffer(blob);\n  });\n}\n\n/** The declared name/MIME for a source, before extension inference. */\nfunction identify(source: FileSource): { name: string; declaredMediaType?: string } {\n  switch (source.kind) {\n    case \"file\":\n      return { name: source.file.name || \"file\", declaredMediaType: source.file.type };\n    case \"blob\":\n      return { name: source.name, declaredMediaType: source.mediaType ?? source.blob.type };\n    case \"buffer\":\n      return { name: source.name, declaredMediaType: source.mediaType };\n    case \"text\":\n      return {\n        name: source.name,\n        declaredMediaType: source.mediaType ?? mediaTypeFromName(source.name) ?? \"text/plain\",\n      };\n    case \"url\":\n      return { name: source.name ?? nameFromUrl(source.url), declaredMediaType: source.mediaType };\n  }\n}\n\n/** Byte length where the platform already knows it, without reading anything. */\nfunction knownSize(source: FileSource): number | undefined {\n  switch (source.kind) {\n    case \"file\":\n      return source.file.size;\n    case \"blob\":\n      return source.blob.size;\n    case \"buffer\":\n      return source.buffer.byteLength;\n    // `text` would need an encode pass, `url` a fetch — neither is free, so we\n    // report \"unknown\" rather than doing work a caller may not want.\n    default:\n      return undefined;\n  }\n}\n\nfunction assertNotAborted(signal: AbortSignal | undefined): void {\n  if (signal?.aborted) throw signal.reason instanceof Error ? signal.reason : new Error(\"Aborted\");\n}\n\n/**\n * Turn any {@link FileSource} into a uniform reader.\n *\n * Cheap and synchronous — it resolves identity only. Nothing is read, fetched or\n * decoded until a `bytes()` / `text()` / `url()` call.\n */\nexport function normalizeFileSource(source: FileSource): ResolvedFileSource {\n  const { name, declaredMediaType } = identify(source);\n  const kind = resolveFileKind(name, declaredMediaType);\n  const alt = \"alt\" in source ? source.alt : undefined;\n\n  let bytesPromise: Promise<ArrayBuffer> | undefined;\n  let textPromise: Promise<string> | undefined;\n  let objectUrl: string | undefined;\n\n  async function readBytes(signal?: AbortSignal): Promise<ArrayBuffer> {\n    assertNotAborted(signal);\n    switch (source.kind) {\n      case \"file\":\n        return blobToArrayBuffer(source.file);\n      case \"blob\":\n        return blobToArrayBuffer(source.blob);\n      case \"buffer\":\n        return source.buffer;\n      case \"text\":\n        return new TextEncoder().encode(source.text).buffer as ArrayBuffer;\n      case \"url\": {\n        // The caller's own signal (via `init`) still applies; this one is layered\n        // on top so a per-read abort works even when `init` carries none.\n        const res = await fetch(source.url, {\n          ...source.init,\n          signal: signal ?? source.init?.signal,\n        });\n        if (!res.ok) {\n          throw new Error(`Could not read \"${name}\": the server responded ${res.status}.`);\n        }\n        return res.arrayBuffer();\n      }\n    }\n  }\n\n  async function blobOf(signal?: AbortSignal): Promise<Blob> {\n    if (source.kind === \"file\") return source.file;\n    if (source.kind === \"blob\") return source.blob;\n    const buffer = await bytes(signal);\n    return new Blob([buffer], { type: kind.mediaType });\n  }\n\n  function bytes(signal?: AbortSignal): Promise<ArrayBuffer> {\n    // Memoize the success only: a rejected read must be retryable.\n    bytesPromise ??= readBytes(signal).catch((error: unknown) => {\n      bytesPromise = undefined;\n      throw error;\n    });\n    return bytesPromise;\n  }\n\n  function text(signal?: AbortSignal): Promise<string> {\n    if (source.kind === \"text\") return Promise.resolve(source.text);\n    textPromise ??= bytes(signal)\n      .then((buffer) => new TextDecoder().decode(buffer))\n      .catch((error: unknown) => {\n        textPromise = undefined;\n        throw error;\n      });\n    return textPromise;\n  }\n\n  async function url(signal?: AbortSignal): Promise<string> {\n    // A public remote file is already a URL an element can stream. One carrying\n    // `init` is not: the element cannot replay those headers, so we fetch here.\n    if (source.kind === \"url\" && !source.init) return source.url;\n\n    if (objectUrl) return objectUrl;\n    if (typeof URL === \"undefined\" || typeof URL.createObjectURL !== \"function\") {\n      throw new Error(\n        `Could not create a URL for \"${name}\": no object-URL support in this environment.`,\n      );\n    }\n    objectUrl = URL.createObjectURL(await blobOf(signal));\n    return objectUrl;\n  }\n\n  function revoke(): void {\n    if (!objectUrl) return;\n    URL.revokeObjectURL(objectUrl);\n    objectUrl = undefined;\n  }\n\n  return {\n    name,\n    mediaType: kind.mediaType,\n    category: kind.category,\n    extension: kind.extension,\n    alt,\n    size: knownSize(source),\n    bytes,\n    text,\n    url,\n    revoke,\n  };\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-GRWGNWIJ.js

@@ -0,0 +1,187 @@
+"use client";
+import {
+  FieldContext,
+  useFieldContext
+} from "./chunk-22Z735L6.js";
+import {
+  hasRenderableContent
+} from "./chunk-TAQI4JTE.js";
+import {
+  Label
+} from "./chunk-TEKBTTP2.js";
+import {
+  cn
+} from "./chunk-KBNWM27Q.js";
+
+// src/components/field/field.tsx
+import {
+  cloneElement,
+  forwardRef,
+  useCallback,
+  useId,
+  useLayoutEffect,
+  useMemo,
+  useState
+} from "react";
+import { Slot } from "@radix-ui/react-slot";
+import { jsx } from "react/jsx-runtime";
+var FieldRoot = forwardRef(function FieldRoot2({ invalid = false, required = false, className, children, ...props }, ref) {
+  const [descriptionIds, setDescriptionIds] = useState([]);
+  const registerDescription = useCallback((descId) => {
+    setDescriptionIds((prev) => prev.includes(descId) ? prev : [...prev, descId]);
+  }, []);
+  const unregisterDescription = useCallback((descId) => {
+    setDescriptionIds((prev) => prev.includes(descId) ? prev.filter((x) => x !== descId) : prev);
+  }, []);
+  const [errorIds, setErrorIds] = useState([]);
+  const registerError = useCallback((errId) => {
+    setErrorIds((prev) => prev.includes(errId) ? prev : [...prev, errId]);
+  }, []);
+  const unregisterError = useCallback((errId) => {
+    setErrorIds((prev) => prev.includes(errId) ? prev.filter((x) => x !== errId) : prev);
+  }, []);
+  const describedBy = useMemo(() => {
+    const ids = [...descriptionIds, ...errorIds];
+    return ids.length > 0 ? ids.join(" ") : void 0;
+  }, [descriptionIds, errorIds]);
+  const [controlOrder, setControlOrder] = useState([]);
+  const registerControl = useCallback((controlId) => {
+    setControlOrder((prev) => prev.includes(controlId) ? prev : [...prev, controlId]);
+  }, []);
+  const unregisterControl = useCallback((controlId) => {
+    setControlOrder(
+      (prev) => prev.includes(controlId) ? prev.filter((x) => x !== controlId) : prev
+    );
+  }, []);
+  const labelFor = controlOrder[0];
+  const value = useMemo(
+    () => ({
+      labelFor,
+      registerControl,
+      unregisterControl,
+      invalid,
+      required,
+      describedBy,
+      registerDescription,
+      unregisterDescription,
+      registerError,
+      unregisterError
+    }),
+    [
+      labelFor,
+      registerControl,
+      unregisterControl,
+      invalid,
+      required,
+      describedBy,
+      registerDescription,
+      unregisterDescription,
+      registerError,
+      unregisterError
+    ]
+  );
+  return /* @__PURE__ */ jsx(FieldContext.Provider, { value, children: /* @__PURE__ */ jsx("div", { ref, "data-slot": "field", className: cn("space-y-2", className), ...props, children }) });
+});
+var FieldLabel = forwardRef(function FieldLabel2({ className, ...props }, ref) {
+  const { labelFor, invalid } = useFieldContext("FieldLabel");
+  return /* @__PURE__ */ jsx(
+    Label,
+    {
+      ref,
+      htmlFor: labelFor,
+      "data-slot": "field-label",
+      className: cn(
+        "transition-colors duration-fast ease-standard",
+        invalid && "text-destructive-text",
+        className
+      ),
+      ...props
+    }
+  );
+});
+var FieldControl = forwardRef(
+  function FieldControl2({ children }, ref) {
+    const { invalid, required, describedBy, registerControl, unregisterControl } = useFieldContext("FieldControl");
+    const generatedId = useId();
+    const control = children;
+    const childProps = control.props;
+    const id = childProps.id ?? generatedId;
+    const composedDescribedBy = [childProps["aria-describedby"] ?? null, describedBy ?? null].filter(Boolean).join(" ") || void 0;
+    useLayoutEffect(() => {
+      registerControl(id);
+      return () => unregisterControl(id);
+    }, [id, registerControl, unregisterControl]);
+    return /* @__PURE__ */ jsx(
+      Slot,
+      {
+        ref,
+        id,
+        "aria-describedby": composedDescribedBy,
+        "aria-invalid": invalid,
+        "aria-required": required || void 0,
+        "data-slot": "field-control",
+        children: cloneElement(control, { id, "aria-describedby": composedDescribedBy })
+      }
+    );
+  }
+);
+var FieldDescription = forwardRef(function FieldDescription2({ className, children, id, ...props }, ref) {
+  const { registerDescription, unregisterDescription } = useFieldContext("FieldDescription");
+  const instanceId = useId();
+  const generatedId = `${instanceId}-description`;
+  const descriptionId = id ?? generatedId;
+  const hasContent = hasRenderableContent(children);
+  useLayoutEffect(() => {
+    if (!hasContent) return void 0;
+    registerDescription(descriptionId);
+    return () => unregisterDescription(descriptionId);
+  }, [hasContent, descriptionId, registerDescription, unregisterDescription]);
+  if (!hasContent) return null;
+  return /* @__PURE__ */ jsx(
+    "p",
+    {
+      ref,
+      id: descriptionId,
+      "data-slot": "field-description",
+      className: cn("text-body text-muted-foreground", className),
+      ...props,
+      children
+    }
+  );
+});
+var FieldError = forwardRef(
+  function FieldError2({ className, children, id, ...props }, ref) {
+    const { registerError, unregisterError } = useFieldContext("FieldError");
+    const instanceId = useId();
+    const generatedId = `${instanceId}-error`;
+    const errorId = id ?? generatedId;
+    const hasContent = hasRenderableContent(children);
+    useLayoutEffect(() => {
+      if (!hasContent) return void 0;
+      registerError(errorId);
+      return () => unregisterError(errorId);
+    }, [hasContent, errorId, registerError, unregisterError]);
+    if (!hasContent) return null;
+    return /* @__PURE__ */ jsx(
+      "p",
+      {
+        ref,
+        id: errorId,
+        role: "alert",
+        "data-slot": "field-error",
+        className: cn("text-body font-medium text-destructive-text", className),
+        ...props,
+        children
+      }
+    );
+  }
+);
+
+export {
+  FieldRoot,
+  FieldLabel,
+  FieldControl,
+  FieldDescription,
+  FieldError
+};
+//# sourceMappingURL=chunk-GRWGNWIJ.js.map

package/dist/chunk-GRWGNWIJ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/field/field.tsx"],"sourcesContent":["\"use client\";\n\nimport {\n  cloneElement,\n  forwardRef,\n  useCallback,\n  useId,\n  useLayoutEffect,\n  useMemo,\n  useState,\n  type ComponentPropsWithoutRef,\n  type ElementRef,\n  type HTMLAttributes,\n  type ReactElement,\n} from \"react\";\nimport { Slot } from \"@radix-ui/react-slot\";\nimport { cn } from \"../../lib/cn\";\nimport { hasRenderableContent } from \"../../lib/has-renderable-content\";\nimport { Label } from \"../label\";\nimport { FieldContext, useFieldContext, type FieldContextValue } from \"./field-context\";\n\n// ── FieldRoot ─────────────────────────────────────────────────────────────\n\nexport interface FieldRootProps extends HTMLAttributes<HTMLDivElement> {\n  /**\n   * Whether the field is currently invalid. Drives `aria-invalid` on every\n   * `FieldControl` and error styling on `FieldLabel` — independent of\n   * whether a `FieldError` with content is actually mounted, so a caller can\n   * mark the control invalid before its message has settled.\n   */\n  invalid?: boolean;\n  /** Whether the field is required. Drives `aria-required` on every `FieldControl`. */\n  required?: boolean;\n}\n\n/**\n * Compound-anatomy field: `FieldRoot` owns id generation and `aria-describedby`\n * composition; `FieldLabel`/`FieldControl`/`FieldDescription`/`FieldError` read\n * that state from context and can be composed in ANY order/layout — including\n * more than one `FieldControl` in one row (e.g. first/last name) or a\n * `FieldDescription` placed before the control. Mirrors the same accessibility\n * wiring `FieldRow` (`../field-row`) already validated (id/`aria-describedby`/\n * `aria-invalid`/`role=\"alert\"`), adapted to a shared lifted-state context so\n * it holds across independently-composed parts; `FieldRow` remains the\n * convenience wrapper for the common single-control case and is unaffected by\n * this addition (#43).\n *\n * @example\n * ```tsx\n * <FieldRoot invalid={!!error} required>\n *   <FieldLabel>{label}</FieldLabel>\n *   <FieldControl><Input /></FieldControl>\n *   <FieldDescription>{helpText}</FieldDescription>\n *   <FieldError>{error}</FieldError>\n * </FieldRoot>\n * ```\n */\nexport const FieldRoot = forwardRef<HTMLDivElement, FieldRootProps>(function FieldRoot(\n  { invalid = false, required = false, className, children, ...props },\n  ref,\n) {\n  // Each `FieldDescription`/`FieldError` INSTANCE generates and registers its\n  // own id (see below) — two lists, not one shared slot per part type, so\n  // more than one of either part under one `FieldRoot` gets distinct ids\n  // instead of colliding, and unmounting one instance only ever removes that\n  // instance's own id from its own list (never a sibling's).\n  const [descriptionIds, setDescriptionIds] = useState<readonly string[]>([]);\n  const registerDescription = useCallback((descId: string) => {\n    setDescriptionIds((prev) => (prev.includes(descId) ? prev : [...prev, descId]));\n  }, []);\n  const unregisterDescription = useCallback((descId: string) => {\n    setDescriptionIds((prev) => (prev.includes(descId) ? prev.filter((x) => x !== descId) : prev));\n  }, []);\n\n  const [errorIds, setErrorIds] = useState<readonly string[]>([]);\n  const registerError = useCallback((errId: string) => {\n    setErrorIds((prev) => (prev.includes(errId) ? prev : [...prev, errId]));\n  }, []);\n  const unregisterError = useCallback((errId: string) => {\n    setErrorIds((prev) => (prev.includes(errId) ? prev.filter((x) => x !== errId) : prev));\n  }, []);\n\n  // Fixed semantic order — every description before every error — regardless\n  // of DOM order or registration order, so \"description placed before the\n  // control\" reorders the VISIBLE layout without reordering the announced\n  // description, and a second description/error is appended rather than\n  // replacing the first.\n  const describedBy = useMemo(() => {\n    const ids = [...descriptionIds, ...errorIds];\n    return ids.length > 0 ? ids.join(\" \") : undefined;\n  }, [descriptionIds, errorIds]);\n\n  // `FieldLabel`'s `htmlFor` can only point to ONE control, so it binds to\n  // whichever `FieldControl` registers FIRST (JSX/mount order) — the common\n  // single-control case gets this for free; a multi-control row (e.g.\n  // first/last name) still labels the first field, and every additional\n  // control needs its own explicit `id` the same way any two form controls\n  // would (no new coordination prop invented for this).\n  const [controlOrder, setControlOrder] = useState<readonly string[]>([]);\n  const registerControl = useCallback((controlId: string) => {\n    setControlOrder((prev) => (prev.includes(controlId) ? prev : [...prev, controlId]));\n  }, []);\n  const unregisterControl = useCallback((controlId: string) => {\n    setControlOrder((prev) =>\n      prev.includes(controlId) ? prev.filter((x) => x !== controlId) : prev,\n    );\n  }, []);\n  const labelFor = controlOrder[0];\n\n  const value = useMemo<FieldContextValue>(\n    () => ({\n      labelFor,\n      registerControl,\n      unregisterControl,\n      invalid,\n      required,\n      describedBy,\n      registerDescription,\n      unregisterDescription,\n      registerError,\n      unregisterError,\n    }),\n    [\n      labelFor,\n      registerControl,\n      unregisterControl,\n      invalid,\n      required,\n      describedBy,\n      registerDescription,\n      unregisterDescription,\n      registerError,\n      unregisterError,\n    ],\n  );\n\n  return (\n    <FieldContext.Provider value={value}>\n      <div ref={ref} data-slot=\"field\" className={cn(\"space-y-2\", className)} {...props}>\n        {children}\n      </div>\n    </FieldContext.Provider>\n  );\n});\n\n// ── FieldLabel ────────────────────────────────────────────────────────────\n\nexport const FieldLabel = forwardRef<\n  ElementRef<typeof Label>,\n  ComponentPropsWithoutRef<typeof Label>\n>(function FieldLabel({ className, ...props }, ref) {\n  const { labelFor, invalid } = useFieldContext(\"FieldLabel\");\n  return (\n    <Label\n      ref={ref}\n      htmlFor={labelFor}\n      data-slot=\"field-label\"\n      className={cn(\n        \"transition-colors duration-fast ease-standard\",\n        invalid && \"text-destructive-text\",\n        className,\n      )}\n      {...props}\n    />\n  );\n});\n\n// ── FieldControl ──────────────────────────────────────────────────────────\n\nexport interface FieldControlProps {\n  /**\n   * The single field control (`Input`, `Textarea`, `Select`, …). Receives\n   * `id`/`aria-describedby`/`aria-invalid`/`aria-required` via a Radix\n   * `Slot` — must be a single element that forwards those props to a real\n   * form control. Compose more than one `FieldControl` inside one\n   * `FieldRoot` for a multi-control row (each gets its own independent id;\n   * give every control but the first its own explicit `id`, the same way\n   * you would for any two form controls that must not collide). `FieldLabel`\n   * can only associate with ONE control (the first to mount), so give every\n   * OTHER control in the row its own `aria-label` — a shared visual label\n   * plus a placeholder is not a real accessible name for the rest.\n   */\n  children: ReactElement<{\n    id?: string;\n    \"aria-describedby\"?: string;\n  }>;\n}\n\nexport const FieldControl = forwardRef<ElementRef<typeof Slot>, FieldControlProps>(\n  function FieldControl({ children }, ref) {\n    const { invalid, required, describedBy, registerControl, unregisterControl } =\n      useFieldContext(\"FieldControl\");\n    // Independent per-instance fallback id — guarantees uniqueness with no\n    // coordination needed when more than one `FieldControl` shares a\n    // `FieldRoot` (e.g. a first/last-name row).\n    const generatedId = useId();\n\n    // Same \"child wins, but COMPOSE rather than discard\" merge FieldRow uses:\n    // Radix `Slot` merges child props OVER slot props, so a control that\n    // already carries its own `id`/`aria-describedby` must not silently lose\n    // the label association / description-error wiring.\n    const control = children;\n    const childProps = control.props;\n    const id = childProps.id ?? generatedId;\n    const composedDescribedBy =\n      [childProps[\"aria-describedby\"] ?? null, describedBy ?? null].filter(Boolean).join(\" \") ||\n      undefined;\n\n    useLayoutEffect(() => {\n      registerControl(id);\n      return () => unregisterControl(id);\n    }, [id, registerControl, unregisterControl]);\n\n    return (\n      <Slot\n        ref={ref}\n        id={id}\n        aria-describedby={composedDescribedBy}\n        aria-invalid={invalid}\n        aria-required={required || undefined}\n        data-slot=\"field-control\"\n      >\n        {cloneElement(control, { id, \"aria-describedby\": composedDescribedBy })}\n      </Slot>\n    );\n  },\n);\n\n// ── FieldDescription ──────────────────────────────────────────────────────\n\n/**\n * Optional field help text. Renders nothing — and registers no\n * `aria-describedby` reference — when `children` is falsy (`false`/`0`/`\"\"`/\n * `null`/`undefined`), an empty array, or an array containing only falsy\n * values (`{list.map(...)}` on an empty list; `[a && \"x\", b && \"y\"]` with\n * both false) — matching `FieldRow`'s `description ? … : null` convention:\n * `{hint && <FieldDescription>{hint}</FieldDescription>}` is the supported\n * way to express \"no description\".\n *\n * **Known limit:** a child that is itself a COMPONENT that renders nothing\n * (returns `null`/an empty fragment) is not knowable from the element\n * before render, so it still produces an empty paragraph that\n * `aria-describedby` points at. `FieldRow` and the wider React ecosystem\n * share this limit — pass a falsy child instead of a component that may\n * render nothing.\n */\nexport const FieldDescription = forwardRef<\n  HTMLParagraphElement,\n  HTMLAttributes<HTMLParagraphElement>\n>(function FieldDescription({ className, children, id, ...props }, ref) {\n  const { registerDescription, unregisterDescription } = useFieldContext(\"FieldDescription\");\n  // Own id per INSTANCE — two `FieldDescription`s under one `FieldRoot` (a hint\n  // above the control and a hint below it) must not collide on one shared id.\n  const instanceId = useId();\n  const generatedId = `${instanceId}-description`;\n  // Caller-supplied `id` wins — same \"child wins\" resolution `FieldControl`\n  // already uses (`childProps.id ?? generatedId`). Resolving ONE effective id\n  // up front, and destructuring `id` out of `...props` above, means the value\n  // registered into `aria-describedby` and the value actually rendered on the\n  // `<p>` can never diverge (PR #97 review finding 3).\n  const descriptionId = id ?? generatedId;\n  // Same falsy-content convention `FieldRow` uses (`description ? … : null`)\n  // — see `hasRenderableContent` (`../../lib/has-renderable-content`) for\n  // the full rationale, shared with `FieldError` below and `FieldRow`.\n  const hasContent = hasRenderableContent(children);\n\n  useLayoutEffect(() => {\n    if (!hasContent) return undefined;\n    registerDescription(descriptionId);\n    return () => unregisterDescription(descriptionId);\n  }, [hasContent, descriptionId, registerDescription, unregisterDescription]);\n\n  if (!hasContent) return null;\n\n  return (\n    <p\n      ref={ref}\n      id={descriptionId}\n      data-slot=\"field-description\"\n      className={cn(\"text-body text-muted-foreground\", className)}\n      {...props}\n    >\n      {children}\n    </p>\n  );\n});\n\n// ── FieldError ────────────────────────────────────────────────────────────\n\n/**\n * Validation error text, announced via `role=\"alert\"`. Renders nothing —\n * and registers no `aria-describedby` reference — when `children` is falsy\n * (`false`/`0`/`\"\"`/`null`/`undefined`), an empty array, or an array\n * containing only falsy values (`{errors.map(...)}` on an empty array is\n * exactly how a real form renders \"no errors\") — matching `FieldRow`'s\n * `error ? … : null` convention: `{error && <FieldError>{error}</FieldError>}`\n * is the supported way to express \"no error\".\n *\n * **Known limit:** a child that is itself a COMPONENT that renders nothing\n * (returns `null`/an empty fragment) is not knowable from the element\n * before render, so it still produces an empty `role=\"alert\"` element that\n * `aria-describedby` points at (a screen reader announces an empty alert).\n * `FieldRow` and the wider React ecosystem share this limit — pass a falsy\n * child instead of a component that may render nothing.\n */\nexport const FieldError = forwardRef<HTMLParagraphElement, HTMLAttributes<HTMLParagraphElement>>(\n  function FieldError({ className, children, id, ...props }, ref) {\n    const { registerError, unregisterError } = useFieldContext(\"FieldError\");\n    // Own id per INSTANCE — same reasoning as `FieldDescription`.\n    const instanceId = useId();\n    const generatedId = `${instanceId}-error`;\n    // Caller-supplied `id` wins — same resolution as `FieldDescription`/\n    // `FieldControl` (PR #97 review finding 3: this had the identical\n    // ordering bug as `FieldDescription`).\n    const errorId = id ?? generatedId;\n    // Same falsy-content convention as `FieldDescription`/`FieldRow`'s\n    // `error ? … : null` — see `hasRenderableContent`\n    // (`../../lib/has-renderable-content`) for the full rationale.\n    const hasContent = hasRenderableContent(children);\n\n    useLayoutEffect(() => {\n      if (!hasContent) return undefined;\n      registerError(errorId);\n      return () => unregisterError(errorId);\n    }, [hasContent, errorId, registerError, unregisterError]);\n\n    if (!hasContent) return null;\n\n    return (\n      <p\n        ref={ref}\n        id={errorId}\n        role=\"alert\"\n        data-slot=\"field-error\"\n        className={cn(\"text-body font-medium text-destructive-text\", className)}\n        {...props}\n      >\n        {children}\n      </p>\n    );\n  },\n);\n"],"mappings":"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","names":["FieldRoot","FieldLabel","FieldControl","FieldDescription","FieldError"]}

package/dist/chunk-GV6GQXKX.js

@@ -0,0 +1,176 @@
+"use client";
+
+// src/components/schema-form/from-json-schema.ts
+var UNSUPPORTED_COMBINATORS = ["$ref", "allOf", "oneOf", "anyOf", "not"];
+var UnsupportedJsonSchemaError = class extends Error {
+  constructor(keyword, path) {
+    super(
+      `fromJsonSchema: unsupported JSON Schema keyword "${keyword}" at "${path}". fromJsonSchema() maps only a narrow, documented subset (string/number/integer/boolean/enum/array-of-string/object) and does not resolve $ref or implement allOf/oneOf/anyOf/not. Pre-resolve or inline this part of the schema before calling fromJsonSchema(), or build the affected FieldSpec by hand.`
+    );
+    this.name = "UnsupportedJsonSchemaError";
+  }
+};
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function assertSupported(schema, path) {
+  if (!isPlainObject(schema)) return;
+  for (const keyword of UNSUPPORTED_COMBINATORS) {
+    if (keyword in schema) throw new UnsupportedJsonSchemaError(keyword, path);
+  }
+  if (isPlainObject(schema.properties)) {
+    for (const [key, sub] of Object.entries(schema.properties)) {
+      assertSupported(sub, `${path}/properties/${key}`);
+    }
+  }
+  if ("items" in schema) {
+    assertSupported(schema.items, `${path}/items`);
+  }
+}
+function stringArray(values) {
+  if (!Array.isArray(values) || !values.every((v) => typeof v === "string")) return null;
+  return values;
+}
+var SUPPORTED_STRING_FORMATS = /* @__PURE__ */ new Set(["email", "uri", "date", "date-time"]);
+function mapProperty(name, schema, required) {
+  if (!isPlainObject(schema)) return null;
+  const title = typeof schema.title === "string" ? schema.title : void 0;
+  const description = typeof schema.description === "string" ? schema.description : void 0;
+  const base = {
+    name,
+    ...title !== void 0 ? { label: title } : {},
+    ...description !== void 0 ? { description } : {},
+    ...required ? { required: true } : {}
+  };
+  switch (schema.type) {
+    case "string": {
+      const enumValues = stringArray(schema.enum);
+      if (enumValues) {
+        return {
+          type: "enum",
+          ...base,
+          options: enumValues,
+          ...typeof schema.default === "string" ? { default: schema.default } : {}
+        };
+      }
+      const format = typeof schema.format === "string" && SUPPORTED_STRING_FORMATS.has(schema.format) ? schema.format : void 0;
+      return {
+        type: "string",
+        ...base,
+        ...format !== void 0 ? { format } : {},
+        ...Number.isInteger(schema.minLength) && schema.minLength >= 0 ? { minLength: schema.minLength } : {},
+        ...Number.isInteger(schema.maxLength) && schema.maxLength >= 0 ? { maxLength: schema.maxLength } : {},
+        ...typeof schema.pattern === "string" ? { pattern: schema.pattern } : {},
+        ...typeof schema.default === "string" ? { default: schema.default } : {}
+      };
+    }
+    case "number": {
+      const validDefault = typeof schema.default === "number";
+      return {
+        type: "number",
+        ...base,
+        ...typeof schema.minimum === "number" ? { min: schema.minimum } : {},
+        ...typeof schema.maximum === "number" ? { max: schema.maximum } : {},
+        ...validDefault ? { default: schema.default } : {}
+      };
+    }
+    case "integer": {
+      const validDefault = typeof schema.default === "number" && Number.isInteger(schema.default);
+      return {
+        type: "integer",
+        ...base,
+        ...typeof schema.minimum === "number" ? { min: schema.minimum } : {},
+        ...typeof schema.maximum === "number" ? { max: schema.maximum } : {},
+        ...validDefault ? { default: schema.default } : {}
+      };
+    }
+    case "boolean":
+      return {
+        type: "boolean",
+        ...base,
+        ...typeof schema.default === "boolean" ? { default: schema.default } : {}
+      };
+    case "array": {
+      if (!isPlainObject(schema.items) || schema.items.type !== "string") return null;
+      const itemEnum = stringArray(schema.items.enum);
+      if (itemEnum) {
+        const enumDefault = stringArray(schema.default);
+        return {
+          type: "multi-enum",
+          ...base,
+          options: itemEnum,
+          ...enumDefault && enumDefault.every((v) => itemEnum.includes(v)) ? { default: enumDefault } : {}
+        };
+      }
+      const listDefault = stringArray(schema.default);
+      return {
+        type: "list",
+        ...base,
+        ...Number.isInteger(schema.minItems) && schema.minItems >= 0 ? { minItems: schema.minItems } : {},
+        ...Number.isInteger(schema.maxItems) && schema.maxItems >= 0 ? { maxItems: schema.maxItems } : {},
+        ...listDefault ? { default: listDefault } : {}
+      };
+    }
+    case "object": {
+      const nested = mapProperties(schema);
+      if (nested.length === 0) return null;
+      return {
+        type: "group",
+        name,
+        ...title !== void 0 ? { label: title } : {},
+        ...description !== void 0 ? { description } : {},
+        ...required ? { required: true } : {},
+        variant: "advanced",
+        groups: [{ key: name, label: title ?? name, fields: nested }]
+      };
+    }
+    default:
+      return null;
+  }
+}
+function mapProperties(objectSchema) {
+  const properties = isPlainObject(objectSchema.properties) ? objectSchema.properties : {};
+  const required = stringArray(objectSchema.required) ?? [];
+  const fields = [];
+  for (const [name, propertySchema] of Object.entries(properties)) {
+    const field = mapProperty(name, propertySchema, required.includes(name));
+    if (field) fields.push(field);
+  }
+  return fields;
+}
+function fromJsonSchema(schema, options) {
+  assertSupported(schema, "#");
+  if (!isPlainObject(schema) || schema.type !== "object") {
+    throw new UnsupportedJsonSchemaError('type (expected "object" at the top level)', "#");
+  }
+  return {
+    formName: options.formName,
+    title: options.title ?? (typeof schema.title === "string" ? schema.title : void 0),
+    description: options.description ?? (typeof schema.description === "string" ? schema.description : void 0),
+    submitLabel: options.submitLabel,
+    fields: mapProperties(schema)
+  };
+}
+function jsonSchemaRequestBody(spec, values) {
+  return collectRequestBody(spec.fields, values);
+}
+function collectRequestBody(fields, values) {
+  const body = {};
+  for (const field of fields) {
+    if (field.type === "group") {
+      const branch = field.groups[0];
+      if (branch) body[field.name] = collectRequestBody(branch.fields, values);
+      continue;
+    }
+    const value = values[field.name];
+    if (value !== void 0) body[field.name] = value;
+  }
+  return body;
+}
+
+export {
+  UnsupportedJsonSchemaError,
+  fromJsonSchema,
+  jsonSchemaRequestBody
+};
+//# sourceMappingURL=chunk-GV6GQXKX.js.map

package/dist/chunk-GV6GQXKX.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/schema-form/from-json-schema.ts"],"sourcesContent":["/**\n * from-json-schema.ts — `fromJsonSchema()`: the narrow, documented JSON\n * Schema → `FormSpec` adapter (issue #22, maintainer ruling 2026-09-01).\n *\n * Many consumers already have their config described as JSON Schema (an\n * OpenAPI request body, a connector manifest). This maps ONLY the common\n * subset such schemas actually use onto `SchemaForm`'s `FieldSpec`\n * vocabulary:\n *\n *   { type: \"string\" }                          → StringFieldSpec\n *   { type: \"string\", enum: [...] }              → EnumFieldSpec\n *   { type: \"number\" | \"integer\" }                → NumberFieldSpec / IntegerFieldSpec\n *   { type: \"boolean\" }                            → BooleanFieldSpec\n *   { type: \"array\", items: { type: \"string\" } }    → ListFieldSpec (free text)\n *   { type: \"array\",\n *     items: { type: \"string\", enum: [...] } }       → MultiEnumFieldSpec\n *                                                        (a CONSTRAINED array\n *                                                        item schema maps onto\n *                                                        the field type that\n *                                                        actually enforces the\n *                                                        constraint — see\n *                                                        \"Constraint keywords\"\n *                                                        below for why this\n *                                                        one keyword IS read)\n *   { type: \"object\", properties: {...} }            → GroupFieldSpec\n *                                                        (variant: \"advanced\",\n *                                                        one always-open branch)\n *\n * `title`/`description` map to `label`/`description`; `required` (the\n * enclosing object schema's array of property names) maps to `required:\n * true`; `default` maps when it is type-compatible; `minLength`/`maxLength`/\n * `pattern`/`minimum`/`maximum`/`minItems`/`maxItems` map to their FieldSpec\n * equivalents. `format` maps only the four values `StringFieldSpec` itself\n * understands (`email`/`uri`/`date`/`date-time`) — any other `format` value\n * (`\"binary\"`, `\"password\"`, a custom one) is ignored predictably, the same\n * way an unknown JSON Schema `format` is defined to be advisory, not\n * validating.\n *\n * Deliberately NOT a general draft-07/2020-12 implementation (the maintainer\n * ruling's explicit narrow option) — this module does not resolve `$ref` and\n * does not implement the `allOf`/`oneOf`/`anyOf`/`not` combinators. Those\n * keywords change what a schema actually MEANS, and approximating them would\n * risk producing a field that looks plausible but is wrong (e.g. rendering a\n * `$ref`'d object as an empty string field) — silently wrong is exactly what\n * this adapter must never be. So `fromJsonSchema()` REFUSES: any of those\n * five keywords, found anywhere in the input (top-level or nested inside a\n * property/items schema), throws `UnsupportedJsonSchemaError` naming the\n * keyword and its JSON-Pointer-style path. Pre-resolve/inline that part of\n * the schema before calling `fromJsonSchema()`, or hand-write the affected\n * `FieldSpec`.\n *\n * A property whose `type` this subset does not cover (e.g. `\"null\"`, a\n * JSON-Schema-2020-12 array-of-types, an array of non-string items, an\n * object schema with no `properties`) is DROPPED from the result —\n * predictable and non-fatal, the same lenient-parse philosophy\n * `normalizeFormSpec` already uses for the render path, because omitting one\n * field is recoverable in a way a mis-mapped `$ref`/combinator is not.\n *\n * CONSTRAINT KEYWORDS this subset does not read: `const`, `if`/`then`/`else`,\n * `dependentSchemas`, `dependentRequired`, `additionalProperties`,\n * `patternProperties`, `propertyNames`, `contains`, `multipleOf`,\n * `exclusiveMinimum`/`exclusiveMaximum`, `uniqueItems`. These are\n * READ-IGNORED, not refused — unlike `$ref`/`allOf`/`oneOf`/`anyOf`/`not`,\n * none of them changes what TYPE a property maps to, so ignoring one never\n * produces a wrongly-shaped field. But ignoring one DOES widen what the\n * rendered form accepts relative to the source schema (a `const`-pinned\n * property renders as an ordinary editable field, not a fixed one; a\n * `multipleOf`-constrained number accepts any value in range). This is the\n * one place `fromJsonSchema()` is honestly silently-permissive rather than\n * silently-wrong or refusing — call it out in review when a schema leans on\n * one of these keywords for validation the mapped form will not enforce.\n * `items.enum` is the one exception among these: a constrained array-item\n * schema is common enough (and cheap enough to map faithfully) that it reads\n * `items.enum` and maps onto `MultiEnumFieldSpec` — see the table above —\n * rather than joining this ignore list and widening into a free-text\n * `ListFieldSpec`.\n *\n * Widening this subset later (more `format`s, `$ref` resolution) is an\n * additive, non-breaking change to this one function — see issue #22's\n * \"worth having alongside\" list.\n */\n\nimport type { FieldSpec, FormSpec, FormValues } from \"./schema-form-spec\";\n\n/**\n * The JSON Schema keywords this adapter refuses to approximate. Each changes\n * a schema's actual shape in a way a narrow field-by-field mapping cannot\n * safely ignore.\n */\nconst UNSUPPORTED_COMBINATORS = [\"$ref\", \"allOf\", \"oneOf\", \"anyOf\", \"not\"] as const;\n\n/**\n * Thrown by `fromJsonSchema()` when the input uses a JSON Schema keyword\n * outside its documented subset (see this module's doc comment) — never\n * silently mismapped.\n */\nexport class UnsupportedJsonSchemaError extends Error {\n  constructor(keyword: string, path: string) {\n    super(\n      `fromJsonSchema: unsupported JSON Schema keyword \"${keyword}\" at \"${path}\". ` +\n        \"fromJsonSchema() maps only a narrow, documented subset (string/number/\" +\n        \"integer/boolean/enum/array-of-string/object) and does not resolve \" +\n        \"$ref or implement allOf/oneOf/anyOf/not. Pre-resolve or inline this \" +\n        \"part of the schema before calling fromJsonSchema(), or build the \" +\n        \"affected FieldSpec by hand.\",\n    );\n    this.name = \"UnsupportedJsonSchemaError\";\n  }\n}\n\ntype JsonSchemaObject = Record<string, unknown>;\n\nfunction isPlainObject(value: unknown): value is JsonSchemaObject {\n  return typeof value === \"object\" && value !== null && !Array.isArray(value);\n}\n\n/** Recursively asserts none of `UNSUPPORTED_COMBINATORS` appears anywhere under `schema`. */\nfunction assertSupported(schema: unknown, path: string): void {\n  if (!isPlainObject(schema)) return;\n  for (const keyword of UNSUPPORTED_COMBINATORS) {\n    if (keyword in schema) throw new UnsupportedJsonSchemaError(keyword, path);\n  }\n  if (isPlainObject(schema.properties)) {\n    for (const [key, sub] of Object.entries(schema.properties)) {\n      assertSupported(sub, `${path}/properties/${key}`);\n    }\n  }\n  if (\"items\" in schema) {\n    assertSupported(schema.items, `${path}/items`);\n  }\n}\n\n/** `values` narrowed to `string[]`, or `null` if any entry isn't a string. */\nfunction stringArray(values: unknown): string[] | null {\n  if (!Array.isArray(values) || !values.every((v) => typeof v === \"string\")) return null;\n  return values as string[];\n}\n\nconst SUPPORTED_STRING_FORMATS = new Set([\"email\", \"uri\", \"date\", \"date-time\"]);\n\nfunction mapProperty(name: string, schema: unknown, required: boolean): FieldSpec | null {\n  if (!isPlainObject(schema)) return null;\n\n  const title = typeof schema.title === \"string\" ? schema.title : undefined;\n  const description = typeof schema.description === \"string\" ? schema.description : undefined;\n  const base = {\n    name,\n    ...(title !== undefined ? { label: title } : {}),\n    ...(description !== undefined ? { description } : {}),\n    ...(required ? { required: true as const } : {}),\n  };\n\n  switch (schema.type) {\n    case \"string\": {\n      const enumValues = stringArray(schema.enum);\n      if (enumValues) {\n        return {\n          type: \"enum\",\n          ...base,\n          options: enumValues,\n          ...(typeof schema.default === \"string\" ? { default: schema.default } : {}),\n        };\n      }\n      const format =\n        typeof schema.format === \"string\" && SUPPORTED_STRING_FORMATS.has(schema.format)\n          ? (schema.format as \"email\" | \"uri\" | \"date\" | \"date-time\")\n          : undefined;\n      return {\n        type: \"string\",\n        ...base,\n        ...(format !== undefined ? { format } : {}),\n        ...(Number.isInteger(schema.minLength) && (schema.minLength as number) >= 0\n          ? { minLength: schema.minLength as number }\n          : {}),\n        ...(Number.isInteger(schema.maxLength) && (schema.maxLength as number) >= 0\n          ? { maxLength: schema.maxLength as number }\n          : {}),\n        ...(typeof schema.pattern === \"string\" ? { pattern: schema.pattern } : {}),\n        ...(typeof schema.default === \"string\" ? { default: schema.default } : {}),\n      };\n    }\n\n    case \"number\": {\n      const validDefault = typeof schema.default === \"number\";\n      return {\n        type: \"number\",\n        ...base,\n        ...(typeof schema.minimum === \"number\" ? { min: schema.minimum } : {}),\n        ...(typeof schema.maximum === \"number\" ? { max: schema.maximum } : {}),\n        ...(validDefault ? { default: schema.default as number } : {}),\n      };\n    }\n\n    case \"integer\": {\n      const validDefault = typeof schema.default === \"number\" && Number.isInteger(schema.default);\n      return {\n        type: \"integer\",\n        ...base,\n        ...(typeof schema.minimum === \"number\" ? { min: schema.minimum } : {}),\n        ...(typeof schema.maximum === \"number\" ? { max: schema.maximum } : {}),\n        ...(validDefault ? { default: schema.default as number } : {}),\n      };\n    }\n\n    case \"boolean\":\n      return {\n        type: \"boolean\",\n        ...base,\n        ...(typeof schema.default === \"boolean\" ? { default: schema.default } : {}),\n      };\n\n    case \"array\": {\n      // Only array-of-string is in the documented subset (issue #22's\n      // \"array-of-string\" entry) — an array of numbers/objects/booleans, or\n      // one with no `items` schema at all, is dropped predictably rather than\n      // guessed at.\n      if (!isPlainObject(schema.items) || schema.items.type !== \"string\") return null;\n\n      // A CONSTRAINED item schema (`items.enum`) is a multi-select from a\n      // fixed option list, not free text — map it onto the FieldSpec that\n      // actually enforces that constraint (`multi-enum`) rather than\n      // relaxing it into an unconstrained `list` (fix-round-1, issue #22: a\n      // validator probe found `{type:'array', items:{type:'string',\n      // enum:[...]}}` was silently widening to free text). `minItems`/\n      // `maxItems` have no `multi-enum` equivalent and are dropped here —\n      // documented in this module's doc comment alongside the other\n      // constraint keywords this subset does not enforce.\n      const itemEnum = stringArray(schema.items.enum);\n      if (itemEnum) {\n        const enumDefault = stringArray(schema.default);\n        return {\n          type: \"multi-enum\",\n          ...base,\n          options: itemEnum,\n          ...(enumDefault && enumDefault.every((v) => itemEnum.includes(v))\n            ? { default: enumDefault }\n            : {}),\n        };\n      }\n\n      const listDefault = stringArray(schema.default);\n      return {\n        type: \"list\",\n        ...base,\n        ...(Number.isInteger(schema.minItems) && (schema.minItems as number) >= 0\n          ? { minItems: schema.minItems as number }\n          : {}),\n        ...(Number.isInteger(schema.maxItems) && (schema.maxItems as number) >= 0\n          ? { maxItems: schema.maxItems as number }\n          : {}),\n        ...(listDefault ? { default: listDefault } : {}),\n      };\n    }\n\n    case \"object\": {\n      const nested = mapProperties(schema);\n      if (nested.length === 0) return null; // an empty/property-less object has nothing to render\n      return {\n        type: \"group\",\n        name,\n        ...(title !== undefined ? { label: title } : {}),\n        ...(description !== undefined ? { description } : {}),\n        ...(required ? { required: true } : {}),\n        variant: \"advanced\",\n        groups: [{ key: name, label: title ?? name, fields: nested }],\n      };\n    }\n\n    default:\n      // An unrecognized/absent `type` (JSON-Schema-2020-12 type arrays,\n      // `\"null\"`, a schema with no `type` at all) — outside the documented\n      // subset, dropped predictably rather than mismapped.\n      return null;\n  }\n}\n\n/** Maps every property of an OBJECT schema onto `FieldSpec[]`, dropping unsupported ones. */\nfunction mapProperties(objectSchema: JsonSchemaObject): FieldSpec[] {\n  const properties = isPlainObject(objectSchema.properties) ? objectSchema.properties : {};\n  const required = stringArray(objectSchema.required) ?? [];\n  const fields: FieldSpec[] = [];\n  for (const [name, propertySchema] of Object.entries(properties)) {\n    const field = mapProperty(name, propertySchema, required.includes(name));\n    if (field) fields.push(field);\n  }\n  return fields;\n}\n\nexport interface FromJsonSchemaOptions {\n  /** `FormSpec.formName` — required; JSON Schema has no equivalent stable identifier. */\n  formName: string;\n  /** Overrides the mapped `schema.title`. */\n  title?: string;\n  /** Overrides the mapped `schema.description`. */\n  description?: string;\n  /** `FormSpec.submitLabel` — JSON Schema has no equivalent. */\n  submitLabel?: string;\n}\n\n/**\n * Maps a JSON Schema OBJECT schema (an OpenAPI request body, a connector\n * manifest) onto a `FormSpec`, using only the documented subset described in\n * this module's doc comment. Throws `UnsupportedJsonSchemaError` if `schema`\n * (at any depth) uses `$ref`/`allOf`/`oneOf`/`anyOf`/`not`, or if the\n * top-level schema is not an object schema — never silently mismapped. A\n * property whose shape falls outside the subset is dropped, not thrown on.\n */\nexport function fromJsonSchema(schema: unknown, options: FromJsonSchemaOptions): FormSpec {\n  assertSupported(schema, \"#\");\n  if (!isPlainObject(schema) || schema.type !== \"object\") {\n    throw new UnsupportedJsonSchemaError('type (expected \"object\" at the top level)', \"#\");\n  }\n  return {\n    formName: options.formName,\n    title: options.title ?? (typeof schema.title === \"string\" ? schema.title : undefined),\n    description:\n      options.description ??\n      (typeof schema.description === \"string\" ? schema.description : undefined),\n    submitLabel: options.submitLabel,\n    fields: mapProperties(schema),\n  };\n}\n\n/**\n * Reconstructs the NESTED JSON object shape that `fromJsonSchema()`'s\n * `{ type: \"object\", properties: {...} }` mapping flattens away (PR #119\n * review thread 3, P1). `SchemaForm` stores every field's value in one flat\n * `FormValues` map keyed by BARE property name (`GroupFieldSpec` — see the\n * \"no notion of an active branch\" comment on `schema-form-spec.ts`'s\n * `GroupFieldSpec` — has no value slot of its own), so a form built from a\n * nested schema like `{ address: { properties: { city, zip } } }` submits\n * `{ city, zip }` instead of the advertised `{ address: { city, zip } }`.\n *\n * Call this (instead of reading `effectiveValues`/`onSubmit`'s payload\n * directly) when the schema passed to `fromJsonSchema()` had nested\n * `\"object\"` properties and the caller needs the request body back in its\n * original shape — e.g. `SchemaFormTestAction`'s `onTest` or a submit\n * handler that forwards the payload to the API the schema describes.\n *\n * Walks `spec.fields` and, for each `group` field this adapter produced\n * (always `variant: \"advanced\"`, always exactly one branch — see\n * `mapProperty`'s `\"object\"` case), recurses into `groups[0].fields` and\n * nests the result under that group's own `name` instead of splicing its\n * children into the top level.\n *\n * Two known, out-of-scope limits (see the reply on review thread 3):\n *  1. Two properties at DIFFERENT nesting depths that happen to share a bare\n *     name (`{ name }` at the top level and `{ address: { name } }`) collide\n *     in the flat `FormValues` map itself, upstream of this function — this\n *     function cannot recover data `SchemaForm` never kept separate.\n *  2. A nested object's own `required` flag (`GroupFieldSpec.required`) is\n *     mapped but never validated anywhere in `schema-form-spec.ts`'s\n *     `collectValidatableFields` — fixing that touches a file outside this\n *     unit's scope fence and is called out, unfixed, in the PR review reply.\n */\nexport function jsonSchemaRequestBody(spec: FormSpec, values: FormValues): Record<string, unknown> {\n  return collectRequestBody(spec.fields, values);\n}\n\nfunction collectRequestBody(fields: FieldSpec[], values: FormValues): Record<string, unknown> {\n  const body: Record<string, unknown> = {};\n  for (const field of fields) {\n    if (field.type === \"group\") {\n      // `fromJsonSchema()` only ever emits a single-branch `\"advanced\"`\n      // group per nested object (`mapProperty`'s `\"object\"` case) — nest\n      // the branch's reconstructed values under the group's own name.\n      const branch = field.groups[0];\n      if (branch) body[field.name] = collectRequestBody(branch.fields, values);\n      continue;\n    }\n    const value = values[field.name];\n    if (value !== undefined) body[field.name] = value;\n  }\n  return body;\n}\n"],"mappings":"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","names":[]}