@powerduck/schema-designer 0.1.0

package/dist/chunk-HI5FBHCO.js

@@ -0,0 +1,1057 @@
+import { resolveLocalReference } from './chunk-KX3LFFOV.js';
+
+// src/core/tree.ts
+var UNSAFE_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function isUnsafeKey(key) {
+  return UNSAFE_KEYS.has(key);
+}
+function samePath(a, b) {
+  return a.length === b.length && a.every((segment, index) => segment === b[index]);
+}
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value))
+    return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function safeRun(scope, fn, fallback, onError, path) {
+  try {
+    return fn();
+  } catch (cause) {
+    try {
+      onError?.({
+        scope,
+        message: cause instanceof Error ? cause.message : String(cause),
+        cause,
+        path
+      });
+    } catch {
+    }
+    return fallback;
+  }
+}
+var MAX_CLONE_DEPTH = 512;
+function cloneSchema(value, seen, depth = 0) {
+  if (value === null || typeof value !== "object") return value;
+  if (depth > MAX_CLONE_DEPTH) {
+    throw new RangeError(
+      `Schema exceeds maximum clone depth of ${MAX_CLONE_DEPTH}`
+    );
+  }
+  const memo = seen ?? /* @__PURE__ */ new WeakMap();
+  const source = value;
+  if (memo.has(source)) return memo.get(source);
+  if (Array.isArray(value)) {
+    const out2 = new Array(value.length);
+    memo.set(source, out2);
+    for (let i = 0; i < value.length; i += 1) {
+      out2[i] = cloneSchema(value[i], memo, depth + 1);
+    }
+    return out2;
+  }
+  const out = /* @__PURE__ */ Object.create(null);
+  memo.set(source, out);
+  for (const key of Object.keys(value)) {
+    Object.defineProperty(out, key, {
+      value: cloneSchema(
+        value[key],
+        memo,
+        depth + 1
+      ),
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  }
+  return out;
+}
+function setIn(root, path, value) {
+  if (path.length === 0) return value ?? root;
+  const [head, ...rest] = path;
+  if (Array.isArray(root)) {
+    const index = Number(head);
+    if (!Number.isInteger(index) || index < 0 || index >= root.length)
+      return root;
+    const child2 = root[index];
+    const nextChild2 = rest.length === 0 ? value : setIn(
+      isPlainObject(child2) || Array.isArray(child2) ? child2 : {},
+      rest,
+      value
+    );
+    if (nextChild2 === child2) return root;
+    const copy = root.slice();
+    copy[index] = nextChild2;
+    return copy;
+  }
+  const container = root;
+  const child = Object.hasOwn(container, head) ? container[head] : void 0;
+  const nextChild = rest.length === 0 ? value : setIn(
+    isPlainObject(child) || Array.isArray(child) ? child : {},
+    rest,
+    value
+  );
+  if (nextChild === child) return root;
+  return { ...container, [head]: nextChild };
+}
+function getIn(root, path) {
+  let cursor = root;
+  for (const token of path) {
+    if (Array.isArray(cursor)) {
+      const index = Number(token);
+      if (!Number.isInteger(index)) return void 0;
+      cursor = cursor[index];
+      continue;
+    }
+    if (!isPlainObject(cursor)) return void 0;
+    if (!Object.prototype.hasOwnProperty.call(cursor, token)) return void 0;
+    cursor = cursor[token];
+  }
+  return cursor;
+}
+function deleteIn(root, path) {
+  if (path.length === 0) return root;
+  const parentPath = path.slice(0, -1);
+  const key = path[path.length - 1];
+  const parent = getIn(root, parentPath);
+  if (Array.isArray(parent)) {
+    const index = Number(key);
+    if (!/^(0|[1-9][0-9]*)$/.test(key) || index >= parent.length) return root;
+    return setIn(
+      root,
+      parentPath,
+      parent.filter((_, position) => position !== index)
+    );
+  }
+  if (!isPlainObject(parent) || !Object.prototype.hasOwnProperty.call(parent, key))
+    return root;
+  const next = /* @__PURE__ */ Object.create(null);
+  for (const existing of Object.keys(parent)) {
+    if (existing === key) continue;
+    next[existing] = parent[existing];
+  }
+  return setIn(root, parentPath, next);
+}
+function patchSchema(root, path, patch) {
+  const target = getIn(root, path);
+  const base = isPlainObject(target) ? target : {};
+  const next = { ...base };
+  let changed = false;
+  for (const key of Object.keys(patch)) {
+    const value = patch[key];
+    if (value === void 0) {
+      if (Object.prototype.hasOwnProperty.call(next, key)) {
+        delete next[key];
+        changed = true;
+      }
+      continue;
+    }
+    if (next[key] !== value) {
+      Object.defineProperty(next, key, {
+        value,
+        enumerable: true,
+        writable: true,
+        configurable: true
+      });
+      changed = true;
+    }
+  }
+  if (!changed) return root;
+  return setIn(root, path, next);
+}
+function reorderKeys(source, fromKey, toIndex) {
+  if (!isPlainObject(source)) return source;
+  const keys = Object.keys(source);
+  const from = keys.indexOf(fromKey);
+  if (from < 0) return source;
+  const target = Math.max(0, Math.min(keys.length - 1, toIndex));
+  if (target === from) return source;
+  keys.splice(from, 1);
+  keys.splice(target, 0, fromKey);
+  const out = /* @__PURE__ */ Object.create(null);
+  for (const key of keys) {
+    out[key] = source[key];
+  }
+  return out;
+}
+function renameKey(source, fromKey, toKey) {
+  if (!isPlainObject(source) || fromKey === toKey) return source;
+  if (!Object.prototype.hasOwnProperty.call(source, fromKey)) return source;
+  if (Object.prototype.hasOwnProperty.call(source, toKey)) return source;
+  const out = /* @__PURE__ */ Object.create(null);
+  for (const key of Object.keys(source)) {
+    if (key === fromKey) out[toKey] = source[key];
+    else out[key] = source[key];
+  }
+  return out;
+}
+function insertKeyAfter(source, afterKey, key, value) {
+  const base = isPlainObject(source) ? source : {};
+  const out = /* @__PURE__ */ Object.create(null);
+  let inserted = false;
+  for (const existing of Object.keys(base)) {
+    out[existing] = base[existing];
+    if (existing === afterKey) {
+      out[key] = value;
+      inserted = true;
+    }
+  }
+  if (!inserted) out[key] = value;
+  return out;
+}
+function uniqueKey(source, base) {
+  const owner = isPlainObject(source) ? source : {};
+  if (!Object.prototype.hasOwnProperty.call(owner, base)) return base;
+  let counter = 2;
+  while (Object.prototype.hasOwnProperty.call(owner, `${base}${counter}`))
+    counter += 1;
+  return `${base}${counter}`;
+}
+var KEY_PATTERN = /^[A-Za-z_$][A-Za-z0-9_$-]*$/;
+function isValidKey(key) {
+  return typeof key === "string";
+}
+function setRequired(root, ownerPath, key, required) {
+  const owner = getIn(root, ownerPath);
+  const current = isPlainObject(owner) && Array.isArray(owner.required) ? owner.required : [];
+  const has = current.includes(key);
+  if (has === required) return root;
+  const next = required ? [...current, key] : current.filter((item) => item !== key);
+  if (next.length === 0) {
+    const base = isPlainObject(owner) ? { ...owner } : {};
+    delete base.required;
+    return setIn(root, ownerPath, base);
+  }
+  return patchSchema(root, ownerPath, { required: next });
+}
+function renameRequired(root, ownerPath, fromKey, toKey) {
+  const owner = getIn(root, ownerPath);
+  if (!isPlainObject(owner) || !Array.isArray(owner.required)) return root;
+  if (!owner.required.includes(fromKey)) return root;
+  return patchSchema(root, ownerPath, {
+    required: owner.required.map((item) => item === fromKey ? toKey : item)
+  });
+}
+function removeRequired(root, ownerPath, key) {
+  return setRequired(root, ownerPath, key, false);
+}
+var REF_PREFIX = "#/";
+var MAX_REF_HOPS = 64;
+function decodePointerToken(token) {
+  return token.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+function resolveRef(ref, root, onError) {
+  if (typeof ref !== "string" || ref !== "#" && !ref.startsWith(REF_PREFIX) || !isPlainObject(root)) {
+    return null;
+  }
+  return safeRun(
+    "resolveRef",
+    () => {
+      let current = ref;
+      const visited = /* @__PURE__ */ new Set();
+      for (let hop = 0; hop < MAX_REF_HOPS; hop += 1) {
+        if (visited.has(current)) return null;
+        visited.add(current);
+        if (current !== "#" && !current.startsWith(REF_PREFIX)) return null;
+        const tokens = decodeURIComponent(current.slice(REF_PREFIX.length)).split("/").map(decodePointerToken);
+        const cursor = resolveLocalReference(current, root);
+        if (typeof cursor === "boolean")
+          return { schema: cursor, name: tokens[tokens.length - 1] ?? current };
+        if (!isPlainObject(cursor)) return null;
+        const next = cursor.$ref;
+        if (typeof next !== "string") {
+          const name = tokens[tokens.length - 1] ?? current;
+          return { schema: cursor, name };
+        }
+        current = next;
+      }
+      return null;
+    },
+    null,
+    onError
+  );
+}
+function signatureOf(schema) {
+  if (!isPlainObject(schema)) return "";
+  const top = Object.keys(schema);
+  const props = isPlainObject(schema.properties) ? Object.keys(schema.properties) : [];
+  const required = Array.isArray(schema.required) ? schema.required.length : 0;
+  return `${top.length}|${top.join(",")}|${props.join(",")}|${required}`;
+}
+function verifyExternalSchema(next, previous, previousSignature, onError) {
+  if (!isPlainObject(next)) {
+    onError?.({
+      scope: "commit",
+      message: "schema prop must be a plain object"
+    });
+    return {
+      schema: previous ?? {},
+      mutated: false,
+      signature: previousSignature
+    };
+  }
+  const signature = signatureOf(next);
+  const mutated = previous === next && signature !== previousSignature;
+  return { schema: next, mutated, signature };
+}
+function schemaTypeOf(schema) {
+  if (!isPlainObject(schema)) return "string";
+  const raw = schema.type;
+  if (Array.isArray(raw)) {
+    const first = raw.find((item) => item !== "null");
+    return first ?? "string";
+  }
+  if (typeof raw === "string") return raw;
+  if (isPlainObject(schema.properties)) return "object";
+  if (isPlainObject(schema.items)) return "array";
+  return "string";
+}
+function typeLabel(schema) {
+  const base = schemaTypeOf(schema);
+  if (base === "array" && isPlainObject(schema?.items)) {
+    return `array of ${schemaTypeOf(schema?.items)}`;
+  }
+  if (schema?.format) return `${base} \xB7 ${schema.format}`;
+  if (Array.isArray(schema?.enum) && schema.enum.length > 0) return "enum";
+  return base;
+}
+function isExpandable(schema) {
+  if (!isPlainObject(schema)) return false;
+  if (isPlainObject(schema.properties) && Object.keys(schema.properties).length > 0)
+    return true;
+  if (isPlainObject(schema.items) || typeof schema.items === "boolean")
+    return true;
+  if ([schema.prefixItems, schema.allOf, schema.anyOf, schema.oneOf].some(
+    (items) => Array.isArray(items) && items.length
+  ))
+    return true;
+  return false;
+}
+function defaultSchemaFor(type) {
+  switch (type) {
+    case "object":
+      return { type: "object", properties: {} };
+    case "array":
+      return { type: "array", items: { type: "string" } };
+    default:
+      return { type };
+  }
+}
+function changeSchemaType(schema, nextType) {
+  const next = cloneSchema(schema);
+  next.type = nextType;
+  const remove = (...keys) => {
+    for (const key of keys) delete next[key];
+  };
+  if (nextType !== "string") {
+    remove("minLength", "maxLength", "pattern");
+  }
+  if (nextType !== "number" && nextType !== "integer") {
+    remove(
+      "minimum",
+      "maximum",
+      "exclusiveMinimum",
+      "exclusiveMaximum",
+      "multipleOf"
+    );
+  }
+  if (nextType !== "array") {
+    remove(
+      "items",
+      "prefixItems",
+      "minItems",
+      "maxItems",
+      "uniqueItems",
+      "contains",
+      "minContains",
+      "maxContains"
+    );
+  }
+  if (nextType !== "object") {
+    remove(
+      "properties",
+      "required",
+      "additionalProperties",
+      "patternProperties",
+      "propertyNames",
+      "minProperties",
+      "maxProperties",
+      "dependentRequired",
+      "dependentSchemas",
+      "unevaluatedProperties"
+    );
+  }
+  if (nextType === "object" && !isPlainObject(next.properties)) {
+    next.properties = {};
+  }
+  if (nextType === "array" && !Object.prototype.hasOwnProperty.call(next, "items")) {
+    next.items = { type: "string" };
+  }
+  return next;
+}
+function refBlockSegment(isRefRoot, insideRef, hasChildren) {
+  if (isRefRoot) return hasChildren ? "head" : "single";
+  if (insideRef) return "body";
+  return "none";
+}
+function walk(value, key, path, parentPath, depth, required, insideRef, context) {
+  if (context.out.length >= context.maxRows) {
+    context.overflow.hit = true;
+    return;
+  }
+  if (typeof value !== "boolean" && !isPlainObject(value)) return;
+  const schema = typeof value === "boolean" ? {} : value;
+  const id = pointerId(path) || "$root";
+  let resolved = schema;
+  let resolvedValue = value;
+  let refName;
+  let recursive = false;
+  let isRefRoot = false;
+  if (isPlainObject(schema) && typeof schema.$ref === "string") {
+    isRefRoot = true;
+    if (context.refStack.includes(schema.$ref)) {
+      recursive = true;
+      refName = schema.$ref.split("/").pop();
+    } else {
+      const hit = resolveRef(
+        schema.$ref,
+        context.document ?? context.root,
+        context.onError
+      );
+      if (hit) {
+        resolvedValue = hit.schema;
+        resolved = typeof hit.schema === "boolean" ? {} : hit.schema;
+        refName = hit.name;
+      } else {
+        recursive = false;
+        refName = schema.$ref.split("/").pop();
+      }
+    }
+  }
+  const expandable = depth < 128 && !recursive && isExpandable(resolved);
+  const expanded = expandable && (context.expandAll || context.expanded.has(id));
+  const readOnly = insideRef;
+  const node = {
+    id,
+    key,
+    path,
+    parentPath,
+    depth,
+    kind: parentPath.length === 0 && key === "" ? "root" : parentPath[parentPath.length - 1] !== "properties" ? "items" : "property",
+    schema,
+    value,
+    resolved,
+    resolvedValue,
+    required,
+    expandable,
+    expanded,
+    refName,
+    recursive,
+    refSegment: refBlockSegment(isRefRoot, insideRef, expanded),
+    readOnly,
+    sortable: !insideRef && parentPath[parentPath.length - 1] === "properties"
+  };
+  context.out.push(node);
+  if (!expanded) return;
+  const childInsideRef = insideRef || isRefRoot;
+  const nextRefStack = isRefRoot && typeof schema.$ref === "string" ? [...context.refStack, schema.$ref] : context.refStack;
+  const childContext = {
+    ...context,
+    refStack: nextRefStack,
+    out: context.out
+  };
+  const requiredSet = Array.isArray(resolved.required) ? new Set(resolved.required) : /* @__PURE__ */ new Set();
+  const basePath = path;
+  if (isPlainObject(resolved.properties)) {
+    const keys = Object.keys(resolved.properties);
+    for (const childKey of keys) {
+      if (context.out.length >= context.maxRows) {
+        context.overflow.hit = true;
+        break;
+      }
+      walk(
+        resolved.properties[childKey],
+        childKey,
+        [...basePath, "properties", childKey],
+        [...basePath, "properties"],
+        depth + 1,
+        requiredSet.has(childKey),
+        childInsideRef,
+        childContext
+      );
+    }
+  }
+  if (isPlainObject(resolved.items) || typeof resolved.items === "boolean") {
+    walk(
+      resolved.items,
+      "items",
+      [...basePath, "items"],
+      basePath,
+      depth + 1,
+      false,
+      childInsideRef,
+      childContext
+    );
+  }
+  for (const keyword of ["prefixItems", "allOf", "anyOf", "oneOf"]) {
+    const entries = resolved[keyword];
+    if (!Array.isArray(entries)) continue;
+    for (let index = 0; index < entries.length; index++) {
+      if (context.out.length >= context.maxRows) {
+        context.overflow.hit = true;
+        break;
+      }
+      walk(
+        entries[index],
+        `${keyword}[${index}]`,
+        [...basePath, keyword, String(index)],
+        [...basePath, keyword],
+        depth + 1,
+        false,
+        childInsideRef,
+        childContext
+      );
+    }
+  }
+  if (isRefRoot) {
+    const last = context.out[context.out.length - 1];
+    if (last && last !== node) last.refSegment = "tail";
+  }
+}
+function flattenSchema(options) {
+  const { root, onError } = options;
+  return safeRun(
+    "flatten",
+    () => {
+      const out = [];
+      const overflow = { hit: false };
+      const context = {
+        ...options,
+        maxRows: Number.isFinite(options.maxRows) ? Math.max(1, Math.floor(options.maxRows)) : 5e3,
+        out,
+        refStack: [],
+        overflow
+      };
+      if (!isPlainObject(root)) return { nodes: out, overflow: false };
+      const requiredSet = Array.isArray(root.required) ? new Set(root.required) : /* @__PURE__ */ new Set();
+      if (isPlainObject(root.properties)) {
+        for (const key of Object.keys(root.properties)) {
+          if (context.out.length >= context.maxRows) {
+            context.overflow.hit = true;
+            break;
+          }
+          walk(
+            root.properties[key],
+            key,
+            ["properties", key],
+            ["properties"],
+            0,
+            requiredSet.has(key),
+            false,
+            context
+          );
+        }
+      }
+      if (isPlainObject(root.properties)) {
+        for (const keyword of [
+          "items",
+          "prefixItems",
+          "allOf",
+          "anyOf",
+          "oneOf"
+        ]) {
+          const value = root[keyword];
+          const entries = Array.isArray(value) ? value : keyword === "items" && (isPlainObject(value) || typeof value === "boolean") ? [value] : [];
+          for (let index = 0; index < entries.length; index++) {
+            const singleton = keyword === "items" && !Array.isArray(value);
+            walk(
+              entries[index],
+              singleton ? keyword : `${keyword}[${index}]`,
+              singleton ? [keyword] : [keyword, String(index)],
+              singleton ? [] : [keyword],
+              0,
+              false,
+              false,
+              context
+            );
+            if (context.overflow.hit) break;
+          }
+        }
+      }
+      if (!isPlainObject(root.properties) && (root.type || root.$ref || root.items !== void 0 || root.prefixItems || root.allOf || root.anyOf || root.oneOf)) {
+        walk(root, "", [], [], 0, false, false, context);
+      }
+      return { nodes: out, overflow: overflow.hit };
+    },
+    { nodes: [], overflow: false },
+    onError
+  );
+}
+function pruneExpanded(expanded, removedPath) {
+  const prefix = pointerId(removedPath);
+  let changed = false;
+  const next = /* @__PURE__ */ new Set();
+  for (const id of expanded) {
+    if (id === prefix || id.startsWith(`${prefix}/`)) {
+      changed = true;
+      continue;
+    }
+    next.add(id);
+  }
+  return changed ? next : expanded;
+}
+function remapExpanded(expanded, fromPath, toPath) {
+  const from = pointerId(fromPath);
+  const to = pointerId(toPath);
+  if (from === to) return expanded;
+  let changed = false;
+  const next = /* @__PURE__ */ new Set();
+  for (const id of expanded) {
+    if (id === from) {
+      next.add(to);
+      changed = true;
+    } else if (id.startsWith(`${from}/`)) {
+      next.add(`${to}${id.slice(from.length)}`);
+      changed = true;
+    } else {
+      next.add(id);
+    }
+  }
+  return changed ? next : expanded;
+}
+function requiredOwnerPath(parentPath) {
+  if (parentPath.length === 0) return null;
+  if (parentPath[parentPath.length - 1] !== "properties") return null;
+  return parentPath.slice(0, -1);
+}
+function stripUndefined(source) {
+  const out = /* @__PURE__ */ Object.create(null);
+  for (const key of Object.keys(source)) {
+    if (source[key] !== void 0) out[key] = source[key];
+  }
+  return out;
+}
+function pointerId(path) {
+  return path.map((segment) => segment.replace(/~/g, "~0").replace(/\//g, "~1")).join("/");
+}
+
+// src/core/schema.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isSchema(value) {
+  return isRecord(value);
+}
+function toSchemaRecord(schema) {
+  if (!isRecord(schema)) return {};
+  return { ...schema };
+}
+var cloneSchema2 = cloneSchema;
+function asOpenApiSchema(value) {
+  return value;
+}
+function compactSchema(value) {
+  const result = {};
+  for (const [key, item] of Object.entries(value)) {
+    if (item !== void 0)
+      Object.defineProperty(result, key, {
+        value: item,
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+  }
+  return result;
+}
+function mergeSchema(schema, patch) {
+  return compactSchema({ ...toSchemaRecord(schema), ...toSchemaRecord(patch) });
+}
+var INLINE_SCHEMA_TYPES = /* @__PURE__ */ new Set([
+  "string",
+  "number",
+  "integer",
+  "boolean",
+  "array",
+  "object",
+  "null",
+  "any"
+]);
+function normalizeSchemaType(value) {
+  if (typeof value === "string" && INLINE_SCHEMA_TYPES.has(value)) {
+    return value;
+  }
+  return "any";
+}
+function getSchemaType(schema) {
+  const record = toSchemaRecord(schema);
+  const type = record.type;
+  if (Array.isArray(type))
+    return type.length === 1 ? normalizeSchemaType(type[0]) : "any";
+  if (typeof type === "string") return normalizeSchemaType(type);
+  if ("properties" in record || "additionalProperties" in record || "patternProperties" in record || "required" in record)
+    return "object";
+  if ("items" in record || "prefixItems" in record || "contains" in record)
+    return "array";
+  if (typeof record.const === "boolean") return "boolean";
+  if (typeof record.const === "number")
+    return Number.isInteger(record.const) ? "integer" : "number";
+  if (record.const === null) return "null";
+  if (Array.isArray(record.enum) && record.enum.length > 0) {
+    const first = record.enum[0];
+    if (typeof first === "boolean") return "boolean";
+    if (typeof first === "number")
+      return Number.isInteger(first) ? "integer" : "number";
+    if (first === null) return "null";
+    if (Array.isArray(first)) return "array";
+    if (isRecord(first)) return "object";
+    if (typeof first === "string") return "string";
+  }
+  return "any";
+}
+var TYPE_FIELDS = [
+  "format",
+  "minLength",
+  "maxLength",
+  "pattern",
+  "minimum",
+  "maximum",
+  "exclusiveMinimum",
+  "exclusiveMaximum",
+  "multipleOf",
+  "items",
+  "prefixItems",
+  "minItems",
+  "maxItems",
+  "uniqueItems",
+  "contains",
+  "minContains",
+  "maxContains",
+  "unevaluatedItems",
+  "properties",
+  "required",
+  "additionalProperties",
+  "minProperties",
+  "maxProperties",
+  "patternProperties",
+  "propertyNames",
+  "dependentRequired",
+  "dependentSchemas",
+  "unevaluatedProperties",
+  "contentEncoding",
+  "contentMediaType",
+  "discriminator"
+];
+function createSchemaForType(type, previous) {
+  if (previous && getSchemaType(previous) === type) return previous;
+  const base = cloneSchema2(previous ?? {});
+  for (const key of TYPE_FIELDS) delete base[key];
+  if (type === "any") {
+    delete base.type;
+    return compactSchema(base);
+  }
+  base.type = type;
+  if (type === "object") {
+    base.properties = {};
+    base.required = void 0;
+  }
+  if (type === "array") {
+    base.items = {
+      type: "string"
+    };
+  }
+  if (type === "boolean") {
+    delete base.format;
+  }
+  if (type === "null") {
+    delete base.default;
+    delete base.example;
+    delete base.examples;
+    delete base.enum;
+    delete base.const;
+  }
+  return compactSchema(base);
+}
+function normalizeFormatOptions(options) {
+  return Array.from(new Set((options ?? []).filter(Boolean)));
+}
+function parseOptionalNumber(value) {
+  if (value.trim() === "") return void 0;
+  const num = Number(value);
+  return Number.isFinite(num) ? num : void 0;
+}
+function toInputValue(value) {
+  return value === void 0 || value === null ? "" : String(value);
+}
+function stringifySchemaValue(value) {
+  if (value === void 0) return "";
+  if (typeof value === "string") return value;
+  if (value === null) return "null";
+  try {
+    return JSON.stringify(value, null, 2);
+  } catch {
+    return "";
+  }
+}
+function canParseSchemaValue(value, type) {
+  if (!value.trim()) return true;
+  if (type === "null") return value.trim() === "null";
+  if (type === "array") {
+    try {
+      return Array.isArray(JSON.parse(value));
+    } catch {
+      return false;
+    }
+  }
+  if (type === "object") {
+    try {
+      const parsed = JSON.parse(value);
+      return isRecord(parsed);
+    } catch {
+      return false;
+    }
+  }
+  if (type === "any") {
+    try {
+      JSON.parse(value);
+      return true;
+    } catch {
+      return true;
+    }
+  }
+  if (type === "number") return Number.isFinite(Number(value));
+  if (type === "integer") return Number.isInteger(Number(value));
+  if (type === "boolean") return value === "true" || value === "false";
+  return true;
+}
+function parseSchemaValue(value, type) {
+  if (type === "string") return value;
+  if (value.trim() === "") return void 0;
+  if (type === "number")
+    return Number.isFinite(Number(value)) ? Number(value) : void 0;
+  if (type === "integer") {
+    const parsed = Number(value);
+    return Number.isInteger(parsed) ? parsed : void 0;
+  }
+  if (type === "boolean") {
+    if (value === "true") return true;
+    if (value === "false") return false;
+    return void 0;
+  }
+  if (type === "null") return value.trim() === "null" ? null : void 0;
+  if (type === "array") {
+    try {
+      const parsed = JSON.parse(value);
+      return Array.isArray(parsed) ? parsed : void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  if (type === "object") {
+    try {
+      const parsed = JSON.parse(value);
+      return isRecord(parsed) ? parsed : void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  if (type === "any") {
+    try {
+      return JSON.parse(value);
+    } catch {
+      return value;
+    }
+  }
+  return value;
+}
+function getEnumValues(schema) {
+  const value = toSchemaRecord(schema).enum;
+  return Array.isArray(value) ? [...value] : [];
+}
+function getProperties(schema) {
+  const properties = toSchemaRecord(schema).properties;
+  if (!isRecord(properties)) return {};
+  const result = {};
+  Object.entries(properties).forEach(([key, value]) => {
+    Object.defineProperty(result, key, {
+      value: typeof value === "boolean" || isRecord(value) ? value : {},
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  });
+  return result;
+}
+function getRequiredProperties(schema) {
+  const required = toSchemaRecord(schema).required;
+  return new Set(
+    Array.isArray(required) ? required.filter((item) => typeof item === "string") : []
+  );
+}
+function updateProperty(schema, name, propertySchema) {
+  const nextProperties = getProperties(schema);
+  Object.defineProperty(nextProperties, name, {
+    value: propertySchema,
+    enumerable: true,
+    writable: true,
+    configurable: true
+  });
+  return compactSchema({
+    ...toSchemaRecord(schema),
+    type: "object",
+    properties: nextProperties
+  });
+}
+function removeProperty(schema, name) {
+  const nextProperties = getProperties(schema);
+  delete nextProperties[name];
+  const required = Array.from(getRequiredProperties(schema)).filter(
+    (item) => item !== name
+  );
+  return compactSchema({
+    ...toSchemaRecord(schema),
+    properties: nextProperties,
+    required: required.length ? required : void 0
+  });
+}
+function renameProperty(schema, oldName, newName) {
+  if (oldName === newName) return schema;
+  const nextProperties = getProperties(schema);
+  if (!Object.hasOwn(nextProperties, oldName) || Object.hasOwn(nextProperties, newName))
+    return schema;
+  const renamedProperties = Object.fromEntries(
+    Object.entries(nextProperties).map(([key, value]) => [
+      key === oldName ? newName : key,
+      value
+    ])
+  );
+  const required = Array.from(getRequiredProperties(schema)).map(
+    (item) => item === oldName ? newName : item
+  );
+  return compactSchema({
+    ...toSchemaRecord(schema),
+    properties: renamedProperties,
+    required: required.length ? required : void 0
+  });
+}
+function setPropertyRequired(schema, name, required) {
+  const next = getRequiredProperties(schema);
+  if (required) next.add(name);
+  else next.delete(name);
+  return compactSchema({
+    ...toSchemaRecord(schema),
+    required: next.size ? Array.from(next) : void 0
+  });
+}
+function getArrayItems(schema) {
+  const items = toSchemaRecord(schema).items;
+  return typeof items === "boolean" || isRecord(items) ? items : void 0;
+}
+function getPrefixItems(schema) {
+  const value = toSchemaRecord(schema).prefixItems;
+  return Array.isArray(value) ? value.filter(
+    (item) => typeof item === "boolean" || isRecord(item)
+  ) : [];
+}
+function getComposition(schema, key) {
+  const value = toSchemaRecord(schema)[key];
+  return Array.isArray(value) ? value.filter(
+    (item) => typeof item === "boolean" || isRecord(item)
+  ) : [];
+}
+function setComposition(schema, key, values) {
+  return compactSchema({
+    ...toSchemaRecord(schema),
+    [key]: values.length ? values : void 0
+  });
+}
+function getReferenceOptions(schema) {
+  const record = toSchemaRecord(schema);
+  const refs = [];
+  const components = toSchemaRecord(record.components);
+  const schemas = toSchemaRecord(components.schemas);
+  Object.keys(schemas).forEach(
+    (key) => refs.push(
+      `#/components/schemas/${key.replace(/~/g, "~0").replace(/\//g, "~1")}`
+    )
+  );
+  const defs = toSchemaRecord(record.$defs);
+  Object.keys(defs).forEach(
+    (key) => refs.push(`#/$defs/${key.replace(/~/g, "~0").replace(/\//g, "~1")}`)
+  );
+  const legacyDefs = toSchemaRecord(record.definitions);
+  Object.keys(legacyDefs).forEach(
+    (key) => refs.push(`#/definitions/${key.replace(/~/g, "~0").replace(/\//g, "~1")}`)
+  );
+  return refs;
+}
+function getSchemaSummary(schema) {
+  if (typeof schema === "boolean")
+    return schema ? "Any value" : "No values allowed";
+  const record = toSchemaRecord(schema);
+  if (typeof record.$ref === "string" && record.$ref)
+    return `Reference: ${record.$ref}`;
+  const type = getSchemaType(schema);
+  if (type === "object") {
+    const count = Object.keys(getProperties(schema)).length;
+    return `${type} \xB7 ${count} propert${count === 1 ? "y" : "ies"}`;
+  }
+  if (type === "array") {
+    return Object.hasOwn(record, "items") ? "array \xB7 typed items" : "array";
+  }
+  if (Array.isArray(record.enum) && record.enum.length)
+    return `${type} \xB7 enum (${record.enum.length})`;
+  if (typeof record.description === "string" && record.description.trim())
+    return `${type} \xB7 ${record.description.trim()}`;
+  return type;
+}
+function diffSchemaLines(before, after) {
+  const a = before.split("\n");
+  const b = after.split("\n");
+  if (before === after) return a.map((value) => ({ kind: "same", value }));
+  if (a.length * b.length > 25e4) {
+    let prefix = 0;
+    while (prefix < a.length && prefix < b.length && a[prefix] === b[prefix])
+      prefix++;
+    let suffix = 0;
+    while (suffix < a.length - prefix && suffix < b.length - prefix && a[a.length - 1 - suffix] === b[b.length - 1 - suffix])
+      suffix++;
+    return [
+      ...a.slice(0, prefix).map((value) => ({ kind: "same", value })),
+      ...a.slice(prefix, a.length - suffix).map((value) => ({ kind: "removed", value })),
+      ...b.slice(prefix, b.length - suffix).map((value) => ({ kind: "added", value })),
+      ...a.slice(a.length - suffix).map((value) => ({ kind: "same", value }))
+    ];
+  }
+  const dp = Array.from(
+    { length: a.length + 1 },
+    () => Array(b.length + 1).fill(0)
+  );
+  for (let i2 = a.length - 1; i2 >= 0; i2 -= 1) {
+    for (let j2 = b.length - 1; j2 >= 0; j2 -= 1) {
+      dp[i2][j2] = a[i2] === b[j2] ? dp[i2 + 1][j2 + 1] + 1 : Math.max(dp[i2 + 1][j2], dp[i2][j2 + 1]);
+    }
+  }
+  const result = [];
+  let i = 0;
+  let j = 0;
+  while (i < a.length && j < b.length) {
+    if (a[i] === b[j]) {
+      result.push({ kind: "same", value: a[i] });
+      i += 1;
+      j += 1;
+    } else if (dp[i + 1][j] >= dp[i][j + 1]) {
+      result.push({ kind: "removed", value: a[i] });
+      i += 1;
+    } else {
+      result.push({ kind: "added", value: b[j] });
+      j += 1;
+    }
+  }
+  while (i < a.length) result.push({ kind: "removed", value: a[i++] });
+  while (j < b.length) result.push({ kind: "added", value: b[j++] });
+  return result;
+}
+function setEnumValues(schema, values) {
+  return mergeSchema(schema, { enum: values.length ? values : void 0 });
+}
+
+export { KEY_PATTERN, asOpenApiSchema, canParseSchemaValue, changeSchemaType, cloneSchema, cloneSchema2, compactSchema, createSchemaForType, defaultSchemaFor, deleteIn, diffSchemaLines, flattenSchema, getArrayItems, getComposition, getEnumValues, getIn, getPrefixItems, getProperties, getReferenceOptions, getRequiredProperties, getSchemaSummary, getSchemaType, insertKeyAfter, isExpandable, isPlainObject, isRecord, isSchema, isUnsafeKey, isValidKey, mergeSchema, normalizeFormatOptions, normalizeSchemaType, parseOptionalNumber, parseSchemaValue, patchSchema, pointerId, pruneExpanded, remapExpanded, removeProperty, removeRequired, renameKey, renameProperty, renameRequired, reorderKeys, requiredOwnerPath, resolveRef, safeRun, samePath, schemaTypeOf, setComposition, setEnumValues, setIn, setPropertyRequired, setRequired, stringifySchemaValue, stripUndefined, toInputValue, toSchemaRecord, typeLabel, uniqueKey, updateProperty, verifyExternalSchema };