@scalar/openapi-parser 0.10.16 → 0.11.0

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

@@ -1 +1 @@
-{"version":3,"file":"openapi.d.ts","sourceRoot":"","sources":["../../../src/utils/openapi/openapi.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,cAAc,EAAS,MAAM,sBAAsB,CAAA;AACzF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAA;AAGlD;;GAEG;AACH,wBAAgB,OAAO,CAAC,aAAa,CAAC,EAAE,cAAc;kBASpC,sBAAsB,YAAY,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE9D"}
+{"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,18 +1,15 @@
-import { loadCommand } from './commands/loadCommand.js';
-
-/**
- * Creates a fluent OpenAPI pipeline
- */
+import { loadCommand } from "./commands/loadCommand.js";
 function openapi(globalOptions) {
-    // Create a new queue
-    const queue = {
-        input: null,
-        options: globalOptions,
-        tasks: [],
-    };
-    return {
-        load: (input, options) => loadCommand(queue, input, options),
-    };
+  const queue = {
+    input: null,
+    options: globalOptions,
+    tasks: []
+  };
+  return {
+    load: (input, options) => loadCommand(queue, input, options)
+  };
 }
-
-export { openapi };
+export {
+  openapi
+};
+//# sourceMappingURL=openapi.js.map

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

@@ -0,0 +1,7 @@
+{
+  "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.js

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,7 @@
+{
+  "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

@@ -0,0 +1,309 @@
+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

@@ -0,0 +1,7 @@
+{
+  "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,4 +1,4 @@
-import type { Queue, Task } from '../../../types/index.ts';
+import type { Queue, Task } from '../../../types/index.js';
 /**
  * Add a new task to the existing queue
  */

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

@@ -1 +1 @@
-{"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,yBAAyB,CAAA;AAE1D;;GAEG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,IAAI,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,GAI7D,KAAK,CAAC,CAAC,CAAC,CACd"}
+{"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,11 +1,10 @@
-/**
- * Add a new task to the existing queue
- */
 function queueTask(queue, task) {
-    return {
-        ...queue,
-        tasks: [...queue.tasks, task],
-    };
+  return {
+    ...queue,
+    tasks: [...queue.tasks, task]
+  };
 }
-
-export { queueTask };
+export {
+  queueTask
+};
+//# sourceMappingURL=queueTask.js.map

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

@@ -0,0 +1,7 @@
+{
+  "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,4 +1,4 @@
-import type { CommandChain, Queue, Task } from '../../../types/index.ts';
+import type { CommandChain, Queue, Task } from '../../../types/index.js';
 /**
  * Takes a queue of tasks and works through them
  */

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

@@ -1 +1 @@
-{"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,yBAAyB,CAAA;AAO/E;;GAEG;AACH,wBAAsB,gBAAgB,CAAC,CAAC,SAAS,IAAI,EAAE,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAmElG"}
+{"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,67 +1,52 @@
-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';
-
-/**
- * Takes a queue of tasks and works through them
- */
+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 = {};
-    // Work through the whole queue
-    for (const task of queue.tasks) {
-        const name = task.name;
-        const options = 'options' in task ? task.options : undefined;
-        // Use the result of the previous task, or fall back to the original input
-        const currentSpecification = result.specification
-            ? result.specification
-            : typeof input === 'object'
-                ? // Detach from the original object
-                    structuredClone(input)
-                : input;
-        // load
-        if (name === 'load') {
-            result = {
-                ...result,
-                ...(await load(input, options)),
-            };
-        }
-        // validate
-        else if (name === 'filter') {
-            result = {
-                ...result,
-                ...filter(currentSpecification, options),
-            };
-        }
-        // dereference
-        else if (name === 'dereference') {
-            result = {
-                ...result,
-                ...(await dereference(currentSpecification, options)),
-            };
-        }
-        // upgrade
-        else if (name === 'upgrade') {
-            result = {
-                ...result,
-                ...upgrade(currentSpecification),
-            };
-        }
-        // validate
-        else if (name === 'validate') {
-            result = {
-                ...result,
-                ...(await validate(currentSpecification, options)),
-            };
-        }
-        // Make TS complain when we forgot to handle a command.
-        else ;
+  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;
+  }
+  return result;
 }
-
-export { workThroughQueue };
+export {
+  workThroughQueue
+};
+//# sourceMappingURL=workThroughQueue.js.map

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

@@ -0,0 +1,7 @@
+{
+  "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": []
+}