@powerduck/schema-designer 0.1.0

package/dist/chunk-KX3LFFOV.js

@@ -0,0 +1,88 @@
+// src/core/references.ts
+var maps = /* @__PURE__ */ new Set([
+  "properties",
+  "patternProperties",
+  "$defs",
+  "definitions",
+  "dependentSchemas"
+]);
+var arrays = /* @__PURE__ */ new Set(["allOf", "anyOf", "oneOf", "prefixItems"]);
+var singles = /* @__PURE__ */ new Set([
+  "items",
+  "contains",
+  "not",
+  "if",
+  "then",
+  "else",
+  "additionalProperties",
+  "unevaluatedProperties",
+  "unevaluatedItems",
+  "propertyNames"
+]);
+function resolveLocalReference(reference, document) {
+  if (reference === "#") return document;
+  if (!reference.startsWith("#/")) return void 0;
+  let tokens;
+  try {
+    tokens = decodeURIComponent(reference.slice(2)).split("/").map((token) => token.replace(/~1/g, "/").replace(/~0/g, "~"));
+  } catch {
+    return void 0;
+  }
+  let value = document;
+  for (const token of tokens) {
+    if (value === null || typeof value !== "object" || !Object.hasOwn(value, token))
+      return void 0;
+    value = value[token];
+  }
+  return value;
+}
+function dereferenceLocalSchema(schema, document = schema, maxDepth = 64) {
+  const depthLimit = Number.isFinite(maxDepth) ? Math.max(0, Math.min(128, Math.floor(maxDepth))) : 64;
+  let visitedNodes = 0;
+  const visit = (value, depth, refs) => {
+    if (++visitedNodes > 2e4)
+      throw new RangeError("Schema reference node budget exceeded");
+    if (depth > depthLimit)
+      throw new RangeError("Schema reference depth exceeded");
+    if (Array.isArray(value))
+      return value.map((item) => visit(item, depth + 1, refs));
+    if (value === null || typeof value !== "object") return value;
+    const record = value;
+    if (typeof record.$ref === "string") {
+      if (refs.has(record.$ref))
+        throw new Error(
+          `Recursive reference cannot be generated: ${record.$ref}`
+        );
+      const target = resolveLocalReference(record.$ref, document);
+      if (target === void 0)
+        throw new Error(`Unresolved local reference: ${record.$ref}`);
+      const nextRefs = new Set(refs).add(record.$ref);
+      const resolved = visit(target, depth + 1, nextRefs);
+      const { $ref, ...siblings } = record;
+      if (!Object.keys(siblings).length) return resolved;
+      return { allOf: [resolved, visit(siblings, depth + 1, refs)] };
+    }
+    return Object.fromEntries(
+      Object.entries(record).map(([key, item]) => {
+        if (maps.has(key) && item && typeof item === "object" && !Array.isArray(item)) {
+          return [
+            key,
+            Object.fromEntries(
+              Object.entries(item).map(([name, child]) => [
+                name,
+                visit(child, depth + 1, refs)
+              ])
+            )
+          ];
+        }
+        return [
+          key,
+          arrays.has(key) || singles.has(key) ? visit(item, depth + 1, refs) : item
+        ];
+      })
+    );
+  };
+  return visit(schema, 0, /* @__PURE__ */ new Set());
+}
+
+export { dereferenceLocalSchema, resolveLocalReference };

package/dist/chunk-MADPN2PJ.js

@@ -0,0 +1,185 @@
+import { resolveLocalReference } from './chunk-KX3LFFOV.js';
+
+// src/react/parametersTable/libs/parameterValue.ts
+function isReference(value) {
+  return typeof value === "object" && value !== null && "$ref" in value && typeof value.$ref === "string";
+}
+function resolveObject(value, document) {
+  const seen = /* @__PURE__ */ new Set();
+  let result = value;
+  while (isReference(result)) {
+    if (!document || seen.has(result.$ref) || seen.size >= 64) return void 0;
+    seen.add(result.$ref);
+    const target = resolveLocalReference(result.$ref, document);
+    if (!target || typeof target !== "object" || Array.isArray(target))
+      return void 0;
+    const { $ref, ...siblings } = result;
+    result = { ...target, ...siblings };
+  }
+  return result && typeof result === "object" && !Array.isArray(result) ? result : void 0;
+}
+function resolveSchema(value, document) {
+  if (typeof value === "boolean") return value;
+  if (isReference(value) && document) {
+    const seen = /* @__PURE__ */ new Set();
+    let current = value;
+    while (isReference(current)) {
+      if (seen.has(current.$ref) || seen.size >= 64) return void 0;
+      seen.add(current.$ref);
+      const target = resolveLocalReference(current.$ref, document);
+      if (typeof target === "boolean") {
+        if (!target) return false;
+        const { $ref: $ref2, ...siblings2 } = current;
+        return Object.keys(siblings2).length ? siblings2 : true;
+      }
+      if (!target || typeof target !== "object" || Array.isArray(target))
+        return void 0;
+      const { $ref, ...siblings } = current;
+      current = { ...target, ...siblings };
+    }
+    return current;
+  }
+  return resolveObject(value, document);
+}
+function resolveExamplesMap(examples, document) {
+  if (!examples) {
+    return void 0;
+  }
+  const entries = Object.entries(examples);
+  for (const [name, rawExample] of entries) {
+    const example = resolveObject(rawExample, document);
+    if (!example) continue;
+    if (Object.prototype.hasOwnProperty.call(example, "value")) {
+      return {
+        value: example.value,
+        source: "examples",
+        exampleName: name
+      };
+    }
+    if (Object.prototype.hasOwnProperty.call(example, "dataValue")) {
+      return {
+        value: example.dataValue,
+        source: "examples",
+        exampleName: name
+      };
+    }
+    if (example.serializedValue !== void 0) {
+      return {
+        value: example.serializedValue,
+        source: "examples",
+        exampleName: name
+      };
+    }
+    if (example.externalValue) {
+      return {
+        value: void 0,
+        source: "external-example",
+        exampleName: name,
+        externalValue: example.externalValue
+      };
+    }
+  }
+  return void 0;
+}
+function resolveContent(parameter, document) {
+  if (!parameter.content) {
+    return {};
+  }
+  const entries = Object.entries(parameter.content);
+  if (entries.length === 0) {
+    return {};
+  }
+  const mediaType = resolveObject(entries[0][1], document);
+  if (!mediaType) {
+    return {};
+  }
+  const schema = resolveSchema(mediaType.schema, document);
+  if (mediaType.example !== void 0) {
+    return {
+      schema,
+      value: {
+        value: mediaType.example,
+        source: "example"
+      }
+    };
+  }
+  const examplesValue = resolveExamplesMap(mediaType.examples, document);
+  return {
+    schema,
+    value: examplesValue
+  };
+}
+function resolveParameterSchema(parameter, document) {
+  if (parameter.schema !== void 0)
+    return resolveSchema(parameter.schema, document);
+  return resolveContent(parameter, document).schema;
+}
+function resolveParameterValue(parameter, document) {
+  if (parameter.example !== void 0) {
+    return {
+      value: parameter.example,
+      source: "example"
+    };
+  }
+  const examplesValue = resolveExamplesMap(parameter.examples, document);
+  if (examplesValue) {
+    return examplesValue;
+  }
+  const content = resolveContent(parameter, document);
+  if (content.value) {
+    return content.value;
+  }
+  const schema = resolveParameterSchema(parameter, document);
+  if (schema && typeof schema === "object") {
+    if (schema.example !== void 0) {
+      return {
+        value: schema.example,
+        source: "schema-example"
+      };
+    }
+    if (Array.isArray(schema.examples) && schema.examples.length) {
+      return { value: schema.examples[0], source: "schema-example" };
+    }
+    if (schema.default !== void 0) {
+      return {
+        value: schema.default,
+        source: "schema-default"
+      };
+    }
+  }
+  return {
+    value: void 0,
+    source: "missing"
+  };
+}
+function resolveParameterType(parameter, document) {
+  const schema = resolveParameterSchema(parameter, document);
+  if (typeof schema === "boolean") return schema ? "any" : "never";
+  if (!schema) {
+    return "unknown";
+  }
+  if (Array.isArray(schema.type)) {
+    return schema.type.join(" | ");
+  }
+  if (schema.type) {
+    if (schema.format) {
+      return `${schema.type} (${schema.format})`;
+    }
+    return schema.type;
+  }
+  if (schema.oneOf) {
+    return "oneOf";
+  }
+  if (schema.anyOf) {
+    return "anyOf";
+  }
+  if (schema.allOf) {
+    return "allOf";
+  }
+  if (schema.$ref) {
+    return "reference";
+  }
+  return "unknown";
+}
+
+export { isReference, resolveParameterSchema, resolveParameterType, resolveParameterValue };