@scalar/openapi-parser 0.11.1 → 0.13.0

package/dist/utils/openapi/openapi.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"openapi.d.ts","sourceRoot":"","sources":["../../../src/utils/openapi/openapi.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,cAAc,EAAS,MAAM,mBAAmB,CAAA;AACtF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAG/C;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,aAAa,CAAC,EAAE,cAAc;kBASpC,sBAAsB,YAAY,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE9D"}

package/dist/utils/openapi/openapi.js

@@ -1,15 +0,0 @@
-import { loadCommand } from "./commands/loadCommand.js";
-function openapi(globalOptions) {
-  const queue = {
-    input: null,
-    options: globalOptions,
-    tasks: []
-  };
-  return {
-    load: (input, options) => loadCommand(queue, input, options)
-  };
-}
-export {
-  openapi
-};
-//# sourceMappingURL=openapi.js.map

package/dist/utils/openapi/openapi.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/utils/openapi/openapi.ts"],
-  "sourcesContent": ["import type { AnyApiDefinitionFormat, OpenApiOptions, Queue } from '../../types/index'\nimport type { LoadOptions } from '../load/load'\nimport { loadCommand } from './commands/loadCommand'\n\n/**\n * Creates a fluent OpenAPI pipeline\n *\n * @deprecated We are about to drop the pipeline syntax. Use the individual utilities instead.\n */\nexport function openapi(globalOptions?: OpenApiOptions) {\n  // Create a new queue\n  const queue = {\n    input: null,\n    options: globalOptions,\n    tasks: [],\n  } as Queue<[]>\n\n  return {\n    load: (input: AnyApiDefinitionFormat, options?: LoadOptions) => loadCommand(queue, input, options),\n  }\n}\n"],
-  "mappings": "AAEA,SAAS,mBAAmB;AAOrB,SAAS,QAAQ,eAAgC;AAEtD,QAAM,QAAQ;AAAA,IACZ,OAAO;AAAA,IACP,SAAS;AAAA,IACT,OAAO,CAAC;AAAA,EACV;AAEA,SAAO;AAAA,IACL,MAAM,CAAC,OAA+B,YAA0B,YAAY,OAAO,OAAO,OAAO;AAAA,EACnG;AACF;",
-  "names": []
-}

package/dist/utils/openapi/openapi.test-d.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=openapi.test-d.d.ts.map

package/dist/utils/openapi/openapi.test-d.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"openapi.test-d.d.ts","sourceRoot":"","sources":["../../../src/utils/openapi/openapi.test-d.ts"],"names":[],"mappings":""}

package/dist/utils/openapi/openapi.test-d.js

@@ -1,14 +0,0 @@
-import { describe, expectTypeOf, it } from "vitest";
-import { openapi } from "./openapi.js";
-describe("openapi", () => {
-  it("returns the correct type for load()", async () => {
-    const result = await openapi().load({}).get();
-    expectTypeOf(result.filesystem).toMatchTypeOf();
-    expectTypeOf(result.valid).toMatchTypeOf();
-  });
-  it("returns the correct type for validate()", async () => {
-    const result = await openapi().load({}).validate().get();
-    expectTypeOf(result.valid).toMatchTypeOf();
-  });
-});
-//# sourceMappingURL=openapi.test-d.js.map

package/dist/utils/openapi/openapi.test-d.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/utils/openapi/openapi.test-d.ts"],
-  "sourcesContent": ["import { describe, expectTypeOf, it } from 'vitest'\n\nimport type { Filesystem } from '../../types/index'\nimport { openapi } from './openapi'\n\ndescribe('openapi', () => {\n  it('returns the correct type for load()', async () => {\n    const result = await openapi().load({}).get()\n\n    expectTypeOf(result.filesystem).toMatchTypeOf<Filesystem>()\n\n    // @ts-expect-error `valid` should be undefined\n    expectTypeOf(result.valid).toMatchTypeOf<boolean>()\n  })\n\n  it('returns the correct type for validate()', async () => {\n    const result = await openapi().load({}).validate().get()\n\n    expectTypeOf(result.valid).toMatchTypeOf<boolean>()\n  })\n})\n"],
-  "mappings": "AAAA,SAAS,UAAU,cAAc,UAAU;AAG3C,SAAS,eAAe;AAExB,SAAS,WAAW,MAAM;AACxB,KAAG,uCAAuC,YAAY;AACpD,UAAM,SAAS,MAAM,QAAQ,EAAE,KAAK,CAAC,CAAC,EAAE,IAAI;AAE5C,iBAAa,OAAO,UAAU,EAAE,cAA0B;AAG1D,iBAAa,OAAO,KAAK,EAAE,cAAuB;AAAA,EACpD,CAAC;AAED,KAAG,2CAA2C,YAAY;AACxD,UAAM,SAAS,MAAM,QAAQ,EAAE,KAAK,CAAC,CAAC,EAAE,SAAS,EAAE,IAAI;AAEvD,iBAAa,OAAO,KAAK,EAAE,cAAuB;AAAA,EACpD,CAAC;AACH,CAAC;",
-  "names": []
-}

package/dist/utils/openapi/openapi.test.js

@@ -1,309 +0,0 @@
-import { join } from "node:path";
-import { describe, expect, it } from "vitest";
-import { stringify } from "yaml";
-import { readFiles } from "../../plugins/read-files/readFiles.js";
-import { openapi } from "./openapi.js";
-const example = {
-  openapi: "3.1.0",
-  info: {
-    title: "Hello World",
-    version: "1.0.0"
-  },
-  paths: {}
-};
-const EXAMPLE_FILE = join(new URL(import.meta.url).pathname, "../../examples/openapi.yaml");
-describe("pipeline", () => {
-  it("load object", async () => {
-    const { specification } = await openapi().load(example).get();
-    expect(specification.openapi).toBe("3.1.0");
-  });
-  it("load string", async () => {
-    const { specification } = await openapi().load(JSON.stringify(example)).get();
-    expect(specification.openapi).toBe("3.1.0");
-  });
-  it("load file", async () => {
-    const { specification } = await openapi().load(EXAMPLE_FILE, {
-      plugins: [readFiles()]
-    }).get();
-    expect(specification.openapi).toBe("3.1.0");
-  });
-  it("load file + validate", async () => {
-    const { specification } = await openapi().load(EXAMPLE_FILE, {
-      plugins: [readFiles()]
-    }).validate().get();
-    expect(specification.openapi).toBe("3.1.0");
-  });
-  it("files", async () => {
-    const filesystem = await openapi().load(EXAMPLE_FILE, {
-      plugins: [readFiles()]
-    }).files();
-    expect(filesystem).toMatchObject([
-      {
-        isEntrypoint: true,
-        specification: {
-          openapi: "3.1.0",
-          info: {
-            title: "Hello World",
-            version: "1.0.0"
-          },
-          paths: {}
-        },
-        filename: null,
-        references: []
-      }
-    ]);
-  });
-  it("upgrade from 3.0 to 3.1", async () => {
-    const { specification } = await openapi().load({
-      ...example,
-      openapi: "3.0.0"
-    }).upgrade().get();
-    expect(specification.openapi).toBe("3.1.1");
-  });
-  it("details", async () => {
-    const { version } = await openapi().load({
-      ...example,
-      openapi: "3.0.0"
-    }).details();
-    expect(version).toBe("3.0");
-  });
-  it("upgrade > dereference", async () => {
-    const { version } = await openapi().load({
-      ...example,
-      openapi: "3.0.0"
-    }).upgrade().dereference().get();
-    expect(version).toBe("3.1");
-  });
-  it("filter x-internal", async () => {
-    const otherExample = {
-      openapi: "3.1.0",
-      info: {
-        title: "Hello World",
-        version: "1.0.0"
-      },
-      paths: {
-        "/": {
-          get: {
-            "x-internal": true,
-            "responses": {
-              200: {
-                description: "OK"
-              }
-            }
-          }
-        },
-        "/foobar": {
-          get: {
-            responses: {
-              200: {
-                description: "OK"
-              }
-            }
-          }
-        }
-      }
-    };
-    const { specification } = await openapi().load(otherExample).filter((schema) => !schema?.["x-internal"]).get();
-    expect(specification.paths["/"].get).toBeUndefined();
-    expect(specification.paths["/foobar"].get).not.toBeUndefined();
-  });
-  it("filter tags", async () => {
-    const otherExample = {
-      openapi: "3.1.0",
-      info: {
-        title: "Hello World",
-        version: "1.0.0"
-      },
-      paths: {
-        "/": {
-          get: {
-            tags: ["Beta"],
-            responses: {
-              200: {
-                description: "OK"
-              }
-            }
-          }
-        },
-        "/foobar": {
-          get: {
-            responses: {
-              200: {
-                description: "OK"
-              }
-            }
-          }
-        }
-      }
-    };
-    const { specification } = await openapi().load(otherExample).filter((schema) => !schema?.tags?.includes("Beta")).get();
-    expect(specification.paths["/"].get).toBeUndefined();
-    expect(specification.paths["/foobar"].get).not.toBeUndefined();
-  });
-  it("upgrade > filter", async () => {
-    const otherExample = JSON.stringify({
-      openapi: "3.0.0",
-      info: {
-        title: "Hello World",
-        version: "1.0.0"
-      },
-      paths: {
-        "/": {
-          get: {
-            tags: ["Beta"],
-            responses: {
-              200: {
-                description: "OK"
-              }
-            }
-          }
-        },
-        "/foobar": {
-          get: {
-            responses: {
-              200: {
-                description: "OK"
-              }
-            }
-          }
-        }
-      }
-    });
-    const { specification } = await openapi().load(otherExample).upgrade().filter((schema) => !schema?.tags?.includes("Beta")).get();
-    expect(specification.openapi).toBe("3.1.1");
-    expect(specification.paths["/"].get).toBeUndefined();
-    expect(specification.paths["/foobar"].get).not.toBeUndefined();
-  });
-  it("validate", async () => {
-    const result = await openapi().load(example).validate().get();
-    expect(result).toMatchObject({
-      valid: true,
-      version: "3.1"
-    });
-  });
-  it("toJson", async () => {
-    const result = await openapi().load(example).toJson();
-    expect(result).toBe(JSON.stringify(example, null, 2));
-  });
-  it("toYaml", async () => {
-    const result = await openapi().load(example).toYaml();
-    expect(result).toBe(stringify(example));
-  });
-  it("dereference", async () => {
-    const result = await openapi().load(example).dereference().get();
-    expect(result.schema.info.title).toBe("Hello World");
-  });
-  it("validate > dereference", async () => {
-    const result = await openapi().load(example).validate().dereference().get();
-    expect(result.valid).toBe(true);
-    expect(result.errors).toStrictEqual([]);
-    expect(result.schema.info.title).toBe("Hello World");
-  });
-  it("throws an error when dereference fails (global)", async () => {
-    expect(async () => {
-      await openapi({
-        throwOnError: true
-      }).load({
-        openapi: "3.1.0",
-        info: {},
-        paths: {
-          "/foobar": {
-            post: {
-              requestBody: {
-                $ref: "#/components/requestBodies/DoesNotExist"
-              }
-            }
-          }
-        }
-      }).dereference().get();
-    }).rejects.toThrowError("Can\u2019t resolve reference: #/components/requestBodies/DoesNotExist");
-  });
-  it("throws an error when dereference fails (only dereference)", async () => {
-    expect(async () => {
-      await openapi().load({
-        openapi: "3.1.0",
-        info: {},
-        paths: {
-          "/foobar": {
-            post: {
-              requestBody: {
-                $ref: "#/components/requestBodies/DoesNotExist"
-              }
-            }
-          }
-        }
-      }).dereference({
-        throwOnError: true
-      }).get();
-    }).rejects.toThrowError("Can\u2019t resolve reference: #/components/requestBodies/DoesNotExist");
-  });
-  it("throws an error when validate fails (global)", async () => {
-    expect(async () => {
-      await openapi({
-        throwOnError: true
-      }).load({
-        openapi: "3.1.0",
-        info: {
-          title: "Hello World"
-        },
-        paths: {
-          "/foobar": {
-            post: {
-              requestBody: {
-                $ref: "#/components/requestBodies/DoesNotExist"
-              }
-            }
-          }
-        }
-      }).validate().get();
-    }).rejects.toThrowError("Can\u2019t resolve reference: #/components/requestBodies/DoesNotExist");
-  });
-  it("throws an error when validate fails (only validate)", async () => {
-    expect(async () => {
-      await openapi().load({
-        openapi: "3.1.0",
-        info: {
-          title: "Hello World"
-        },
-        paths: {
-          "/foobar": {
-            post: {
-              requestBody: {
-                $ref: "#/components/requestBodies/DoesNotExist"
-              }
-            }
-          }
-        }
-      }).validate({
-        throwOnError: true
-      }).get();
-    }).rejects.toThrowError("Can\u2019t resolve reference: #/components/requestBodies/DoesNotExist");
-  });
-  it("works with then & catch", async () => {
-    return new Promise((resolve, reject) => {
-      openapi().load({
-        openapi: "3.1.0",
-        info: {
-          title: "Hello World"
-        },
-        paths: {
-          "/foobar": {
-            post: {
-              requestBody: {
-                $ref: "#/components/requestBodies/DoesNotExist"
-              }
-            }
-          }
-        }
-      }).validate({
-        throwOnError: true
-      }).get().then(() => {
-        reject();
-      }).catch((error) => {
-        expect(error.message).toBe("Can\u2019t resolve reference: #/components/requestBodies/DoesNotExist");
-        resolve(null);
-      });
-    });
-  });
-});
-//# sourceMappingURL=openapi.test.js.map

package/dist/utils/openapi/openapi.test.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/utils/openapi/openapi.test.ts"],
-  "sourcesContent": ["import { join } from 'node:path'\nimport { describe, expect, it } from 'vitest'\nimport { stringify } from 'yaml'\n\nimport { readFiles } from '../../plugins/read-files/readFiles'\nimport { openapi } from './openapi'\n\nconst example = {\n  openapi: '3.1.0',\n  info: {\n    title: 'Hello World',\n    version: '1.0.0',\n  },\n  paths: {},\n}\n\nconst EXAMPLE_FILE = join(new URL(import.meta.url).pathname, '../../examples/openapi.yaml')\n\ndescribe('pipeline', () => {\n  it('load object', async () => {\n    const { specification } = await openapi().load(example).get()\n\n    expect(specification.openapi).toBe('3.1.0')\n  })\n\n  it('load string', async () => {\n    const { specification } = await openapi().load(JSON.stringify(example)).get()\n\n    expect(specification.openapi).toBe('3.1.0')\n  })\n\n  it('load file', async () => {\n    const { specification } = await openapi()\n      .load(EXAMPLE_FILE, {\n        plugins: [readFiles()],\n      })\n      .get()\n\n    expect(specification.openapi).toBe('3.1.0')\n  })\n\n  it('load file + validate', async () => {\n    const { specification } = await openapi()\n      .load(EXAMPLE_FILE, {\n        plugins: [readFiles()],\n      })\n      .validate()\n      .get()\n\n    expect(specification.openapi).toBe('3.1.0')\n  })\n\n  it('files', async () => {\n    const filesystem = await openapi()\n      .load(EXAMPLE_FILE, {\n        plugins: [readFiles()],\n      })\n      .files()\n\n    expect(filesystem).toMatchObject([\n      {\n        isEntrypoint: true,\n        specification: {\n          openapi: '3.1.0',\n          info: {\n            title: 'Hello World',\n            version: '1.0.0',\n          },\n          paths: {},\n        },\n        filename: null,\n        references: [],\n      },\n    ])\n  })\n\n  it('upgrade from 3.0 to 3.1', async () => {\n    const { specification } = await openapi()\n      .load({\n        ...example,\n        openapi: '3.0.0',\n      })\n      .upgrade()\n      .get()\n\n    expect(specification.openapi).toBe('3.1.1')\n  })\n\n  it('details', async () => {\n    const { version } = await openapi()\n      .load({\n        ...example,\n        openapi: '3.0.0',\n      })\n      .details()\n\n    expect(version).toBe('3.0')\n  })\n\n  it('upgrade > dereference', async () => {\n    const { version } = await openapi()\n      .load({\n        ...example,\n        openapi: '3.0.0',\n      })\n      .upgrade()\n      .dereference()\n      .get()\n\n    expect(version).toBe('3.1')\n  })\n\n  it('filter x-internal', async () => {\n    const otherExample = {\n      openapi: '3.1.0',\n      info: {\n        title: 'Hello World',\n        version: '1.0.0',\n      },\n      paths: {\n        '/': {\n          get: {\n            'x-internal': true,\n            'responses': {\n              200: {\n                description: 'OK',\n              },\n            },\n          },\n        },\n        '/foobar': {\n          get: {\n            responses: {\n              200: {\n                description: 'OK',\n              },\n            },\n          },\n        },\n      },\n    }\n\n    const { specification } = await openapi()\n      .load(otherExample)\n      .filter((schema) => !schema?.['x-internal'])\n      .get()\n\n    expect(specification.paths['/'].get).toBeUndefined()\n    expect(specification.paths['/foobar'].get).not.toBeUndefined()\n  })\n\n  it('filter tags', async () => {\n    const otherExample = {\n      openapi: '3.1.0',\n      info: {\n        title: 'Hello World',\n        version: '1.0.0',\n      },\n      paths: {\n        '/': {\n          get: {\n            tags: ['Beta'],\n            responses: {\n              200: {\n                description: 'OK',\n              },\n            },\n          },\n        },\n        '/foobar': {\n          get: {\n            responses: {\n              200: {\n                description: 'OK',\n              },\n            },\n          },\n        },\n      },\n    }\n\n    const { specification } = await openapi()\n      .load(otherExample)\n      .filter((schema) => !schema?.tags?.includes('Beta'))\n      .get()\n\n    expect(specification.paths['/'].get).toBeUndefined()\n    expect(specification.paths['/foobar'].get).not.toBeUndefined()\n  })\n\n  it('upgrade > filter', async () => {\n    const otherExample = JSON.stringify({\n      openapi: '3.0.0',\n      info: {\n        title: 'Hello World',\n        version: '1.0.0',\n      },\n      paths: {\n        '/': {\n          get: {\n            tags: ['Beta'],\n            responses: {\n              200: {\n                description: 'OK',\n              },\n            },\n          },\n        },\n        '/foobar': {\n          get: {\n            responses: {\n              200: {\n                description: 'OK',\n              },\n            },\n          },\n        },\n      },\n    })\n\n    const { specification } = await openapi()\n      .load(otherExample)\n      .upgrade()\n      .filter((schema) => !schema?.tags?.includes('Beta'))\n      .get()\n\n    expect(specification.openapi).toBe('3.1.1')\n    expect(specification.paths['/'].get).toBeUndefined()\n    expect(specification.paths['/foobar'].get).not.toBeUndefined()\n  })\n\n  it('validate', async () => {\n    const result = await openapi().load(example).validate().get()\n\n    expect(result).toMatchObject({\n      valid: true,\n      version: '3.1',\n    })\n  })\n\n  it('toJson', async () => {\n    const result = await openapi().load(example).toJson()\n\n    expect(result).toBe(JSON.stringify(example, null, 2))\n  })\n\n  it('toYaml', async () => {\n    const result = await openapi().load(example).toYaml()\n\n    expect(result).toBe(stringify(example))\n  })\n\n  it('dereference', async () => {\n    const result = await openapi().load(example).dereference().get()\n\n    expect(result.schema.info.title).toBe('Hello World')\n  })\n\n  it('validate > dereference', async () => {\n    const result = await openapi().load(example).validate().dereference().get()\n\n    expect(result.valid).toBe(true)\n    expect(result.errors).toStrictEqual([])\n    expect(result.schema.info.title).toBe('Hello World')\n  })\n\n  it('throws an error when dereference fails (global)', async () => {\n    expect(async () => {\n      await openapi({\n        throwOnError: true,\n      })\n        .load({\n          openapi: '3.1.0',\n          info: {},\n          paths: {\n            '/foobar': {\n              post: {\n                requestBody: {\n                  $ref: '#/components/requestBodies/DoesNotExist',\n                },\n              },\n            },\n          },\n        })\n        .dereference()\n        .get()\n    }).rejects.toThrowError('Can\u2019t resolve reference: #/components/requestBodies/DoesNotExist')\n  })\n\n  it('throws an error when dereference fails (only dereference)', async () => {\n    expect(async () => {\n      await openapi()\n        .load({\n          openapi: '3.1.0',\n          info: {},\n          paths: {\n            '/foobar': {\n              post: {\n                requestBody: {\n                  $ref: '#/components/requestBodies/DoesNotExist',\n                },\n              },\n            },\n          },\n        })\n        .dereference({\n          throwOnError: true,\n        })\n        .get()\n    }).rejects.toThrowError('Can\u2019t resolve reference: #/components/requestBodies/DoesNotExist')\n  })\n\n  it('throws an error when validate fails (global)', async () => {\n    expect(async () => {\n      await openapi({\n        throwOnError: true,\n      })\n        .load({\n          openapi: '3.1.0',\n          info: {\n            title: 'Hello World',\n          },\n          paths: {\n            '/foobar': {\n              post: {\n                requestBody: {\n                  $ref: '#/components/requestBodies/DoesNotExist',\n                },\n              },\n            },\n          },\n        })\n        .validate()\n        .get()\n    }).rejects.toThrowError('Can\u2019t resolve reference: #/components/requestBodies/DoesNotExist')\n  })\n\n  it('throws an error when validate fails (only validate)', async () => {\n    expect(async () => {\n      await openapi()\n        .load({\n          openapi: '3.1.0',\n          info: {\n            title: 'Hello World',\n          },\n          paths: {\n            '/foobar': {\n              post: {\n                requestBody: {\n                  $ref: '#/components/requestBodies/DoesNotExist',\n                },\n              },\n            },\n          },\n        })\n        .validate({\n          throwOnError: true,\n        })\n        .get()\n    }).rejects.toThrowError('Can\u2019t resolve reference: #/components/requestBodies/DoesNotExist')\n  })\n\n  it('works with then & catch', async () => {\n    return new Promise((resolve, reject) => {\n      openapi()\n        .load({\n          openapi: '3.1.0',\n          info: {\n            title: 'Hello World',\n          },\n          paths: {\n            '/foobar': {\n              post: {\n                requestBody: {\n                  $ref: '#/components/requestBodies/DoesNotExist',\n                },\n              },\n            },\n          },\n        })\n        .validate({\n          throwOnError: true,\n        })\n        .get()\n        .then(() => {\n          reject()\n        })\n        .catch((error) => {\n          expect(error.message).toBe('Can\u2019t resolve reference: #/components/requestBodies/DoesNotExist')\n\n          resolve(null)\n        })\n    })\n  })\n})\n"],
-  "mappings": "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",
-  "names": []
-}

package/dist/utils/openapi/utils/queueTask.d.ts

@@ -1,6 +0,0 @@
-import type { Queue, Task } from '../../../types/index.js';
-/**
- * Add a new task to the existing queue
- */
-export declare function queueTask<T extends Task[]>(queue: Queue, task: Task): Queue<T>;
-//# sourceMappingURL=queueTask.d.ts.map

package/dist/utils/openapi/utils/queueTask.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"queueTask.d.ts","sourceRoot":"","sources":["../../../../src/utils/openapi/utils/queueTask.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,sBAAsB,CAAA;AAEvD;;GAEG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,IAAI,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,GAI7D,KAAK,CAAC,CAAC,CAAC,CACd"}

package/dist/utils/openapi/utils/queueTask.js

@@ -1,10 +0,0 @@
-function queueTask(queue, task) {
-  return {
-    ...queue,
-    tasks: [...queue.tasks, task]
-  };
-}
-export {
-  queueTask
-};
-//# sourceMappingURL=queueTask.js.map

package/dist/utils/openapi/utils/queueTask.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../../src/utils/openapi/utils/queueTask.ts"],
-  "sourcesContent": ["import type { Queue, Task } from '../../../types/index'\n\n/**\n * Add a new task to the existing queue\n */\nexport function queueTask<T extends Task[]>(queue: Queue, task: Task) {\n  return {\n    ...queue,\n    tasks: [...queue.tasks, task],\n  } as Queue<T>\n}\n"],
-  "mappings": "AAKO,SAAS,UAA4B,OAAc,MAAY;AACpE,SAAO;AAAA,IACL,GAAG;AAAA,IACH,OAAO,CAAC,GAAG,MAAM,OAAO,IAAI;AAAA,EAC9B;AACF;",
-  "names": []
-}

package/dist/utils/openapi/utils/workThroughQueue.d.ts

@@ -1,6 +0,0 @@
-import type { CommandChain, Queue, Task } from '../../../types/index.js';
-/**
- * Takes a queue of tasks and works through them
- */
-export declare function workThroughQueue<T extends Task[]>(queue: Queue<T>): Promise<CommandChain<T>>;
-//# sourceMappingURL=workThroughQueue.d.ts.map

package/dist/utils/openapi/utils/workThroughQueue.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"workThroughQueue.d.ts","sourceRoot":"","sources":["../../../../src/utils/openapi/utils/workThroughQueue.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAS,KAAK,EAAE,IAAI,EAAE,MAAM,sBAAsB,CAAA;AAO5E;;GAEG;AACH,wBAAsB,gBAAgB,CAAC,CAAC,SAAS,IAAI,EAAE,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAkElG"}

package/dist/utils/openapi/utils/workThroughQueue.js

@@ -1,52 +0,0 @@
-import { dereference } from "../../dereference.js";
-import { filter } from "../../filter.js";
-import { load } from "../../load/load.js";
-import { upgrade } from "../../upgrade.js";
-import { validate } from "../../validate.js";
-async function workThroughQueue(queue) {
-  const { input } = {
-    ...queue
-  };
-  let result = {};
-  for (const task of queue.tasks) {
-    const name = task.name;
-    const options = "options" in task ? task.options : void 0;
-    const currentSpecification = result.specification ? result.specification : typeof input === "object" ? (
-      // Detach from the original object
-      structuredClone(input)
-    ) : input;
-    if (name === "load") {
-      result = {
-        ...result,
-        ...await load(input, options)
-      };
-    } else if (name === "filter") {
-      result = {
-        ...result,
-        ...filter(currentSpecification, options)
-      };
-    } else if (name === "dereference") {
-      result = {
-        ...result,
-        ...await dereference(currentSpecification, options)
-      };
-    } else if (name === "upgrade") {
-      result = {
-        ...result,
-        ...upgrade(currentSpecification)
-      };
-    } else if (name === "validate") {
-      result = {
-        ...result,
-        ...await validate(currentSpecification, options)
-      };
-    } else {
-      const _ = name;
-    }
-  }
-  return result;
-}
-export {
-  workThroughQueue
-};
-//# sourceMappingURL=workThroughQueue.js.map

package/dist/utils/openapi/utils/workThroughQueue.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../../src/utils/openapi/utils/workThroughQueue.ts"],
-  "sourcesContent": ["import type { CommandChain, Merge, Queue, Task } from '../../../types/index'\nimport { dereference } from '../../dereference'\nimport { filter } from '../../filter'\nimport { load } from '../../load/load'\nimport { upgrade } from '../../upgrade'\nimport { validate } from '../../validate'\n\n/**\n * Takes a queue of tasks and works through them\n */\nexport async function workThroughQueue<T extends Task[]>(queue: Queue<T>): Promise<CommandChain<T>> {\n  const { input } = {\n    ...queue,\n  }\n  let result = {} as CommandChain<T>\n\n  // Work through the whole queue\n  for (const task of queue.tasks) {\n    const name: keyof Commands = task.name\n    const options: any = 'options' in task ? task.options : undefined\n\n    // Use the result of the previous task, or fall back to the original input\n    const currentSpecification = result.specification\n      ? result.specification\n      : typeof input === 'object'\n        ? // Detach from the original object\n          structuredClone(input)\n        : input\n\n    // load\n    if (name === 'load') {\n      result = {\n        ...result,\n        ...(await load(input, options as Commands['load']['task']['options'])),\n      } as Merge<typeof result, Awaited<typeof load>>\n    }\n\n    // validate\n    else if (name === 'filter') {\n      result = {\n        ...result,\n        ...filter(currentSpecification, options as Commands['filter']['task']['options']),\n      } as Merge<typeof result, ReturnType<typeof filter>>\n    }\n\n    // dereference\n    else if (name === 'dereference') {\n      result = {\n        ...result,\n        ...(await dereference(currentSpecification, options as Commands['dereference']['task']['options'])),\n      } as Merge<typeof result, Awaited<typeof dereference>>\n    }\n\n    // upgrade\n    else if (name === 'upgrade') {\n      result = {\n        ...result,\n        ...upgrade(currentSpecification),\n      } as Merge<typeof result, ReturnType<typeof upgrade>>\n    }\n\n    // validate\n    else if (name === 'validate') {\n      result = {\n        ...result,\n        ...(await validate(currentSpecification, options as Commands['validate']['task']['options'])),\n      } as Merge<typeof result, Awaited<typeof validate>>\n    }\n\n    // Make TS complain when we forgot to handle a command.\n    else {\n      const _: never = name\n    }\n  }\n\n  return result\n}\n"],
-  "mappings": "AACA,SAAS,mBAAmB;AAC5B,SAAS,cAAc;AACvB,SAAS,YAAY;AACrB,SAAS,eAAe;AACxB,SAAS,gBAAgB;AAKzB,eAAsB,iBAAmC,OAA2C;AAClG,QAAM,EAAE,MAAM,IAAI;AAAA,IAChB,GAAG;AAAA,EACL;AACA,MAAI,SAAS,CAAC;AAGd,aAAW,QAAQ,MAAM,OAAO;AAC9B,UAAM,OAAuB,KAAK;AAClC,UAAM,UAAe,aAAa,OAAO,KAAK,UAAU;AAGxD,UAAM,uBAAuB,OAAO,gBAChC,OAAO,gBACP,OAAO,UAAU;AAAA;AAAA,MAEf,gBAAgB,KAAK;AAAA,QACrB;AAGN,QAAI,SAAS,QAAQ;AACnB,eAAS;AAAA,QACP,GAAG;AAAA,QACH,GAAI,MAAM,KAAK,OAAO,OAA8C;AAAA,MACtE;AAAA,IACF,WAGS,SAAS,UAAU;AAC1B,eAAS;AAAA,QACP,GAAG;AAAA,QACH,GAAG,OAAO,sBAAsB,OAAgD;AAAA,MAClF;AAAA,IACF,WAGS,SAAS,eAAe;AAC/B,eAAS;AAAA,QACP,GAAG;AAAA,QACH,GAAI,MAAM,YAAY,sBAAsB,OAAqD;AAAA,MACnG;AAAA,IACF,WAGS,SAAS,WAAW;AAC3B,eAAS;AAAA,QACP,GAAG;AAAA,QACH,GAAG,QAAQ,oBAAoB;AAAA,MACjC;AAAA,IACF,WAGS,SAAS,YAAY;AAC5B,eAAS;AAAA,QACP,GAAG;AAAA,QACH,GAAI,MAAM,SAAS,sBAAsB,OAAkD;AAAA,MAC7F;AAAA,IACF,OAGK;AACH,YAAM,IAAW;AAAA,IACnB;AAAA,EACF;AAEA,SAAO;AACT;",
-  "names": []
-}