@lostgradient/cinder 0.5.0 → 0.6.0

package/dist/server/index.server-g789yep6.js

@@ -0,0 +1,1035 @@
+import {
+  Select
+} from "./index.server-ex3ea9z0.js";
+import {
+  Number_input
+} from "./index.server-d146g8pr.js";
+import {
+  Textarea
+} from "./index.server-435sj5m6.js";
+import {
+  Input
+} from "./index.server-bfsbp9dz.js";
+import {
+  Checkbox
+} from "./index.server-e8x1hgw6.js";
+import {
+  classNames
+} from "./index.server-z7nvkz8v.js";
+import {
+  __require
+} from "./index.server-0v6na3yp.js";
+
+// src/components/schema-form/schema-form.svelte
+import * as $2 from "svelte/internal/server";
+
+// src/components/schema-form/schema-form-body.svelte
+import * as $ from "svelte/internal/server";
+import { tick } from "svelte";
+
+// src/components/schema-form/schema-form-model.ts
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function createSchemaFormModel(schema) {
+  return {
+    field: fieldFromJsonSchema(schema, [], "value", true),
+    sourceSchema: schema
+  };
+}
+function fieldFromJsonSchema(schema, path, key, required) {
+  if (!isRecord(schema)) {
+    return baseField("json", {}, path, key, required);
+  }
+  const normalizedSchema = schema;
+  const options = enumOptions(normalizedSchema);
+  if (options.length > 0) {
+    return { ...baseField("enum", normalizedSchema, path, key, required), options };
+  }
+  const schemaType = schemaTypeOf(normalizedSchema);
+  const schemaProperties = normalizedSchema["properties"];
+  if (schemaType === "object" || isRecord(schemaProperties)) {
+    const requiredProperties = requiredPropertyNames(normalizedSchema);
+    const properties = isRecord(schemaProperties) ? schemaProperties : {};
+    const fields = Object.entries(properties).map(([propertyKey, propertySchema]) => fieldFromJsonSchema(propertySchema, [...path, propertyKey], propertyKey, requiredProperties.has(propertyKey)));
+    return { ...baseField("object", normalizedSchema, path, key, required), fields };
+  }
+  if (schemaType === "array") {
+    const schemaItems = normalizedSchema["items"];
+    const itemSchema = isRecord(schemaItems) ? schemaItems : {};
+    const item = fieldFromJsonSchema(itemSchema, [...path, "0"], "item", true);
+    return { ...baseField("array", normalizedSchema, path, key, required), item };
+  }
+  const fieldKind = fieldKindForSchemaType(schemaType);
+  if (fieldKind) {
+    return baseField(fieldKind, normalizedSchema, path, key, required);
+  }
+  return baseField("json", normalizedSchema, path, key, required);
+}
+function fieldKindForSchemaType(type) {
+  switch (type) {
+    case "string":
+    case "number":
+    case "integer":
+    case "boolean":
+    case "array":
+    case "object":
+      return type;
+    default:
+      return;
+  }
+}
+function baseField(kind, schema, path, key, required) {
+  const description = schema["description"];
+  return {
+    kind,
+    key,
+    path,
+    label: fieldLabel(schema, key),
+    required,
+    ...typeof description === "string" && description.length > 0 ? { description } : {},
+    schema,
+    fields: [],
+    options: []
+  };
+}
+function schemaTypeOf(schema) {
+  const { type } = schema;
+  if (typeof type === "string")
+    return type;
+  if (Array.isArray(type)) {
+    const supported = type.find((candidate) => typeof candidate === "string" && candidate !== "null");
+    return typeof supported === "string" ? supported : undefined;
+  }
+  return;
+}
+function requiredPropertyNames(schema) {
+  const required = schema["required"];
+  if (!Array.isArray(required))
+    return new Set;
+  return new Set(required.filter((property) => typeof property === "string"));
+}
+function enumOptions(schema) {
+  const values = schema["enum"];
+  if (!Array.isArray(values) || values.length === 0)
+    return [];
+  if (!values.every((value) => isJsonPrimitive(value)))
+    return [];
+  return values.map((value) => ({
+    label: String(value),
+    value,
+    encodedValue: encodeEnumValue(value)
+  }));
+}
+function isJsonPrimitive(value) {
+  return value === null || ["string", "number", "boolean"].includes(typeof value);
+}
+function encodeEnumValue(value) {
+  return JSON.stringify(value);
+}
+function decodeEnumValue(value) {
+  const parsed = JSON.parse(value);
+  if (!isJsonPrimitive(parsed)) {
+    throw new Error("SchemaForm enum values must be JSON primitives.");
+  }
+  return parsed;
+}
+function fieldLabel(schema, key) {
+  const title = schema["title"];
+  if (typeof title === "string" && title.trim().length > 0) {
+    return title;
+  }
+  if (key === "value")
+    return "Value";
+  return key.replaceAll(/[-_]+/g, " ").replaceAll(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/^\w/, (letter) => letter.toUpperCase());
+}
+function defaultValueForField(field) {
+  if ("default" in field.schema)
+    return cloneJsonCompatible(field.schema["default"]);
+  if (field.kind === "object") {
+    const value = {};
+    for (const child of field.fields) {
+      value[child.key] = defaultValueForField(child);
+    }
+    return value;
+  }
+  if (field.kind === "array")
+    return [];
+  if (field.kind === "boolean")
+    return false;
+  if (field.kind === "enum")
+    return field.options[0]?.value ?? "";
+  if (field.kind === "string")
+    return "";
+  if (field.kind === "json")
+    return null;
+  return;
+}
+function initialValueForField(field, value) {
+  if (value === undefined)
+    return defaultValueForField(field);
+  const clonedValue = cloneJsonCompatible(value);
+  if (clonedValue === undefined)
+    return defaultValueForField(field);
+  return mergeInitialValueWithFieldDefaults(field, clonedValue);
+}
+function mergeInitialValueWithFieldDefaults(field, value) {
+  if (field.kind === "object" && isRecord(value)) {
+    const defaultValue = defaultValueForField(field);
+    const defaultRecord = isRecord(defaultValue) ? defaultValue : {};
+    const result = { ...defaultRecord };
+    const fieldKeys = new Set(field.fields.map((child) => child.key));
+    for (const child of field.fields) {
+      const seededValue = Object.hasOwn(value, child.key) ? value[child.key] : defaultRecord[child.key];
+      result[child.key] = seededValue === undefined ? defaultValueForField(child) : mergeInitialValueWithFieldDefaults(child, seededValue);
+    }
+    for (const [key, extraValue] of Object.entries(value)) {
+      if (!fieldKeys.has(key))
+        result[key] = extraValue;
+    }
+    return result;
+  }
+  if (field.kind === "array" && Array.isArray(value) && field.item) {
+    return value.map((item) => mergeInitialValueWithFieldDefaults(field.item, item));
+  }
+  return value;
+}
+function cloneJsonCompatible(value) {
+  if (value === undefined)
+    return;
+  try {
+    const serializedValue = JSON.stringify(value, cloneJsonCompatibleReplacer);
+    if (serializedValue === undefined)
+      return;
+    const clonedValue = JSON.parse(serializedValue);
+    return clonedValue;
+  } catch {
+    return;
+  }
+}
+function cloneJsonCompatibleReplacer(_key, value) {
+  if (typeof value === "number" && !Number.isFinite(value)) {
+    throw new TypeError("SchemaForm values must contain finite numbers.");
+  }
+  if (typeof value === "bigint") {
+    throw new TypeError("SchemaForm values must not contain bigint values.");
+  }
+  return value;
+}
+function pathKey(path) {
+  return path.map((segment) => segment.replaceAll("~", "~0").replaceAll("/", "~1")).join("/");
+}
+function pathId(path) {
+  return path.length === 0 ? "value" : path.map(domIdSegment).join("__");
+}
+function domIdSegment(segment) {
+  let encoded = "";
+  for (const character of segment) {
+    if (/^[a-zA-Z0-9]$/.test(character)) {
+      encoded += character;
+    } else {
+      encoded += `_${character.codePointAt(0)?.toString(16) ?? "0"}_`;
+    }
+  }
+  return `${segment.length}_${encoded}`;
+}
+function getValueAtPath(value, path) {
+  let current = value;
+  for (const segment of path) {
+    if (Array.isArray(current)) {
+      const index = Number(segment);
+      current = Number.isInteger(index) ? current[index] : undefined;
+    } else if (isRecord(current)) {
+      current = current[segment];
+    } else {
+      return;
+    }
+  }
+  return current;
+}
+function setValueAtPath(value, path, next) {
+  if (path.length === 0)
+    return next;
+  const [head, ...tail] = path;
+  if (head === undefined)
+    return next;
+  if (Array.isArray(value)) {
+    const copy2 = [...value];
+    const index = Number(head);
+    if (!Number.isInteger(index) || index < 0)
+      return copy2;
+    copy2[index] = setValueAtPath(copy2[index], tail, next);
+    return copy2;
+  }
+  const copy = isRecord(value) ? { ...value } : {};
+  copy[head] = setValueAtPath(copy[head], tail, next);
+  return copy;
+}
+function pruneUndefined(value) {
+  if (Array.isArray(value))
+    return value.map((item) => pruneUndefined(item));
+  if (!isRecord(value))
+    return value;
+  const output = {};
+  for (const [key, child] of Object.entries(value)) {
+    if (child !== undefined)
+      output[key] = pruneUndefined(child);
+  }
+  return output;
+}
+function arrayValueAtPath(value, path) {
+  const array = getValueAtPath(value, path);
+  return Array.isArray(array) ? array : [];
+}
+function rebaseFieldPath(field, path) {
+  const originalPath = field.path;
+  function rebase(candidate) {
+    const suffix = candidate.path.slice(originalPath.length);
+    return {
+      ...candidate,
+      path: [...path, ...suffix],
+      fields: candidate.fields.map(rebase),
+      ...candidate.item ? { item: rebase(candidate.item) } : {}
+    };
+  }
+  return rebase(field);
+}
+
+// src/components/schema-form/schema-form-validation.ts
+var validatorCache = new WeakMap;
+async function validateSchemaValue(schema, value) {
+  if (!isRecord(schema)) {
+    return validationFailure(value, "SchemaForm only accepts JSON Schema objects.");
+  }
+  if (isLegacyStandardSchema(schema)) {
+    return validationFailure(value, "SchemaForm only accepts JSON Schema objects.");
+  }
+  return validateJsonSchemaValue(schema, value);
+}
+async function validateJsonSchemaValue(schema, value) {
+  let validate;
+  try {
+    validate = await validatorForSchema(schema);
+  } catch (error) {
+    return validationFailure(value, readableSchemaError(error));
+  }
+  let valid;
+  try {
+    const result = validate(value);
+    valid = isPromiseLike(result) ? (await result, true) : result;
+  } catch (error) {
+    if (isAjvValidationError(error))
+      return {
+        valid: false,
+        value,
+        issues: ajvIssues(error.errors)
+      };
+    return validationFailure(value, readableSchemaError(error));
+  }
+  if (valid)
+    return { valid: true, value, issues: [] };
+  return {
+    valid: false,
+    value,
+    issues: ajvIssues(validate.errors ?? [])
+  };
+}
+function validationFailure(value, message) {
+  return {
+    valid: false,
+    value,
+    issues: [{ path: [], message }]
+  };
+}
+function isLegacyStandardSchema(schema) {
+  const standard = schema["~standard"];
+  return isRecord(standard) && standard["version"] === 1;
+}
+function readableSchemaError(error) {
+  const message = error instanceof Error ? error.message : typeof error === "string" ? error : "";
+  if (message.startsWith("Invalid JSON Schema"))
+    return message;
+  return message === "" ? "Invalid JSON Schema." : `Invalid JSON Schema: ${message}`;
+}
+function isPromiseLike(value) {
+  return isRecord(value) && typeof value["then"] === "function";
+}
+function isAjvValidationError(error) {
+  return isRecord(error) && Array.isArray(error["errors"]);
+}
+function validatorForSchema(schema) {
+  const cached = validatorCache.get(schema);
+  if (cached)
+    return cached;
+  const promise = createValidator(schema).catch((error) => {
+    validatorCache.delete(schema);
+    throw error;
+  });
+  validatorCache.set(schema, promise);
+  return promise;
+}
+async function createValidator(schema) {
+  const draft = jsonSchemaDraft(schema);
+  if (draft === "draft-07") {
+    const { default: Ajv } = await import("ajv");
+    return new Ajv({ strict: false, allErrors: true, addUsedSchema: false }).compile(schema);
+  }
+  if (draft === "2019-09") {
+    const { default: Ajv2019 } = await import("ajv/dist/2019.js");
+    return new Ajv2019({ strict: false, allErrors: true, addUsedSchema: false }).compile(schema);
+  }
+  const { default: Ajv2020 } = await import("ajv/dist/2020.js");
+  return new Ajv2020({ strict: false, allErrors: true, addUsedSchema: false }).compile(schema);
+}
+function jsonSchemaDraft(schema) {
+  const id = schema["$schema"];
+  if (typeof id !== "string")
+    return "2020-12";
+  if (id.includes("draft-07"))
+    return "draft-07";
+  if (id.includes("2019-09"))
+    return "2019-09";
+  return "2020-12";
+}
+function ajvIssues(errors) {
+  return errors.map((error) => ({
+    path: ajvErrorPath(error),
+    message: readableAjvMessage(error)
+  }));
+}
+function readableAjvMessage(error) {
+  const fieldName = ajvErrorPath(error).at(-1) ?? "Value";
+  const label = humanizeFieldName(fieldName);
+  if (error.keyword === "required")
+    return `${label} is required.`;
+  if (error.keyword === "minLength")
+    return `${label} is too short.`;
+  if (error.keyword === "maxLength")
+    return `${label} is too long.`;
+  if (error.keyword === "minimum")
+    return `${label} must be at least ${error.params?.["limit"]}.`;
+  if (error.keyword === "maximum")
+    return `${label} must be at most ${error.params?.["limit"]}.`;
+  if (error.keyword === "type")
+    return `${label} must be ${error.params?.["type"]}.`;
+  return error.message ?? "Invalid value";
+}
+function humanizeFieldName(name) {
+  return name.replace(/[_-]+/g, " ").replace(/([a-z])([A-Z])/g, "$1 $2").replace(/^./, (character) => character.toUpperCase());
+}
+function ajvErrorPath(error) {
+  const parentPath = jsonPointerToPath(error.instancePath);
+  if (error.keyword !== "required" || !isRecord(error.params))
+    return parentPath;
+  const missingProperty = error.params["missingProperty"];
+  return typeof missingProperty === "string" ? [...parentPath, missingProperty] : parentPath;
+}
+function jsonPointerToPath(pointer) {
+  if (pointer === "")
+    return [];
+  return pointer.slice(1).split("/").map((segment) => segment.replaceAll("~1", "/").replaceAll("~0", "~"));
+}
+function issuesByPath(issues) {
+  const grouped = {};
+  for (const issue of issues) {
+    const key = pathKey(issue.path);
+    grouped[key] ??= issue.message;
+  }
+  return grouped;
+}
+function parseJsonDraft(path, text) {
+  try {
+    return { ok: true, value: JSON.parse(text) };
+  } catch (error) {
+    return {
+      ok: false,
+      issue: {
+        path,
+        message: error instanceof Error ? error.message : "Invalid JSON"
+      }
+    };
+  }
+}
+function serializeValidatedValue(value) {
+  try {
+    const serialized = JSON.stringify(value, schemaFormJsonReplacer);
+    if (serialized === undefined) {
+      throw new TypeError("Validated value is not JSON serializable.");
+    }
+    return { ok: true, value: serialized };
+  } catch (error) {
+    return {
+      ok: false,
+      issue: {
+        path: [],
+        message: error instanceof Error ? error.message : "Validated value is not JSON serializable"
+      }
+    };
+  }
+}
+function schemaFormJsonReplacer(_key, value) {
+  if (typeof value === "number" && !Number.isFinite(value)) {
+    throw new TypeError("Validated value contains a non-finite number.");
+  }
+  if (typeof value === "bigint") {
+    throw new TypeError("Validated value contains a bigint, which is not JSON serializable.");
+  }
+  return value;
+}
+function readSchemaFormData(formData, name = "value") {
+  const raw = formData.get(name);
+  if (typeof raw !== "string")
+    return;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return;
+  }
+}
+
+// src/components/schema-form/schema-form-body.svelte
+function Schema_form_body($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    const generatedId = $.props_id($$renderer2);
+    let {
+      schema,
+      value,
+      name = "value",
+      submitLabel = "Submit",
+      class: customClassName,
+      onsubmit,
+      novalidate,
+      $$slots,
+      $$events,
+      ...rest
+    } = $$props;
+    const initialModel = createSchemaFormModel(schema);
+    const initialFormValue = initialValueForField(initialModel.field, value);
+    const model = $.derived(() => createSchemaFormModel(schema));
+    let formElement = undefined;
+    let serializedInputElement = undefined;
+    let formValue = initialFormValue;
+    let errors = {};
+    let rawDrafts = seedRawDrafts(initialModel.field, initialFormValue);
+    let touchedValidationSequences = {};
+    let serializedValue = "";
+    let submitting = false;
+    let allowNativeSubmit = false;
+    let activeSubmitId = 0;
+    let arrayKeyCounter = 0;
+    let arrayKeys = seedArrayKeys(initialModel.field, initialFormValue);
+    const formId = $.derived(() => rest.id ?? `${generatedId}-form`);
+    const rootFields = $.derived(() => model().field.kind === "object" ? model().field.fields : [model().field]);
+    const rootError = $.derived(() => model().field.kind === "object" ? errors[pathKey([])] : undefined);
+    const rootErrorId = $.derived(() => `${formId()}-${pathId([])}-error`);
+    function fieldDomId(field) {
+      return `${formId()}-${pathId(field.path)}`;
+    }
+    function fieldError(field) {
+      return errors[pathKey(field.path)];
+    }
+    function stringValue(field) {
+      const current = getValueAtPath(formValue, field.path);
+      return current === undefined || current === null ? "" : String(current);
+    }
+    function numberValue(field) {
+      const current = getValueAtPath(formValue, field.path);
+      return typeof current === "number" ? current : undefined;
+    }
+    function booleanValue(field) {
+      return getValueAtPath(formValue, field.path) === true;
+    }
+    function enumValue(field) {
+      const current = getValueAtPath(formValue, field.path);
+      const option = field.options.find((candidate) => Object.is(candidate.value, current));
+      return option?.encodedValue ?? field.options[0]?.encodedValue ?? "";
+    }
+    function selectOptions(field) {
+      return field.options.map((option) => ({ value: option.encodedValue, label: option.label }));
+    }
+    function numberFieldValue(field) {
+      return numberValue(field) ?? null;
+    }
+    function rawJsonValue(field) {
+      const key = pathKey(field.path);
+      if (rawDrafts[key] !== undefined)
+        return rawDrafts[key];
+      return JSON.stringify(getValueAtPath(formValue, field.path) ?? null, null, 2);
+    }
+    function bumpTouchedValidationSequence(path) {
+      const key = pathKey(path);
+      touchedValidationSequences = {
+        ...touchedValidationSequences,
+        [key]: (touchedValidationSequences[key] ?? 0) + 1
+      };
+    }
+    function updateValue(path, next) {
+      if (submitting)
+        return;
+      formValue = setValueAtPath(formValue, path, next);
+      const key = pathKey(path);
+      bumpTouchedValidationSequence(path);
+      if (errors[key]) {
+        const { [key]: _removed, ...remaining } = errors;
+        errors = remaining;
+      }
+      setSerializedValue("");
+    }
+    async function validateTouchedField(field) {
+      if (submitting)
+        return;
+      const fieldKey = pathKey(field.path);
+      const sequence = (touchedValidationSequences[fieldKey] ?? 0) + 1;
+      touchedValidationSequences = { ...touchedValidationSequences, [fieldKey]: sequence };
+      const raw = rawJsonIssues();
+      const rawIssue = raw.issues.find((candidateIssue) => {
+        const candidateKey = pathKey(candidateIssue.path);
+        return candidateKey === fieldKey || candidateKey.startsWith(`${fieldKey}/`);
+      });
+      if (rawIssue) {
+        errors = { ...errors, [fieldKey]: rawIssue.message };
+        return;
+      }
+      const candidate = pruneUndefined(raw.value);
+      const result = await validateSchemaValue(schema, candidate);
+      if (touchedValidationSequences[fieldKey] !== sequence)
+        return;
+      const issue = (result.valid ? [] : result.issues).find((candidateIssue) => {
+        const candidateKey = pathKey(candidateIssue.path);
+        return candidateKey === fieldKey || candidateKey.startsWith(`${fieldKey}/`);
+      });
+      if (issue) {
+        errors = { ...errors, [fieldKey]: issue.message };
+        return;
+      }
+      if (errors[fieldKey]) {
+        const { [fieldKey]: _removed, ...remaining } = errors;
+        errors = remaining;
+      }
+    }
+    function setSerializedValue(next) {
+      serializedValue = next;
+      if (serializedInputElement)
+        serializedInputElement.value = next;
+    }
+    function updateEnum(field, event) {
+      if (submitting)
+        return;
+      const select = event.currentTarget;
+      updateValue(field.path, decodeEnumValue(select.value));
+    }
+    function updateRawJsonValue(field, next) {
+      if (submitting)
+        return;
+      const key = pathKey(field.path);
+      rawDrafts = { ...rawDrafts, [key]: next };
+      bumpTouchedValidationSequence(field.path);
+      if (errors[key]) {
+        const { [key]: _removed, ...remaining } = errors;
+        errors = remaining;
+      }
+      setSerializedValue("");
+    }
+    function arrayRows(field) {
+      const values = arrayValueAtPath(formValue, field.path);
+      const keys = arrayKeys[pathKey(field.path)] ?? [];
+      return values.map((_, index) => ({ key: keys[index] ?? `${pathKey(field.path)}-${index}`, index }));
+    }
+    function addArrayItem(field) {
+      if (submitting)
+        return;
+      const values = arrayValueAtPath(formValue, field.path);
+      const nextValue = field.item ? defaultValueForField(field.item) : null;
+      updateValue(field.path, [...values, nextValue]);
+      const key = pathKey(field.path);
+      arrayKeys = {
+        ...arrayKeys,
+        [key]: [...arrayKeys[key] ?? [], `${key}-${arrayKeyCounter++}`]
+      };
+    }
+    function removeArrayItem(field, index) {
+      if (submitting)
+        return;
+      const values = arrayValueAtPath(formValue, field.path);
+      updateValue(field.path, values.filter((_, candidateIndex) => candidateIndex !== index));
+      rawDrafts = reindexArrayPathState(rawDrafts, field.path, index);
+      errors = reindexArrayPathState(errors, field.path, index);
+      touchedValidationSequences = bumpPathValidationSequences(reindexArrayPathState(touchedValidationSequences, field.path, index), field.path);
+      const key = pathKey(field.path);
+      arrayKeys = {
+        ...arrayKeys,
+        [key]: (arrayKeys[key] ?? []).filter((_, candidateIndex) => candidateIndex !== index)
+      };
+    }
+    function reindexArrayPathState(state, arrayPath, removedIndex) {
+      const prefix = pathKey(arrayPath);
+      const pathPrefix = prefix === "" ? "" : `${prefix}/`;
+      const next = {};
+      for (const [key, stateValue] of Object.entries(state)) {
+        if (!key.startsWith(pathPrefix)) {
+          next[key] = stateValue;
+          continue;
+        }
+        const relativeKey = key.slice(pathPrefix.length);
+        if (relativeKey === "") {
+          next[key] = stateValue;
+          continue;
+        }
+        const [indexSegment = "", ...remainingSegments] = relativeKey.split("/");
+        const index = Number(indexSegment);
+        if (!Number.isInteger(index) || index < 0) {
+          next[key] = stateValue;
+          continue;
+        }
+        if (index < removedIndex) {
+          next[key] = stateValue;
+          continue;
+        }
+        if (index === removedIndex)
+          continue;
+        const shiftedKey = [String(index - 1), ...remainingSegments].join("/");
+        next[`${pathPrefix}${shiftedKey}`] = stateValue;
+      }
+      return next;
+    }
+    function bumpPathValidationSequences(state, path) {
+      const prefix = pathKey(path);
+      const pathPrefix = prefix === "" ? "" : `${prefix}/`;
+      const next = {};
+      for (const [key, sequence] of Object.entries(state)) {
+        next[key] = key === prefix || key.startsWith(pathPrefix) ? sequence + 1 : sequence;
+      }
+      return next;
+    }
+    function seedRawDrafts(field, currentValue) {
+      const drafts = {};
+      for (const jsonField of currentJsonFields(field, currentValue)) {
+        drafts[pathKey(jsonField.path)] = JSON.stringify(getValueAtPath(currentValue, jsonField.path) ?? null, null, 2);
+      }
+      return drafts;
+    }
+    function currentJsonFields(field, currentValue) {
+      const fields = [];
+      function visit(candidate) {
+        if (candidate.kind === "json")
+          fields.push(candidate);
+        for (const child of candidate.fields)
+          visit(child);
+        if (candidate.kind === "array" && candidate.item) {
+          for (const [index] of arrayValueAtPath(currentValue, candidate.path).entries()) {
+            visit(rebaseFieldPath(candidate.item, [...candidate.path, String(index)]));
+          }
+        }
+      }
+      visit(field);
+      return fields;
+    }
+    function seedArrayKeys(field, currentValue) {
+      const keys = {};
+      function visit(candidate) {
+        if (candidate.kind === "array") {
+          const key = pathKey(candidate.path);
+          keys[key] = arrayValueAtPath(currentValue, candidate.path).map(() => `${key}-${arrayKeyCounter++}`);
+        }
+        for (const child of candidate.fields)
+          visit(child);
+        if (candidate.item)
+          visit(candidate.item);
+      }
+      visit(field);
+      return keys;
+    }
+    function rawJsonIssues() {
+      let nextValue = formValue;
+      const issues = [];
+      for (const field of currentJsonFields(model().field, formValue)) {
+        const draft = rawDrafts[pathKey(field.path)];
+        if (draft === undefined)
+          continue;
+        const parsed = parseJsonDraft(field.path, draft);
+        if (parsed.ok) {
+          nextValue = setValueAtPath(nextValue, field.path, parsed.value);
+        } else {
+          issues.push(parsed.issue);
+        }
+      }
+      return { value: nextValue, issues };
+    }
+    async function reportSubmitIssues(issues, submitId) {
+      if (activeSubmitId !== submitId)
+        return;
+      errors = issuesByPath(issues);
+      setSerializedValue("");
+      submitting = false;
+      await focusFirstError(submitId);
+    }
+    async function focusFirstError(submitId) {
+      await tick();
+      if (activeSubmitId !== submitId)
+        return;
+      formElement?.querySelector('[aria-invalid="true"], [data-cinder-invalid="true"], .cinder-schema-form__error')?.focus();
+    }
+    function shouldResumeNativeSubmit() {
+      return onsubmit === undefined && (rest.action !== undefined || rest.method !== undefined);
+    }
+    function nativeSubmitter(event) {
+      const submitter = event.submitter;
+      if (submitter instanceof HTMLButtonElement && submitter.type === "submit" && submitter.form === formElement) {
+        return submitter;
+      }
+      if (submitter instanceof HTMLInputElement && (submitter.type === "submit" || submitter.type === "image") && submitter.form === formElement) {
+        return submitter;
+      }
+      return;
+    }
+    async function handleSubmit(event) {
+      if (allowNativeSubmit) {
+        allowNativeSubmit = false;
+        return;
+      }
+      event.preventDefault();
+      if (submitting)
+        return;
+      const submitId = activeSubmitId + 1;
+      activeSubmitId = submitId;
+      submitting = true;
+      try {
+        const raw = rawJsonIssues();
+        if (raw.issues.length > 0) {
+          await reportSubmitIssues(raw.issues, submitId);
+          return;
+        }
+        const candidate = pruneUndefined(raw.value);
+        const result = await validateSchemaValue(schema, candidate);
+        if (!result.valid) {
+          await reportSubmitIssues(result.issues, submitId);
+          return;
+        }
+        const serialized = serializeValidatedValue(result.value);
+        if (!serialized.ok) {
+          await reportSubmitIssues([serialized.issue], submitId);
+          return;
+        }
+        formValue = result.value;
+        errors = {};
+        setSerializedValue(serialized.value);
+        await onsubmit?.(result.value, event);
+        if (shouldResumeNativeSubmit()) {
+          allowNativeSubmit = true;
+          await tick();
+          formElement?.requestSubmit(nativeSubmitter(event));
+        }
+      } finally {
+        if (activeSubmitId === submitId)
+          submitting = false;
+      }
+    }
+    function groupLegend($$renderer3, field) {
+      $$renderer3.push(`<legend class="cinder-schema-form__legend">${$.escape(field.label)} `);
+      if (field.required) {
+        $$renderer3.push("<!--[0-->");
+        $$renderer3.push(`<span class="cinder-_required-marker" aria-hidden="true">*</span>`);
+      } else {
+        $$renderer3.push("<!--[-1-->");
+      }
+      $$renderer3.push(`<!--]--></legend> `);
+      if (field.description) {
+        $$renderer3.push("<!--[0-->");
+        $$renderer3.push(`<p${$.attr("id", `${$.stringify(fieldDomId(field))}-description`)} class="cinder-schema-form__description">${$.escape(field.description)}</p>`);
+      } else {
+        $$renderer3.push("<!--[-1-->");
+      }
+      $$renderer3.push(`<!--]--> `);
+      if (fieldError(field)) {
+        $$renderer3.push("<!--[0-->");
+        $$renderer3.push(`<p${$.attr("id", `${$.stringify(fieldDomId(field))}-error`)} class="cinder-schema-form__error" aria-live="polite" tabindex="-1">${$.escape(fieldError(field))}</p>`);
+      } else {
+        $$renderer3.push("<!--[-1-->");
+      }
+      $$renderer3.push(`<!--]-->`);
+    }
+    function renderField($$renderer3, field) {
+      const id = fieldDomId(field);
+      const error = fieldError(field);
+      const labelledProps = {
+        label: field.label,
+        ...field.description !== undefined ? { description: field.description } : {},
+        ...error !== undefined ? { error } : {}
+      };
+      if (field.kind === "object") {
+        $$renderer3.push("<!--[0-->");
+        $$renderer3.push(`<fieldset class="cinder-schema-form__fieldset">`);
+        groupLegend($$renderer3, field);
+        $$renderer3.push(`<!----> <div class="cinder-schema-form__fields"><!--[-->`);
+        const each_array = $.ensure_array_like(field.fields);
+        for (let $$index = 0, $$length = each_array.length;$$index < $$length; $$index++) {
+          let child = each_array[$$index];
+          renderField($$renderer3, child);
+        }
+        $$renderer3.push(`<!--]--></div></fieldset>`);
+      } else if (field.kind === "array") {
+        $$renderer3.push("<!--[1-->");
+        $$renderer3.push(`<fieldset class="cinder-schema-form__fieldset">`);
+        groupLegend($$renderer3, field);
+        $$renderer3.push(`<!----> <div class="cinder-schema-form__array"${$.attr("data-cinder-empty", arrayRows(field).length === 0 || undefined)}><!--[-->`);
+        const each_array_1 = $.ensure_array_like(arrayRows(field));
+        for (let $$index_1 = 0, $$length = each_array_1.length;$$index_1 < $$length; $$index_1++) {
+          let row = each_array_1[$$index_1];
+          const itemField = field.item ? rebaseFieldPath(field.item, [...field.path, String(row.index)]) : undefined;
+          $$renderer3.push(`<div class="cinder-schema-form__array-item">`);
+          if (itemField) {
+            $$renderer3.push("<!--[0-->");
+            renderField($$renderer3, itemField);
+          } else {
+            $$renderer3.push("<!--[-1-->");
+          }
+          $$renderer3.push(`<!--]--> <button type="button" class="cinder-schema-form__secondary-button"${$.attr("aria-label", `Remove ${field.label} item ${row.index + 1}`)}${$.attr("disabled", submitting, true)}>Remove</button></div>`);
+        }
+        $$renderer3.push(`<!--]--></div> <button type="button" class="cinder-schema-form__secondary-button"${$.attr("disabled", submitting, true)}>Add ${$.escape(field.label)}</button></fieldset>`);
+      } else {
+        $$renderer3.push("<!--[-1-->");
+        $$renderer3.push(`<div class="cinder-schema-form__field">`);
+        if (field.kind === "string") {
+          $$renderer3.push("<!--[0-->");
+          var bind_get = () => stringValue(field);
+          var bind_set = (next) => updateValue(field.path, next);
+          Input($$renderer3, $.spread_props([
+            { id },
+            labelledProps,
+            {
+              required: field.required,
+              disabled: submitting,
+              onblur: () => validateTouchedField(field),
+              get value() {
+                return bind_get();
+              },
+              set value($$value) {
+                bind_set($$value);
+              }
+            }
+          ]));
+        } else if (field.kind === "number" || field.kind === "integer") {
+          $$renderer3.push("<!--[1-->");
+          var bind_get_1 = () => numberFieldValue(field);
+          var bind_set_1 = (next) => updateValue(field.path, next ?? undefined);
+          Number_input($$renderer3, $.spread_props([
+            { id },
+            labelledProps,
+            {
+              required: field.required,
+              disabled: submitting,
+              step: field.kind === "integer" ? 1 : undefined,
+              onblur: () => validateTouchedField(field),
+              get value() {
+                return bind_get_1();
+              },
+              set value($$value) {
+                bind_set_1($$value);
+              }
+            }
+          ]));
+        } else if (field.kind === "enum") {
+          $$renderer3.push("<!--[2-->");
+          Select($$renderer3, $.spread_props([
+            { id },
+            labelledProps,
+            {
+              required: field.required,
+              disabled: submitting,
+              options: selectOptions(field),
+              value: enumValue(field),
+              onchange: (event) => updateEnum(field, event),
+              onblur: () => validateTouchedField(field)
+            }
+          ]));
+        } else if (field.kind === "boolean") {
+          $$renderer3.push("<!--[3-->");
+          var bind_get_2 = () => booleanValue(field);
+          var bind_set_2 = (next) => updateValue(field.path, next);
+          Checkbox($$renderer3, $.spread_props([
+            { id },
+            labelledProps,
+            {
+              disabled: submitting,
+              get checked() {
+                return bind_get_2();
+              },
+              set checked($$value) {
+                bind_set_2($$value);
+              }
+            }
+          ]));
+        } else {
+          $$renderer3.push("<!--[-1-->");
+          var bind_get_3 = () => rawJsonValue(field);
+          var bind_set_3 = (next) => updateRawJsonValue(field, next);
+          Textarea($$renderer3, $.spread_props([
+            { id },
+            labelledProps,
+            {
+              required: field.required,
+              disabled: submitting,
+              rows: 6,
+              spellcheck: false,
+              class: "cinder-schema-form__json-control",
+              onblur: () => validateTouchedField(field),
+              get value() {
+                return bind_get_3();
+              },
+              set value($$value) {
+                bind_set_3($$value);
+              }
+            }
+          ]));
+        }
+        $$renderer3.push(`<!--]--></div>`);
+      }
+      $$renderer3.push(`<!--]-->`);
+    }
+    let $$settled = true;
+    let $$inner_renderer;
+    function $$render_inner($$renderer3) {
+      $$renderer3.push(`<form${$.attributes({
+        ...rest,
+        id: formId(),
+        class: $.clsx(classNames("cinder-schema-form", customClassName)),
+        novalidate: novalidate ?? true
+      })}>`);
+      if (rootError()) {
+        $$renderer3.push("<!--[0-->");
+        $$renderer3.push(`<p${$.attr("id", rootErrorId())} class="cinder-schema-form__error" role="alert" aria-live="polite" tabindex="-1">${$.escape(rootError())}</p>`);
+      } else {
+        $$renderer3.push("<!--[-1-->");
+      }
+      $$renderer3.push(`<!--]--> <div class="cinder-schema-form__fields"><!--[-->`);
+      const each_array_2 = $.ensure_array_like(rootFields());
+      for (let $$index_2 = 0, $$length = each_array_2.length;$$index_2 < $$length; $$index_2++) {
+        let field = each_array_2[$$index_2];
+        renderField($$renderer3, field);
+      }
+      $$renderer3.push(`<!--]--></div> <input type="hidden"${$.attr("name", name)}${$.attr("value", serializedValue)}/> <button type="submit" class="cinder-schema-form__submit"${$.attr("disabled", submitting, true)}>${$.escape(submitting ? "Validating..." : submitLabel)}</button></form>`);
+    }
+    do {
+      $$settled = true;
+      $$inner_renderer = $$renderer2.copy();
+      $$render_inner($$inner_renderer);
+    } while (!$$settled);
+    $$renderer2.subsume($$inner_renderer);
+  }, Schema_form_body);
+}
+
+// src/components/schema-form/schema-form.svelte
+function Schema_form($$renderer, $$props) {
+  let { schema, $$slots, $$events, ...rest } = $$props;
+  $$renderer.push(`<!---->`);
+  {
+    Schema_form_body($$renderer, $2.spread_props([{ schema }, rest]));
+  }
+  $$renderer.push(`<!---->`);
+}
+
+// src/components/schema-form/index.ts
+var schema_form_default = Schema_form;
+export { readSchemaFormData, Schema_form, schema_form_default };
+
+//# debugId=A900EECA213EAECE64756E2164756E21