@fuma-content/studio 1.0.3 → 1.0.4

package/build/server/__ssr_build/assets/client-BHaLyky8.js

@@ -0,0 +1,1162 @@
+import { r as reactExports, j as jsxRuntimeExports } from "../index.js";
+import { S as Select, a as SelectTrigger, b as SelectValue, c as SelectContent, d as SelectItem } from "./select-B8QQSB6X.js";
+import { c as createLucideIcon, b as cn, C as ChevronRight, j as buttonVariants, X } from "./index-By9m5mBe.js";
+import { Ajv2020 } from "ajv/dist/2020.js";
+import { cva } from "class-variance-authority";
+const __iconNode$1 = [
+  ["path", { d: "M5 12h14", key: "1ays0h" }],
+  ["path", { d: "M12 5v14", key: "s699le" }]
+];
+const Plus = createLucideIcon("plus", __iconNode$1);
+const __iconNode = [
+  ["path", { d: "M10 11v6", key: "nco0om" }],
+  ["path", { d: "M14 11v6", key: "outv1u" }],
+  ["path", { d: "M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6", key: "miytrc" }],
+  ["path", { d: "M3 6h18", key: "d0wm0j" }],
+  ["path", { d: "M8 6V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2", key: "e791ji" }]
+];
+const Trash2 = createLucideIcon("trash-2", __iconNode);
+function objectGet(obj, key) {
+  let cur = obj;
+  for (const prop of key) {
+    if (typeof cur !== "object" || cur === null || !(prop in cur)) return;
+    cur = cur[prop];
+  }
+  return cur;
+}
+function objectSet(obj, key, value) {
+  if (key.length === 0) return value;
+  const parent = objectGet(obj, key.slice(0, -1));
+  if (typeof parent !== "object" || parent === null) throw new Error("missing parent object");
+  parent[key[key.length - 1]] = value;
+  return obj;
+}
+function deepEqual$1(a, b) {
+  if (a === b) return true;
+  if (a == null || b == null) return false;
+  if (typeof a !== "object" || typeof b !== "object") return false;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) return false;
+    return a.every((item, index) => deepEqual$1(item, b[index]));
+  }
+  if (Array.isArray(a) || Array.isArray(b)) return false;
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  if (keysA.length !== keysB.length) return false;
+  return keysA.every((key) => Object.prototype.hasOwnProperty.call(b, key) && deepEqual$1(a[key], b[key]));
+}
+function stringifyFieldKey(fieldKey) {
+  return fieldKey.map((v) => `${typeof v}:${v}`).join(".");
+}
+const Context = reactExports.createContext(null);
+function StfProvider({ value, children }) {
+  return /* @__PURE__ */ jsxRuntimeExports.jsx(Context, {
+    value,
+    children
+  });
+}
+function useStf(options) {
+  const { defaultValues } = options;
+  const dataEngine = reactExports.useMemo(() => new DataEngine(defaultValues), []);
+  return reactExports.useMemo(() => ({ dataEngine }), [dataEngine]);
+}
+function useDataEngine(stf) {
+  if (stf) return stf.dataEngine;
+  return reactExports.use(Context).dataEngine;
+}
+function useArray(field, options = {}) {
+  const engine = useDataEngine();
+  const [items] = useFieldValue(field, {
+    defaultValue: options.defaultValue,
+    compute(value) {
+      const items$1 = [];
+      if (Array.isArray(value)) for (let i = 0; i < value.length; i++) items$1.push({
+        field: [...field, i],
+        index: i
+      });
+      return items$1;
+    },
+    isChanged(prev, next) {
+      return prev.length !== next.length;
+    }
+  });
+  return {
+    items,
+    insertItem(itemValue) {
+      const value = engine.get(field);
+      engine.update(field, Array.isArray(value) ? [...value, itemValue] : [itemValue]);
+    },
+    removeItem(index) {
+      engine.delete([...field, index]);
+    }
+  };
+}
+function useObject(field, options) {
+  const engine = useDataEngine();
+  const [objectKeys] = useFieldValue(field, {
+    defaultValue: options.defaultValue,
+    compute(currentValue) {
+      return currentValue ? Object.keys(currentValue) : [];
+    },
+    isChanged(prev, next) {
+      return !deepEqual$1(prev, next);
+    }
+  });
+  return {
+    properties: reactExports.useMemo(() => {
+      const properties = [];
+      const unknownKeys = new Set(objectKeys);
+      for (const [key, prop] of Object.entries(options.properties)) {
+        unknownKeys.delete(key);
+        properties.push({
+          kind: "fixed",
+          field: [...field, key],
+          key,
+          info: prop
+        });
+      }
+      for (const [pattern, prop] of Object.entries(options.patternProperties ?? {})) {
+        const regex = RegExp(pattern);
+        for (const key of unknownKeys) {
+          if (!key.match(regex)) continue;
+          unknownKeys.delete(key);
+          properties.push({
+            kind: "pattern",
+            info: prop,
+            key,
+            pattern,
+            field: [...field, key]
+          });
+        }
+      }
+      if (options.fallback) for (const key of unknownKeys) properties.push({
+        kind: "fallback",
+        field: [...field, key],
+        key,
+        info: options.fallback
+      });
+      return properties;
+    }, [
+      field,
+      objectKeys,
+      options.fallback,
+      options.patternProperties,
+      options.properties
+    ]),
+    onAppend(name, value) {
+      name = name.trim();
+      if (name.length === 0) return;
+      engine.init([...field, name], value);
+    },
+    onDelete(name) {
+      return engine.delete([...field, name]);
+    }
+  };
+}
+function getDefaultValue$1(defaultValue) {
+  return typeof defaultValue === "function" ? defaultValue() : defaultValue;
+}
+var ListenerManager = class {
+  constructor() {
+    this.listeners = /* @__PURE__ */ new Set();
+    this.indexed = /* @__PURE__ */ new Map();
+  }
+  add(listener) {
+    if (!listener.field) {
+      this.listeners.add(listener);
+      return;
+    }
+    const key = stringifyFieldKey(listener.field);
+    const set = this.indexed.get(key) ?? /* @__PURE__ */ new Set();
+    set.add(listener);
+    this.indexed.set(key, set);
+  }
+  remove(listener) {
+    if (!listener.field) this.listeners.delete(listener);
+    else this.indexed.get(stringifyFieldKey(listener.field))?.delete(listener);
+  }
+  onUpdate(field, ctx) {
+    for (const v of this.listeners) v.onUpdate?.(field, ctx);
+    const updatedKey = stringifyFieldKey(field);
+    if (ctx.swallow) {
+      const set = this.indexed.get(updatedKey);
+      if (set) for (const v of set) v.onUpdate?.(field, ctx);
+    } else for (const [k, listeners] of this.indexed.entries()) {
+      if (k !== updatedKey && !k.startsWith(updatedKey + ".")) continue;
+      for (const v of listeners) v.onUpdate?.(field, ctx);
+    }
+  }
+  onInit(field) {
+    for (const v of this.listeners) v.onInit?.(field);
+    const set = this.indexed.get(stringifyFieldKey(field));
+    if (set) for (const v of set) v.onInit?.(field);
+  }
+  onDelete(field) {
+    for (const v of this.listeners) v.onDelete?.(field);
+    const set = this.indexed.get(stringifyFieldKey(field));
+    if (set) for (const v of set) v.onDelete?.(field);
+  }
+};
+var DataEngine = class {
+  constructor(defaultValues = {}) {
+    this.attachedDataMap = /* @__PURE__ */ new Map();
+    this.listeners = new ListenerManager();
+    this.data = getDefaultValue$1(defaultValues);
+  }
+  listen(listener) {
+    this.listeners.add(listener);
+  }
+  unlisten(listener) {
+    this.listeners.remove(listener);
+  }
+  getData() {
+    return this.data;
+  }
+  /**
+  * init a field
+  * @param key the key of field
+  * @param defaultValue the initial value, the field is also created for `undefined`
+  * @returns the value of initialized field, or the current value of field if already initialized
+  */
+  init(key, defaultValue) {
+    if (key.length === 0) return this.data;
+    let cur = this.data;
+    const currentKey = [];
+    for (let i = 0; i < key.length; i++) {
+      const propKey = key[i];
+      const propValue = cur[propKey];
+      if (i === key.length - 1) {
+        if (propValue !== void 0) return propValue;
+        cur[propKey] = getDefaultValue$1(defaultValue);
+        this.listeners.onUpdate(currentKey, { swallow: true });
+        this.listeners.onInit(key);
+        return cur[propKey];
+      } else if (typeof propValue === "object" && propValue !== null) cur = propValue;
+      else {
+        if (propValue !== void 0) console.warn(`the original value of field ${currentKey.join(".")} is overidden, this might be unexpected.`);
+        cur = cur[propKey] = {};
+        this.listeners.onUpdate(currentKey, { swallow: true });
+      }
+      currentKey.push(propKey);
+    }
+  }
+  delete(key) {
+    if (key.length === 0) return;
+    const parentKey = key.slice(0, -1);
+    const prop = key[key.length - 1];
+    const parent = this.get(parentKey);
+    if (Array.isArray(parent) && typeof prop === "number") {
+      const [deleted] = parent.splice(prop, 1);
+      this.listeners.onUpdate(parentKey, { swallow: false });
+      this.listeners.onDelete(key);
+      return deleted;
+    } else if (typeof parent === "object" && parent !== null) {
+      const temp = parent[prop];
+      delete parent[prop];
+      this.listeners.onUpdate(parentKey, { swallow: true });
+      this.listeners.onDelete(key);
+      return temp;
+    }
+  }
+  get(key) {
+    return objectGet(this.data, key);
+  }
+  /**
+  * update the value of field if it exists
+  * @returns if the field is updated
+  */
+  update(key, value) {
+    try {
+      this.data = objectSet(this.data, key, value);
+      this.listeners.onUpdate(key, { swallow: false });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  attachedData(namespace) {
+    return {
+      get: (field) => {
+        return this.attachedDataMap.get(`${namespace}:${stringifyFieldKey(field)}`);
+      },
+      set: (field, value) => {
+        this.attachedDataMap.set(`${namespace}:${stringifyFieldKey(field)}`, value);
+      },
+      delete: (field) => {
+        if (field) this.attachedDataMap.delete(`${namespace}:${stringifyFieldKey(field)}`);
+        else for (const key of this.attachedDataMap.keys()) if (key.startsWith(`${namespace}:`)) this.attachedDataMap.delete(key);
+      }
+    };
+  }
+  reset(data) {
+    this.update([], data);
+    this.attachedDataMap.clear();
+  }
+};
+function useFieldValue(key, options = {}) {
+  const engine = useDataEngine(options.stf);
+  const { compute = (v) => v, defaultValue, isChanged = (a, b) => a !== b } = options;
+  const [value, setValue] = reactExports.useState(() => compute(engine.init(key, defaultValue)));
+  useListener({
+    field: key,
+    onUpdate() {
+      const computed = compute(engine.get(key));
+      if (isChanged(value, computed)) setValue(computed);
+    },
+    onDelete() {
+      const computed = compute(void 0);
+      if (isChanged(value, computed)) setValue(computed);
+    }
+  });
+  return [value, (newValue) => engine.update(key, newValue)];
+}
+function useListener(listener) {
+  const engine = useDataEngine(listener.stf);
+  const listenerRef = reactExports.useRef(listener);
+  listenerRef.current = listener;
+  reactExports.useEffect(() => {
+    const internal = {
+      field: listener.field,
+      onDelete(...args) {
+        return listenerRef.current.onDelete?.(...args);
+      },
+      onInit(...args) {
+        return listenerRef.current.onInit?.(...args);
+      },
+      onUpdate(...args) {
+        return listenerRef.current.onUpdate?.(...args);
+      }
+    };
+    engine.listen(internal);
+    return () => {
+      engine.unlisten(internal);
+    };
+  }, [engine, listener.field]);
+}
+function Input({ className, type, ...props }) {
+  return /* @__PURE__ */ jsxRuntimeExports.jsx(
+    "input",
+    {
+      type,
+      "data-slot": "input",
+      className: cn(
+        "h-9 w-full min-w-0 rounded-4xl border border-input bg-input/30 px-3 py-1 text-base outline-none transition-colors file:inline-flex file:h-7 file:border-0 file:bg-transparent file:font-medium file:text-foreground file:text-sm placeholder:text-muted-foreground focus-visible:border-ring focus-visible:ring-[3px] focus-visible:ring-ring/50 disabled:pointer-events-none disabled:cursor-not-allowed disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-[3px] aria-invalid:ring-destructive/20 md:text-sm dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40",
+        className
+      ),
+      ...props
+    }
+  );
+}
+function getDefaultValue(schema) {
+  if (typeof schema === "boolean") return null;
+  const type = schema.type;
+  if (Array.isArray(type))
+    return getDefaultValue({
+      ...schema,
+      type: type[0]
+    });
+  if (type === "object" && typeof schema === "object")
+    return Object.fromEntries(
+      Object.entries(schema.properties ?? {}).map(([key, prop]) => {
+        return [key, getDefaultValue(prop)];
+      })
+    );
+  if (type === "array") return [];
+  if (type === "null") return null;
+  if (type === "string") {
+    if (typeof schema === "object" && schema.format === "binary") return void 0;
+    return "";
+  }
+  if (type === "number" || type === "integer") return 0;
+  if (type === "boolean") return false;
+}
+var FormatFlags = /* @__PURE__ */ ((FormatFlags2) => {
+  FormatFlags2[FormatFlags2["None"] = 0] = "None";
+  FormatFlags2[FormatFlags2["UseAlias"] = 1] = "UseAlias";
+  return FormatFlags2;
+})(FormatFlags || {});
+function schemaToString(value, flags = 0) {
+  function union(union2, sep, flags2) {
+    const members = /* @__PURE__ */ new Set();
+    let nullable = false;
+    for (const item of union2) {
+      const result2 = run(
+        item,
+        flags2 | 1
+        /* UseAlias */
+      );
+      if (result2 === "null") {
+        nullable = true;
+      } else if (result2 !== "unknown") {
+        members.add(result2);
+      }
+    }
+    const result = Array.from(members).join(sep);
+    return nullable ? `${result} | null` : result;
+  }
+  function run(schema, flags2) {
+    if (schema === true) return "any";
+    else if (schema === false) return "never";
+    if ((flags2 & 1) === 1) {
+      if (schema.title) return schema.title;
+    }
+    if (Array.isArray(schema.type)) {
+      return union(
+        schema.type.map((type) => ({
+          ...schema,
+          type
+        })),
+        " | ",
+        flags2
+      );
+    }
+    if (schema.type === "array")
+      return `array<${schema.items ? run(
+        schema.items,
+        flags2 | 1
+        /* UseAlias */
+      ) : "unknown"}>`;
+    const or = schema.oneOf ?? schema.anyOf;
+    if (schema.oneOf && schema.anyOf) {
+      return `(${union(schema.oneOf, " | ", flags2)}) & (${union(schema.anyOf, " | ", flags2)})`;
+    } else if (or) {
+      return union(or, " | ", flags2);
+    }
+    if (schema.allOf) {
+      return union(schema.allOf, " & ", flags2);
+    }
+    if (schema.not) return `not ${run(schema.not, flags2)}`;
+    if (schema.type === "string" && schema.format === "binary") return "file";
+    if (schema.type && Array.isArray(schema.type)) {
+      return schema.type.filter((v) => v !== "null").join(" | ");
+    }
+    if (schema.type) {
+      return schema.type;
+    }
+    return "unknown";
+  }
+  return run(value, flags);
+}
+function deepEqual(a, b) {
+  if (a === b) {
+    return true;
+  }
+  if (a == null || b == null) {
+    return false;
+  }
+  if (typeof a !== "object" || typeof b !== "object") {
+    return false;
+  }
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) {
+      return false;
+    }
+    return a.every((item, index) => deepEqual(item, b[index]));
+  }
+  if (Array.isArray(a) || Array.isArray(b)) {
+    return false;
+  }
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  if (keysA.length !== keysB.length) {
+    return false;
+  }
+  return keysA.every(
+    (key) => Object.prototype.hasOwnProperty.call(b, key) && deepEqual(a[key], b[key])
+  );
+}
+function mergeAllOf(schema) {
+  if (typeof schema === "boolean" || !schema.allOf) return schema;
+  const { allOf, ...rest } = schema;
+  let result = rest;
+  for (const item of allOf) {
+    result = intersection(result, item);
+  }
+  return result;
+}
+function intersection(a, b) {
+  a = mergeAllOf(a);
+  b = mergeAllOf(b);
+  if (typeof a === "boolean" && typeof b === "boolean") return a && b;
+  if (typeof a === "boolean") return a;
+  if (typeof b === "boolean") return b;
+  const result = { ...a };
+  for (const _k in b) {
+    const key = _k;
+    switch (key) {
+      case "$id":
+      case "$comment":
+      case "description":
+      case "additionalItems":
+      case "examples":
+      case "allOf":
+      case "writeOnly":
+      case "readOnly":
+        break;
+      case "title": {
+        const value = b[key];
+        if (value === void 0) break;
+        if (result[key]) {
+          result[key] = `${result[key]} & ${value}`;
+        } else {
+          result[key] = value;
+        }
+        break;
+      }
+      case "minItems":
+      case "minimum":
+      case "exclusiveMinimum":
+      case "minProperties":
+      case "minContains":
+      case "minLength": {
+        const value = b[key];
+        if (value === void 0) break;
+        result[key] = result[key] === void 0 ? value : Math.max(result[key], value);
+        break;
+      }
+      case "maxContains":
+      case "maxItems":
+      case "maxLength":
+      case "maxProperties":
+      case "maximum":
+      case "exclusiveMaximum": {
+        const value = b[key];
+        if (value === void 0) break;
+        result[key] = result[key] === void 0 ? value : Math.min(result[key], value);
+        break;
+      }
+      // intersection
+      case "enum":
+      case "anyOf":
+      case "oneOf": {
+        const value = b[key];
+        if (value === void 0) break;
+        result[key] = result[key] === void 0 ? value : intersectArray(result[key], value);
+        break;
+      }
+      // require same
+      case "format":
+      case "const":
+      case "type": {
+        const value = b[key];
+        if (value === void 0) break;
+        result[key] ??= value;
+        if (!deepEqual(result[key], value)) return false;
+        break;
+      }
+      // add
+      case "required": {
+        const value = b[key];
+        if (value === void 0) break;
+        result[key] = [...result[key] ?? [], ...value];
+        break;
+      }
+      case "properties":
+      case "patternProperties": {
+        const value = b[key];
+        if (value === void 0) break;
+        if (result[key] === void 0) {
+          result[key] = value;
+          break;
+        }
+        const out = {};
+        const allProps = /* @__PURE__ */ new Set();
+        for (const k in result[key]) allProps.add(k);
+        for (const k in value) allProps.add(k);
+        for (const prop of allProps) {
+          const aProp = result[key][prop];
+          const bProp = value[prop];
+          if (aProp === void 0) {
+            out[prop] = bProp;
+          } else if (bProp === void 0) {
+            out[prop] = aProp;
+          } else {
+            out[prop] = intersection(aProp, bProp);
+          }
+        }
+        result[key] = out;
+        break;
+      }
+      case "additionalProperties":
+      case "contains":
+      case "items": {
+        const value = b[key];
+        if (value === void 0) break;
+        result[key] = result[key] === void 0 ? value : intersection(result[key], value);
+        break;
+      }
+      case "not": {
+        const value = b[key];
+        if (value === void 0) break;
+        if (result[key] && value) {
+          result.not = { anyOf: [result[key], value] };
+        } else if (value) {
+          result.not = value;
+        }
+        break;
+      }
+      default:
+        result[key] = b[key];
+    }
+  }
+  return result;
+}
+function intersectArray(a, b) {
+  const out = /* @__PURE__ */ new Set();
+  for (const item of a) {
+    if (b.includes(item)) out.add(item);
+  }
+  for (const item of b) {
+    if (a.includes(item)) out.add(item);
+  }
+  return Array.from(out);
+}
+const SchemaContext = reactExports.createContext(void 0);
+const anyFields = {
+  type: ["string", "number", "boolean", "array", "object"],
+  items: true,
+  additionalProperties: true
+};
+function SchemaProvider({
+  schema,
+  children
+}) {
+  const ajv = reactExports.useMemo(
+    () => new Ajv2020({
+      strict: false,
+      validateSchema: false,
+      validateFormats: false,
+      schemas: [schema]
+    }),
+    [schema]
+  );
+  return /* @__PURE__ */ jsxRuntimeExports.jsx(SchemaContext.Provider, { value: reactExports.useMemo(() => ({ schema, ajv }), [schema, ajv]), children });
+}
+function useFieldInfo(fieldName, schema) {
+  const { ajv } = reactExports.use(SchemaContext);
+  const engine = useDataEngine();
+  const attachedData = engine.attachedData("field-info");
+  const [info, setInfo] = reactExports.useState(() => {
+    const value = engine.get(fieldName);
+    const initialInfo = attachedData.get(fieldName);
+    if (initialInfo) return initialInfo;
+    const out = {
+      oneOf: -1
+    };
+    const union = getUnion(schema);
+    if (union) {
+      const [members, field] = union;
+      out.oneOf = members.findIndex((item) => ajv.validate(item, value));
+      if (out.oneOf === -1) out.oneOf = 0;
+      out.unionField = field;
+    }
+    if (Array.isArray(schema.type)) {
+      const types = schema.type;
+      out.selectedType = types.find((type) => ajv.validate({ ...schema, type }, value)) ?? types.at(0);
+    }
+    if (schema.allOf) {
+      const merged = mergeAllOf(schema);
+      if (typeof merged !== "boolean")
+        out.intersection = {
+          merged
+        };
+    }
+    return out;
+  });
+  attachedData.set(fieldName, info);
+  return {
+    info,
+    updateInfo(value) {
+      const updated = {
+        ...info,
+        ...value
+      };
+      if (updated.oneOf === info.oneOf && updated.selectedType === info.selectedType) return;
+      setInfo(updated);
+      let valueSchema = schema;
+      if (updated.unionField) {
+        valueSchema = schema[updated.unionField][updated.oneOf];
+      } else if (updated.selectedType) {
+        valueSchema = { ...schema, type: updated.selectedType };
+      }
+      engine.update(fieldName, getDefaultValue(valueSchema));
+    }
+  };
+}
+function useSchemaContext() {
+  return reactExports.use(SchemaContext);
+}
+function useResolvedSchema(schema) {
+  const { ajv } = reactExports.use(SchemaContext);
+  return reactExports.useMemo(() => fallbackAny(dereference(schema, { ajv })), [ajv, schema]);
+}
+function fallbackAny(schema) {
+  return typeof schema === "boolean" ? anyFields : schema;
+}
+function getUnion(schema) {
+  if (schema.anyOf) {
+    return [schema.anyOf, "anyOf"];
+  }
+  if (schema.oneOf) return [schema.oneOf, "oneOf"];
+}
+function dereference(schema, { ajv }) {
+  if (typeof schema === "boolean") return schema;
+  if (schema.$ref) return ajv.getSchema(schema.$ref)?.schema ?? false;
+  return schema;
+}
+const labelVariants = cva(
+  "text-xs font-medium text-foreground peer-disabled:cursor-not-allowed peer-disabled:opacity-70"
+);
+function FieldLabel(props) {
+  return /* @__PURE__ */ jsxRuntimeExports.jsx("label", { ...props, className: cn("w-full inline-flex items-center gap-0.5", props.className), children: props.children });
+}
+function FieldLabelType(props) {
+  return /* @__PURE__ */ jsxRuntimeExports.jsx("code", { ...props, className: cn("text-xs text-muted-foreground", props.className), children: props.children });
+}
+function ObjectInput({
+  field: _field,
+  fieldName,
+  ...props
+}) {
+  const field = useResolvedSchema(_field);
+  const [nextName, setNextName] = reactExports.useState("");
+  const { properties, onAppend, onDelete } = useObject(fieldName, {
+    defaultValue: () => getDefaultValue(field),
+    properties: field.properties ?? {},
+    fallback: field.additionalProperties,
+    patternProperties: field.patternProperties
+  });
+  const isDynamic = field.patternProperties ?? field.additionalProperties;
+  return /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { ...props, className: cn("grid grid-cols-1 gap-4 @md:grid-cols-2", props.className), children: [
+    properties.map((child) => {
+      let toolbar = null;
+      if (child.kind === "pattern" || child.kind === "fallback") {
+        toolbar = /* @__PURE__ */ jsxRuntimeExports.jsx(
+          "button",
+          {
+            type: "button",
+            "aria-label": "Remove Item",
+            className: cn(
+              buttonVariants({
+                variant: "outline",
+                size: "icon-xs"
+              })
+            ),
+            onClick: () => {
+              onDelete(child.key);
+            },
+            children: /* @__PURE__ */ jsxRuntimeExports.jsx(Trash2, {})
+          }
+        );
+      }
+      return /* @__PURE__ */ jsxRuntimeExports.jsx(
+        FieldSet,
+        {
+          name: child.key,
+          field: child.info,
+          fieldName: child.field,
+          isRequired: field.required?.includes(child.key),
+          toolbar
+        },
+        child.key
+      );
+    }),
+    isDynamic && /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "flex gap-2 col-span-full", children: [
+      /* @__PURE__ */ jsxRuntimeExports.jsx(
+        Input,
+        {
+          value: nextName,
+          placeholder: "Enter Property Name",
+          onChange: (e) => setNextName(e.target.value),
+          onKeyDown: (e) => {
+            if (e.key === "Enter") {
+              setNextName("");
+              onAppend(nextName);
+              e.preventDefault();
+            }
+          }
+        }
+      ),
+      /* @__PURE__ */ jsxRuntimeExports.jsx(
+        "button",
+        {
+          type: "button",
+          className: cn(buttonVariants({ variant: "secondary", size: "sm" }), "px-4"),
+          onClick: () => {
+            onAppend(nextName);
+            setNextName("");
+          },
+          children: "New"
+        }
+      )
+    ] })
+  ] });
+}
+function FieldInput({
+  field,
+  fieldName,
+  isRequired,
+  ...props
+}) {
+  const engine = useDataEngine();
+  const [value, setValue] = useFieldValue(fieldName);
+  const id = stringifyFieldKey(fieldName);
+  if (field.type === "null") return;
+  function renderUnset(children) {
+    return /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { ...props, className: cn("flex flex-row gap-2", props.className), children: [
+      children,
+      value !== void 0 && !isRequired && /* @__PURE__ */ jsxRuntimeExports.jsx(
+        "button",
+        {
+          type: "button",
+          onClick: () => engine.delete(fieldName),
+          className: "text-muted-foreground",
+          children: /* @__PURE__ */ jsxRuntimeExports.jsx(X, { className: "size-4" })
+        }
+      )
+    ] });
+  }
+  if (field.enum && field.enum.length > 0) {
+    const idx = field.enum.indexOf(value);
+    return /* @__PURE__ */ jsxRuntimeExports.jsxs(Select, { value: String(idx), onValueChange: (v) => setValue(field.enum[Number(v)]), children: [
+      /* @__PURE__ */ jsxRuntimeExports.jsx(SelectTrigger, { id, ...props, children: /* @__PURE__ */ jsxRuntimeExports.jsx(SelectValue, {}) }),
+      /* @__PURE__ */ jsxRuntimeExports.jsxs(SelectContent, { children: [
+        field.enum.map((item, i) => /* @__PURE__ */ jsxRuntimeExports.jsx(SelectItem, { value: String(i), children: typeof item === "string" ? item : JSON.stringify(item, null, 2) }, i)),
+        !isRequired && /* @__PURE__ */ jsxRuntimeExports.jsx(SelectItem, { value: "-1", children: "Unset" })
+      ] })
+    ] });
+  }
+  if (field.type === "boolean") {
+    return /* @__PURE__ */ jsxRuntimeExports.jsxs(
+      Select,
+      {
+        value: String(value),
+        onValueChange: (value2) => setValue(value2 === "undefined" ? void 0 : value2 === "true"),
+        children: [
+          /* @__PURE__ */ jsxRuntimeExports.jsx(SelectTrigger, { id, ...props, children: /* @__PURE__ */ jsxRuntimeExports.jsx(SelectValue, {}) }),
+          /* @__PURE__ */ jsxRuntimeExports.jsxs(SelectContent, { children: [
+            /* @__PURE__ */ jsxRuntimeExports.jsx(SelectItem, { value: "true", children: "True" }),
+            /* @__PURE__ */ jsxRuntimeExports.jsx(SelectItem, { value: "false", children: "False" }),
+            !isRequired && /* @__PURE__ */ jsxRuntimeExports.jsx(SelectItem, { value: "undefined", children: "Unset" })
+          ] })
+        ]
+      }
+    );
+  }
+  if (field.type === "integer" || field.type === "number") {
+    return renderUnset(
+      /* @__PURE__ */ jsxRuntimeExports.jsx(
+        Input,
+        {
+          id,
+          placeholder: "Enter value",
+          type: "number",
+          step: field.type === "integer" ? 1 : void 0,
+          value: String(value ?? ""),
+          onChange: (e) => setValue(Number.isNaN(e.target.valueAsNumber) ? void 0 : e.target.valueAsNumber)
+        }
+      )
+    );
+  }
+  if (field.type === "string" && field.format === "binary") {
+    return renderUnset(
+      /* @__PURE__ */ jsxRuntimeExports.jsxs(jsxRuntimeExports.Fragment, { children: [
+        /* @__PURE__ */ jsxRuntimeExports.jsx(
+          "label",
+          {
+            htmlFor: id,
+            className: cn(
+              buttonVariants({
+                variant: "secondary",
+                className: "w-full h-9 gap-2 truncate"
+              })
+            ),
+            children: value instanceof File ? /* @__PURE__ */ jsxRuntimeExports.jsxs(jsxRuntimeExports.Fragment, { children: [
+              /* @__PURE__ */ jsxRuntimeExports.jsx("span", { className: "text-muted-foreground text-xs", children: "Selected" }),
+              /* @__PURE__ */ jsxRuntimeExports.jsx("span", { className: "truncate w-0 flex-1 text-end", children: value.name })
+            ] }) : /* @__PURE__ */ jsxRuntimeExports.jsx("span", { className: "text-muted-foreground", children: "Upload" })
+          }
+        ),
+        /* @__PURE__ */ jsxRuntimeExports.jsx(
+          "input",
+          {
+            id,
+            type: "file",
+            multiple: false,
+            onChange: (e) => {
+              if (!e.target.files || e.target.files.length === 0) return;
+              setValue(e.target.files.item(0));
+            },
+            hidden: true
+          }
+        )
+      ] })
+    );
+  }
+  return renderUnset(
+    /* @__PURE__ */ jsxRuntimeExports.jsx(
+      Input,
+      {
+        id,
+        placeholder: "Enter value",
+        type: field.format === "date" ? "date" : "text",
+        value: String(value ?? ""),
+        onChange: (e) => setValue(e.target.value)
+      }
+    )
+  );
+}
+function FieldSet({
+  field: _field,
+  fieldName,
+  toolbar,
+  name,
+  isRequired,
+  depth = 0,
+  slotType,
+  collapsible = true,
+  ...props
+}) {
+  const field = useResolvedSchema(_field);
+  const [show, setShow] = reactExports.useState(!collapsible);
+  const { info, updateInfo } = useFieldInfo(fieldName, field);
+  const id = stringifyFieldKey(fieldName);
+  const dataEngine = useDataEngine();
+  if (_field === false) return;
+  function renderLabelTrigger(schema = field) {
+    if (!collapsible) return renderLabelName();
+    return /* @__PURE__ */ jsxRuntimeExports.jsxs(
+      "button",
+      {
+        type: "button",
+        className: cn(labelVariants(), "inline-flex items-center gap-1 font-mono me-auto"),
+        onClick: () => {
+          dataEngine.init(fieldName, getDefaultValue(schema));
+          setShow((prev) => !prev);
+        },
+        children: [
+          /* @__PURE__ */ jsxRuntimeExports.jsx(ChevronRight, { className: cn("size-3.5 text-muted-foreground", show && "rotate-90") }),
+          name,
+          isRequired && /* @__PURE__ */ jsxRuntimeExports.jsx("span", { className: "text-red-400/80", children: "*" })
+        ]
+      }
+    );
+  }
+  function renderLabelName() {
+    return /* @__PURE__ */ jsxRuntimeExports.jsxs("span", { className: cn(labelVariants(), "font-mono me-auto"), children: [
+      name,
+      isRequired && /* @__PURE__ */ jsxRuntimeExports.jsx("span", { className: "text-red-400/80 mx-1", children: "*" })
+    ] });
+  }
+  if (info.unionField && field[info.unionField]) {
+    const union = field[info.unionField];
+    const showSelect = union.length > 1;
+    return /* @__PURE__ */ jsxRuntimeExports.jsx(
+      FieldSet,
+      {
+        ...props,
+        name,
+        fieldName,
+        isRequired,
+        field: union[info.oneOf],
+        depth: depth + 1,
+        slotType: showSelect ? false : slotType,
+        collapsible,
+        toolbar: /* @__PURE__ */ jsxRuntimeExports.jsxs(jsxRuntimeExports.Fragment, { children: [
+          showSelect && /* @__PURE__ */ jsxRuntimeExports.jsx(
+            "select",
+            {
+              className: "text-xs font-mono",
+              value: info.oneOf,
+              onChange: (e) => {
+                updateInfo({
+                  oneOf: Number(e.target.value)
+                });
+              },
+              children: union.map((item, i) => /* @__PURE__ */ jsxRuntimeExports.jsx("option", { value: i, className: "bg-popover text-popover-foreground", children: schemaToString(item, FormatFlags.UseAlias) }, i))
+            }
+          ),
+          toolbar
+        ] })
+      }
+    );
+  }
+  if (Array.isArray(field.type)) {
+    const showSelect = field.type.length > 1;
+    return /* @__PURE__ */ jsxRuntimeExports.jsx(
+      FieldSet,
+      {
+        ...props,
+        name,
+        fieldName,
+        isRequired,
+        field: {
+          ...field,
+          type: info.selectedType
+        },
+        depth: depth + 1,
+        slotType: showSelect ? false : slotType,
+        collapsible,
+        toolbar: /* @__PURE__ */ jsxRuntimeExports.jsxs(jsxRuntimeExports.Fragment, { children: [
+          showSelect && /* @__PURE__ */ jsxRuntimeExports.jsx(
+            "select",
+            {
+              className: "text-xs font-mono",
+              value: info.selectedType,
+              onChange: (e) => {
+                updateInfo({
+                  selectedType: e.target.value
+                });
+              },
+              children: field.type.map((item) => /* @__PURE__ */ jsxRuntimeExports.jsx("option", { value: item, className: "bg-popover text-popover-foreground", children: item }, item))
+            }
+          ),
+          toolbar
+        ] })
+      }
+    );
+  }
+  if (field.type === "object" || info.intersection) {
+    const schema = info.intersection?.merged ?? field;
+    return /* @__PURE__ */ jsxRuntimeExports.jsxs(
+      "fieldset",
+      {
+        ...props,
+        className: cn("flex flex-col gap-1.5 col-span-full @container", props.className),
+        children: [
+          /* @__PURE__ */ jsxRuntimeExports.jsxs(FieldLabel, { htmlFor: id, children: [
+            renderLabelTrigger(schema),
+            slotType ?? /* @__PURE__ */ jsxRuntimeExports.jsx(FieldLabelType, { children: schemaToString(field) }),
+            toolbar
+          ] }),
+          show && /* @__PURE__ */ jsxRuntimeExports.jsx(
+            ObjectInput,
+            {
+              field: schema,
+              fieldName,
+              className: "rounded-lg border bg-card text-card-foreground p-2 shadow-sm"
+            }
+          )
+        ]
+      }
+    );
+  }
+  if (field.type === "array") {
+    return /* @__PURE__ */ jsxRuntimeExports.jsxs("fieldset", { ...props, className: cn("flex flex-col gap-1.5 col-span-full", props.className), children: [
+      /* @__PURE__ */ jsxRuntimeExports.jsxs(FieldLabel, { htmlFor: id, children: [
+        renderLabelTrigger(),
+        slotType ?? /* @__PURE__ */ jsxRuntimeExports.jsx(FieldLabelType, { children: schemaToString(field) }),
+        toolbar
+      ] }),
+      show && /* @__PURE__ */ jsxRuntimeExports.jsx(
+        ArrayInput,
+        {
+          fieldName,
+          items: field.items ?? anyFields,
+          className: "rounded-lg border bg-card text-card-foreground p-2 shadow-sm"
+        }
+      )
+    ] });
+  }
+  return /* @__PURE__ */ jsxRuntimeExports.jsxs("fieldset", { ...props, className: cn("flex flex-col gap-1.5", props.className), children: [
+    /* @__PURE__ */ jsxRuntimeExports.jsxs(FieldLabel, { htmlFor: id, children: [
+      renderLabelName(),
+      slotType ?? /* @__PURE__ */ jsxRuntimeExports.jsx(FieldLabelType, { children: schemaToString(field) }),
+      toolbar
+    ] }),
+    /* @__PURE__ */ jsxRuntimeExports.jsx(FieldInput, { field, fieldName, isRequired })
+  ] });
+}
+function ArrayInput({
+  fieldName,
+  items: itemSchema,
+  ...props
+}) {
+  const name = fieldName.at(-1) ?? "";
+  const { items, insertItem, removeItem } = useArray(fieldName, {
+    defaultValue: []
+  });
+  return /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { ...props, className: cn("flex flex-col gap-2", props.className), children: [
+    items.map((item) => /* @__PURE__ */ jsxRuntimeExports.jsx(
+      FieldSet,
+      {
+        name: /* @__PURE__ */ jsxRuntimeExports.jsxs("span", { className: "text-muted-foreground", children: [
+          name,
+          "[",
+          item.index,
+          "]"
+        ] }),
+        field: itemSchema,
+        isRequired: true,
+        fieldName: item.field,
+        toolbar: /* @__PURE__ */ jsxRuntimeExports.jsx(
+          "button",
+          {
+            type: "button",
+            "aria-label": "Remove Item",
+            className: cn(
+              buttonVariants({
+                variant: "outline",
+                size: "icon-xs"
+              })
+            ),
+            onClick: () => removeItem(item.index),
+            children: /* @__PURE__ */ jsxRuntimeExports.jsx(Trash2, {})
+          }
+        )
+      },
+      item.index
+    )),
+    /* @__PURE__ */ jsxRuntimeExports.jsxs(
+      "button",
+      {
+        type: "button",
+        className: cn(
+          buttonVariants({
+            variant: "secondary",
+            className: "gap-1.5 py-2",
+            size: "sm"
+          })
+        ),
+        onClick: () => {
+          insertItem(getDefaultValue(itemSchema));
+        },
+        children: [
+          /* @__PURE__ */ jsxRuntimeExports.jsx(Plus, { className: "size-4" }),
+          "New Item"
+        ]
+      }
+    )
+  ] });
+}
+function JSONSchemaEditorProvider({
+  children,
+  defaultValue,
+  onValueChange,
+  ...props
+}) {
+  const stf = useStf({
+    defaultValues: defaultValue
+  });
+  useListener({
+    stf,
+    onUpdate() {
+      onValueChange(stf.dataEngine.getData());
+    }
+  });
+  return /* @__PURE__ */ jsxRuntimeExports.jsx(StfProvider, { value: stf, children: /* @__PURE__ */ jsxRuntimeExports.jsx(SchemaProvider, { ...props, children }) });
+}
+function JSONSchemaEditorContent() {
+  const { schema } = useSchemaContext();
+  const field = useResolvedSchema(schema);
+  if (field.format === "binary") return /* @__PURE__ */ jsxRuntimeExports.jsx(FieldSet, { field, fieldName: [] });
+  return /* @__PURE__ */ jsxRuntimeExports.jsx(FieldSet, { field, fieldName: [], collapsible: false });
+}
+export {
+  Input as I,
+  JSONSchemaEditorProvider as J,
+  Plus as P,
+  Trash2 as T,
+  JSONSchemaEditorContent as a,
+  anyFields as b
+};