@scalar/helpers 0.2.16 → 0.2.18

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @scalar/helpers
 
+## 0.2.18
+
+### Patch Changes
+
+- [#8314](https://github.com/scalar/scalar/pull/8314): chore: limit concurrent operations while migrating workspaces
+
+## 0.2.17
+
+### Patch Changes
+
+- [#8310](https://github.com/scalar/scalar/pull/8310): refactor: move helpers to the helpers package to share primitive helpers
+
 ## 0.2.16
 
 ### Patch Changes

package/dist/general/create-limiter.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Creates a function that limits the number of concurrent executions of async functions.
+ *
+ * @param maxConcurrent - Maximum number of concurrent executions allowed
+ * @returns A function that wraps async functions to limit their concurrent execution
+ *
+ * @example
+ * ```ts
+ * const limiter = createLimiter(2) // Allow max 2 concurrent executions
+ *
+ * // These will run with max 2 at a time
+ * const results = await Promise.all([
+ *   limiter(() => fetch('/api/1')),
+ *   limiter(() => fetch('/api/2')),
+ *   limiter(() => fetch('/api/3')),
+ *   limiter(() => fetch('/api/4'))
+ * ])
+ * ```
+ */
+export declare function createLimiter(maxConcurrent: number): <T>(fn: () => Promise<T>) => Promise<T>;
+//# sourceMappingURL=create-limiter.d.ts.map

package/dist/general/create-limiter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-limiter.d.ts","sourceRoot":"","sources":["../../src/general/create-limiter.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,aAAa,CAAC,aAAa,EAAE,MAAM,IAgB9B,CAAC,MAAM,MAAM,OAAO,CAAC,CAAC,CAAC,KAAG,OAAO,CAAC,CAAC,CAAC,CAgBxD"}

package/dist/general/create-limiter.js

@@ -0,0 +1,32 @@
+import { Queue } from "../queue/queue.js";
+function createLimiter(maxConcurrent) {
+  let activeCount = 0;
+  const queue = new Queue();
+  const next = () => {
+    if (queue.isEmpty() || activeCount >= maxConcurrent) {
+      return;
+    }
+    const resolve = queue.dequeue();
+    if (resolve) {
+      resolve();
+    }
+  };
+  const run = async (fn) => {
+    if (activeCount >= maxConcurrent) {
+      await new Promise((resolve) => queue.enqueue(resolve));
+    }
+    activeCount++;
+    try {
+      const result = await fn();
+      return result;
+    } finally {
+      activeCount--;
+      next();
+    }
+  };
+  return run;
+}
+export {
+  createLimiter
+};
+//# sourceMappingURL=create-limiter.js.map

package/dist/general/create-limiter.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/general/create-limiter.ts"],
+  "sourcesContent": ["import { Queue } from '../queue/queue'\n\n/**\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 = new Queue<() => void>()\n\n  const next = () => {\n    if (queue.isEmpty() || activeCount >= maxConcurrent) {\n      return\n    }\n\n    const resolve = queue.dequeue()\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.enqueue(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": "AAAA,SAAS,aAAa;AAqBf,SAAS,cAAc,eAAuB;AACnD,MAAI,cAAc;AAClB,QAAM,QAAQ,IAAI,MAAkB;AAEpC,QAAM,OAAO,MAAM;AACjB,QAAI,MAAM,QAAQ,KAAK,eAAe,eAAe;AACnD;AAAA,IACF;AAEA,UAAM,UAAU,MAAM,QAAQ;AAE9B,QAAI,SAAS;AACX,cAAQ;AAAA,IACV;AAAA,EACF;AAEA,QAAM,MAAM,OAAU,OAAqC;AACzD,QAAI,eAAe,eAAe;AAChC,YAAM,IAAI,QAAc,CAAC,YAAY,MAAM,QAAQ,OAAO,CAAC;AAAA,IAC7D;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/json/escape-json-pointer.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Escapes a JSON pointer string.
+ *
+ * Example: `/foo/bar~baz` -> `~1foo~1bar~0baz`
+ */
+export declare const escapeJsonPointer: (str: string) => string;
+//# sourceMappingURL=escape-json-pointer.d.ts.map

package/dist/json/escape-json-pointer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"escape-json-pointer.d.ts","sourceRoot":"","sources":["../../src/json/escape-json-pointer.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,GAAI,KAAK,MAAM,KAAG,MAAsD,CAAA"}

package/dist/json/escape-json-pointer.js

@@ -0,0 +1,5 @@
+const escapeJsonPointer = (str) => str.replace(/~/g, "~0").replace(/\//g, "~1");
+export {
+  escapeJsonPointer
+};
+//# sourceMappingURL=escape-json-pointer.js.map

package/dist/json/escape-json-pointer.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/json/escape-json-pointer.ts"],
+  "sourcesContent": ["/**\n * Escapes a JSON pointer string.\n *\n * Example: `/foo/bar~baz` -> `~1foo~1bar~0baz`\n */\nexport const escapeJsonPointer = (str: string): string => str.replace(/~/g, '~0').replace(/\\//g, '~1')\n"],
+  "mappings": "AAKO,MAAM,oBAAoB,CAAC,QAAwB,IAAI,QAAQ,MAAM,IAAI,EAAE,QAAQ,OAAO,IAAI;",
+  "names": []
+}

package/dist/json/parse-json-pointer-segments.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Translate `/paths/~1test` to `['paths', '/test']`
+ */
+export declare const parseJsonPointerSegments: (path: string) => string[];
+//# sourceMappingURL=parse-json-pointer-segments.d.ts.map

package/dist/json/parse-json-pointer-segments.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-json-pointer-segments.d.ts","sourceRoot":"","sources":["../../src/json/parse-json-pointer-segments.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,eAAO,MAAM,wBAAwB,GAAI,MAAM,MAAM,KAAG,MAAM,EAOjC,CAAA"}

package/dist/json/parse-json-pointer-segments.js

@@ -0,0 +1,6 @@
+import { unescapeJsonPointer } from "./unescape-json-pointer.js";
+const parseJsonPointerSegments = (path) => path.split("/").slice(1).map(unescapeJsonPointer);
+export {
+  parseJsonPointerSegments
+};
+//# sourceMappingURL=parse-json-pointer-segments.js.map

package/dist/json/parse-json-pointer-segments.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/json/parse-json-pointer-segments.ts"],
+  "sourcesContent": ["import { unescapeJsonPointer } from './unescape-json-pointer'\n\n/**\n * Translate `/paths/~1test` to `['paths', '/test']`\n */\nexport const parseJsonPointerSegments = (path: string): string[] =>\n  path\n    // ['', 'paths', '~1test']\n    .split('/')\n    // ['paths', '~1test']\n    .slice(1)\n    // ['paths', '/test']\n    .map(unescapeJsonPointer)\n"],
+  "mappings": "AAAA,SAAS,2BAA2B;AAK7B,MAAM,2BAA2B,CAAC,SACvC,KAEG,MAAM,GAAG,EAET,MAAM,CAAC,EAEP,IAAI,mBAAmB;",
+  "names": []
+}

package/dist/json/unescape-json-pointer.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Unescape JSON pointer
+ *
+ * Examples:
+ * /foo~1bar~0baz -> /foo/bar~baz
+ */
+export declare const unescapeJsonPointer: (uri: string) => string;
+//# sourceMappingURL=unescape-json-pointer.d.ts.map

package/dist/json/unescape-json-pointer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unescape-json-pointer.d.ts","sourceRoot":"","sources":["../../src/json/unescape-json-pointer.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,GAAI,KAAK,MAAM,KAAG,MAAgE,CAAA"}

package/dist/json/unescape-json-pointer.js

@@ -0,0 +1,5 @@
+const unescapeJsonPointer = (uri) => decodeURI(uri.replace(/~1/g, "/").replace(/~0/g, "~"));
+export {
+  unescapeJsonPointer
+};
+//# sourceMappingURL=unescape-json-pointer.js.map

package/dist/json/unescape-json-pointer.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/json/unescape-json-pointer.ts"],
+  "sourcesContent": ["/**\n * Unescape JSON pointer\n *\n * Examples:\n * /foo~1bar~0baz -> /foo/bar~baz\n */\nexport const unescapeJsonPointer = (uri: string): string => decodeURI(uri.replace(/~1/g, '/').replace(/~0/g, '~'))\n"],
+  "mappings": "AAMO,MAAM,sBAAsB,CAAC,QAAwB,UAAU,IAAI,QAAQ,OAAO,GAAG,EAAE,QAAQ,OAAO,GAAG,CAAC;",
+  "names": []
+}

package/dist/object/get-value-at-path.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Retrieves a nested value from the source document using a path array
+ *
+ * @example
+ * ```ts
+ * getValueByPath(document, ['components', 'schemas', 'User'])
+ *
+ * { id: '123', name: 'John Doe' }
+ * ```
+ */
+export declare function getValueAtPath<R = unknown>(obj: any, pointer: string[]): R;
+//# sourceMappingURL=get-value-at-path.d.ts.map

package/dist/object/get-value-at-path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-value-at-path.d.ts","sourceRoot":"","sources":["../../src/object/get-value-at-path.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAAC,CAAC,GAAG,OAAO,EAAE,GAAG,EAAE,GAAG,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,CAAC,CAO1E"}

package/dist/object/get-value-at-path.js

@@ -0,0 +1,12 @@
+function getValueAtPath(obj, pointer) {
+  return pointer.reduce((acc, part) => {
+    if (acc === void 0 || acc === null) {
+      return void 0;
+    }
+    return acc[part];
+  }, obj);
+}
+export {
+  getValueAtPath
+};
+//# sourceMappingURL=get-value-at-path.js.map

package/dist/object/get-value-at-path.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/object/get-value-at-path.ts"],
+  "sourcesContent": ["/**\n * Retrieves a nested value from the source document using a path array\n *\n * @example\n * ```ts\n * getValueByPath(document, ['components', 'schemas', 'User'])\n *\n * { id: '123', name: 'John Doe' }\n * ```\n */\nexport function getValueAtPath<R = unknown>(obj: any, pointer: string[]): R {\n  return pointer.reduce((acc, part) => {\n    if (acc === undefined || acc === null) {\n      return undefined\n    }\n    return acc[part]\n  }, obj)\n}\n"],
+  "mappings": "AAUO,SAAS,eAA4B,KAAU,SAAsB;AAC1E,SAAO,QAAQ,OAAO,CAAC,KAAK,SAAS;AACnC,QAAI,QAAQ,UAAa,QAAQ,MAAM;AACrC,aAAO;AAAA,IACT;AACA,WAAO,IAAI,IAAI;AAAA,EACjB,GAAG,GAAG;AACR;",
+  "names": []
+}

package/dist/object/to-json-compatible.d.ts

@@ -0,0 +1,19 @@
+type RemoveCircularOptions = {
+    /** Prefix to add before the path in $ref values */
+    prefix?: string;
+    /** Cache of already processed objects */
+    cache?: WeakMap<object, string>;
+};
+/**
+ * Traverses an object or array, returning a deep copy in which circular references are replaced
+ * by JSON Reference objects of the form: `{ $ref: "#/path/to/original" }`.
+ * This allows safe serialization of objects with cycles, following the JSON Reference convention (RFC 6901).
+ * An optional `prefix` for the `$ref` path can be provided via options.
+ *
+ * @param obj - The input object or array to process
+ * @param options - Optional configuration; you can set a prefix for $ref pointers
+ * @returns A new object or array, with all circular references replaced by $ref pointers
+ */
+export declare const toJsonCompatible: <T>(obj: T, options?: RemoveCircularOptions) => T;
+export {};
+//# sourceMappingURL=to-json-compatible.d.ts.map

package/dist/object/to-json-compatible.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-json-compatible.d.ts","sourceRoot":"","sources":["../../src/object/to-json-compatible.ts"],"names":[],"mappings":"AAGA,KAAK,qBAAqB,GAAG;IAC3B,mDAAmD;IACnD,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,yCAAyC;IACzC,KAAK,CAAC,EAAE,OAAO,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAChC,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,gBAAgB,GAAI,CAAC,EAAE,KAAK,CAAC,EAAE,UAAS,qBAA0B,KAAG,CAqFjF,CAAA"}

package/dist/object/to-json-compatible.js

@@ -0,0 +1,68 @@
+import { escapeJsonPointer } from "../json/escape-json-pointer.js";
+import { Queue } from "../queue/queue.js";
+const toJsonCompatible = (obj, options = {}) => {
+  const { prefix = "", cache = /* @__PURE__ */ new WeakMap() } = options;
+  const toRef = (path) => ({ $ref: `#${path ?? ""}` });
+  if (typeof obj !== "object" || obj === null) {
+    return obj;
+  }
+  const rootPath = prefix;
+  cache.set(obj, rootPath);
+  const rootResult = Array.isArray(obj) ? new Array(obj.length) : {};
+  const queue = new Queue();
+  queue.enqueue({ node: obj, result: rootResult, path: rootPath });
+  while (!queue.isEmpty()) {
+    const frame = queue.dequeue();
+    if (!frame) {
+      continue;
+    }
+    const { node, result, path } = frame;
+    if (Array.isArray(node)) {
+      const input = node;
+      const out2 = result;
+      for (let index = 0; index < input.length; index++) {
+        if (!(index in input)) {
+          continue;
+        }
+        const item = input[index];
+        const itemPath = `${path}/${index}`;
+        if (typeof item !== "object" || item === null) {
+          out2[index] = item;
+          continue;
+        }
+        const existingPath = cache.get(item);
+        if (existingPath !== void 0) {
+          out2[index] = toRef(existingPath);
+          continue;
+        }
+        cache.set(item, itemPath);
+        const childResult = Array.isArray(item) ? new Array(item.length) : {};
+        out2[index] = childResult;
+        queue.enqueue({ node: item, result: childResult, path: itemPath });
+      }
+      continue;
+    }
+    const out = result;
+    for (const [key, value] of Object.entries(node)) {
+      const valuePath = `${path}/${escapeJsonPointer(key)}`;
+      if (typeof value !== "object" || value === null) {
+        out[key] = value;
+        continue;
+      }
+      const existingPath = cache.get(value);
+      if (existingPath !== void 0) {
+        out[key] = toRef(existingPath);
+        continue;
+      }
+      cache.set(value, valuePath);
+      const childResult = Array.isArray(value) ? new Array(value.length) : {};
+      out[key] = childResult;
+      queue.enqueue({ node: value, result: childResult, path: valuePath });
+    }
+  }
+  return rootResult;
+};
+export {
+  toJsonCompatible
+};
+//# sourceMappingURL=to-json-compatible.js.map

package/dist/object/to-json-compatible.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/object/to-json-compatible.ts"],
+  "sourcesContent": ["import { escapeJsonPointer } from '@/json/escape-json-pointer'\nimport { Queue } from '@/queue/queue'\n\ntype RemoveCircularOptions = {\n  /** Prefix to add before the path in $ref values */\n  prefix?: string\n  /** Cache of already processed objects */\n  cache?: WeakMap<object, string>\n}\n\n/**\n * Traverses an object or array, returning a deep copy in which circular references are replaced\n * by JSON Reference objects of the form: `{ $ref: \"#/path/to/original\" }`.\n * This allows safe serialization of objects with cycles, following the JSON Reference convention (RFC 6901).\n * An optional `prefix` for the `$ref` path can be provided via options.\n *\n * @param obj - The input object or array to process\n * @param options - Optional configuration; you can set a prefix for $ref pointers\n * @returns A new object or array, with all circular references replaced by $ref pointers\n */\nexport const toJsonCompatible = <T>(obj: T, options: RemoveCircularOptions = {}): T => {\n  const { prefix = '', cache = new WeakMap<object, string>() } = options\n\n  const toRef = (path: string | undefined) => ({ $ref: `#${path ?? ''}` })\n\n  // Primitives and null are returned as-is\n  if (typeof obj !== 'object' || obj === null) {\n    return obj\n  }\n\n  const rootPath = prefix\n  cache.set(obj as object, rootPath)\n\n  const rootResult: unknown = Array.isArray(obj) ? new Array((obj as unknown[]).length) : {}\n\n  const queue = new Queue<{ node: object; result: unknown; path: string }>()\n  queue.enqueue({ node: obj as object, result: rootResult, path: rootPath })\n\n  while (!queue.isEmpty()) {\n    const frame = queue.dequeue()\n    if (!frame) {\n      continue\n    }\n\n    const { node, result, path } = frame\n\n    // Handle arrays (preserve sparse arrays like Array#map does)\n    if (Array.isArray(node)) {\n      const input = node as unknown[]\n      const out = result as unknown[]\n\n      for (let index = 0; index < input.length; index++) {\n        if (!(index in input)) {\n          continue\n        }\n\n        const item = input[index]\n        const itemPath = `${path}/${index}`\n\n        if (typeof item !== 'object' || item === null) {\n          out[index] = item\n          continue\n        }\n\n        const existingPath = cache.get(item as object)\n        if (existingPath !== undefined) {\n          out[index] = toRef(existingPath)\n          continue\n        }\n\n        cache.set(item as object, itemPath)\n\n        const childResult: unknown = Array.isArray(item) ? new Array((item as unknown[]).length) : {}\n        out[index] = childResult\n        queue.enqueue({ node: item as object, result: childResult, path: itemPath })\n      }\n\n      continue\n    }\n\n    // Handle objects - create a new object with processed values\n    const out = result as Record<string, unknown>\n    for (const [key, value] of Object.entries(node)) {\n      const valuePath = `${path}/${escapeJsonPointer(key)}`\n\n      if (typeof value !== 'object' || value === null) {\n        out[key] = value\n        continue\n      }\n\n      const existingPath = cache.get(value as object)\n      if (existingPath !== undefined) {\n        out[key] = toRef(existingPath)\n        continue\n      }\n\n      cache.set(value as object, valuePath)\n\n      const childResult: unknown = Array.isArray(value) ? new Array((value as unknown[]).length) : {}\n      out[key] = childResult\n      queue.enqueue({ node: value as object, result: childResult, path: valuePath })\n    }\n  }\n\n  return rootResult as T\n}\n"],
+  "mappings": "AAAA,SAAS,yBAAyB;AAClC,SAAS,aAAa;AAmBf,MAAM,mBAAmB,CAAI,KAAQ,UAAiC,CAAC,MAAS;AACrF,QAAM,EAAE,SAAS,IAAI,QAAQ,oBAAI,QAAwB,EAAE,IAAI;AAE/D,QAAM,QAAQ,CAAC,UAA8B,EAAE,MAAM,IAAI,QAAQ,EAAE,GAAG;AAGtE,MAAI,OAAO,QAAQ,YAAY,QAAQ,MAAM;AAC3C,WAAO;AAAA,EACT;AAEA,QAAM,WAAW;AACjB,QAAM,IAAI,KAAe,QAAQ;AAEjC,QAAM,aAAsB,MAAM,QAAQ,GAAG,IAAI,IAAI,MAAO,IAAkB,MAAM,IAAI,CAAC;AAEzF,QAAM,QAAQ,IAAI,MAAuD;AACzE,QAAM,QAAQ,EAAE,MAAM,KAAe,QAAQ,YAAY,MAAM,SAAS,CAAC;AAEzE,SAAO,CAAC,MAAM,QAAQ,GAAG;AACvB,UAAM,QAAQ,MAAM,QAAQ;AAC5B,QAAI,CAAC,OAAO;AACV;AAAA,IACF;AAEA,UAAM,EAAE,MAAM,QAAQ,KAAK,IAAI;AAG/B,QAAI,MAAM,QAAQ,IAAI,GAAG;AACvB,YAAM,QAAQ;AACd,YAAMA,OAAM;AAEZ,eAAS,QAAQ,GAAG,QAAQ,MAAM,QAAQ,SAAS;AACjD,YAAI,EAAE,SAAS,QAAQ;AACrB;AAAA,QACF;AAEA,cAAM,OAAO,MAAM,KAAK;AACxB,cAAM,WAAW,GAAG,IAAI,IAAI,KAAK;AAEjC,YAAI,OAAO,SAAS,YAAY,SAAS,MAAM;AAC7C,UAAAA,KAAI,KAAK,IAAI;AACb;AAAA,QACF;AAEA,cAAM,eAAe,MAAM,IAAI,IAAc;AAC7C,YAAI,iBAAiB,QAAW;AAC9B,UAAAA,KAAI,KAAK,IAAI,MAAM,YAAY;AAC/B;AAAA,QACF;AAEA,cAAM,IAAI,MAAgB,QAAQ;AAElC,cAAM,cAAuB,MAAM,QAAQ,IAAI,IAAI,IAAI,MAAO,KAAmB,MAAM,IAAI,CAAC;AAC5F,QAAAA,KAAI,KAAK,IAAI;AACb,cAAM,QAAQ,EAAE,MAAM,MAAgB,QAAQ,aAAa,MAAM,SAAS,CAAC;AAAA,MAC7E;AAEA;AAAA,IACF;AAGA,UAAM,MAAM;AACZ,eAAW,CAAC,KAAK,KAAK,KAAK,OAAO,QAAQ,IAAI,GAAG;AAC/C,YAAM,YAAY,GAAG,IAAI,IAAI,kBAAkB,GAAG,CAAC;AAEnD,UAAI,OAAO,UAAU,YAAY,UAAU,MAAM;AAC/C,YAAI,GAAG,IAAI;AACX;AAAA,MACF;AAEA,YAAM,eAAe,MAAM,IAAI,KAAe;AAC9C,UAAI,iBAAiB,QAAW;AAC9B,YAAI,GAAG,IAAI,MAAM,YAAY;AAC7B;AAAA,MACF;AAEA,YAAM,IAAI,OAAiB,SAAS;AAEpC,YAAM,cAAuB,MAAM,QAAQ,KAAK,IAAI,IAAI,MAAO,MAAoB,MAAM,IAAI,CAAC;AAC9F,UAAI,GAAG,IAAI;AACX,YAAM,QAAQ,EAAE,MAAM,OAAiB,QAAQ,aAAa,MAAM,UAAU,CAAC;AAAA,IAC/E;AAAA,EACF;AAEA,SAAO;AACT;",
+  "names": ["out"]
+}

package/dist/queue/queue.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Represents a node in a singly linked list structure, used internally by the Queue.
+ *
+ * Example:
+ *   const node = new Node<number>(42);
+ *   console.log(node.data); // 42
+ *   console.log(node.next); // null
+ */
+export declare class Node<T> {
+    data: T;
+    next: Node<T> | null;
+    constructor(data: T);
+}
+/**
+ * A generic queue implementation using a singly linked list.
+ *
+ * Example usage:
+ *
+ *   const q = new Queue<number>();
+ *   q.enqueue(1);
+ *   q.enqueue(2);
+ *   q.enqueue(3);
+ *   console.log(q.dequeue()); // 1
+ *   console.log(q.peek());    // 2
+ *   console.log(q.getSize()); // 2
+ *   console.log(q.toString()); // "2 -> 3"
+ *   console.log(q.isEmpty()); // false
+ */
+export declare class Queue<T> {
+    front: Node<T> | null;
+    rear: Node<T> | null;
+    size: number;
+    constructor();
+    /**
+     * Adds an element to the end of the queue.
+     * @param data - The data to add to the queue.
+     */
+    enqueue(data: T): void;
+    /**
+     * Removes and returns the front element of the queue.
+     * @returns The data from the removed node, or null if the queue is empty.
+     */
+    dequeue(): T | null;
+    /**
+     * Returns the front element of the queue without removing it.
+     * @returns The front data, or null if the queue is empty.
+     */
+    peek(): T | null;
+    /**
+     * Checks whether the queue is empty.
+     * @returns True if the queue has no elements, false otherwise.
+     */
+    isEmpty(): boolean;
+    /**
+     * Returns the number of elements in the queue.
+     * @returns The size of the queue.
+     */
+    getSize(): number;
+    /**
+     * Returns a string representation of the queue.
+     * @returns Elements of the queue separated by ' -> '.
+     */
+    toString(): string;
+}
+//# sourceMappingURL=queue.d.ts.map

package/dist/queue/queue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue.d.ts","sourceRoot":"","sources":["../../src/queue/queue.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,qBAAa,IAAI,CAAC,CAAC;IACjB,IAAI,EAAE,CAAC,CAAA;IACP,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,CAAA;gBACR,IAAI,EAAE,CAAC;CAIpB;AAED;;;;;;;;;;;;;;GAcG;AAEH,qBAAa,KAAK,CAAC,CAAC;IAClB,KAAK,EAAE,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,CAAA;IACrB,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,CAAA;IACpB,IAAI,EAAE,MAAM,CAAA;;IAQZ;;;OAGG;IACH,OAAO,CAAC,IAAI,EAAE,CAAC;IAYf;;;OAGG;IACH,OAAO;IAaP;;;OAGG;IACH,IAAI;IAOJ;;;OAGG;IACH,OAAO;IAIP;;;OAGG;IACH,OAAO;IAIP;;;OAGG;IACH,QAAQ;CAST"}

package/dist/queue/queue.js

@@ -0,0 +1,91 @@
+class Node {
+  data;
+  next;
+  constructor(data) {
+    this.data = data;
+    this.next = null;
+  }
+}
+class Queue {
+  front;
+  rear;
+  size;
+  constructor() {
+    this.front = null;
+    this.rear = null;
+    this.size = 0;
+  }
+  /**
+   * Adds an element to the end of the queue.
+   * @param data - The data to add to the queue.
+   */
+  enqueue(data) {
+    const newNode = new Node(data);
+    if (this.isEmpty() || !this.rear) {
+      this.front = newNode;
+      this.rear = newNode;
+    } else {
+      this.rear.next = newNode;
+      this.rear = newNode;
+    }
+    this.size++;
+  }
+  /**
+   * Removes and returns the front element of the queue.
+   * @returns The data from the removed node, or null if the queue is empty.
+   */
+  dequeue() {
+    if (this.isEmpty() || !this.front) {
+      return null;
+    }
+    const removedNode = this.front;
+    this.front = this.front.next;
+    if (this.front === null) {
+      this.rear = null;
+    }
+    this.size--;
+    return removedNode.data;
+  }
+  /**
+   * Returns the front element of the queue without removing it.
+   * @returns The front data, or null if the queue is empty.
+   */
+  peek() {
+    if (this.isEmpty() || !this.front) {
+      return null;
+    }
+    return this.front.data;
+  }
+  /**
+   * Checks whether the queue is empty.
+   * @returns True if the queue has no elements, false otherwise.
+   */
+  isEmpty() {
+    return this.size === 0;
+  }
+  /**
+   * Returns the number of elements in the queue.
+   * @returns The size of the queue.
+   */
+  getSize() {
+    return this.size;
+  }
+  /**
+   * Returns a string representation of the queue.
+   * @returns Elements of the queue separated by ' -> '.
+   */
+  toString() {
+    let current = this.front;
+    const elements = [];
+    while (current) {
+      elements.push(current.data);
+      current = current.next;
+    }
+    return elements.join(" -> ");
+  }
+}
+export {
+  Node,
+  Queue
+};
+//# sourceMappingURL=queue.js.map

package/dist/queue/queue.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/queue/queue.ts"],
+  "sourcesContent": ["/**\n * Represents a node in a singly linked list structure, used internally by the Queue.\n *\n * Example:\n *   const node = new Node<number>(42);\n *   console.log(node.data); // 42\n *   console.log(node.next); // null\n */\nexport class Node<T> {\n  data: T\n  next: Node<T> | null\n  constructor(data: T) {\n    this.data = data\n    this.next = null\n  }\n}\n\n/**\n * A generic queue implementation using a singly linked list.\n *\n * Example usage:\n *\n *   const q = new Queue<number>();\n *   q.enqueue(1);\n *   q.enqueue(2);\n *   q.enqueue(3);\n *   console.log(q.dequeue()); // 1\n *   console.log(q.peek());    // 2\n *   console.log(q.getSize()); // 2\n *   console.log(q.toString()); // \"2 -> 3\"\n *   console.log(q.isEmpty()); // false\n */\n\nexport class Queue<T> {\n  front: Node<T> | null\n  rear: Node<T> | null\n  size: number\n\n  constructor() {\n    this.front = null\n    this.rear = null\n    this.size = 0\n  }\n\n  /**\n   * Adds an element to the end of the queue.\n   * @param data - The data to add to the queue.\n   */\n  enqueue(data: T) {\n    const newNode = new Node(data)\n    if (this.isEmpty() || !this.rear) {\n      this.front = newNode\n      this.rear = newNode\n    } else {\n      this.rear.next = newNode\n      this.rear = newNode\n    }\n    this.size++\n  }\n\n  /**\n   * Removes and returns the front element of the queue.\n   * @returns The data from the removed node, or null if the queue is empty.\n   */\n  dequeue() {\n    if (this.isEmpty() || !this.front) {\n      return null\n    }\n    const removedNode = this.front\n    this.front = this.front.next\n    if (this.front === null) {\n      this.rear = null\n    }\n    this.size--\n    return removedNode.data\n  }\n\n  /**\n   * Returns the front element of the queue without removing it.\n   * @returns The front data, or null if the queue is empty.\n   */\n  peek() {\n    if (this.isEmpty() || !this.front) {\n      return null\n    }\n    return this.front.data\n  }\n\n  /**\n   * Checks whether the queue is empty.\n   * @returns True if the queue has no elements, false otherwise.\n   */\n  isEmpty() {\n    return this.size === 0\n  }\n\n  /**\n   * Returns the number of elements in the queue.\n   * @returns The size of the queue.\n   */\n  getSize() {\n    return this.size\n  }\n\n  /**\n   * Returns a string representation of the queue.\n   * @returns Elements of the queue separated by ' -> '.\n   */\n  toString() {\n    let current = this.front\n    const elements = []\n    while (current) {\n      elements.push(current.data)\n      current = current.next\n    }\n    return elements.join(' -> ')\n  }\n}\n"],
+  "mappings": "AAQO,MAAM,KAAQ;AAAA,EACnB;AAAA,EACA;AAAA,EACA,YAAY,MAAS;AACnB,SAAK,OAAO;AACZ,SAAK,OAAO;AAAA,EACd;AACF;AAkBO,MAAM,MAAS;AAAA,EACpB;AAAA,EACA;AAAA,EACA;AAAA,EAEA,cAAc;AACZ,SAAK,QAAQ;AACb,SAAK,OAAO;AACZ,SAAK,OAAO;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,QAAQ,MAAS;AACf,UAAM,UAAU,IAAI,KAAK,IAAI;AAC7B,QAAI,KAAK,QAAQ,KAAK,CAAC,KAAK,MAAM;AAChC,WAAK,QAAQ;AACb,WAAK,OAAO;AAAA,IACd,OAAO;AACL,WAAK,KAAK,OAAO;AACjB,WAAK,OAAO;AAAA,IACd;AACA,SAAK;AAAA,EACP;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,UAAU;AACR,QAAI,KAAK,QAAQ,KAAK,CAAC,KAAK,OAAO;AACjC,aAAO;AAAA,IACT;AACA,UAAM,cAAc,KAAK;AACzB,SAAK,QAAQ,KAAK,MAAM;AACxB,QAAI,KAAK,UAAU,MAAM;AACvB,WAAK,OAAO;AAAA,IACd;AACA,SAAK;AACL,WAAO,YAAY;AAAA,EACrB;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,OAAO;AACL,QAAI,KAAK,QAAQ,KAAK,CAAC,KAAK,OAAO;AACjC,aAAO;AAAA,IACT;AACA,WAAO,KAAK,MAAM;AAAA,EACpB;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,UAAU;AACR,WAAO,KAAK,SAAS;AAAA,EACvB;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,UAAU;AACR,WAAO,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,WAAW;AACT,QAAI,UAAU,KAAK;AACnB,UAAM,WAAW,CAAC;AAClB,WAAO,SAAS;AACd,eAAS,KAAK,QAAQ,IAAI;AAC1B,gBAAU,QAAQ;AAAA,IACpB;AACA,WAAO,SAAS,KAAK,MAAM;AAAA,EAC7B;AACF;",
+  "names": []
+}

package/package.json

@@ -14,7 +14,7 @@
     "helpers",
     "js"
   ],
-  "version": "0.2.16",
+  "version": "0.2.18",
   "engines": {
     "node": ">=20"
   },
@@ -57,6 +57,11 @@
       "types": "./dist/http/*.d.ts",
       "default": "./dist/http/*.js"
     },
+    "./json/*": {
+      "import": "./dist/json/*.js",
+      "types": "./dist/json/*.d.ts",
+      "default": "./dist/json/*.js"
+    },
     "./node/*": {
       "import": "./dist/node/*.js",
       "types": "./dist/node/*.d.ts",

package/dist/object/circular-to-refs.d.ts

@@ -1,24 +0,0 @@
-/**
- * Detects and breaks circular JavaScript object references in an OpenAPI document tree.
- *
- * The legacy API client (via openapi-parser's dereference) resolved all $refs inline:
- * it deleted the $ref key and copied every property from the resolved target directly
- * onto the object. For self-referencing or mutually-referencing schemas this created
- * circular JS object graphs that cannot be serialized to JSON or validated by TypeBox.
- *
- * This function walks the object tree depth-first, detects cycles via reference identity,
- * extracts each circular component into the appropriate components section (schemas,
- * responses, parameters, etc.) with a generated name, and replaces ALL occurrences
- * (both first and back-references) with **only** `$ref` and any extra properties
- * (no extra schema properties) so that TypeBox's Value.Cast picks the reference branch
- * of the schemaOrReference union.
- *
- * Returns a new (deep-cloned) document with all cycles replaced. When no circular
- * references exist, the output is structurally identical to the input.
- *
- * @param document - The OpenAPI document to process
- * @param extraProps - Extra properties to add as siblings to the $ref (e.g., '$ref-value')
- * @returns A new document with circular references replaced by $ref pointers
- */
-export declare const circularToRefs: (document: Record<string, unknown>, extraProps?: Record<string, unknown>) => Record<string, unknown>;
-//# sourceMappingURL=circular-to-refs.d.ts.map

package/dist/object/circular-to-refs.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"circular-to-refs.d.ts","sourceRoot":"","sources":["../../src/object/circular-to-refs.ts"],"names":[],"mappings":"AAyFA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,cAAc,GACzB,UAAU,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACjC,aAAY,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,KACvC,MAAM,CAAC,MAAM,EAAE,OAAO,CAwWxB,CAAA"}

package/dist/object/circular-to-refs.js

@@ -1,290 +0,0 @@
-const COMPONENT_PREFIXES = {
-  schemas: "CircularSchema",
-  responses: "CircularResponse",
-  parameters: "CircularParameter",
-  examples: "CircularExample",
-  requestBodies: "CircularRequestBody",
-  headers: "CircularHeader",
-  securitySchemes: "CircularSecurityScheme",
-  links: "CircularLink",
-  callbacks: "CircularCallback",
-  pathItems: "CircularPathItem"
-};
-const COMPONENT_TYPES = Object.keys(COMPONENT_PREFIXES);
-const KEY_TO_CONTEXT = {
-  responses: "responses",
-  parameters: "parameters",
-  requestBody: "requestBodies",
-  headers: "headers",
-  examples: "examples",
-  links: "links",
-  callbacks: "callbacks",
-  securitySchemes: "securitySchemes",
-  schema: "schemas",
-  items: "schemas",
-  additionalProperties: "schemas",
-  allOf: "schemas",
-  oneOf: "schemas",
-  anyOf: "schemas",
-  not: "schemas",
-  properties: "schemas",
-  patternProperties: "schemas",
-  get: "pathItems",
-  put: "pathItems",
-  post: "pathItems",
-  delete: "pathItems",
-  options: "pathItems",
-  head: "pathItems",
-  patch: "pathItems",
-  trace: "pathItems"
-};
-const NON_REFERENCE_CONTAINER_KEYS = /* @__PURE__ */ new Set(["properties", "patternProperties", "responses"]);
-const getContextForKey = (key) => {
-  const context = KEY_TO_CONTEXT[key];
-  if (context !== void 0) {
-    return context;
-  }
-  if (key.includes("{$") || key.charCodeAt(0) === 47) {
-    return "pathItems";
-  }
-  return null;
-};
-const circularToRefs = (document, extraProps = {}) => {
-  const circularMeta = /* @__PURE__ */ new Map();
-  const objectContext = /* @__PURE__ */ new Map();
-  const existingComponentNames = /* @__PURE__ */ new Map();
-  const nonReferenceContainers = /* @__PURE__ */ new WeakSet();
-  const nonReferenceContainerInfo = /* @__PURE__ */ new WeakMap();
-  const counters = {
-    schemas: 0,
-    responses: 0,
-    parameters: 0,
-    examples: 0,
-    requestBodies: 0,
-    headers: 0,
-    securitySchemes: 0,
-    links: 0,
-    callbacks: 0,
-    pathItems: 0
-  };
-  const scanExistingComponents = (doc) => {
-    const components = doc.components;
-    if (!components) {
-      return;
-    }
-    for (const componentType of COMPONENT_TYPES) {
-      const section = components[componentType];
-      if (!section) {
-        continue;
-      }
-      for (const [name, value] of Object.entries(section)) {
-        if (value !== null && typeof value === "object") {
-          existingComponentNames.set(value, { type: componentType, name });
-        }
-      }
-    }
-  };
-  const identifyCircularObjects = (value, ancestors, context) => {
-    if (value === null || typeof value !== "object") {
-      return;
-    }
-    const obj = value;
-    if (ancestors.has(obj)) {
-      if (nonReferenceContainers.has(obj)) {
-        return;
-      }
-      if (!circularMeta.has(obj)) {
-        const existing = existingComponentNames.get(obj);
-        if (existing) {
-          circularMeta.set(obj, existing);
-        } else {
-          const componentType = objectContext.get(obj) ?? context;
-          const count = ++counters[componentType];
-          circularMeta.set(obj, {
-            type: componentType,
-            name: `${COMPONENT_PREFIXES[componentType]}${count}`
-          });
-        }
-      }
-      return;
-    }
-    if (!objectContext.has(obj)) {
-      objectContext.set(obj, context);
-    }
-    ancestors.add(obj);
-    if (Array.isArray(obj)) {
-      for (const item of obj) {
-        identifyCircularObjects(item, ancestors, context);
-      }
-    } else {
-      const record = obj;
-      for (const key of Object.keys(record)) {
-        const child = record[key];
-        if (NON_REFERENCE_CONTAINER_KEYS.has(key) && child !== null && typeof child === "object" && !Array.isArray(child)) {
-          nonReferenceContainers.add(child);
-          nonReferenceContainerInfo.set(child, {
-            key,
-            owner: obj
-          });
-        }
-        const newContext = getContextForKey(key) ?? context;
-        identifyCircularObjects(child, ancestors, newContext);
-      }
-    }
-    ancestors.delete(obj);
-  };
-  const extractedComponents = /* @__PURE__ */ new Map();
-  const hasExtraProps = Object.keys(extraProps).length > 0;
-  const createRefObject = (meta) => {
-    const ref = { $ref: `#/components/${meta.type}/${meta.name}` };
-    return hasExtraProps ? { ...ref, ...extraProps } : ref;
-  };
-  const getOrCreateExtractedSection = (type) => {
-    const existing = extractedComponents.get(type);
-    if (existing !== void 0) {
-      return existing;
-    }
-    const section = /* @__PURE__ */ new Map();
-    extractedComponents.set(type, section);
-    return section;
-  };
-  const ensureMeta = (obj, fallbackType) => {
-    const existingMeta = circularMeta.get(obj);
-    if (existingMeta !== void 0) {
-      return existingMeta;
-    }
-    const existingName = existingComponentNames.get(obj);
-    if (existingName !== void 0) {
-      circularMeta.set(obj, existingName);
-      return existingName;
-    }
-    const count = ++counters[fallbackType];
-    const meta = {
-      type: fallbackType,
-      name: `${COMPONENT_PREFIXES[fallbackType]}${count}`
-    };
-    circularMeta.set(obj, meta);
-    return meta;
-  };
-  const createLiftedRefForContainer = (container, clonedContainer) => {
-    const info = nonReferenceContainerInfo.get(container);
-    if (info === void 0) {
-      return void 0;
-    }
-    if (info.key === "properties" || info.key === "patternProperties") {
-      const meta = ensureMeta(info.owner, "schemas");
-      return createRefObject(meta);
-    }
-    const responses = container;
-    for (const [key, value] of Object.entries(responses)) {
-      if (value === null || typeof value !== "object" || value === container) {
-        continue;
-      }
-      const responseObject = value;
-      const meta = ensureMeta(responseObject, "responses");
-      if (!existingComponentNames.has(responseObject)) {
-        const section = getOrCreateExtractedSection(meta.type);
-        if (!section.has(meta.name)) {
-          const clonedValue = clonedContainer?.[key];
-          if (clonedValue !== void 0) {
-            section.set(meta.name, clonedValue);
-          }
-        }
-      }
-      return createRefObject(meta);
-    }
-    return void 0;
-  };
-  const cloneNode = (obj, visited, context) => {
-    return Array.isArray(obj) ? cloneArray(obj, visited, context) : cloneObject(obj, visited, context);
-  };
-  const cloneNodeWithVisitTracking = (obj, visited, context) => {
-    visited.add(obj);
-    const cloned = cloneNode(obj, visited, context);
-    visited.delete(obj);
-    return cloned;
-  };
-  const cloneWithRefs = (value, visited, context) => {
-    if (value === null || typeof value !== "object") {
-      return value;
-    }
-    const obj = value;
-    const meta = circularMeta.get(obj);
-    if (meta !== void 0) {
-      if (visited.has(obj)) {
-        return createRefObject(meta);
-      }
-      const cloned2 = cloneNodeWithVisitTracking(obj, visited, context);
-      if (existingComponentNames.has(obj)) {
-        return cloned2;
-      }
-      const section2 = getOrCreateExtractedSection(meta.type);
-      if (!section2.has(meta.name)) {
-        section2.set(meta.name, cloned2);
-      }
-      return createRefObject(meta);
-    }
-    if (visited.has(obj)) {
-      return void 0;
-    }
-    const cloned = cloneNodeWithVisitTracking(obj, visited, context);
-    const lateMeta = circularMeta.get(obj);
-    if (lateMeta === void 0 || existingComponentNames.has(obj)) {
-      return cloned;
-    }
-    const section = getOrCreateExtractedSection(lateMeta.type);
-    if (!section.has(lateMeta.name)) {
-      section.set(lateMeta.name, cloned);
-    }
-    return createRefObject(lateMeta);
-  };
-  const cloneArray = (arr, visited, context) => {
-    const result2 = [];
-    for (const item of arr) {
-      const clonedItem = cloneWithRefs(item, visited, context);
-      if (clonedItem !== void 0) {
-        result2.push(clonedItem);
-      }
-    }
-    return result2;
-  };
-  const cloneObject = (obj, visited, context) => {
-    const record = obj;
-    const result2 = {};
-    for (const key of Object.keys(record)) {
-      const newContext = getContextForKey(key) ?? context;
-      const value = record[key];
-      const clonedValue = cloneWithRefs(value, visited, newContext);
-      if (clonedValue !== void 0) {
-        result2[key] = clonedValue;
-        continue;
-      }
-      if (value === obj && nonReferenceContainers.has(obj)) {
-        const liftedRef = createLiftedRefForContainer(obj, result2);
-        if (liftedRef !== void 0) {
-          result2[key] = liftedRef;
-        }
-      }
-    }
-    return result2;
-  };
-  scanExistingComponents(document);
-  identifyCircularObjects(document, /* @__PURE__ */ new Set(), "schemas");
-  const result = cloneWithRefs(document, /* @__PURE__ */ new Set(), "schemas");
-  if (extractedComponents.size > 0) {
-    const components = result.components ?? {};
-    for (const [componentType, items] of extractedComponents) {
-      const section = components[componentType] ?? {};
-      for (const [name, component] of items) {
-        section[name] = component;
-      }
-      components[componentType] = section;
-    }
-    result.components = components;
-  }
-  return result;
-};
-export {
-  circularToRefs
-};
-//# sourceMappingURL=circular-to-refs.js.map

package/dist/object/circular-to-refs.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/object/circular-to-refs.ts"],
-  "sourcesContent": ["/**\n * OpenAPI component types that can contain circular references.\n * Each type maps to a section in `#/components/{type}`.\n */\nconst COMPONENT_PREFIXES = {\n  schemas: 'CircularSchema',\n  responses: 'CircularResponse',\n  parameters: 'CircularParameter',\n  examples: 'CircularExample',\n  requestBodies: 'CircularRequestBody',\n  headers: 'CircularHeader',\n  securitySchemes: 'CircularSecurityScheme',\n  links: 'CircularLink',\n  callbacks: 'CircularCallback',\n  pathItems: 'CircularPathItem',\n} as const\n\ntype ComponentType = keyof typeof COMPONENT_PREFIXES\nconst COMPONENT_TYPES = Object.keys(COMPONENT_PREFIXES) as ComponentType[]\n\n/**\n * Lookup table for OpenAPI keys that change the component context.\n * Using an object lookup is faster than a switch statement for many keys.\n */\nconst KEY_TO_CONTEXT: Readonly<Record<string, ComponentType>> = {\n  responses: 'responses',\n  parameters: 'parameters',\n  requestBody: 'requestBodies',\n  headers: 'headers',\n  examples: 'examples',\n  links: 'links',\n  callbacks: 'callbacks',\n  securitySchemes: 'securitySchemes',\n  schema: 'schemas',\n  items: 'schemas',\n  additionalProperties: 'schemas',\n  allOf: 'schemas',\n  oneOf: 'schemas',\n  anyOf: 'schemas',\n  not: 'schemas',\n  properties: 'schemas',\n  patternProperties: 'schemas',\n  get: 'pathItems',\n  put: 'pathItems',\n  post: 'pathItems',\n  delete: 'pathItems',\n  options: 'pathItems',\n  head: 'pathItems',\n  patch: 'pathItems',\n  trace: 'pathItems',\n}\n\n/**\n * These container objects must remain maps in OpenAPI and cannot be replaced by a Reference Object.\n * When a cycle points to one of these containers, we lift the ref to a legal parent object.\n */\nconst NON_REFERENCE_CONTAINER_KEYS = new Set(['properties', 'patternProperties', 'responses'])\n\n/**\n * Determines the component context for a given OpenAPI key.\n * Returns the appropriate ComponentType or null to inherit parent context.\n */\nconst getContextForKey = (key: string): ComponentType | null => {\n  // Fast path: direct lookup for known keys\n  const context = KEY_TO_CONTEXT[key]\n  if (context !== undefined) {\n    return context\n  }\n\n  // Callback path expressions (keys containing '{$') or path templates have pathItem values\n  if (key.includes('{$') || key.charCodeAt(0) === 47 /* '/' */) {\n    return 'pathItems'\n  }\n\n  // No context change \u2014 inherit from parent\n  return null\n}\n\n/** Metadata about a circular object: its component type and generated name */\ntype CircularMeta = {\n  readonly type: ComponentType\n  readonly name: string\n}\n\ntype NonReferenceContainerInfo = {\n  readonly key: 'properties' | 'patternProperties' | 'responses'\n  readonly owner: object\n}\n\n/**\n * Detects and breaks circular JavaScript object references in an OpenAPI document tree.\n *\n * The legacy API client (via openapi-parser's dereference) resolved all $refs inline:\n * it deleted the $ref key and copied every property from the resolved target directly\n * onto the object. For self-referencing or mutually-referencing schemas this created\n * circular JS object graphs that cannot be serialized to JSON or validated by TypeBox.\n *\n * This function walks the object tree depth-first, detects cycles via reference identity,\n * extracts each circular component into the appropriate components section (schemas,\n * responses, parameters, etc.) with a generated name, and replaces ALL occurrences\n * (both first and back-references) with **only** `$ref` and any extra properties\n * (no extra schema properties) so that TypeBox's Value.Cast picks the reference branch\n * of the schemaOrReference union.\n *\n * Returns a new (deep-cloned) document with all cycles replaced. When no circular\n * references exist, the output is structurally identical to the input.\n *\n * @param document - The OpenAPI document to process\n * @param extraProps - Extra properties to add as siblings to the $ref (e.g., '$ref-value')\n * @returns A new document with circular references replaced by $ref pointers\n */\nexport const circularToRefs = (\n  document: Record<string, unknown>,\n  extraProps: Record<string, unknown> = {},\n): Record<string, unknown> => {\n  /**\n   * Phase 1 structures:\n   * - circularMeta: Maps circular objects to their component type and generated name\n   * - objectContext: Records the context when an object is first encountered\n   * - existingComponentNames: Maps objects to their existing component names (if in components section)\n   * - counters: Tracks unique naming counters per component type\n   */\n  const circularMeta = new Map<object, CircularMeta>()\n  const objectContext = new Map<object, ComponentType>()\n  const existingComponentNames = new Map<object, { type: ComponentType; name: string }>()\n  const nonReferenceContainers = new WeakSet<object>()\n  const nonReferenceContainerInfo = new WeakMap<object, NonReferenceContainerInfo>()\n  const counters: Record<ComponentType, number> = {\n    schemas: 0,\n    responses: 0,\n    parameters: 0,\n    examples: 0,\n    requestBodies: 0,\n    headers: 0,\n    securitySchemes: 0,\n    links: 0,\n    callbacks: 0,\n    pathItems: 0,\n  }\n\n  /**\n   * Pre-scan: Map existing components to their names.\n   * This allows us to reference existing schemas instead of creating duplicates.\n   */\n  const scanExistingComponents = (doc: Record<string, unknown>): void => {\n    const components = doc.components as Record<string, unknown> | undefined\n    if (!components) {\n      return\n    }\n\n    for (const componentType of COMPONENT_TYPES) {\n      const section = components[componentType] as Record<string, unknown> | undefined\n      if (!section) {\n        continue\n      }\n\n      for (const [name, value] of Object.entries(section)) {\n        if (value !== null && typeof value === 'object') {\n          existingComponentNames.set(value as object, { type: componentType, name })\n        }\n      }\n    }\n  }\n\n  /**\n   * Phase 1: Identify all circular objects in the tree.\n   *\n   * We traverse depth-first, tracking ancestors in the current path. When we\n   * encounter an object already in the ancestor set, we've found a cycle.\n   * We record the circular object with its context and a generated name.\n   *\n   * @param value - Current value being traversed\n   * @param ancestors - Set of objects in the current traversal path\n   * @param context - Current OpenAPI component context\n   */\n  const identifyCircularObjects = (value: unknown, ancestors: Set<object>, context: ComponentType): void => {\n    // Primitives and null cannot be circular\n    if (value === null || typeof value !== 'object') {\n      return\n    }\n\n    const obj = value as object\n\n    // Cycle detected: this object is already in our ancestor chain\n    if (ancestors.has(obj)) {\n      // Keep container maps as maps; we will lift refs on their entries during cloning.\n      if (nonReferenceContainers.has(obj)) {\n        return\n      }\n\n      // Only register once \u2014 use existing name if available, otherwise generate new one\n      if (!circularMeta.has(obj)) {\n        const existing = existingComponentNames.get(obj)\n        if (existing) {\n          // Use the existing component name\n          circularMeta.set(obj, existing)\n        } else {\n          // Generate a new name\n          const componentType = objectContext.get(obj) ?? context\n          const count = ++counters[componentType]\n          circularMeta.set(obj, {\n            type: componentType,\n            name: `${COMPONENT_PREFIXES[componentType]}${count}`,\n          })\n        }\n      }\n      return\n    }\n\n    // Record context on first encounter for accurate categorization\n    if (!objectContext.has(obj)) {\n      objectContext.set(obj, context)\n    }\n\n    // Add to ancestor chain and recurse\n    ancestors.add(obj)\n\n    if (Array.isArray(obj)) {\n      for (const item of obj) {\n        identifyCircularObjects(item, ancestors, context)\n      }\n    } else {\n      // Objects: check each property, updating context as needed\n      const record = obj as Record<string, unknown>\n      for (const key of Object.keys(record)) {\n        const child = record[key]\n        if (\n          NON_REFERENCE_CONTAINER_KEYS.has(key) &&\n          child !== null &&\n          typeof child === 'object' &&\n          !Array.isArray(child)\n        ) {\n          nonReferenceContainers.add(child as object)\n          nonReferenceContainerInfo.set(child as object, {\n            key: key as NonReferenceContainerInfo['key'],\n            owner: obj,\n          })\n        }\n\n        const newContext = getContextForKey(key) ?? context\n        identifyCircularObjects(child, ancestors, newContext)\n      }\n    }\n\n    // Remove from ancestor chain when backtracking\n    ancestors.delete(obj)\n  }\n\n  /** Stores processed (cycle-free) definitions by type and name */\n  const extractedComponents = new Map<ComponentType, Map<string, unknown>>()\n\n  /** Precompute whether we have extra props to avoid repeated Object.keys calls */\n  const hasExtraProps = Object.keys(extraProps).length > 0\n\n  /** Creates a $ref object pointing to the extracted component */\n  const createRefObject = (meta: CircularMeta): Record<string, unknown> => {\n    const ref = { $ref: `#/components/${meta.type}/${meta.name}` }\n    return hasExtraProps ? { ...ref, ...extraProps } : ref\n  }\n\n  /** Gets or creates the target section for extracted components. */\n  const getOrCreateExtractedSection = (type: ComponentType): Map<string, unknown> => {\n    const existing = extractedComponents.get(type)\n    if (existing !== undefined) {\n      return existing\n    }\n\n    const section = new Map<string, unknown>()\n    extractedComponents.set(type, section)\n    return section\n  }\n\n  /** Ensures an object has component metadata so it can be referenced legally. */\n  const ensureMeta = (obj: object, fallbackType: ComponentType): CircularMeta => {\n    const existingMeta = circularMeta.get(obj)\n    if (existingMeta !== undefined) {\n      return existingMeta\n    }\n\n    const existingName = existingComponentNames.get(obj)\n    if (existingName !== undefined) {\n      circularMeta.set(obj, existingName)\n      return existingName\n    }\n\n    const count = ++counters[fallbackType]\n    const meta: CircularMeta = {\n      type: fallbackType,\n      name: `${COMPONENT_PREFIXES[fallbackType]}${count}`,\n    }\n    circularMeta.set(obj, meta)\n    return meta\n  }\n\n  /** Lifts illegal container self-cycles to a legal reference target. */\n  const createLiftedRefForContainer = (\n    container: object,\n    clonedContainer?: Record<string, unknown>,\n  ): Record<string, unknown> | undefined => {\n    const info = nonReferenceContainerInfo.get(container)\n    if (info === undefined) {\n      return undefined\n    }\n\n    if (info.key === 'properties' || info.key === 'patternProperties') {\n      const meta = ensureMeta(info.owner, 'schemas')\n      return createRefObject(meta)\n    }\n\n    // responses map values must be Response Object or Reference Object.\n    // Lift self-cycle to the first concrete response entry.\n    const responses = container as Record<string, unknown>\n    for (const [key, value] of Object.entries(responses)) {\n      if (value === null || typeof value !== 'object' || value === container) {\n        continue\n      }\n\n      const responseObject = value as object\n      const meta = ensureMeta(responseObject, 'responses')\n      if (!existingComponentNames.has(responseObject)) {\n        const section = getOrCreateExtractedSection(meta.type)\n        if (!section.has(meta.name)) {\n          const clonedValue = clonedContainer?.[key]\n          if (clonedValue !== undefined) {\n            section.set(meta.name, clonedValue)\n          }\n        }\n      }\n\n      return createRefObject(meta)\n    }\n\n    return undefined\n  }\n\n  const cloneNode = (obj: object, visited: Set<object>, context: ComponentType): unknown => {\n    return Array.isArray(obj) ? cloneArray(obj, visited, context) : cloneObject(obj, visited, context)\n  }\n\n  const cloneNodeWithVisitTracking = (obj: object, visited: Set<object>, context: ComponentType): unknown => {\n    // Keep visit bookkeeping in one place so all clone paths handle cycles consistently.\n    visited.add(obj)\n    const cloned = cloneNode(obj, visited, context)\n    visited.delete(obj)\n    return cloned\n  }\n\n  /**\n   * Phase 2: Create a deep clone with circular references replaced by $refs.\n   * For circular objects, we extract to components and return $ref.\n   * For non-circular objects, we simply deep clone.\n   */\n  const cloneWithRefs = (value: unknown, visited: Set<object>, context: ComponentType): unknown => {\n    if (value === null || typeof value !== 'object') {\n      return value\n    }\n\n    const obj = value as object\n    const meta = circularMeta.get(obj)\n\n    // If this is a circular object and we're already visiting it, return a $ref to break the cycle\n    if (meta !== undefined) {\n      if (visited.has(obj)) {\n        return createRefObject(meta)\n      }\n\n      const cloned = cloneNodeWithVisitTracking(obj, visited, context)\n      if (existingComponentNames.has(obj)) {\n        // Do not extract \u2014 it already exists in components.\n        // Just clone it in place and replace circular back-references with $ref.\n        return cloned\n      }\n\n      const section = getOrCreateExtractedSection(meta.type)\n      if (!section.has(meta.name)) {\n        // Store the extracted clone once; later occurrences can directly return a $ref.\n        section.set(meta.name, cloned)\n      }\n\n      return createRefObject(meta)\n    }\n\n    // Non-circular object: track traversal path to handle cycles that are intentionally\n    // not extracted (for container maps where we lift refs to legal targets).\n    if (visited.has(obj)) {\n      return undefined\n    }\n\n    const cloned = cloneNodeWithVisitTracking(obj, visited, context)\n\n    // This object may become referenceable while cloning children (e.g. lifting\n    // a container self-cycle to the parent object). If so, extract it now.\n    const lateMeta = circularMeta.get(obj)\n    if (lateMeta === undefined || existingComponentNames.has(obj)) {\n      // Existing components keep their inline structure, but still have back-refs normalized.\n      return cloned\n    }\n\n    const section = getOrCreateExtractedSection(lateMeta.type)\n    if (!section.has(lateMeta.name)) {\n      section.set(lateMeta.name, cloned)\n    }\n\n    return createRefObject(lateMeta)\n  }\n\n  /**\n   * Clones an array, recursively processing each element.\n   */\n  const cloneArray = (arr: unknown[], visited: Set<object>, context: ComponentType): unknown[] => {\n    const result: unknown[] = []\n    for (const item of arr) {\n      const clonedItem = cloneWithRefs(item, visited, context)\n      if (clonedItem !== undefined) {\n        result.push(clonedItem)\n      }\n    }\n    return result\n  }\n\n  /**\n   * Clones an object, recursively processing each property.\n   * Updates context based on property keys.\n   */\n  const cloneObject = (obj: object, visited: Set<object>, context: ComponentType): Record<string, unknown> => {\n    const record = obj as Record<string, unknown>\n    const result: Record<string, unknown> = {}\n\n    for (const key of Object.keys(record)) {\n      const newContext = getContextForKey(key) ?? context\n      const value = record[key]\n      const clonedValue = cloneWithRefs(value, visited, newContext)\n      if (clonedValue !== undefined) {\n        result[key] = clonedValue\n        continue\n      }\n\n      // If a value loops back to its parent container map, lift to a legal reference target.\n      if (value === obj && nonReferenceContainers.has(obj)) {\n        const liftedRef = createLiftedRefForContainer(obj, result)\n        if (liftedRef !== undefined) {\n          result[key] = liftedRef\n        }\n      }\n    }\n\n    return result\n  }\n\n  // Execute Pre-scan: map existing components\n  scanExistingComponents(document)\n\n  // Execute Phase 1: identify all circular objects\n  identifyCircularObjects(document, new Set(), 'schemas')\n\n  // Execute Phase 2: clone with refs\n  const result = cloneWithRefs(document, new Set(), 'schemas') as Record<string, unknown>\n\n  // Inject extracted components into the result document\n  if (extractedComponents.size > 0) {\n    const components = (result.components ?? {}) as Record<string, unknown>\n\n    for (const [componentType, items] of extractedComponents) {\n      const section = (components[componentType] ?? {}) as Record<string, unknown>\n      for (const [name, component] of items) {\n        section[name] = component\n      }\n      components[componentType] = section\n    }\n\n    result.components = components\n  }\n\n  return result\n}\n"],
-  "mappings": "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",
-  "names": ["cloned", "section", "result"]
-}