@scalar/json-magic 0.1.0

package/dist/bundle/plugins/parse-json/index.js

@@ -0,0 +1,22 @@
+import { isJsonObject } from "../../../utils/is-json-object.js";
+function parseJson() {
+  return {
+    validate: isJsonObject,
+    exec: async (value) => {
+      try {
+        return {
+          ok: true,
+          data: JSON.parse(value)
+        };
+      } catch {
+        return {
+          ok: false
+        };
+      }
+    }
+  };
+}
+export {
+  parseJson
+};
+//# sourceMappingURL=index.js.map

package/dist/bundle/plugins/parse-json/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/bundle/plugins/parse-json/index.ts"],
+  "sourcesContent": ["import { isJsonObject } from '@/utils/is-json-object'\nimport type { Plugin, ResolveResult } from '@/bundle'\n\n/**\n * Creates a plugin that parses JSON strings into JavaScript objects.\n * @returns A plugin object with validate and exec functions\n * @example\n * ```ts\n * const jsonPlugin = parseJson()\n * const result = jsonPlugin.exec('{\"name\": \"John\", \"age\": 30}')\n * // result = { name: 'John', age: 30 }\n * ```\n */\nexport function parseJson(): Plugin {\n  return {\n    validate: isJsonObject,\n    exec: async (value): Promise<ResolveResult> => {\n      try {\n        return {\n          ok: true,\n          data: JSON.parse(value),\n        }\n      } catch {\n        return {\n          ok: false,\n        }\n      }\n    },\n  }\n}\n"],
+  "mappings": "AAAA,SAAS,oBAAoB;AAatB,SAAS,YAAoB;AAClC,SAAO;AAAA,IACL,UAAU;AAAA,IACV,MAAM,OAAO,UAAkC;AAC7C,UAAI;AACF,eAAO;AAAA,UACL,IAAI;AAAA,UACJ,MAAM,KAAK,MAAM,KAAK;AAAA,QACxB;AAAA,MACF,QAAQ;AACN,eAAO;AAAA,UACL,IAAI;AAAA,QACN;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACF;",
+  "names": []
+}

package/dist/bundle/plugins/parse-yaml/index.d.ts

@@ -0,0 +1,13 @@
+import type { Plugin } from '../../../bundle/bundle.js';
+/**
+ * Creates a plugin that parses YAML strings into JavaScript objects.
+ * @returns A plugin object with validate and exec functions
+ * @example
+ * ```ts
+ * const yamlPlugin = parseYaml()
+ * const result = yamlPlugin.exec('name: John\nage: 30')
+ * // result = { name: 'John', age: 30 }
+ * ```
+ */
+export declare function parseYaml(): Plugin;
+//# sourceMappingURL=index.d.ts.map

package/dist/bundle/plugins/parse-yaml/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/bundle/plugins/parse-yaml/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAiB,MAAM,iBAAiB,CAAA;AAI5D;;;;;;;;;GASG;AACH,wBAAgB,SAAS,IAAI,MAAM,CAgBlC"}

package/dist/bundle/plugins/parse-yaml/index.js

@@ -0,0 +1,23 @@
+import { isYaml } from "../../../utils/is-yaml.js";
+import YAML from "yaml";
+function parseYaml() {
+  return {
+    validate: isYaml,
+    exec: async (value) => {
+      try {
+        return {
+          ok: true,
+          data: YAML.parse(value)
+        };
+      } catch {
+        return {
+          ok: false
+        };
+      }
+    }
+  };
+}
+export {
+  parseYaml
+};
+//# sourceMappingURL=index.js.map

package/dist/bundle/plugins/parse-yaml/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/bundle/plugins/parse-yaml/index.ts"],
+  "sourcesContent": ["import type { Plugin, ResolveResult } from '@/bundle/bundle'\nimport { isYaml } from '@/utils/is-yaml'\nimport YAML from 'yaml'\n\n/**\n * Creates a plugin that parses YAML strings into JavaScript objects.\n * @returns A plugin object with validate and exec functions\n * @example\n * ```ts\n * const yamlPlugin = parseYaml()\n * const result = yamlPlugin.exec('name: John\\nage: 30')\n * // result = { name: 'John', age: 30 }\n * ```\n */\nexport function parseYaml(): Plugin {\n  return {\n    validate: isYaml,\n    exec: async (value): Promise<ResolveResult> => {\n      try {\n        return {\n          ok: true,\n          data: YAML.parse(value),\n        }\n      } catch {\n        return {\n          ok: false,\n        }\n      }\n    },\n  }\n}\n"],
+  "mappings": "AACA,SAAS,cAAc;AACvB,OAAO,UAAU;AAYV,SAAS,YAAoB;AAClC,SAAO;AAAA,IACL,UAAU;AAAA,IACV,MAAM,OAAO,UAAkC;AAC7C,UAAI;AACF,eAAO;AAAA,UACL,IAAI;AAAA,UACJ,MAAM,KAAK,MAAM,KAAK;AAAA,QACxB;AAAA,MACF,QAAQ;AACN,eAAO;AAAA,UACL,IAAI;AAAA,QACN;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACF;",
+  "names": []
+}

package/dist/bundle/plugins/read-files/index.d.ts

@@ -0,0 +1,29 @@
+import { type Plugin, type ResolveResult } from '../../../bundle/bundle.js';
+/**
+ * Reads and normalizes data from a local file
+ * @param path - The file path to read from
+ * @returns A promise that resolves to either the normalized data or an error result
+ * @example
+ * ```ts
+ * const result = await readFile('./schemas/user.json')
+ * if (result.ok) {
+ *   console.log(result.data) // The normalized data
+ * } else {
+ *   console.log('Failed to read file')
+ * }
+ * ```
+ */
+export declare function readFile(path: string): Promise<ResolveResult>;
+/**
+ * Creates a plugin for handling local file references.
+ * This plugin validates and reads data from local filesystem paths.
+ *
+ * @returns A plugin object with validate and exec functions
+ * @example
+ * const filePlugin = readFiles()
+ * if (filePlugin.validate('./local-schema.json')) {
+ *   const result = await filePlugin.exec('./local-schema.json')
+ * }
+ */
+export declare function readFiles(): Plugin;
+//# sourceMappingURL=index.d.ts.map

package/dist/bundle/plugins/read-files/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/bundle/plugins/read-files/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAc,KAAK,MAAM,EAAE,KAAK,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAE7E;;;;;;;;;;;;;GAaG;AACH,wBAAsB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,CAmBnE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,SAAS,IAAI,MAAM,CAKlC"}

package/dist/bundle/plugins/read-files/index.js

@@ -0,0 +1,30 @@
+import { normalize } from "../../../utils/normalize.js";
+import { isFilePath } from "../../../bundle/bundle.js";
+async function readFile(path) {
+  const fs = typeof window === "undefined" ? await import("node:fs/promises") : void 0;
+  if (fs === void 0) {
+    throw "Can not use readFiles plugin outside of a node environment";
+  }
+  try {
+    const fileContents = await fs.readFile(path, { encoding: "utf-8" });
+    return {
+      ok: true,
+      data: normalize(fileContents)
+    };
+  } catch {
+    return {
+      ok: false
+    };
+  }
+}
+function readFiles() {
+  return {
+    validate: isFilePath,
+    exec: readFile
+  };
+}
+export {
+  readFile,
+  readFiles
+};
+//# sourceMappingURL=index.js.map

package/dist/bundle/plugins/read-files/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/bundle/plugins/read-files/index.ts"],
+  "sourcesContent": ["import { normalize } from '@/utils/normalize'\nimport { isFilePath, type Plugin, type ResolveResult } from '@/bundle/bundle'\n\n/**\n * Reads and normalizes data from a local file\n * @param path - The file path to read from\n * @returns A promise that resolves to either the normalized data or an error result\n * @example\n * ```ts\n * const result = await readFile('./schemas/user.json')\n * if (result.ok) {\n *   console.log(result.data) // The normalized data\n * } else {\n *   console.log('Failed to read file')\n * }\n * ```\n */\nexport async function readFile(path: string): Promise<ResolveResult> {\n  const fs = typeof window === 'undefined' ? await import('node:fs/promises') : undefined\n\n  if (fs === undefined) {\n    throw 'Can not use readFiles plugin outside of a node environment'\n  }\n\n  try {\n    const fileContents = await fs.readFile(path, { encoding: 'utf-8' })\n\n    return {\n      ok: true,\n      data: normalize(fileContents),\n    }\n  } catch {\n    return {\n      ok: false,\n    }\n  }\n}\n\n/**\n * Creates a plugin for handling local file references.\n * This plugin validates and reads data from local filesystem paths.\n *\n * @returns A plugin object with validate and exec functions\n * @example\n * const filePlugin = readFiles()\n * if (filePlugin.validate('./local-schema.json')) {\n *   const result = await filePlugin.exec('./local-schema.json')\n * }\n */\nexport function readFiles(): Plugin {\n  return {\n    validate: isFilePath,\n    exec: readFile,\n  }\n}\n"],
+  "mappings": "AAAA,SAAS,iBAAiB;AAC1B,SAAS,kBAAmD;AAgB5D,eAAsB,SAAS,MAAsC;AACnE,QAAM,KAAK,OAAO,WAAW,cAAc,MAAM,OAAO,kBAAkB,IAAI;AAE9E,MAAI,OAAO,QAAW;AACpB,UAAM;AAAA,EACR;AAEA,MAAI;AACF,UAAM,eAAe,MAAM,GAAG,SAAS,MAAM,EAAE,UAAU,QAAQ,CAAC;AAElE,WAAO;AAAA,MACL,IAAI;AAAA,MACJ,MAAM,UAAU,YAAY;AAAA,IAC9B;AAAA,EACF,QAAQ;AACN,WAAO;AAAA,MACL,IAAI;AAAA,IACN;AAAA,EACF;AACF;AAaO,SAAS,YAAoB;AAClC,SAAO;AAAA,IACL,UAAU;AAAA,IACV,MAAM;AAAA,EACR;AACF;",
+  "names": []
+}

package/dist/bundle/value-generator.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Generates a short SHA-1 hash from a string value.
+ * This function is used to create unique identifiers for external references
+ * while keeping the hash length manageable. It uses the Web Crypto API to
+ * generate a SHA-1 hash and returns the first 7 characters of the hex string.
+ * If the hash would be all numbers, it ensures at least one letter is included.
+ *
+ * @param value - The string to hash
+ * @returns A 7-character hexadecimal hash with at least one letter
+ * @example
+ * // Returns "2ae91d7"
+ * await getHash("https://example.com/schema.json")
+ */
+export declare function getHash(value: string): Promise<string>;
+/**
+ * Generates a unique compressed value for a string, handling collisions by recursively compressing
+ * until a unique value is found. This is used to create unique identifiers for external
+ * references in the bundled OpenAPI document.
+ *
+ * @param compress - Function that generates a compressed value from a string
+ * @param value - The original string value to compress
+ * @param compressedToValue - Object mapping compressed values to their original values
+ * @param prevCompressedValue - Optional previous compressed value to use as input for generating a new value
+ * @param depth - Current recursion depth to prevent infinite loops
+ * @returns A unique compressed value that doesn't conflict with existing values
+ *
+ * @example
+ * const valueMap = {}
+ * // First call generates compressed value for "example.com/schema.json"
+ * const value1 = await generateUniqueValue(compress, "example.com/schema.json", valueMap)
+ * // Returns something like "2ae91d7"
+ *
+ * // Second call with same value returns same compressed value
+ * const value2 = await generateUniqueValue(compress, "example.com/schema.json", valueMap)
+ * // Returns same value as value1
+ *
+ * // Call with different value generates new unique compressed value
+ * const value3 = await generateUniqueValue(compress, "example.com/other.json", valueMap)
+ * // Returns different value like "3bf82e9"
+ */
+export declare function generateUniqueValue(compress: (value: string) => Promise<string> | string, value: string, compressedToValue: Record<string, string>, prevCompressedValue?: string, depth?: number): Promise<string>;
+/**
+ * Factory function that creates a value generator with caching capabilities.
+ * The generator maintains a bidirectional mapping between original values and their compressed forms.
+ *
+ * @param compress - Function that generates a compressed value from a string
+ * @param compressedToValue - Initial mapping of compressed values to their original values
+ * @returns An object with a generate method that produces unique compressed values
+ *
+ * @example
+ * const compress = (value) => value.substring(0, 6) // Simple compression example
+ * const initialMap = { 'abc123': 'example.com/schema.json' }
+ * const generator = uniqueValueGeneratorFactory(compress, initialMap)
+ *
+ * // Generate compressed value for new string
+ * const compressed = await generator.generate('example.com/other.json')
+ * // Returns something like 'example'
+ *
+ * // Generate compressed value for existing string
+ * const cached = await generator.generate('example.com/schema.json')
+ * // Returns 'abc123' from cache
+ */
+export declare const uniqueValueGeneratorFactory: (compress: (value: string) => Promise<string> | string, compressedToValue: Record<string, string>) => {
+    /**
+     * Generates a unique compressed value for the given input string.
+     * First checks if a compressed value already exists in the cache.
+     * If not, generates a new unique compressed value and stores it in the cache.
+     *
+     * @param value - The original string value to compress
+     * @returns A Promise that resolves to the compressed string value
+     *
+     * @example
+     * const generator = uniqueValueGeneratorFactory(compress, {})
+     * const compressed = await generator.generate('example.com/schema.json')
+     * // Returns a unique compressed value like 'example'
+     */
+    generate: (value: string) => Promise<string>;
+};
+//# sourceMappingURL=value-generator.d.ts.map

package/dist/bundle/value-generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"value-generator.d.ts","sourceRoot":"","sources":["../../src/bundle/value-generator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,wBAAsB,OAAO,CAAC,KAAK,EAAE,MAAM,mBAe1C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAsB,mBAAmB,CACvC,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM,EACrD,KAAK,EAAE,MAAM,EACb,iBAAiB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EACzC,mBAAmB,CAAC,EAAE,MAAM,EAC5B,KAAK,SAAI,mBAoBV;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,2BAA2B,aAC5B,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM,qBAClC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAMvC;;;;;;;;;;;;OAYG;sBACqB,MAAM;CAqBjC,CAAA"}

package/dist/bundle/value-generator.js

@@ -0,0 +1,55 @@
+async function getHash(value) {
+  const encoder = new TextEncoder();
+  const data = encoder.encode(value);
+  const hashBuffer = await crypto.subtle.digest("SHA-1", data);
+  const hashArray = Array.from(new Uint8Array(hashBuffer));
+  const hashHex = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+  const hash = hashHex.substring(0, 7);
+  return hash.match(/^\d+$/) ? "a" + hash.substring(1) : hash;
+}
+async function generateUniqueValue(compress, value, compressedToValue, prevCompressedValue, depth = 0) {
+  const MAX_DEPTH = 100;
+  if (depth >= MAX_DEPTH) {
+    throw "Can not generate unique compressed values";
+  }
+  const compressedValue = await compress(prevCompressedValue ?? value);
+  if (compressedToValue[compressedValue] !== void 0 && compressedToValue[compressedValue] !== value) {
+    return generateUniqueValue(compress, value, compressedToValue, compressedValue, depth + 1);
+  }
+  compressedToValue[compressedValue] = value;
+  return compressedValue;
+}
+const uniqueValueGeneratorFactory = (compress, compressedToValue) => {
+  const valueToCompressed = Object.fromEntries(Object.entries(compressedToValue).map(([key, value]) => [value, key]));
+  return {
+    /**
+     * Generates a unique compressed value for the given input string.
+     * First checks if a compressed value already exists in the cache.
+     * If not, generates a new unique compressed value and stores it in the cache.
+     *
+     * @param value - The original string value to compress
+     * @returns A Promise that resolves to the compressed string value
+     *
+     * @example
+     * const generator = uniqueValueGeneratorFactory(compress, {})
+     * const compressed = await generator.generate('example.com/schema.json')
+     * // Returns a unique compressed value like 'example'
+     */
+    generate: async (value) => {
+      const cache = valueToCompressed[value];
+      if (cache) {
+        return cache;
+      }
+      const generatedValue = await generateUniqueValue(compress, value, compressedToValue);
+      const compressedValue = generatedValue.match(/^\d+$/) ? `a${generatedValue}` : generatedValue;
+      valueToCompressed[value] = compressedValue;
+      return compressedValue;
+    }
+  };
+};
+export {
+  generateUniqueValue,
+  getHash,
+  uniqueValueGeneratorFactory
+};
+//# sourceMappingURL=value-generator.js.map

package/dist/bundle/value-generator.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/bundle/value-generator.ts"],
+  "sourcesContent": ["/**\n * Generates a short SHA-1 hash from a string value.\n * This function is used to create unique identifiers for external references\n * while keeping the hash length manageable. It uses the Web Crypto API to\n * generate a SHA-1 hash and returns the first 7 characters of the hex string.\n * If the hash would be all numbers, it ensures at least one letter is included.\n *\n * @param value - The string to hash\n * @returns A 7-character hexadecimal hash with at least one letter\n * @example\n * // Returns \"2ae91d7\"\n * await getHash(\"https://example.com/schema.json\")\n */\nexport async function getHash(value: string) {\n  // Convert string to ArrayBuffer\n  const encoder = new TextEncoder()\n  const data = encoder.encode(value)\n\n  // Hash the data\n  const hashBuffer = await crypto.subtle.digest('SHA-1', data)\n\n  // Convert buffer to hex string\n  const hashArray = Array.from(new Uint8Array(hashBuffer))\n  const hashHex = hashArray.map((b) => b.toString(16).padStart(2, '0')).join('')\n\n  // Return first 7 characters of the hash, ensuring at least one letter\n  const hash = hashHex.substring(0, 7)\n  return hash.match(/^\\d+$/) ? 'a' + hash.substring(1) : hash\n}\n\n/**\n * Generates a unique compressed value for a string, handling collisions by recursively compressing\n * until a unique value is found. This is used to create unique identifiers for external\n * references in the bundled OpenAPI document.\n *\n * @param compress - Function that generates a compressed value from a string\n * @param value - The original string value to compress\n * @param compressedToValue - Object mapping compressed values to their original values\n * @param prevCompressedValue - Optional previous compressed value to use as input for generating a new value\n * @param depth - Current recursion depth to prevent infinite loops\n * @returns A unique compressed value that doesn't conflict with existing values\n *\n * @example\n * const valueMap = {}\n * // First call generates compressed value for \"example.com/schema.json\"\n * const value1 = await generateUniqueValue(compress, \"example.com/schema.json\", valueMap)\n * // Returns something like \"2ae91d7\"\n *\n * // Second call with same value returns same compressed value\n * const value2 = await generateUniqueValue(compress, \"example.com/schema.json\", valueMap)\n * // Returns same value as value1\n *\n * // Call with different value generates new unique compressed value\n * const value3 = await generateUniqueValue(compress, \"example.com/other.json\", valueMap)\n * // Returns different value like \"3bf82e9\"\n */\nexport async function generateUniqueValue(\n  compress: (value: string) => Promise<string> | string,\n  value: string,\n  compressedToValue: Record<string, string>,\n  prevCompressedValue?: string,\n  depth = 0,\n) {\n  // Prevent infinite recursion by limiting depth\n  const MAX_DEPTH = 100\n\n  if (depth >= MAX_DEPTH) {\n    throw 'Can not generate unique compressed values'\n  }\n\n  // Compress the value, using previous compressed value if provided\n  const compressedValue = await compress(prevCompressedValue ?? value)\n\n  // Handle collision by recursively trying with compressed value as input\n  if (compressedToValue[compressedValue] !== undefined && compressedToValue[compressedValue] !== value) {\n    return generateUniqueValue(compress, value, compressedToValue, compressedValue, depth + 1)\n  }\n\n  // Store mapping and return unique compressed value\n  compressedToValue[compressedValue] = value\n  return compressedValue\n}\n\n/**\n * Factory function that creates a value generator with caching capabilities.\n * The generator maintains a bidirectional mapping between original values and their compressed forms.\n *\n * @param compress - Function that generates a compressed value from a string\n * @param compressedToValue - Initial mapping of compressed values to their original values\n * @returns An object with a generate method that produces unique compressed values\n *\n * @example\n * const compress = (value) => value.substring(0, 6) // Simple compression example\n * const initialMap = { 'abc123': 'example.com/schema.json' }\n * const generator = uniqueValueGeneratorFactory(compress, initialMap)\n *\n * // Generate compressed value for new string\n * const compressed = await generator.generate('example.com/other.json')\n * // Returns something like 'example'\n *\n * // Generate compressed value for existing string\n * const cached = await generator.generate('example.com/schema.json')\n * // Returns 'abc123' from cache\n */\nexport const uniqueValueGeneratorFactory = (\n  compress: (value: string) => Promise<string> | string,\n  compressedToValue: Record<string, string>,\n) => {\n  // Create a reverse mapping from original values to their compressed forms\n  const valueToCompressed = Object.fromEntries(Object.entries(compressedToValue).map(([key, value]) => [value, key]))\n\n  return {\n    /**\n     * Generates a unique compressed value for the given input string.\n     * First checks if a compressed value already exists in the cache.\n     * If not, generates a new unique compressed value and stores it in the cache.\n     *\n     * @param value - The original string value to compress\n     * @returns A Promise that resolves to the compressed string value\n     *\n     * @example\n     * const generator = uniqueValueGeneratorFactory(compress, {})\n     * const compressed = await generator.generate('example.com/schema.json')\n     * // Returns a unique compressed value like 'example'\n     */\n    generate: async (value: string) => {\n      // Check if we already have a compressed value for this input\n      const cache = valueToCompressed[value]\n      if (cache) {\n        return cache\n      }\n\n      // Generate a new unique compressed value\n      const generatedValue = await generateUniqueValue(compress, value, compressedToValue)\n\n      // Ensure the generated string contains at least one non-numeric character\n      // This prevents the `setValueAtPath` function from interpreting the value as an array index\n      // by forcing it to be treated as an object property name\n      const compressedValue = generatedValue.match(/^\\d+$/) ? `a${generatedValue}` : generatedValue\n\n      // Store the new mapping in our cache\n      valueToCompressed[value] = compressedValue\n\n      return compressedValue\n    },\n  }\n}\n"],
+  "mappings": "AAaA,eAAsB,QAAQ,OAAe;AAE3C,QAAM,UAAU,IAAI,YAAY;AAChC,QAAM,OAAO,QAAQ,OAAO,KAAK;AAGjC,QAAM,aAAa,MAAM,OAAO,OAAO,OAAO,SAAS,IAAI;AAG3D,QAAM,YAAY,MAAM,KAAK,IAAI,WAAW,UAAU,CAAC;AACvD,QAAM,UAAU,UAAU,IAAI,CAAC,MAAM,EAAE,SAAS,EAAE,EAAE,SAAS,GAAG,GAAG,CAAC,EAAE,KAAK,EAAE;AAG7E,QAAM,OAAO,QAAQ,UAAU,GAAG,CAAC;AACnC,SAAO,KAAK,MAAM,OAAO,IAAI,MAAM,KAAK,UAAU,CAAC,IAAI;AACzD;AA4BA,eAAsB,oBACpB,UACA,OACA,mBACA,qBACA,QAAQ,GACR;AAEA,QAAM,YAAY;AAElB,MAAI,SAAS,WAAW;AACtB,UAAM;AAAA,EACR;AAGA,QAAM,kBAAkB,MAAM,SAAS,uBAAuB,KAAK;AAGnE,MAAI,kBAAkB,eAAe,MAAM,UAAa,kBAAkB,eAAe,MAAM,OAAO;AACpG,WAAO,oBAAoB,UAAU,OAAO,mBAAmB,iBAAiB,QAAQ,CAAC;AAAA,EAC3F;AAGA,oBAAkB,eAAe,IAAI;AACrC,SAAO;AACT;AAuBO,MAAM,8BAA8B,CACzC,UACA,sBACG;AAEH,QAAM,oBAAoB,OAAO,YAAY,OAAO,QAAQ,iBAAiB,EAAE,IAAI,CAAC,CAAC,KAAK,KAAK,MAAM,CAAC,OAAO,GAAG,CAAC,CAAC;AAElH,SAAO;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAcL,UAAU,OAAO,UAAkB;AAEjC,YAAM,QAAQ,kBAAkB,KAAK;AACrC,UAAI,OAAO;AACT,eAAO;AAAA,MACT;AAGA,YAAM,iBAAiB,MAAM,oBAAoB,UAAU,OAAO,iBAAiB;AAKnF,YAAM,kBAAkB,eAAe,MAAM,OAAO,IAAI,IAAI,cAAc,KAAK;AAG/E,wBAAkB,KAAK,IAAI;AAE3B,aAAO;AAAA,IACT;AAAA,EACF;AACF;",
+  "names": []
+}

package/dist/dereference/dereference.d.ts

@@ -0,0 +1,45 @@
+import type { UnknownObject } from '../types.js';
+type DereferenceResult = {
+    success: true;
+    data: UnknownObject;
+} | {
+    success: false;
+    errors: string[];
+};
+type ReturnDereferenceResult<Opt extends {
+    sync?: boolean;
+}> = Opt['sync'] extends true ? DereferenceResult : Promise<DereferenceResult>;
+/**
+ * Dereferences a JSON object, resolving all $ref pointers.
+ *
+ * This function can operate synchronously (no remote refs, no async plugins) or asynchronously (with remote refs).
+ * If `options.sync` is true, it simply wraps the input in a magic proxy and returns it.
+ * Otherwise, it bundles the document, resolving all $refs (including remote ones), and returns a promise.
+ *
+ * @param input - JSON Schema object to dereference.
+ * @param options - Optional settings. If `sync` is true, dereferencing is synchronous.
+ * @returns A DereferenceResult (or Promise thereof) indicating success and the dereferenced data, or errors.
+ *
+ * @example
+ * // Synchronous dereference (no remote refs)
+ * const result = dereference({ openapi: '3.0.0', info: { title: 'My API', version: '1.0.0' } }, { sync: true });
+ * if (result.success) {
+ *   console.log(result.data); // Magic proxy-wrapped document
+ * }
+ *
+ * @example
+ * // Asynchronous dereference (with remote refs)
+ * dereference({ $ref: 'https://example.com/api.yaml' })
+ *   .then(result => {
+ *     if (result.success) {
+ *       console.log(result.data); // Fully dereferenced document
+ *     } else {
+ *       console.error(result.errors);
+ *     }
+ *   });
+ */
+export declare const dereference: <Opts extends {
+    sync?: boolean;
+}>(input: UnknownObject, options?: Opts) => ReturnDereferenceResult<Opts>;
+export {};
+//# sourceMappingURL=dereference.d.ts.map

package/dist/dereference/dereference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dereference.d.ts","sourceRoot":"","sources":["../../src/dereference/dereference.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAE5C,KAAK,iBAAiB,GAClB;IACE,OAAO,EAAE,IAAI,CAAA;IACb,IAAI,EAAE,aAAa,CAAA;CACpB,GACD;IACE,OAAO,EAAE,KAAK,CAAA;IACd,MAAM,EAAE,MAAM,EAAE,CAAA;CACjB,CAAA;AAEL,KAAK,uBAAuB,CAAC,GAAG,SAAS;IAAE,IAAI,CAAC,EAAE,OAAO,CAAA;CAAE,IAAI,GAAG,CAAC,MAAM,CAAC,SAAS,IAAI,GACnF,iBAAiB,GACjB,OAAO,CAAC,iBAAiB,CAAC,CAAA;AAE9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,WAAW,GAAI,IAAI,SAAS;IAAE,IAAI,CAAC,EAAE,OAAO,CAAA;CAAE,SAClD,aAAa,YACV,IAAI,KACb,uBAAuB,CAAC,IAAI,CAgC9B,CAAA"}

package/dist/dereference/dereference.js

@@ -0,0 +1,37 @@
+import { bundle } from "../bundle/index.js";
+import { fetchUrls } from "../bundle/plugins/fetch-urls/index.js";
+import { createMagicProxy } from "../magic-proxy/index.js";
+const dereference = (input, options) => {
+  if (options?.sync) {
+    return {
+      success: true,
+      data: createMagicProxy(input)
+    };
+  }
+  const errors = [];
+  return bundle(input, {
+    plugins: [fetchUrls()],
+    treeShake: false,
+    urlMap: true,
+    hooks: {
+      onResolveError(node) {
+        errors.push(`Failed to resolve ${node.$ref}`);
+      }
+    }
+  }).then((result) => {
+    if (errors.length > 0) {
+      return {
+        success: false,
+        errors
+      };
+    }
+    return {
+      success: true,
+      data: createMagicProxy(result)
+    };
+  });
+};
+export {
+  dereference
+};
+//# sourceMappingURL=dereference.js.map

package/dist/dereference/dereference.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/dereference/dereference.ts"],
+  "sourcesContent": ["import { bundle } from '@/bundle'\nimport { fetchUrls } from '@/bundle/plugins/fetch-urls'\nimport { createMagicProxy } from '@/magic-proxy'\nimport type { UnknownObject } from '@/types'\n\ntype DereferenceResult =\n  | {\n      success: true\n      data: UnknownObject\n    }\n  | {\n      success: false\n      errors: string[]\n    }\n\ntype ReturnDereferenceResult<Opt extends { sync?: boolean }> = Opt['sync'] extends true\n  ? DereferenceResult\n  : Promise<DereferenceResult>\n\n/**\n * Dereferences a JSON object, resolving all $ref pointers.\n *\n * This function can operate synchronously (no remote refs, no async plugins) or asynchronously (with remote refs).\n * If `options.sync` is true, it simply wraps the input in a magic proxy and returns it.\n * Otherwise, it bundles the document, resolving all $refs (including remote ones), and returns a promise.\n *\n * @param input - JSON Schema object to dereference.\n * @param options - Optional settings. If `sync` is true, dereferencing is synchronous.\n * @returns A DereferenceResult (or Promise thereof) indicating success and the dereferenced data, or errors.\n *\n * @example\n * // Synchronous dereference (no remote refs)\n * const result = dereference({ openapi: '3.0.0', info: { title: 'My API', version: '1.0.0' } }, { sync: true });\n * if (result.success) {\n *   console.log(result.data); // Magic proxy-wrapped document\n * }\n *\n * @example\n * // Asynchronous dereference (with remote refs)\n * dereference({ $ref: 'https://example.com/api.yaml' })\n *   .then(result => {\n *     if (result.success) {\n *       console.log(result.data); // Fully dereferenced document\n *     } else {\n *       console.error(result.errors);\n *     }\n *   });\n */\nexport const dereference = <Opts extends { sync?: boolean }>(\n  input: UnknownObject,\n  options?: Opts,\n): ReturnDereferenceResult<Opts> => {\n  if (options?.sync) {\n    return {\n      success: true,\n      data: createMagicProxy(input),\n    } as ReturnDereferenceResult<Opts>\n  }\n\n  const errors: string[] = []\n\n  return bundle(input, {\n    plugins: [fetchUrls()],\n    treeShake: false,\n    urlMap: true,\n    hooks: {\n      onResolveError(node) {\n        errors.push(`Failed to resolve ${node.$ref}`)\n      },\n    },\n  }).then((result) => {\n    if (errors.length > 0) {\n      return {\n        success: false,\n        errors,\n      }\n    }\n\n    return {\n      success: true,\n      data: createMagicProxy(result as UnknownObject),\n    }\n  }) as ReturnDereferenceResult<Opts>\n}\n"],
+  "mappings": "AAAA,SAAS,cAAc;AACvB,SAAS,iBAAiB;AAC1B,SAAS,wBAAwB;AA8C1B,MAAM,cAAc,CACzB,OACA,YACkC;AAClC,MAAI,SAAS,MAAM;AACjB,WAAO;AAAA,MACL,SAAS;AAAA,MACT,MAAM,iBAAiB,KAAK;AAAA,IAC9B;AAAA,EACF;AAEA,QAAM,SAAmB,CAAC;AAE1B,SAAO,OAAO,OAAO;AAAA,IACnB,SAAS,CAAC,UAAU,CAAC;AAAA,IACrB,WAAW;AAAA,IACX,QAAQ;AAAA,IACR,OAAO;AAAA,MACL,eAAe,MAAM;AACnB,eAAO,KAAK,qBAAqB,KAAK,IAAI,EAAE;AAAA,MAC9C;AAAA,IACF;AAAA,EACF,CAAC,EAAE,KAAK,CAAC,WAAW;AAClB,QAAI,OAAO,SAAS,GAAG;AACrB,aAAO;AAAA,QACL,SAAS;AAAA,QACT;AAAA,MACF;AAAA,IACF;AAEA,WAAO;AAAA,MACL,SAAS;AAAA,MACT,MAAM,iBAAiB,MAAuB;AAAA,IAChD;AAAA,EACF,CAAC;AACH;",
+  "names": []
+}

package/dist/dereference/index.d.ts

@@ -0,0 +1,2 @@
+export { dereference } from './dereference.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/dereference/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/dereference/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA"}

package/dist/dereference/index.js

@@ -0,0 +1,5 @@
+import { dereference } from "./dereference.js";
+export {
+  dereference
+};
+//# sourceMappingURL=index.js.map

package/dist/dereference/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/dereference/index.ts"],
+  "sourcesContent": ["// biome-ignore lint/performance/noBarrelFile: <explanation>\nexport { dereference } from './dereference'\n"],
+  "mappings": "AACA,SAAS,mBAAmB;",
+  "names": []
+}

package/dist/diff/apply.d.ts

@@ -0,0 +1,35 @@
+import type { Difference } from '../diff/diff.js';
+export declare class InvalidChangesDetectedError extends Error {
+    constructor(message: string);
+}
+/**
+ * Applies a set of differences to a document object.
+ * The function traverses the document structure following the paths specified in the differences
+ * and applies the corresponding changes (add, update, or delete) at each location.
+ *
+ * @param document - The original document to apply changes to
+ * @param diff - Array of differences to apply, each containing a path and change type
+ * @returns The modified document with all changes applied
+ *
+ * @example
+ * const original = {
+ *   paths: {
+ *     '/users': {
+ *       get: { responses: { '200': { description: 'OK' } } }
+ *     }
+ *   }
+ * }
+ *
+ * const changes = [
+ *   {
+ *     path: ['paths', '/users', 'get', 'responses', '200', 'content'],
+ *     type: 'add',
+ *     changes: { 'application/json': { schema: { type: 'object' } } }
+ *   }
+ * ]
+ *
+ * const updated = apply(original, changes)
+ * // Result: original document with content added to the 200 response
+ */
+export declare const apply: (document: Record<string, unknown>, diff: Difference[]) => Record<string, unknown>;
+//# sourceMappingURL=apply.d.ts.map

package/dist/diff/apply.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply.d.ts","sourceRoot":"","sources":["../../src/diff/apply.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAE7C,qBAAa,2BAA4B,SAAQ,KAAK;gBACxC,OAAO,EAAE,MAAM;CAI5B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,KAAK,aAAc,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,QAAQ,UAAU,EAAE,KAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAuCnG,CAAA"}

package/dist/diff/apply.js

@@ -0,0 +1,40 @@
+class InvalidChangesDetectedError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "InvalidChangesDetectedError";
+  }
+}
+const apply = (document, diff) => {
+  const applyChange = (current, path, d, depth = 0) => {
+    if (path[depth] === void 0) {
+      throw new InvalidChangesDetectedError(
+        `Process aborted. Path ${path.join(".")} at depth ${depth} is undefined, check diff object`
+      );
+    }
+    if (depth >= path.length - 1) {
+      if (d.type === "add" || d.type === "update") {
+        current[path[depth]] = d.changes;
+      } else {
+        if (Array.isArray(current)) {
+          current.splice(Number.parseInt(path[depth]), 1);
+        } else {
+          delete current[path[depth]];
+        }
+      }
+      return;
+    }
+    if (current[path[depth]] === void 0 || typeof current[path[depth]] !== "object") {
+      throw new InvalidChangesDetectedError("Process aborted, check diff object");
+    }
+    applyChange(current[path[depth]], path, d, depth + 1);
+  };
+  for (const d of diff) {
+    applyChange(document, d.path, d);
+  }
+  return document;
+};
+export {
+  InvalidChangesDetectedError,
+  apply
+};
+//# sourceMappingURL=apply.js.map

package/dist/diff/apply.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/diff/apply.ts"],
+  "sourcesContent": ["import type { Difference } from '@/diff/diff'\n\nexport class InvalidChangesDetectedError extends Error {\n  constructor(message: string) {\n    super(message)\n    this.name = 'InvalidChangesDetectedError'\n  }\n}\n\n/**\n * Applies a set of differences to a document object.\n * The function traverses the document structure following the paths specified in the differences\n * and applies the corresponding changes (add, update, or delete) at each location.\n *\n * @param document - The original document to apply changes to\n * @param diff - Array of differences to apply, each containing a path and change type\n * @returns The modified document with all changes applied\n *\n * @example\n * const original = {\n *   paths: {\n *     '/users': {\n *       get: { responses: { '200': { description: 'OK' } } }\n *     }\n *   }\n * }\n *\n * const changes = [\n *   {\n *     path: ['paths', '/users', 'get', 'responses', '200', 'content'],\n *     type: 'add',\n *     changes: { 'application/json': { schema: { type: 'object' } } }\n *   }\n * ]\n *\n * const updated = apply(original, changes)\n * // Result: original document with content added to the 200 response\n */\nexport const apply = (document: Record<string, unknown>, diff: Difference[]): Record<string, unknown> => {\n  // Traverse the object and apply the change\n  const applyChange = (current: any, path: string[], d: Difference, depth = 0) => {\n    if (path[depth] === undefined) {\n      throw new InvalidChangesDetectedError(\n        `Process aborted. Path ${path.join('.')} at depth ${depth} is undefined, check diff object`,\n      )\n    }\n\n    // We reach where we want to be, now we can apply changes\n    if (depth >= path.length - 1) {\n      if (d.type === 'add' || d.type === 'update') {\n        current[path[depth]] = d.changes\n      } else {\n        // For arrays we don't use delete operator since it will leave blank spots and not actually remove the element\n        if (Array.isArray(current)) {\n          current.splice(Number.parseInt(path[depth]), 1)\n        } else {\n          delete current[path[depth]]\n        }\n      }\n      return\n    }\n\n    // Throw an error\n    // This scenario should not happen\n    // 1- if we are adding a new entry, the diff should only give us the higher level diff\n    // 2- if we are updating/deleting an entry, the path to that entry should exists\n    if (current[path[depth]] === undefined || typeof current[path[depth]] !== 'object') {\n      throw new InvalidChangesDetectedError('Process aborted, check diff object')\n    }\n    applyChange(current[path[depth]], path, d, depth + 1)\n  }\n\n  for (const d of diff) {\n    applyChange(document, d.path, d)\n  }\n\n  return document\n}\n"],
+  "mappings": "AAEO,MAAM,oCAAoC,MAAM;AAAA,EACrD,YAAY,SAAiB;AAC3B,UAAM,OAAO;AACb,SAAK,OAAO;AAAA,EACd;AACF;AA+BO,MAAM,QAAQ,CAAC,UAAmC,SAAgD;AAEvG,QAAM,cAAc,CAAC,SAAc,MAAgB,GAAe,QAAQ,MAAM;AAC9E,QAAI,KAAK,KAAK,MAAM,QAAW;AAC7B,YAAM,IAAI;AAAA,QACR,yBAAyB,KAAK,KAAK,GAAG,CAAC,aAAa,KAAK;AAAA,MAC3D;AAAA,IACF;AAGA,QAAI,SAAS,KAAK,SAAS,GAAG;AAC5B,UAAI,EAAE,SAAS,SAAS,EAAE,SAAS,UAAU;AAC3C,gBAAQ,KAAK,KAAK,CAAC,IAAI,EAAE;AAAA,MAC3B,OAAO;AAEL,YAAI,MAAM,QAAQ,OAAO,GAAG;AAC1B,kBAAQ,OAAO,OAAO,SAAS,KAAK,KAAK,CAAC,GAAG,CAAC;AAAA,QAChD,OAAO;AACL,iBAAO,QAAQ,KAAK,KAAK,CAAC;AAAA,QAC5B;AAAA,MACF;AACA;AAAA,IACF;AAMA,QAAI,QAAQ,KAAK,KAAK,CAAC,MAAM,UAAa,OAAO,QAAQ,KAAK,KAAK,CAAC,MAAM,UAAU;AAClF,YAAM,IAAI,4BAA4B,oCAAoC;AAAA,IAC5E;AACA,gBAAY,QAAQ,KAAK,KAAK,CAAC,GAAG,MAAM,GAAG,QAAQ,CAAC;AAAA,EACtD;AAEA,aAAW,KAAK,MAAM;AACpB,gBAAY,UAAU,EAAE,MAAM,CAAC;AAAA,EACjC;AAEA,SAAO;AACT;",
+  "names": []
+}

package/dist/diff/diff.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Represents the possible types of changes that can be made to a document.
+ * - 'add': A new property is added
+ * - 'update': An existing property's value is changed
+ * - 'delete': A property is removed
+ */
+type ChangeType = 'add' | 'update' | 'delete';
+/**
+ * Represents a single difference between two documents.
+ * @property path - Array of strings representing the path to the changed property
+ * @property changes - The new value for the property (for add/update) or the old value (for delete)
+ * @property type - The type of change that occurred
+ */
+export type Difference = {
+    path: string[];
+    changes: any;
+    type: ChangeType;
+};
+/**
+ * Get the difference between two objects.
+ *
+ * This function performs a breadth-first comparison between two objects and returns
+ * a list of operations needed to transform the first object into the second.
+ *
+ * @param doc1 - The source object to compare from
+ * @param doc2 - The target object to compare to
+ * @returns A list of operations (add/update/delete) with their paths and changes
+ *
+ * @example
+ * // Compare two simple objects
+ * const original = { name: 'John', age: 30 }
+ * const updated = { name: 'John', age: 31, city: 'New York' }
+ * const differences = diff(original, updated)
+ * // Returns:
+ * // [
+ * //   { path: ['age'], changes: 31, type: 'update' },
+ * //   { path: ['city'], changes: 'New York', type: 'add' }
+ * // ]
+ *
+ * @example
+ * // Compare nested objects
+ * const original = {
+ *   user: { name: 'John', settings: { theme: 'light' } }
+ * }
+ * const updated = {
+ *   user: { name: 'John', settings: { theme: 'dark' } }
+ * }
+ * const differences = diff(original, updated)
+ * // Returns:
+ * // [
+ * //   { path: ['user', 'settings', 'theme'], changes: 'dark', type: 'update' }
+ * // ]
+ */
+export declare const diff: (doc1: Record<string, unknown>, doc2: Record<string, unknown>) => Difference[];
+export {};
+//# sourceMappingURL=diff.d.ts.map

package/dist/diff/diff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff.d.ts","sourceRoot":"","sources":["../../src/diff/diff.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,KAAK,UAAU,GAAG,KAAK,GAAG,QAAQ,GAAG,QAAQ,CAAA;AAE7C;;;;;GAKG;AACH,MAAM,MAAM,UAAU,GAAG;IAAE,IAAI,EAAE,MAAM,EAAE,CAAC;IAAC,OAAO,EAAE,GAAG,CAAC;IAAC,IAAI,EAAE,UAAU,CAAA;CAAE,CAAA;AAE3E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,eAAO,MAAM,IAAI,SAAU,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,QAAQ,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAG,UAAU,EA0C7F,CAAA"}

package/dist/diff/diff.js

@@ -0,0 +1,33 @@
+const diff = (doc1, doc2) => {
+  const diff2 = [];
+  const bfs = (el1, el2, prefix = []) => {
+    if (typeof el1 !== typeof el2) {
+      if (typeof el1 === "undefined") {
+        diff2.push({ path: prefix, changes: el2, type: "add" });
+        return;
+      }
+      if (typeof el2 === "undefined") {
+        diff2.push({ path: prefix, changes: el1, type: "delete" });
+        return;
+      }
+      diff2.push({ path: prefix, changes: el2, type: "update" });
+      return;
+    }
+    if (typeof el1 === "object" && typeof el2 === "object" && el1 !== null && el2 !== null) {
+      const keys = /* @__PURE__ */ new Set([...Object.keys(el1), ...Object.keys(el2)]);
+      for (const key of keys) {
+        bfs(el1[key], el2[key], [...prefix, key]);
+      }
+      return;
+    }
+    if (el1 !== el2) {
+      diff2.push({ path: prefix, changes: el2, type: "update" });
+    }
+  };
+  bfs(doc1, doc2);
+  return diff2;
+};
+export {
+  diff
+};
+//# sourceMappingURL=diff.js.map