@powerduck/schema-designer 0.1.0

package/dist/chunk-S7GNTGEE.js

@@ -0,0 +1 @@
+

package/dist/chunk-SMBDRWV2.cjs

@@ -0,0 +1,2 @@
+'use strict';
+

package/dist/chunk-THYDOHOP.cjs

@@ -0,0 +1,2 @@
+'use strict';
+

package/dist/chunk-WRHWOMZQ.cjs

@@ -0,0 +1,190 @@
+'use strict';
+
+var chunkYWDKCX6N_cjs = require('./chunk-YWDKCX6N.cjs');
+
+// 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 = chunkYWDKCX6N_cjs.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 = chunkYWDKCX6N_cjs.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";
+}
+
+exports.isReference = isReference;
+exports.resolveParameterSchema = resolveParameterSchema;
+exports.resolveParameterType = resolveParameterType;
+exports.resolveParameterValue = resolveParameterValue;

package/dist/chunk-YNKP5JJA.cjs

@@ -0,0 +1,32 @@
+'use strict';
+
+var chunkWRHWOMZQ_cjs = require('./chunk-WRHWOMZQ.cjs');
+
+// src/core/parameters.ts
+function parameterKey(parameter) {
+  return JSON.stringify([parameter.in, parameter.name]);
+}
+function initializeParameterValues(parameters) {
+  return Object.fromEntries(
+    parameters.map((parameter) => [
+      parameterKey(parameter),
+      {
+        value: chunkWRHWOMZQ_cjs.resolveParameterValue(parameter).value,
+        enabled: true
+      }
+    ])
+  );
+}
+function parameterValueText(value) {
+  if (value === void 0) return "";
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value) ?? "";
+  } catch {
+    return "";
+  }
+}
+
+exports.initializeParameterValues = initializeParameterValues;
+exports.parameterKey = parameterKey;
+exports.parameterValueText = parameterValueText;

package/dist/chunk-YWDKCX6N.cjs

@@ -0,0 +1,91 @@
+'use strict';
+
+// 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());
+}
+
+exports.dereferenceLocalSchema = dereferenceLocalSchema;
+exports.resolveLocalReference = resolveLocalReference;

package/dist/chunk-ZHNYNFGL.js

@@ -0,0 +1,28 @@
+import { resolveParameterValue } from './chunk-MADPN2PJ.js';
+
+// src/core/parameters.ts
+function parameterKey(parameter) {
+  return JSON.stringify([parameter.in, parameter.name]);
+}
+function initializeParameterValues(parameters) {
+  return Object.fromEntries(
+    parameters.map((parameter) => [
+      parameterKey(parameter),
+      {
+        value: resolveParameterValue(parameter).value,
+        enabled: true
+      }
+    ])
+  );
+}
+function parameterValueText(value) {
+  if (value === void 0) return "";
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value) ?? "";
+  } catch {
+    return "";
+  }
+}
+
+export { initializeParameterValues, parameterKey, parameterValueText };

package/dist/compat/inline.cjs

@@ -0,0 +1,137 @@
+'use strict';
+
+require('../chunk-SMBDRWV2.cjs');
+var chunk4H3LXOL4_cjs = require('../chunk-4H3LXOL4.cjs');
+var chunkGTZH37JS_cjs = require('../chunk-GTZH37JS.cjs');
+require('../chunk-YWDKCX6N.cjs');
+
+
+
+Object.defineProperty(exports, "InlineSchemaEditor", {
+  enumerable: true,
+  get: function () { return chunk4H3LXOL4_cjs.InlineSchemaEditor; }
+});
+Object.defineProperty(exports, "asOpenApiSchema", {
+  enumerable: true,
+  get: function () { return chunkGTZH37JS_cjs.asOpenApiSchema; }
+});
+Object.defineProperty(exports, "canParseSchemaValue", {
+  enumerable: true,
+  get: function () { return chunkGTZH37JS_cjs.canParseSchemaValue; }
+});
+Object.defineProperty(exports, "cloneSchema", {
+  enumerable: true,
+  get: function () { return chunkGTZH37JS_cjs.cloneSchema2; }
+});
+Object.defineProperty(exports, "compactSchema", {
+  enumerable: true,
+  get: function () { return chunkGTZH37JS_cjs.compactSchema; }
+});
+Object.defineProperty(exports, "createSchemaForType", {
+  enumerable: true,
+  get: function () { return chunkGTZH37JS_cjs.createSchemaForType; }
+});
+Object.defineProperty(exports, "diffSchemaLines", {
+  enumerable: true,
+  get: function () { return chunkGTZH37JS_cjs.diffSchemaLines; }
+});
+Object.defineProperty(exports, "getArrayItems", {
+  enumerable: true,
+  get: function () { return chunkGTZH37JS_cjs.getArrayItems; }
+});
+Object.defineProperty(exports, "getComposition", {
+  enumerable: true,
+  get: function () { return chunkGTZH37JS_cjs.getComposition; }
+});
+Object.defineProperty(exports, "getEnumValues", {
+  enumerable: true,
+  get: function () { return chunkGTZH37JS_cjs.getEnumValues; }
+});
+Object.defineProperty(exports, "getPrefixItems", {
+  enumerable: true,
+  get: function () { return chunkGTZH37JS_cjs.getPrefixItems; }
+});
+Object.defineProperty(exports, "getProperties", {
+  enumerable: true,
+  get: function () { return chunkGTZH37JS_cjs.getProperties; }
+});
+Object.defineProperty(exports, "getReferenceOptions", {
+  enumerable: true,
+  get: function () { return chunkGTZH37JS_cjs.getReferenceOptions; }
+});
+Object.defineProperty(exports, "getRequiredProperties", {
+  enumerable: true,
+  get: function () { return chunkGTZH37JS_cjs.getRequiredProperties; }
+});
+Object.defineProperty(exports, "getSchemaSummary", {
+  enumerable: true,
+  get: function () { return chunkGTZH37JS_cjs.getSchemaSummary; }
+});
+Object.defineProperty(exports, "getSchemaType", {
+  enumerable: true,
+  get: function () { return chunkGTZH37JS_cjs.getSchemaType; }
+});
+Object.defineProperty(exports, "isRecord", {
+  enumerable: true,
+  get: function () { return chunkGTZH37JS_cjs.isRecord; }
+});
+Object.defineProperty(exports, "isSchema", {
+  enumerable: true,
+  get: function () { return chunkGTZH37JS_cjs.isSchema; }
+});
+Object.defineProperty(exports, "mergeSchema", {
+  enumerable: true,
+  get: function () { return chunkGTZH37JS_cjs.mergeSchema; }
+});
+Object.defineProperty(exports, "normalizeFormatOptions", {
+  enumerable: true,
+  get: function () { return chunkGTZH37JS_cjs.normalizeFormatOptions; }
+});
+Object.defineProperty(exports, "normalizeSchemaType", {
+  enumerable: true,
+  get: function () { return chunkGTZH37JS_cjs.normalizeSchemaType; }
+});
+Object.defineProperty(exports, "parseOptionalNumber", {
+  enumerable: true,
+  get: function () { return chunkGTZH37JS_cjs.parseOptionalNumber; }
+});
+Object.defineProperty(exports, "parseSchemaValue", {
+  enumerable: true,
+  get: function () { return chunkGTZH37JS_cjs.parseSchemaValue; }
+});
+Object.defineProperty(exports, "removeProperty", {
+  enumerable: true,
+  get: function () { return chunkGTZH37JS_cjs.removeProperty; }
+});
+Object.defineProperty(exports, "renameProperty", {
+  enumerable: true,
+  get: function () { return chunkGTZH37JS_cjs.renameProperty; }
+});
+Object.defineProperty(exports, "setComposition", {
+  enumerable: true,
+  get: function () { return chunkGTZH37JS_cjs.setComposition; }
+});
+Object.defineProperty(exports, "setEnumValues", {
+  enumerable: true,
+  get: function () { return chunkGTZH37JS_cjs.setEnumValues; }
+});
+Object.defineProperty(exports, "setPropertyRequired", {
+  enumerable: true,
+  get: function () { return chunkGTZH37JS_cjs.setPropertyRequired; }
+});
+Object.defineProperty(exports, "stringifySchemaValue", {
+  enumerable: true,
+  get: function () { return chunkGTZH37JS_cjs.stringifySchemaValue; }
+});
+Object.defineProperty(exports, "toInputValue", {
+  enumerable: true,
+  get: function () { return chunkGTZH37JS_cjs.toInputValue; }
+});
+Object.defineProperty(exports, "toSchemaRecord", {
+  enumerable: true,
+  get: function () { return chunkGTZH37JS_cjs.toSchemaRecord; }
+});
+Object.defineProperty(exports, "updateProperty", {
+  enumerable: true,
+  get: function () { return chunkGTZH37JS_cjs.updateProperty; }
+});