@scalar/openapi-parser 0.18.2 → 0.19.0

package/dist/utils/bundle/create-limiter.js

@@ -1,31 +0,0 @@
-function createLimiter(maxConcurrent) {
-  let activeCount = 0;
-  const queue = [];
-  const next = () => {
-    if (queue.length === 0 || activeCount >= maxConcurrent) {
-      return;
-    }
-    const resolve = queue.shift();
-    if (resolve) {
-      resolve();
-    }
-  };
-  const run = async (fn) => {
-    if (activeCount >= maxConcurrent) {
-      await new Promise((resolve) => queue.push(resolve));
-    }
-    activeCount++;
-    try {
-      const result = await fn();
-      return result;
-    } finally {
-      activeCount--;
-      next();
-    }
-  };
-  return run;
-}
-export {
-  createLimiter
-};
-//# sourceMappingURL=create-limiter.js.map

package/dist/utils/bundle/create-limiter.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/utils/bundle/create-limiter.ts"],
-  "sourcesContent": ["/**\n * Creates a function that limits the number of concurrent executions of async functions.\n *\n * @param maxConcurrent - Maximum number of concurrent executions allowed\n * @returns A function that wraps async functions to limit their concurrent execution\n *\n * @example\n * ```ts\n * const limiter = createLimiter(2) // Allow max 2 concurrent executions\n *\n * // These will run with max 2 at a time\n * const results = await Promise.all([\n *   limiter(() => fetch('/api/1')),\n *   limiter(() => fetch('/api/2')),\n *   limiter(() => fetch('/api/3')),\n *   limiter(() => fetch('/api/4'))\n * ])\n * ```\n */\nexport function createLimiter(maxConcurrent: number) {\n  let activeCount = 0\n  const queue: (() => void)[] = []\n\n  const next = () => {\n    if (queue.length === 0 || activeCount >= maxConcurrent) {\n      return\n    }\n\n    const resolve = queue.shift()\n\n    if (resolve) {\n      resolve()\n    }\n  }\n\n  const run = async <T>(fn: () => Promise<T>): Promise<T> => {\n    if (activeCount >= maxConcurrent) {\n      await new Promise<void>((resolve) => queue.push(resolve))\n    }\n\n    activeCount++\n    try {\n      const result = await fn()\n      return result\n    } finally {\n      activeCount--\n      next()\n    }\n  }\n\n  return run\n}\n"],
-  "mappings": "AAmBO,SAAS,cAAc,eAAuB;AACnD,MAAI,cAAc;AAClB,QAAM,QAAwB,CAAC;AAE/B,QAAM,OAAO,MAAM;AACjB,QAAI,MAAM,WAAW,KAAK,eAAe,eAAe;AACtD;AAAA,IACF;AAEA,UAAM,UAAU,MAAM,MAAM;AAE5B,QAAI,SAAS;AACX,cAAQ;AAAA,IACV;AAAA,EACF;AAEA,QAAM,MAAM,OAAU,OAAqC;AACzD,QAAI,eAAe,eAAe;AAChC,YAAM,IAAI,QAAc,CAAC,YAAY,MAAM,KAAK,OAAO,CAAC;AAAA,IAC1D;AAEA;AACA,QAAI;AACF,YAAM,SAAS,MAAM,GAAG;AACxB,aAAO;AAAA,IACT,UAAE;AACA;AACA,WAAK;AAAA,IACP;AAAA,EACF;AAEA,SAAO;AACT;",
-  "names": []
-}

package/dist/utils/bundle/plugins/fetch-urls/index.d.ts

@@ -1,39 +0,0 @@
-import { type Plugin, type ResolveResult } from '../../../../utils/bundle/bundle.js';
-type FetchConfig = Partial<{
-    headers: {
-        headers: HeadersInit;
-        domains: string[];
-    }[];
-    fetch: (input: string | URL | globalThis.Request, init?: RequestInit) => Promise<Response>;
-}>;
-/**
- * Fetches and normalizes data from a remote URL
- * @param url - The URL to fetch data from
- * @returns A promise that resolves to either the normalized data or an error result
- * @example
- * ```ts
- * const result = await fetchUrl('https://api.example.com/data.json')
- * if (result.ok) {
- *   console.log(result.data) // The normalized data
- * } else {
- *   console.log('Failed to fetch data')
- * }
- * ```
- */
-export declare function fetchUrl(url: string, limiter: <T>(fn: () => Promise<T>) => Promise<T>, config?: FetchConfig): Promise<ResolveResult>;
-/**
- * Creates a plugin for handling remote URL references.
- * This plugin validates and fetches data from HTTP/HTTPS URLs.
- *
- * @returns A plugin object with validate and exec functions
- * @example
- * const urlPlugin = fetchUrls()
- * if (urlPlugin.validate('https://example.com/schema.json')) {
- *   const result = await urlPlugin.exec('https://example.com/schema.json')
- * }
- */
-export declare function fetchUrls(config?: FetchConfig & Partial<{
-    limit: number | null;
-}>): Plugin;
-export {};
-//# sourceMappingURL=index.d.ts.map

package/dist/utils/bundle/plugins/fetch-urls/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/utils/bundle/plugins/fetch-urls/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAe,KAAK,MAAM,EAAE,KAAK,aAAa,EAAE,MAAM,uBAAuB,CAAA;AAGpF,KAAK,WAAW,GAAG,OAAO,CAAC;IACzB,OAAO,EAAE;QAAE,OAAO,EAAE,WAAW,CAAC;QAAC,OAAO,EAAE,MAAM,EAAE,CAAA;KAAE,EAAE,CAAA;IACtD,KAAK,EAAE,CAAC,KAAK,EAAE,MAAM,GAAG,GAAG,GAAG,UAAU,CAAC,OAAO,EAAE,IAAI,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAA;CAC3F,CAAC,CAAA;AAcF;;;;;;;;;;;;;GAaG;AACH,wBAAsB,QAAQ,CAC5B,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,EAChD,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,aAAa,CAAC,CAgCxB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,SAAS,CAAC,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC;IAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAAC,GAAG,MAAM,CAQ1F"}

package/dist/utils/bundle/plugins/fetch-urls/index.js

@@ -1,48 +0,0 @@
-import { normalize } from "../../../../utils/normalize.js";
-import { isRemoteUrl } from "../../../../utils/bundle/bundle.js";
-import { createLimiter } from "../../../../utils/bundle/create-limiter.js";
-const getHost = (url) => {
-  try {
-    return new URL(url).host;
-  } catch {
-    return null;
-  }
-};
-async function fetchUrl(url, limiter, config) {
-  try {
-    const host = getHost(url);
-    const headers = config?.headers?.find((a) => a.domains.find((d) => d === host) !== void 0)?.headers;
-    const exec = config?.fetch ?? fetch;
-    const result = await limiter(
-      () => exec(url, {
-        headers
-      })
-    );
-    if (result.ok) {
-      const body = await result.text();
-      return {
-        ok: true,
-        data: normalize(body)
-      };
-    }
-    return {
-      ok: false
-    };
-  } catch {
-    return {
-      ok: false
-    };
-  }
-}
-function fetchUrls(config) {
-  const limiter = config?.limit ? createLimiter(config.limit) : (fn) => fn();
-  return {
-    validate: isRemoteUrl,
-    exec: (value) => fetchUrl(value, limiter, config)
-  };
-}
-export {
-  fetchUrl,
-  fetchUrls
-};
-//# sourceMappingURL=index.js.map

package/dist/utils/bundle/plugins/fetch-urls/index.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../../../src/utils/bundle/plugins/fetch-urls/index.ts"],
-  "sourcesContent": ["import { normalize } from '@/utils/normalize'\nimport { isRemoteUrl, type Plugin, type ResolveResult } from '@/utils/bundle/bundle'\nimport { createLimiter } from '@/utils/bundle/create-limiter'\n\ntype FetchConfig = Partial<{\n  headers: { headers: HeadersInit; domains: string[] }[]\n  fetch: (input: string | URL | globalThis.Request, init?: RequestInit) => Promise<Response>\n}>\n\n/**\n * Safely checks for host from a URL\n * Needed because we cannot create a URL from a relative remote URL ex: examples/openapi.json\n */\nconst getHost = (url: string): string | null => {\n  try {\n    return new URL(url).host\n  } catch {\n    return null\n  }\n}\n\n/**\n * Fetches and normalizes data from a remote URL\n * @param url - The URL to fetch data from\n * @returns A promise that resolves to either the normalized data or an error result\n * @example\n * ```ts\n * const result = await fetchUrl('https://api.example.com/data.json')\n * if (result.ok) {\n *   console.log(result.data) // The normalized data\n * } else {\n *   console.log('Failed to fetch data')\n * }\n * ```\n */\nexport async function fetchUrl(\n  url: string,\n  limiter: <T>(fn: () => Promise<T>) => Promise<T>,\n  config?: FetchConfig,\n): Promise<ResolveResult> {\n  try {\n    const host = getHost(url)\n\n    // Get the headers that match the domain\n    const headers = config?.headers?.find((a) => a.domains.find((d) => d === host) !== undefined)?.headers\n\n    const exec = config?.fetch ?? fetch\n\n    const result = await limiter(() =>\n      exec(url, {\n        headers,\n      }),\n    )\n\n    if (result.ok) {\n      const body = await result.text()\n\n      return {\n        ok: true,\n        data: normalize(body),\n      }\n    }\n\n    return {\n      ok: false,\n    }\n  } catch {\n    return {\n      ok: false,\n    }\n  }\n}\n\n/**\n * Creates a plugin for handling remote URL references.\n * This plugin validates and fetches data from HTTP/HTTPS URLs.\n *\n * @returns A plugin object with validate and exec functions\n * @example\n * const urlPlugin = fetchUrls()\n * if (urlPlugin.validate('https://example.com/schema.json')) {\n *   const result = await urlPlugin.exec('https://example.com/schema.json')\n * }\n */\nexport function fetchUrls(config?: FetchConfig & Partial<{ limit: number | null }>): Plugin {\n  // If there is a limit specified we limit the number of concurrent calls\n  const limiter = config?.limit ? createLimiter(config.limit) : <T>(fn: () => Promise<T>) => fn()\n\n  return {\n    validate: isRemoteUrl,\n    exec: (value) => fetchUrl(value, limiter, config),\n  }\n}\n"],
-  "mappings": "AAAA,SAAS,iBAAiB;AAC1B,SAAS,mBAAoD;AAC7D,SAAS,qBAAqB;AAW9B,MAAM,UAAU,CAAC,QAA+B;AAC9C,MAAI;AACF,WAAO,IAAI,IAAI,GAAG,EAAE;AAAA,EACtB,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AAgBA,eAAsB,SACpB,KACA,SACA,QACwB;AACxB,MAAI;AACF,UAAM,OAAO,QAAQ,GAAG;AAGxB,UAAM,UAAU,QAAQ,SAAS,KAAK,CAAC,MAAM,EAAE,QAAQ,KAAK,CAAC,MAAM,MAAM,IAAI,MAAM,MAAS,GAAG;AAE/F,UAAM,OAAO,QAAQ,SAAS;AAE9B,UAAM,SAAS,MAAM;AAAA,MAAQ,MAC3B,KAAK,KAAK;AAAA,QACR;AAAA,MACF,CAAC;AAAA,IACH;AAEA,QAAI,OAAO,IAAI;AACb,YAAM,OAAO,MAAM,OAAO,KAAK;AAE/B,aAAO;AAAA,QACL,IAAI;AAAA,QACJ,MAAM,UAAU,IAAI;AAAA,MACtB;AAAA,IACF;AAEA,WAAO;AAAA,MACL,IAAI;AAAA,IACN;AAAA,EACF,QAAQ;AACN,WAAO;AAAA,MACL,IAAI;AAAA,IACN;AAAA,EACF;AACF;AAaO,SAAS,UAAU,QAAkE;AAE1F,QAAM,UAAU,QAAQ,QAAQ,cAAc,OAAO,KAAK,IAAI,CAAI,OAAyB,GAAG;AAE9F,SAAO;AAAA,IACL,UAAU;AAAA,IACV,MAAM,CAAC,UAAU,SAAS,OAAO,SAAS,MAAM;AAAA,EAClD;AACF;",
-  "names": []
-}

package/dist/utils/bundle/plugins/parse-json/index.d.ts

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

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

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

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

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

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

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../../../src/utils/bundle/plugins/parse-json/index.ts"],
-  "sourcesContent": ["import type { Plugin, ResolveResult } from '@/utils/bundle/bundle'\nimport { isJson } from '@/utils/is-json'\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: isJson,\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": "AACA,SAAS,cAAc;AAYhB,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/utils/bundle/plugins/parse-yaml/index.d.ts

@@ -1,13 +0,0 @@
-import type { Plugin } from '../../../../utils/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/utils/bundle/plugins/parse-yaml/index.d.ts.map

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

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

@@ -1,23 +0,0 @@
-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/utils/bundle/plugins/parse-yaml/index.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../../../src/utils/bundle/plugins/parse-yaml/index.ts"],
-  "sourcesContent": ["import type { Plugin, ResolveResult } from '@/utils/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/utils/bundle/plugins/read-files/index.d.ts

@@ -1,29 +0,0 @@
-import { type Plugin, type ResolveResult } from '../../../../utils/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/utils/bundle/plugins/read-files/index.d.ts.map

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

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

@@ -1,30 +0,0 @@
-import { normalize } from "../../../../utils/normalize.js";
-import { isFilePath } from "../../../../utils/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/utils/bundle/plugins/read-files/index.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../../../src/utils/bundle/plugins/read-files/index.ts"],
-  "sourcesContent": ["import { normalize } from '@/utils/normalize'\nimport { isFilePath, type Plugin, type ResolveResult } from '@/utils/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/utils/bundle/value-generator.d.ts

@@ -1,79 +0,0 @@
-/**
- * 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/utils/bundle/value-generator.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"value-generator.d.ts","sourceRoot":"","sources":["../../../src/utils/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/utils/bundle/value-generator.js

@@ -1,55 +0,0 @@
-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/utils/bundle/value-generator.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/utils/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": []
-}