@particle-academy/react-fancy 5.14.0 → 5.16.0

package/dist/chunk-AR2IBCX7.cjs

@@ -0,0 +1,1354 @@
+'use strict';
+
+var chunkMPDLL4X3_cjs = require('./chunk-MPDLL4X3.cjs');
+var chunkKKYP5R3G_cjs = require('./chunk-KKYP5R3G.cjs');
+var chunk6FYMMQ3G_cjs = require('./chunk-6FYMMQ3G.cjs');
+var chunkJU5W65N3_cjs = require('./chunk-JU5W65N3.cjs');
+var chunk23CLGUMT_cjs = require('./chunk-23CLGUMT.cjs');
+var chunk5I4PR2KV_cjs = require('./chunk-5I4PR2KV.cjs');
+var chunk6BW5BQMN_cjs = require('./chunk-6BW5BQMN.cjs');
+var chunkYLGTDBB2_cjs = require('./chunk-YLGTDBB2.cjs');
+var chunkFO4GCX67_cjs = require('./chunk-FO4GCX67.cjs');
+var chunkX5VZRFQD_cjs = require('./chunk-X5VZRFQD.cjs');
+var chunkHTKDPFLJ_cjs = require('./chunk-HTKDPFLJ.cjs');
+var chunkY5V5GBN4_cjs = require('./chunk-Y5V5GBN4.cjs');
+var chunkKJ22KE56_cjs = require('./chunk-KJ22KE56.cjs');
+var chunk3Z6ALUWP_cjs = require('./chunk-3Z6ALUWP.cjs');
+var react = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+
+// src/components/JsonEditor/JsonEditor.paths.ts
+function isJsonObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isJsonArray(value) {
+  return Array.isArray(value);
+}
+function isContainerValue(value) {
+  return isJsonObject(value) || isJsonArray(value);
+}
+function parsePath(path) {
+  if (!path) return [];
+  const segments = [];
+  let current = "";
+  let escaped = false;
+  for (const char of path) {
+    if (escaped) {
+      current += char;
+      escaped = false;
+      continue;
+    }
+    if (char === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (char === ".") {
+      segments.push(current);
+      current = "";
+      continue;
+    }
+    current += char;
+  }
+  if (escaped) current += "\\";
+  segments.push(current);
+  return segments;
+}
+function pathToString(segments) {
+  return segments.map((segment) => segment.replace(/\\/g, "\\\\").replace(/\./g, "\\.")).join(".");
+}
+function getAtPath(value, segments) {
+  let current = value;
+  for (const segment of segments) {
+    if (isJsonArray(current)) {
+      const index = Number(segment);
+      if (!Number.isInteger(index)) return void 0;
+      current = current[index];
+    } else if (isJsonObject(current)) {
+      if (!Object.prototype.hasOwnProperty.call(current, segment)) return void 0;
+      current = current[segment];
+    } else {
+      return void 0;
+    }
+    if (current === void 0) return void 0;
+  }
+  return current;
+}
+function updateContainer(value, segments, updater) {
+  if (segments.length === 0) {
+    if (!isContainerValue(value)) return value;
+    const next = updater(value);
+    return next === void 0 ? value : next;
+  }
+  const [head, ...rest] = segments;
+  if (isJsonArray(value)) {
+    const index = Number(head);
+    if (!Number.isInteger(index) || index < 0 || index >= value.length) return value;
+    const child = updateContainer(value[index], rest, updater);
+    if (child === value[index]) return value;
+    const clone = value.slice();
+    clone[index] = child;
+    return clone;
+  }
+  if (isJsonObject(value)) {
+    if (!Object.prototype.hasOwnProperty.call(value, head)) return value;
+    const child = updateContainer(value[head], rest, updater);
+    if (child === value[head]) return value;
+    return { ...value, [head]: child };
+  }
+  return value;
+}
+function applyJsonEdit(value, edit) {
+  const segments = parsePath(edit.path);
+  switch (edit.op) {
+    case "set": {
+      if (segments.length === 0) return edit.value;
+      const parent = segments.slice(0, -1);
+      const key = segments[segments.length - 1];
+      return updateContainer(value, parent, (container) => {
+        if (isJsonArray(container)) {
+          const index = Number(key);
+          if (!Number.isInteger(index) || index < 0 || index >= container.length) return void 0;
+          const clone = container.slice();
+          clone[index] = edit.value;
+          return clone;
+        }
+        return { ...container, [key]: edit.value };
+      });
+    }
+    case "remove": {
+      if (segments.length === 0) return value;
+      const parent = segments.slice(0, -1);
+      const key = segments[segments.length - 1];
+      return updateContainer(value, parent, (container) => {
+        if (isJsonArray(container)) {
+          const index = Number(key);
+          if (!Number.isInteger(index) || index < 0 || index >= container.length) return void 0;
+          return container.filter((_, i) => i !== index);
+        }
+        if (!Object.prototype.hasOwnProperty.call(container, key)) return void 0;
+        const clone = {};
+        for (const [k, v] of Object.entries(container)) {
+          if (k !== key) clone[k] = v;
+        }
+        return clone;
+      });
+    }
+    case "rename": {
+      if (segments.length === 0) return value;
+      const parent = segments.slice(0, -1);
+      const key = segments[segments.length - 1];
+      return updateContainer(value, parent, (container) => {
+        if (!isJsonObject(container)) return void 0;
+        if (!Object.prototype.hasOwnProperty.call(container, key)) return void 0;
+        if (edit.key === key) return void 0;
+        if (Object.prototype.hasOwnProperty.call(container, edit.key)) return void 0;
+        const clone = {};
+        for (const [k, v] of Object.entries(container)) {
+          clone[k === key ? edit.key : k] = v;
+        }
+        return clone;
+      });
+    }
+    case "insert": {
+      return updateContainer(value, segments, (container) => {
+        if (isJsonArray(container)) return [...container, edit.value];
+        if (edit.key === void 0 || edit.key === "") return void 0;
+        if (Object.prototype.hasOwnProperty.call(container, edit.key)) return void 0;
+        return { ...container, [edit.key]: edit.value };
+      });
+    }
+    case "move": {
+      if (segments.length === 0) return value;
+      const parent = segments.slice(0, -1);
+      const from = Number(segments[segments.length - 1]);
+      return updateContainer(value, parent, (container) => {
+        if (!isJsonArray(container)) return void 0;
+        if (!Number.isInteger(from) || from < 0 || from >= container.length) return void 0;
+        const to = Math.min(Math.max(edit.to, 0), container.length - 1);
+        if (to === from) return void 0;
+        const clone = container.slice();
+        const [moved] = clone.splice(from, 1);
+        clone.splice(to, 0, moved);
+        return clone;
+      });
+    }
+  }
+}
+function describeEdit(edit) {
+  const at = edit.path === "" ? "the document" : edit.path;
+  switch (edit.op) {
+    case "set":
+      return `set ${at}`;
+    case "remove":
+      return `remove ${at}`;
+    case "rename":
+      return `rename ${at} to ${edit.key}`;
+    case "insert":
+      return edit.key === void 0 ? `append to ${at}` : `add ${edit.key} to ${at}`;
+    case "move":
+      return `move ${at} to index ${edit.to}`;
+  }
+}
+
+// src/components/JsonEditor/JsonEditor.types.ts
+var JSON_FIELD_TYPES = [
+  "string",
+  "text",
+  "number",
+  "integer",
+  "boolean",
+  "date",
+  "datetime",
+  "enum",
+  "secret",
+  "url",
+  "email",
+  "color",
+  "json",
+  "object",
+  "array"
+];
+
+// src/components/JsonEditor/JsonEditor.keymap.ts
+var TYPE_NAMES = new Set(JSON_FIELD_TYPES);
+function isTypeName(value) {
+  return typeof value === "string" && TYPE_NAMES.has(value);
+}
+function issue(kind, path, message) {
+  return { kind, path, message };
+}
+function parseKeyMap(source) {
+  if (source === void 0 || source === null || source.trim() === "") {
+    return { ok: true, rules: [], issues: [] };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(source);
+  } catch (error) {
+    return {
+      ok: false,
+      rules: [],
+      issues: [
+        issue(
+          "keymap",
+          "",
+          `keyMap is not valid JSON: ${error instanceof Error ? error.message : String(error)}`
+        )
+      ]
+    };
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    return {
+      ok: false,
+      rules: [],
+      issues: [
+        issue(
+          "keymap",
+          "",
+          `keyMap must be a JSON object of path \u2192 type, got ${describeValue(parsed)}.`
+        )
+      ]
+    };
+  }
+  const rules = [];
+  const issues = [];
+  let order = 0;
+  for (const [key, raw] of Object.entries(parsed)) {
+    const rule = normalizeRule(key, raw, issues);
+    if (!rule) continue;
+    const pattern = parsePath(key);
+    rules.push({
+      pattern,
+      rule,
+      source: key,
+      literals: pattern.reduce((n, segment) => n + (segment === "*" ? 0 : 1), 0),
+      order: order++
+    });
+  }
+  return { ok: true, rules, issues };
+}
+function normalizeRule(key, raw, issues) {
+  let candidate;
+  if (typeof raw === "string") {
+    candidate = { type: raw };
+  } else if (typeof raw === "object" && raw !== null && !Array.isArray(raw)) {
+    candidate = raw;
+  } else {
+    issues.push(
+      issue(
+        "rule",
+        key,
+        `Expected a type name or a rule object, got ${describeValue(raw)}.`
+      )
+    );
+    return void 0;
+  }
+  if (!isTypeName(candidate.type)) {
+    issues.push(
+      issue(
+        "rule",
+        key,
+        `Unknown type ${JSON.stringify(candidate.type)}. Known types: ${JSON_FIELD_TYPES.join(", ")}.`
+      )
+    );
+    return void 0;
+  }
+  if (candidate.options !== void 0 && !Array.isArray(candidate.options)) {
+    issues.push(issue("rule", key, "`options` must be an array."));
+    return void 0;
+  }
+  if (candidate.type === "enum" && (!candidate.options || candidate.options.length === 0)) {
+    issues.push(issue("rule", key, "`enum` requires a non-empty `options` array."));
+    return void 0;
+  }
+  return candidate;
+}
+function resolveKeyRule(rules, segments) {
+  let best;
+  for (const entry of rules) {
+    if (!matches(entry.pattern, segments)) continue;
+    if (!best || entry.literals > best.literals || entry.literals === best.literals && entry.order > best.order) {
+      best = entry;
+    }
+  }
+  return best?.rule;
+}
+function matches(pattern, segments) {
+  if (pattern.length !== segments.length) return false;
+  return pattern.every((p, i) => p === "*" || p === segments[i]);
+}
+function describeValue(value) {
+  if (value === void 0) return "undefined";
+  if (value === null) return "null";
+  if (Array.isArray(value)) return "array";
+  return typeof value;
+}
+function inferType(value) {
+  if (Array.isArray(value)) return "array";
+  if (value === null || value === void 0) {
+    return "json";
+  }
+  if (typeof value === "object") return "object";
+  if (typeof value === "boolean") return "boolean";
+  if (typeof value === "number") return "number";
+  return "string";
+}
+function enumValues(rule) {
+  return (rule.options ?? []).map((option) => chunkYLGTDBB2_cjs.resolveOption(option).value);
+}
+function typeMatches(rule, value) {
+  switch (rule.type) {
+    case "string":
+    case "text":
+    case "url":
+    case "email":
+    case "secret":
+    case "color":
+      return typeof value === "string";
+    case "number":
+      return typeof value === "number" && Number.isFinite(value);
+    case "integer":
+      return typeof value === "number" && Number.isInteger(value);
+    case "boolean":
+      return typeof value === "boolean";
+    case "date":
+    case "datetime":
+      return typeof value === "string" && value !== "" && !Number.isNaN(Date.parse(value));
+    case "enum":
+      return (typeof value === "string" || typeof value === "number" || typeof value === "boolean") && enumValues(rule).some((option) => String(option) === String(value));
+    case "object":
+      return isJsonObject(value);
+    case "array":
+      return isJsonArray(value);
+    case "json":
+      if (typeof value !== "string") return true;
+      try {
+        JSON.parse(value);
+        return true;
+      } catch {
+        return false;
+      }
+  }
+}
+function conflictMessage(rule, value) {
+  if (rule.type === "enum") {
+    return `${JSON.stringify(value)} is not one of the declared options (${enumValues(rule).map((option) => JSON.stringify(option)).join(", ")}).`;
+  }
+  if (rule.type === "json") {
+    return "Raw text is not valid JSON.";
+  }
+  if (rule.type === "date" || rule.type === "datetime") {
+    return `Declared ${rule.type}, got ${describeValue(value)} that is not a parseable date.`;
+  }
+  return `Declared ${rule.type}, got ${describeValue(value)}.`;
+}
+function findJsonConflicts(value, rules) {
+  const issues = [];
+  if (rules.length === 0) return issues;
+  const walk = (node, segments) => {
+    if (segments.length > 0) {
+      const rule = resolveKeyRule(rules, segments);
+      if (rule && !typeMatches(rule, node)) {
+        issues.push({
+          kind: "type",
+          path: pathToString(segments),
+          message: conflictMessage(rule, node),
+          expected: rule.type,
+          actual: describeValue(node)
+        });
+      }
+    }
+    if (isJsonArray(node)) {
+      node.forEach((child, index) => walk(child, [...segments, String(index)]));
+    } else if (isJsonObject(node)) {
+      for (const [key, child] of Object.entries(node)) walk(child, [...segments, key]);
+    }
+  };
+  walk(value, []);
+  for (const entry of rules) {
+    if (!entry.rule.required) continue;
+    if (entry.pattern.includes("*")) continue;
+    if (getAtPath(value, entry.pattern) !== void 0) continue;
+    issues.push({
+      kind: "type",
+      path: entry.source,
+      message: `Required key is missing (declared ${entry.rule.type}).`,
+      expected: entry.rule.type,
+      actual: "undefined"
+    });
+  }
+  return issues;
+}
+function seedValue(type, rule) {
+  switch (type) {
+    case "number":
+    case "integer":
+      return 0;
+    case "boolean":
+      return false;
+    case "object":
+      return {};
+    case "array":
+      return [];
+    case "json":
+      return null;
+    case "enum":
+      return rule?.options?.length ? chunkYLGTDBB2_cjs.resolveOption(rule.options[0]).value : "";
+    default:
+      return "";
+  }
+}
+var JsonEditorContext = react.createContext(null);
+function useJsonEditorContext() {
+  const context = react.useContext(JsonEditorContext);
+  if (!context) {
+    throw new Error("JsonEditor rows must be rendered inside a <JsonEditor>.");
+  }
+  return context;
+}
+var COLOR_PICKER_SIZE = {
+  xs: "sm",
+  sm: "sm",
+  md: "md",
+  lg: "lg",
+  xl: "lg"
+};
+function isRawTextType(type) {
+  return type === "number" || type === "integer" || type === "json";
+}
+function toText(value) {
+  if (value === void 0) return "";
+  if (typeof value === "string") return value;
+  return JSON.stringify(value) ?? "";
+}
+function fromText(text, type) {
+  switch (type) {
+    case "number":
+    case "integer": {
+      const trimmed = text.trim();
+      if (trimmed === "") return text;
+      const parsed = Number(trimmed);
+      return Number.isFinite(parsed) ? parsed : text;
+    }
+    case "boolean": {
+      const trimmed = text.trim().toLowerCase();
+      if (trimmed === "true") return true;
+      if (trimmed === "false") return false;
+      return text;
+    }
+    case "json":
+    case "object":
+    case "array":
+      try {
+        return JSON.parse(text);
+      } catch {
+        return text;
+      }
+    default:
+      return text;
+  }
+}
+function JsonEditorValue({ node, mode, size, readOnly, id, onCommit }) {
+  const locked = readOnly || node.rule?.readOnly === true;
+  const resolvedMode = locked ? "view" : mode;
+  const { value, rule } = node;
+  if (node.conflict || isRawTextType(node.type)) {
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      RawValueEditor,
+      {
+        id,
+        text: toText(value),
+        type: node.type,
+        mode: resolvedMode,
+        size,
+        disabled: locked,
+        multiline: node.type === "json" || typeof value === "object",
+        placeholder: rule?.placeholder,
+        onCommitText: (text) => onCommit(fromText(text, node.type))
+      }
+    );
+  }
+  const common = { id, size, mode: resolvedMode, disabled: locked };
+  switch (node.type) {
+    case "boolean":
+      return /* @__PURE__ */ jsxRuntime.jsx(
+        chunkMPDLL4X3_cjs.Switch,
+        {
+          ...common,
+          checked: value === true,
+          onCheckedChange: (next) => onCommit(next)
+        }
+      );
+    case "enum": {
+      const options = rule?.options ?? [];
+      return /* @__PURE__ */ jsxRuntime.jsx(
+        chunkJU5W65N3_cjs.Select,
+        {
+          ...common,
+          list: options,
+          value: String(value),
+          onValueChange: (next) => {
+            const match = options.map((option) => chunkYLGTDBB2_cjs.resolveOption(option)).find((option) => String(option.value) === next);
+            onCommit(match?.value ?? next);
+          }
+        }
+      );
+    }
+    case "date":
+    case "datetime":
+      return /* @__PURE__ */ jsxRuntime.jsx(
+        chunkKKYP5R3G_cjs.DatePicker,
+        {
+          ...common,
+          includeTime: node.type === "datetime",
+          min: rule?.min === void 0 ? void 0 : String(rule.min),
+          max: rule?.max === void 0 ? void 0 : String(rule.max),
+          value: typeof value === "string" ? value : "",
+          onValueChange: (next) => onCommit(next)
+        }
+      );
+    case "color":
+      return /* @__PURE__ */ jsxRuntime.jsx(
+        chunkFO4GCX67_cjs.ColorPicker,
+        {
+          size: COLOR_PICKER_SIZE[size],
+          mode: resolvedMode,
+          disabled: locked,
+          value: typeof value === "string" ? value : "",
+          onChange: (next) => onCommit(next)
+        }
+      );
+    case "text":
+      return /* @__PURE__ */ jsxRuntime.jsx(
+        chunk5I4PR2KV_cjs.Textarea,
+        {
+          ...common,
+          minRows: 2,
+          autoResize: true,
+          placeholder: rule?.placeholder,
+          value: typeof value === "string" ? value : "",
+          onValueChange: (next) => onCommit(next)
+        }
+      );
+    case "secret":
+      return /* @__PURE__ */ jsxRuntime.jsx(
+        chunk6FYMMQ3G_cjs.Input,
+        {
+          ...common,
+          type: "password",
+          reveal: true,
+          placeholder: rule?.placeholder,
+          value: typeof value === "string" ? value : "",
+          onValueChange: (next) => onCommit(next)
+        }
+      );
+    case "url":
+    case "email":
+    case "string":
+    default:
+      return /* @__PURE__ */ jsxRuntime.jsx(
+        chunk6FYMMQ3G_cjs.Input,
+        {
+          ...common,
+          type: node.type === "url" ? "url" : node.type === "email" ? "email" : "text",
+          placeholder: rule?.placeholder,
+          value: typeof value === "string" ? value : "",
+          onValueChange: (next) => onCommit(next)
+        }
+      );
+  }
+}
+function RawValueEditor({
+  id,
+  text,
+  type,
+  mode,
+  size,
+  disabled,
+  multiline,
+  placeholder,
+  onCommitText
+}) {
+  const { showControl, interactive, enterEdit, exitEdit } = chunkKJ22KE56_cjs.useInlineEdit(mode, disabled);
+  if (!showControl) {
+    return /* @__PURE__ */ jsxRuntime.jsx(chunk6BW5BQMN_cjs.DisplayValue, { size, interactive, onActivate: enterEdit, children: text });
+  }
+  const commit = (next) => {
+    if (next !== text) onCommitText(next);
+  };
+  if (multiline) {
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      chunk5I4PR2KV_cjs.Textarea,
+      {
+        id,
+        size,
+        mode: "edit",
+        minRows: 3,
+        disabled,
+        placeholder,
+        defaultValue: text,
+        spellCheck: false,
+        autoFocus: interactive,
+        className: "font-mono",
+        onBlur: (event) => {
+          commit(event.currentTarget.value);
+          exitEdit();
+        }
+      },
+      text
+    );
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    chunk6FYMMQ3G_cjs.Input,
+    {
+      id,
+      size,
+      mode: "edit",
+      type: "text",
+      inputMode: type === "number" || type === "integer" ? "decimal" : void 0,
+      disabled,
+      placeholder,
+      defaultValue: text,
+      spellCheck: false,
+      autoFocus: interactive,
+      onKeyDown: (event) => {
+        if (event.key === "Enter") event.currentTarget.blur();
+      },
+      onBlur: (event) => {
+        commit(event.currentTarget.value);
+        exitEdit();
+      }
+    },
+    text
+  );
+}
+var INDENT = 18;
+function JsonEditorRow({ node }) {
+  const ctx = useJsonEditorContext();
+  const { dotted, key, depth, container, conflict } = node;
+  const expanded = container ? ctx.isExpanded(dotted) : void 0;
+  const pending = ctx.pendingFor(dotted);
+  const renameable = ctx.allowRename && !ctx.readOnly && node.parentKind === "object" && ctx.mode === "edit";
+  const label = node.rule?.label ?? key;
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      "data-react-fancy-json-editor-row": "",
+      "data-path": dotted,
+      "data-key": key,
+      "data-type": node.type,
+      "data-depth": depth,
+      "data-declared": node.declared ? "true" : "false",
+      "data-conflict": conflict ? "true" : void 0,
+      "data-pending": pending.length > 0 ? "true" : void 0,
+      role: "treeitem",
+      "aria-level": depth + 1,
+      "aria-expanded": expanded,
+      className: chunk3Z6ALUWP_cjs.cn(
+        "border-b border-zinc-100 py-1 last:border-b-0 dark:border-zinc-800",
+        conflict && "bg-red-50/60 dark:bg-red-950/20",
+        pending.length > 0 && "bg-violet-50/60 dark:bg-violet-950/20"
+      ),
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-start gap-2 px-2", style: { paddingInlineStart: depth * INDENT + 8 }, children: [
+          container ? /* @__PURE__ */ jsxRuntime.jsx(
+            chunkHTKDPFLJ_cjs.Button,
+            {
+              variant: "ghost",
+              size: "xs",
+              "data-react-fancy-json-editor-toggle": "",
+              "data-path": dotted,
+              "aria-label": expanded ? `Collapse ${label}` : `Expand ${label}`,
+              "aria-expanded": expanded,
+              icon: expanded ? "chevron-down" : "chevron-right",
+              onClick: () => ctx.toggleExpanded(dotted)
+            }
+          ) : /* @__PURE__ */ jsxRuntime.jsx("span", { "aria-hidden": "true", className: "inline-block w-6 shrink-0" }),
+          /* @__PURE__ */ jsxRuntime.jsxs(
+            "div",
+            {
+              "data-react-fancy-json-editor-key": "",
+              "data-path": dotted,
+              className: "w-1/3 min-w-0 shrink-0",
+              children: [
+                renameable ? /* @__PURE__ */ jsxRuntime.jsx(
+                  chunk6FYMMQ3G_cjs.Input,
+                  {
+                    size: ctx.size,
+                    mode: "edit",
+                    defaultValue: key,
+                    spellCheck: false,
+                    "aria-label": `Key of ${dotted}`,
+                    onKeyDown: (event) => {
+                      if (event.key === "Enter") event.currentTarget.blur();
+                    },
+                    onBlur: (event) => {
+                      const next = event.currentTarget.value;
+                      if (next !== key) ctx.renameAt(node, next);
+                    }
+                  },
+                  key
+                ) : /* @__PURE__ */ jsxRuntime.jsx(
+                  chunk23CLGUMT_cjs.Text,
+                  {
+                    as: "span",
+                    size: "sm",
+                    weight: "medium",
+                    color: node.parentKind === "array" ? "muted" : "default",
+                    className: "block truncate py-1 font-mono",
+                    title: dotted,
+                    children: node.parentKind === "array" ? `[${key}]` : label
+                  }
+                ),
+                node.rule?.description && /* @__PURE__ */ jsxRuntime.jsx(chunk23CLGUMT_cjs.Text, { as: "span", size: "xs", color: "muted", className: "block truncate", children: node.rule.description })
+              ]
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            "div",
+            {
+              "data-react-fancy-json-editor-value": "",
+              "data-path": dotted,
+              "data-type": node.type,
+              className: "min-w-0 flex-1",
+              children: container ? /* @__PURE__ */ jsxRuntime.jsx(chunk23CLGUMT_cjs.Text, { as: "span", size: "sm", color: "muted", className: "block py-1 font-mono", children: node.type === "array" ? `[ ${node.childCount} ${node.childCount === 1 ? "item" : "items"} ]` : `{ ${node.childCount} ${node.childCount === 1 ? "key" : "keys"} }` }) : /* @__PURE__ */ jsxRuntime.jsx(
+                JsonEditorValue,
+                {
+                  node,
+                  mode: ctx.mode,
+                  size: ctx.size,
+                  readOnly: ctx.readOnly,
+                  id: `${ctx.idPrefix}-${dotted}`,
+                  onCommit: (next) => ctx.setValueAt(node, next)
+                }
+              )
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex shrink-0 items-center gap-0.5 pt-0.5", children: [
+            node.declared && /* @__PURE__ */ jsxRuntime.jsx(chunkX5VZRFQD_cjs.Badge, { size: "sm", variant: "soft", color: conflict ? "red" : "zinc", children: node.type }),
+            container && ctx.allowAdd && !ctx.readOnly && /* @__PURE__ */ jsxRuntime.jsx(
+              chunkHTKDPFLJ_cjs.Button,
+              {
+                variant: "ghost",
+                size: "xs",
+                "data-react-fancy-json-editor-add": "",
+                "data-path": dotted,
+                "aria-label": `Add to ${label}`,
+                icon: "plus",
+                onClick: () => ctx.setAddingAt(ctx.addingAt === dotted ? null : dotted)
+              }
+            ),
+            ctx.allowReorder && !ctx.readOnly && node.parentKind === "array" && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+              /* @__PURE__ */ jsxRuntime.jsx(
+                chunkHTKDPFLJ_cjs.Button,
+                {
+                  variant: "ghost",
+                  size: "xs",
+                  "data-react-fancy-json-editor-move-up": "",
+                  "data-path": dotted,
+                  "aria-label": `Move ${dotted} up`,
+                  icon: "arrow-up",
+                  onClick: () => ctx.moveAt(node, Number(key) - 1)
+                }
+              ),
+              /* @__PURE__ */ jsxRuntime.jsx(
+                chunkHTKDPFLJ_cjs.Button,
+                {
+                  variant: "ghost",
+                  size: "xs",
+                  "data-react-fancy-json-editor-move-down": "",
+                  "data-path": dotted,
+                  "aria-label": `Move ${dotted} down`,
+                  icon: "arrow-down",
+                  onClick: () => ctx.moveAt(node, Number(key) + 1)
+                }
+              )
+            ] }),
+            ctx.allowRemove && !ctx.readOnly && node.parentKind !== "root" && /* @__PURE__ */ jsxRuntime.jsx(
+              chunkHTKDPFLJ_cjs.Button,
+              {
+                variant: "ghost",
+                size: "xs",
+                color: "red",
+                "data-react-fancy-json-editor-remove": "",
+                "data-path": dotted,
+                "aria-label": `Remove ${dotted}`,
+                icon: "trash-2",
+                onClick: () => ctx.removeAt(node)
+              }
+            )
+          ] })
+        ] }),
+        conflict && /* @__PURE__ */ jsxRuntime.jsx(
+          chunk23CLGUMT_cjs.Text,
+          {
+            as: "span",
+            size: "xs",
+            color: "danger",
+            "data-react-fancy-json-editor-conflict": "",
+            "data-path": dotted,
+            className: "block px-2 pb-1",
+            style: { paddingInlineStart: depth * INDENT + 40 },
+            children: conflict.message
+          }
+        ),
+        pending.map((edit) => /* @__PURE__ */ jsxRuntime.jsxs(
+          "div",
+          {
+            "data-react-fancy-json-editor-pending": "",
+            "data-id": edit.id,
+            "data-path": dotted,
+            className: "flex items-center gap-2 px-2 pb-1",
+            style: { paddingInlineStart: depth * INDENT + 40 },
+            children: [
+              /* @__PURE__ */ jsxRuntime.jsx(chunkX5VZRFQD_cjs.Badge, { size: "sm", variant: "soft", color: "violet", children: "proposed" }),
+              /* @__PURE__ */ jsxRuntime.jsxs(chunk23CLGUMT_cjs.Text, { as: "span", size: "xs", color: "muted", className: "min-w-0 truncate font-mono", children: [
+                edit.label ?? describeEdit(edit),
+                edit.op === "set" || edit.op === "insert" ? ` \u2192 ${toText(edit.value)}` : ""
+              ] }),
+              /* @__PURE__ */ jsxRuntime.jsx(
+                chunkHTKDPFLJ_cjs.Button,
+                {
+                  size: "xs",
+                  color: "emerald",
+                  "data-react-fancy-json-editor-accept": "",
+                  "data-id": edit.id,
+                  onClick: () => ctx.acceptPending(edit.id),
+                  children: "Accept"
+                }
+              ),
+              /* @__PURE__ */ jsxRuntime.jsx(
+                chunkHTKDPFLJ_cjs.Button,
+                {
+                  size: "xs",
+                  variant: "ghost",
+                  "data-react-fancy-json-editor-reject": "",
+                  "data-id": edit.id,
+                  onClick: () => ctx.rejectPending(edit.id),
+                  children: "Reject"
+                }
+              )
+            ]
+          },
+          edit.id
+        ))
+      ]
+    }
+  );
+}
+function JsonEditorAddForm({ path, kind, depth, suggestedType }) {
+  const ctx = useJsonEditorContext();
+  const [key, setKey] = react.useState("");
+  const [type, setType] = react.useState(suggestedType ?? "string");
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      "data-react-fancy-json-editor-add-form": "",
+      "data-path": path,
+      className: "flex items-center gap-2 border-b border-zinc-100 px-2 py-1.5 dark:border-zinc-800",
+      style: { paddingInlineStart: depth * INDENT + 32 },
+      children: [
+        kind === "object" && /* @__PURE__ */ jsxRuntime.jsx(
+          chunk6FYMMQ3G_cjs.Input,
+          {
+            size: ctx.size,
+            mode: "edit",
+            value: key,
+            placeholder: "key",
+            "aria-label": "New key",
+            spellCheck: false,
+            "data-react-fancy-json-editor-add-key": "",
+            onValueChange: setKey
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          chunkJU5W65N3_cjs.Select,
+          {
+            size: ctx.size,
+            mode: "edit",
+            "aria-label": "New value type",
+            "data-react-fancy-json-editor-add-type": "",
+            list: [...JSON_FIELD_TYPES],
+            value: type,
+            onValueChange: (next) => setType(next)
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          chunkHTKDPFLJ_cjs.Button,
+          {
+            size: "xs",
+            color: "blue",
+            "data-react-fancy-json-editor-add-confirm": "",
+            onClick: () => ctx.insertInto(path, kind === "object" ? key : void 0, type),
+            children: "Add"
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          chunkHTKDPFLJ_cjs.Button,
+          {
+            size: "xs",
+            variant: "ghost",
+            "data-react-fancy-json-editor-add-cancel": "",
+            onClick: () => ctx.setAddingAt(null),
+            children: "Cancel"
+          }
+        )
+      ]
+    }
+  );
+}
+function collectContainerPaths(value) {
+  const out = [];
+  const walk = (node, segments) => {
+    if (!isContainerValue(node)) return;
+    if (segments.length > 0) out.push(pathToString(segments));
+    if (isJsonArray(node)) {
+      node.forEach((child, index) => walk(child, [...segments, String(index)]));
+    } else if (isJsonObject(node)) {
+      for (const [key, child] of Object.entries(node)) walk(child, [...segments, key]);
+    }
+  };
+  walk(value, []);
+  return out;
+}
+var JsonEditor = react.forwardRef(function JsonEditor2({
+  value,
+  onChange,
+  keyMap,
+  mode = "view",
+  size = "sm",
+  readOnly = false,
+  expanded,
+  defaultExpanded,
+  onExpandedChange,
+  showIssues = true,
+  onIssuesChange,
+  pendingMode = false,
+  pending,
+  onPendingChange,
+  onActivity,
+  allowAdd = true,
+  allowRemove = true,
+  allowRename = true,
+  allowReorder = true,
+  rootLabel = "value",
+  emptyLabel = "No keys yet.",
+  idPrefix,
+  className,
+  ...rest
+}, ref) {
+  const autoId = react.useId();
+  const prefix = idPrefix ?? autoId;
+  const editSeq = react.useRef(0);
+  const parsedKeyMap = react.useMemo(() => parseKeyMap(keyMap), [keyMap]);
+  const rules = parsedKeyMap.rules;
+  const conflicts = react.useMemo(() => findJsonConflicts(value, rules), [value, rules]);
+  const [editIssues, setEditIssues] = react.useState([]);
+  const issues = react.useMemo(
+    () => [...parsedKeyMap.issues, ...conflicts, ...editIssues],
+    [parsedKeyMap.issues, conflicts, editIssues]
+  );
+  const onIssuesChangeRef = react.useRef(onIssuesChange);
+  onIssuesChangeRef.current = onIssuesChange;
+  const lastIssueSignature = react.useRef(null);
+  react.useEffect(() => {
+    const signature = JSON.stringify(issues);
+    if (signature === lastIssueSignature.current) return;
+    lastIssueSignature.current = signature;
+    onIssuesChangeRef.current?.(issues);
+  }, [issues]);
+  const expandedControlled = expanded !== void 0;
+  const [expandedUncontrolled, setExpandedUncontrolled] = react.useState(
+    defaultExpanded ?? null
+  );
+  const expandedList = expandedControlled ? expanded : expandedUncontrolled;
+  const isExpanded = react.useCallback(
+    (dotted) => expandedList === null || expandedList.includes(dotted),
+    [expandedList]
+  );
+  const toggleExpanded = react.useCallback(
+    (dotted) => {
+      const current = expandedList ?? collectContainerPaths(value);
+      const next = current.includes(dotted) ? current.filter((path) => path !== dotted) : [...current, dotted];
+      if (!expandedControlled) setExpandedUncontrolled(next);
+      onExpandedChange?.(next);
+    },
+    [expandedList, expandedControlled, onExpandedChange, value]
+  );
+  const [addingAt, setAddingAt] = react.useState(null);
+  const stagedPending = react.useMemo(() => pending ?? [], [pending]);
+  const commit = react.useCallback(
+    (edit) => {
+      setEditIssues([]);
+      if (pendingMode) {
+        const staged = {
+          ...edit,
+          id: edit.id ?? `${prefix}-edit-${editSeq.current++}`,
+          label: edit.label ?? describeEdit(edit)
+        };
+        onPendingChange?.([...stagedPending, staged]);
+        onActivity?.({ type: "stage", edit: staged });
+        return;
+      }
+      const next = applyJsonEdit(value, edit);
+      if (next === value) return;
+      onChange?.(next, edit);
+      onActivity?.({ type: "commit", edit });
+    },
+    [pendingMode, prefix, stagedPending, onPendingChange, onActivity, value, onChange]
+  );
+  const refuse = react.useCallback((path, message) => {
+    setEditIssues([{ kind: "edit", path, message }]);
+  }, []);
+  const setValueAt = react.useCallback(
+    (node, next) => {
+      commit({ op: "set", path: node.dotted, value: next });
+    },
+    [commit]
+  );
+  const removeAt = react.useCallback(
+    (node) => {
+      commit({ op: "remove", path: node.dotted });
+    },
+    [commit]
+  );
+  const moveAt = react.useCallback(
+    (node, to) => {
+      commit({ op: "move", path: node.dotted, to });
+    },
+    [commit]
+  );
+  const renameAt = react.useCallback(
+    (node, key) => {
+      if (key === node.key) return;
+      if (key.trim() === "") {
+        refuse(node.dotted, "A key cannot be empty.");
+        return;
+      }
+      const parent = getAtPath(value, node.path.slice(0, -1));
+      if (isJsonObject(parent) && Object.prototype.hasOwnProperty.call(parent, key)) {
+        refuse(node.dotted, `A key named "${key}" already exists here \u2014 rename refused.`);
+        return;
+      }
+      commit({ op: "rename", path: node.dotted, key });
+    },
+    [commit, refuse, value]
+  );
+  const insertInto = react.useCallback(
+    (dotted, key, type) => {
+      const segments = parsePath(dotted);
+      const container = dotted === "" ? value : getAtPath(value, segments);
+      const isArray = isJsonArray(container);
+      if (!isArray) {
+        if (key === void 0 || key.trim() === "") {
+          refuse(dotted, "A new key needs a name.");
+          return;
+        }
+        if (isJsonObject(container) && Object.prototype.hasOwnProperty.call(container, key)) {
+          refuse(dotted, `A key named "${key}" already exists here.`);
+          return;
+        }
+      }
+      const rule = resolveKeyRule(rules, [...segments, isArray ? "*" : key]);
+      setAddingAt(null);
+      commit({
+        op: "insert",
+        path: dotted,
+        key: isArray ? void 0 : key,
+        value: seedValue(type, rule)
+      });
+    },
+    [commit, refuse, rules, value]
+  );
+  const pendingFor = react.useCallback(
+    (dotted) => stagedPending.filter((edit) => edit.path === dotted),
+    [stagedPending]
+  );
+  const acceptPending = react.useCallback(
+    (id) => {
+      const edit = stagedPending.find((candidate) => candidate.id === id);
+      if (!edit) return;
+      const next = applyJsonEdit(value, edit);
+      onPendingChange?.(stagedPending.filter((candidate) => candidate.id !== id));
+      if (next !== value) {
+        onChange?.(next, edit);
+        onActivity?.({ type: "accept", edit });
+      }
+    },
+    [stagedPending, value, onPendingChange, onChange, onActivity]
+  );
+  const rejectPending = react.useCallback(
+    (id) => {
+      const edit = stagedPending.find((candidate) => candidate.id === id);
+      onPendingChange?.(stagedPending.filter((candidate) => candidate.id !== id));
+      if (edit) onActivity?.({ type: "reject", edit });
+    },
+    [stagedPending, onPendingChange, onActivity]
+  );
+  const items = react.useMemo(
+    () => buildItems({
+      value,
+      rules,
+      conflicts,
+      isExpanded,
+      addingAt,
+      rootLabel
+    }),
+    [value, rules, conflicts, isExpanded, addingAt, rootLabel]
+  );
+  const rootIsContainer = isContainerValue(value);
+  const rootKind = isJsonArray(value) ? "array" : "object";
+  const attachedIds = new Set(
+    items.flatMap((item) => item.kind === "node" ? [item.node.dotted] : [])
+  );
+  const orphanPending = stagedPending.filter((edit) => !attachedIds.has(edit.path));
+  const context = react.useMemo(
+    () => ({
+      mode: readOnly ? "view" : mode,
+      size,
+      readOnly,
+      allowAdd: allowAdd && !readOnly,
+      allowRemove: allowRemove && !readOnly,
+      allowRename: allowRename && !readOnly,
+      allowReorder: allowReorder && !readOnly,
+      pendingMode,
+      idPrefix: prefix,
+      isExpanded,
+      toggleExpanded,
+      setValueAt,
+      removeAt,
+      renameAt,
+      moveAt,
+      insertInto,
+      addingAt,
+      setAddingAt,
+      pendingFor,
+      acceptPending,
+      rejectPending
+    }),
+    [
+      mode,
+      size,
+      readOnly,
+      allowAdd,
+      allowRemove,
+      allowRename,
+      allowReorder,
+      pendingMode,
+      prefix,
+      isExpanded,
+      toggleExpanded,
+      setValueAt,
+      removeAt,
+      renameAt,
+      moveAt,
+      insertInto,
+      addingAt,
+      pendingFor,
+      acceptPending,
+      rejectPending
+    ]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(JsonEditorContext.Provider, { value: context, children: /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      ref,
+      ...rest,
+      "data-react-fancy-json-editor": "",
+      "data-issues": String(issues.length),
+      "data-keymap-error": parsedKeyMap.ok ? void 0 : "true",
+      "data-mode": readOnly ? "readonly" : mode,
+      className: chunk3Z6ALUWP_cjs.cn(
+        "overflow-hidden rounded-lg border border-zinc-200 bg-white text-zinc-900 dark:border-zinc-700 dark:bg-zinc-900 dark:text-zinc-100",
+        className
+      ),
+      children: [
+        showIssues && issues.length > 0 && /* @__PURE__ */ jsxRuntime.jsx("div", { "data-react-fancy-json-editor-issues": "", className: "p-2", children: /* @__PURE__ */ jsxRuntime.jsxs(chunkY5V5GBN4_cjs.Callout, { color: parsedKeyMap.ok ? "amber" : "red", children: [
+          /* @__PURE__ */ jsxRuntime.jsx(chunk23CLGUMT_cjs.Text, { size: "sm", weight: "semibold", className: "mb-1", children: parsedKeyMap.ok ? `${issues.length} ${issues.length === 1 ? "issue" : "issues"}` : "The keyMap could not be used \u2014 values are shown untyped." }),
+          /* @__PURE__ */ jsxRuntime.jsx("ul", { className: "space-y-0.5", children: issues.map((issue2, index) => /* @__PURE__ */ jsxRuntime.jsx("li", { children: /* @__PURE__ */ jsxRuntime.jsxs(chunk23CLGUMT_cjs.Text, { as: "span", size: "xs", "data-react-fancy-json-editor-issue": "", "data-kind": issue2.kind, "data-path": issue2.path, children: [
+            issue2.path ? `${issue2.path} \u2014 ` : "",
+            issue2.message
+          ] }) }, `${issue2.kind}-${issue2.path}-${index}`)) })
+        ] }) }),
+        /* @__PURE__ */ jsxRuntime.jsx("div", { "data-react-fancy-json-editor-tree": "", role: "tree", "aria-label": rest["aria-label"] ?? "JSON document", children: items.length === 0 ? /* @__PURE__ */ jsxRuntime.jsx(chunk23CLGUMT_cjs.Text, { as: "p", size: "sm", color: "muted", className: "px-3 py-4", children: emptyLabel }) : items.map(
+          (item) => item.kind === "node" ? /* @__PURE__ */ jsxRuntime.jsx(JsonEditorRow, { node: item.node }, `row:${item.node.dotted}`) : /* @__PURE__ */ jsxRuntime.jsx(
+            JsonEditorAddForm,
+            {
+              path: item.path,
+              kind: item.containerKind,
+              depth: item.depth,
+              suggestedType: item.suggestedType
+            },
+            `add:${item.path}`
+          )
+        ) }),
+        orphanPending.length > 0 && /* @__PURE__ */ jsxRuntime.jsx("div", { "data-react-fancy-json-editor-orphan-pending": "", className: "border-t border-zinc-100 p-2 dark:border-zinc-800", children: orphanPending.map((edit) => /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-2 py-0.5", children: [
+          /* @__PURE__ */ jsxRuntime.jsx(chunk23CLGUMT_cjs.Text, { as: "span", size: "xs", color: "muted", className: "min-w-0 flex-1 truncate font-mono", children: edit.label ?? describeEdit(edit) }),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            chunkHTKDPFLJ_cjs.Button,
+            {
+              size: "xs",
+              color: "emerald",
+              "data-react-fancy-json-editor-accept": "",
+              "data-id": edit.id,
+              onClick: () => acceptPending(edit.id),
+              children: "Accept"
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            chunkHTKDPFLJ_cjs.Button,
+            {
+              size: "xs",
+              variant: "ghost",
+              "data-react-fancy-json-editor-reject": "",
+              "data-id": edit.id,
+              onClick: () => rejectPending(edit.id),
+              children: "Reject"
+            }
+          )
+        ] }, edit.id)) }),
+        rootIsContainer && allowAdd && !readOnly && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "border-t border-zinc-100 p-2 dark:border-zinc-800", children: /* @__PURE__ */ jsxRuntime.jsx(
+          chunkHTKDPFLJ_cjs.Button,
+          {
+            variant: "ghost",
+            size: "xs",
+            icon: "plus",
+            "data-react-fancy-json-editor-add": "",
+            "data-path": "",
+            onClick: () => setAddingAt(addingAt === "" ? null : ""),
+            children: rootKind === "array" ? "Append item" : "Add key"
+          }
+        ) })
+      ]
+    }
+  ) });
+});
+function buildItems({
+  value,
+  rules,
+  conflicts,
+  isExpanded,
+  addingAt,
+  rootLabel
+}) {
+  const out = [];
+  const conflictByPath = /* @__PURE__ */ new Map();
+  for (const issue2 of conflicts) {
+    if (issue2.kind === "type" && !conflictByPath.has(issue2.path)) conflictByPath.set(issue2.path, issue2);
+  }
+  const makeNode = (segments, node, depth, parentKind) => {
+    const rule = segments.length > 0 ? resolveKeyRule(rules, segments) : void 0;
+    const type = rule?.type ?? inferType(node);
+    const dotted = pathToString(segments);
+    const conflict = conflictByPath.get(dotted);
+    const container = !conflict && type !== "json" && isContainerValue(node);
+    return {
+      path: segments,
+      dotted,
+      key: segments[segments.length - 1] ?? rootLabel,
+      depth,
+      value: node,
+      parentKind,
+      rule,
+      type,
+      declared: rule !== void 0,
+      container,
+      childCount: isJsonArray(node) ? node.length : isJsonObject(node) ? Object.keys(node).length : 0,
+      conflict
+    };
+  };
+  const emitChildren = (node, segments, depth) => {
+    if (isJsonArray(node)) {
+      node.forEach((child, index) => emit(child, [...segments, String(index)], depth, "array"));
+    } else if (isJsonObject(node)) {
+      for (const [key, child] of Object.entries(node)) {
+        emit(child, [...segments, key], depth, "object");
+      }
+    }
+  };
+  const emit = (node, segments, depth, parentKind) => {
+    const built = makeNode(segments, node, depth, parentKind);
+    out.push({ kind: "node", node: built });
+    if (!built.container || !isExpanded(built.dotted)) return;
+    emitChildren(node, segments, depth + 1);
+    if (addingAt === built.dotted) {
+      out.push({
+        kind: "add",
+        path: built.dotted,
+        containerKind: isJsonArray(node) ? "array" : "object",
+        depth: depth + 1,
+        suggestedType: resolveKeyRule(rules, [...segments, "*"])?.type
+      });
+    }
+  };
+  if (isContainerValue(value)) {
+    emitChildren(value, [], 0);
+    if (addingAt === "") {
+      out.push({
+        kind: "add",
+        path: "",
+        containerKind: isJsonArray(value) ? "array" : "object",
+        depth: 0,
+        suggestedType: resolveKeyRule(rules, ["*"])?.type
+      });
+    }
+  } else {
+    out.push({ kind: "node", node: makeNode([], value, 0, "root") });
+  }
+  return out;
+}
+
+exports.JSON_FIELD_TYPES = JSON_FIELD_TYPES;
+exports.JsonEditor = JsonEditor;
+exports.applyJsonEdit = applyJsonEdit;
+exports.describeEdit = describeEdit;
+exports.findJsonConflicts = findJsonConflicts;
+exports.getAtPath = getAtPath;
+exports.inferType = inferType;
+exports.parseKeyMap = parseKeyMap;
+exports.parsePath = parsePath;
+exports.pathToString = pathToString;
+exports.resolveKeyRule = resolveKeyRule;
+exports.typeMatches = typeMatches;
+//# sourceMappingURL=chunk-AR2IBCX7.cjs.map
+//# sourceMappingURL=chunk-AR2IBCX7.cjs.map