@scalar/openapi-parser 0.8.1 → 0.8.2

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

@@ -0,0 +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,aAAa,CAAA;AAChF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAG1C;;GAEG;AACH,wBAAgB,OAAO,CAAC,aAAa,CAAC,EAAE,cAAc;kBASpC,sBAAsB,YAAY,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAG9D"}

package/dist/utils/openapi/openapi.js

@@ -0,0 +1 @@
+import{loadCommand as o}from"./commands/loadCommand.js";function n(n){const t={input:null,options:n,tasks:[]};return{load:(n,m)=>o(t,n,m)}}export{n as openapi};

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

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

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

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

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

@@ -0,0 +1,6 @@
+import type { Queue, Task } from '../../../types';
+/**
+ * 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

@@ -0,0 +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,gBAAgB,CAAA;AAEjD;;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

@@ -0,0 +1 @@
+function t(t,s){return{...t,tasks:[...t.tasks,s]}}export{t as queueTask};

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

@@ -0,0 +1,6 @@
+import type { CommandChain, Queue, Task } from '../../../types';
+/**
+ * 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

@@ -0,0 +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,gBAAgB,CAAA;AAOtE;;GAEG;AACH,wBAAsB,gBAAgB,CAAC,CAAC,SAAS,IAAI,EAAE,EACrD,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,GACd,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CA4E1B"}

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

@@ -0,0 +1 @@
+import{dereference as o}from"../../dereference.js";import{filter as t}from"../../filter.js";import{load as e}from"../../load/load.js";import{upgrade as i}from"../../upgrade.js";import{validate as r}from"../../validate.js";async function a(a){const{input:n}={...a};let s={};for(const f of a.tasks){const a=f.name,p="options"in f?f.options:void 0,c=s.specification?s.specification:"object"==typeof n?structuredClone(n):n;"load"===a?s={...s,...await e(n,p)}:"filter"===a?s={...s,...t(c,p)}:"dereference"===a?s={...s,...await o(c,p)}:"upgrade"===a?s={...s,...i(c)}:"validate"===a&&(s={...s,...await r(c,p)})}return s}export{a as workThroughQueue};

package/dist/utils/upgrade.d.ts

@@ -3,5 +3,5 @@ import type { AnyObject, Filesystem, UpgradeResult } from '../types';
 /**
  * Upgrade specification to OpenAPI 3.1.0
  */
-export declare function upgrade(value: string | AnyObject | Filesystem, _options?: AnyObject): UpgradeResult<OpenAPIV3_1.Document>;
+export declare function upgrade(value: string | AnyObject | Filesystem): UpgradeResult<OpenAPIV3_1.Document>;
 //# sourceMappingURL=upgrade.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"upgrade.d.ts","sourceRoot":"","sources":["../../src/utils/upgrade.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AAExD,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAMpE;;GAEG;AACH,wBAAgB,OAAO,CACrB,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,UAAU,EACtC,QAAQ,CAAC,EAAE,SAAS,GACnB,aAAa,CAAC,WAAW,CAAC,QAAQ,CAAC,CAcrC"}
+{"version":3,"file":"upgrade.d.ts","sourceRoot":"","sources":["../../src/utils/upgrade.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AAExD,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAMpE;;GAEG;AACH,wBAAgB,OAAO,CACrB,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,UAAU,GACrC,aAAa,CAAC,WAAW,CAAC,QAAQ,CAAC,CAcrC"}

package/dist/utils/upgrade.js

@@ -1 +1 @@
-import{getEntrypoint as r}from"./getEntrypoint.js";import{makeFilesystem as e}from"./makeFilesystem.js";import{upgradeFromThreeToThreeOne as o}from"./upgradeFromThreeToThreeOne.js";import{upgradeFromTwoToThree as i}from"./upgradeFromTwoToThree.js";function t(t,m){return{specification:[i,o].reduce(((r,e)=>e(r)),r(e(t)).specification),version:"3.1"}}export{t as upgrade};
+import{getEntrypoint as r}from"./getEntrypoint.js";import{makeFilesystem as e}from"./makeFilesystem.js";import{upgradeFromThreeToThreeOne as o}from"./upgradeFromThreeToThreeOne.js";import{upgradeFromTwoToThree as i}from"./upgradeFromTwoToThree.js";function t(t){return{specification:[i,o].reduce(((r,e)=>e(r)),r(e(t)).specification),version:"3.1"}}export{t as upgrade};

package/dist/utils/validate.d.ts

@@ -1,6 +1,7 @@
 import type { AnyObject, Filesystem, ThrowOnErrorOption, ValidateResult } from '../types';
+export type ValidateOptions = ThrowOnErrorOption;
 /**
  * Validates an OpenAPI schema.
  */
-export declare function validate(value: string | AnyObject | Filesystem, options?: ThrowOnErrorOption): Promise<ValidateResult>;
+export declare function validate(value: string | AnyObject | Filesystem, options?: ValidateOptions): Promise<ValidateResult>;
 //# sourceMappingURL=validate.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../src/utils/validate.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,SAAS,EACT,UAAU,EACV,kBAAkB,EAClB,cAAc,EACf,MAAM,UAAU,CAAA;AAGjB;;GAEG;AACH,wBAAsB,QAAQ,CAC5B,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,UAAU,EACtC,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,cAAc,CAAC,CAWzB"}
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../src/utils/validate.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,SAAS,EACT,UAAU,EACV,kBAAkB,EAClB,cAAc,EACf,MAAM,UAAU,CAAA;AAGjB,MAAM,MAAM,eAAe,GAAG,kBAAkB,CAAA;AAEhD;;GAEG;AACH,wBAAsB,QAAQ,CAC5B,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,UAAU,EACtC,OAAO,CAAC,EAAE,eAAe,GACxB,OAAO,CAAC,cAAc,CAAC,CAWzB"}

package/package.json

@@ -17,7 +17,7 @@
     "parser",
     "typescript"
   ],
-  "version": "0.8.1",
+  "version": "0.8.2",
   "engines": {
     "node": ">=18"
   },
@@ -63,7 +63,7 @@
     "rollup": "^4.16.4",
     "rollup-plugin-output-size": "^1.4.1",
     "tinybench": "^2.8.0",
-    "@scalar/openapi-types": "0.1.0"
+    "@scalar/openapi-types": "0.1.1"
   },
   "scripts": {
     "build": "pnpm types:check && rollup -c --configPlugin typescript && pnpm types:build",

package/dist/utils/openapi.d.ts

@@ -1,183 +0,0 @@
-import type { AnyObject, DetailsResult, Filesystem, ThrowOnErrorOption } from '../types';
-import { dereference } from './dereference.js';
-import { filter } from './filter.js';
-import { type LoadPlugin, load } from './load';
-import { upgrade } from './upgrade.js';
-import { validate } from './validate.js';
-/**
- * A queuable action for the pipeline
- */
-export type Action = {
-    action: typeof load | typeof upgrade | typeof filter | typeof dereference | typeof validate;
-    options?: AnyObject;
-};
-/**
- * A queue of tasks to run on an OpenAPI specification
- */
-export type Queue = {
-    specification: AnyApiDefinitionFormat;
-    tasks: Action[];
-};
-/**
- * JSON, YAML or object representation of an OpenAPI API definition
- */
-export type AnyApiDefinitionFormat = string | AnyObject;
-/**
- * Creates a new pipeline
- */
-export declare function openapi(globalOptions?: ThrowOnErrorOption): {
-    load: (specification: AnyApiDefinitionFormat, options?: {
-        plugins?: LoadPlugin[];
-    }) => {
-        get: () => Promise<Partial<import("../types").LoadResult & import("../types").DereferenceResult & import("../types").ValidateResult & import("../types").UpgradeResult & import("../types").FilterResult & {
-            filesystem: Filesystem;
-        }>>;
-        files: () => Promise<Filesystem>;
-        details: () => Promise<DetailsResult>;
-        filter: (callback: (Specification: AnyObject) => boolean) => {
-            get: () => Promise<Partial<import("../types").LoadResult & import("../types").DereferenceResult & import("../types").ValidateResult & import("../types").UpgradeResult & import("../types").FilterResult & {
-                filesystem: Filesystem;
-            }>>;
-            files: () => Promise<Filesystem>;
-            details: () => Promise<DetailsResult>;
-            filter: () => any;
-            upgrade: () => {
-                get: () => Promise<Partial<import("../types").LoadResult & import("../types").DereferenceResult & import("../types").ValidateResult & import("../types").UpgradeResult & import("../types").FilterResult & {
-                    filesystem: Filesystem;
-                }>>;
-                files: () => Promise<Filesystem>;
-                details: () => Promise<DetailsResult>;
-                filter: (callback: (Specification: AnyObject) => boolean) => any;
-                validate: (validateOptions?: ThrowOnErrorOption) => {
-                    filter: (callback: (Specification: AnyObject) => boolean) => any;
-                    get: () => Promise<Partial<import("../types").LoadResult & import("../types").DereferenceResult & import("../types").ValidateResult & import("../types").UpgradeResult & import("../types").FilterResult & {
-                        filesystem: Filesystem;
-                    }>>;
-                    files: () => Promise<Filesystem>;
-                    details: () => Promise<DetailsResult>;
-                    dereference: (dereferenceOptions?: ThrowOnErrorOption) => {
-                        get: () => Promise<Partial<import("../types").LoadResult & import("../types").DereferenceResult & import("../types").ValidateResult & import("../types").UpgradeResult & import("../types").FilterResult & {
-                            filesystem: Filesystem;
-                        }>>;
-                        files: () => Promise<Filesystem>;
-                        filter: (callback: (Specification: AnyObject) => boolean) => any;
-                        toJson: () => Promise<string>;
-                        toYaml: () => Promise<string>;
-                    };
-                    toJson: () => Promise<string>;
-                    toYaml: () => Promise<string>;
-                };
-                dereference: (dereferenceOptions?: ThrowOnErrorOption) => {
-                    get: () => Promise<Partial<import("../types").LoadResult & import("../types").DereferenceResult & import("../types").ValidateResult & import("../types").UpgradeResult & import("../types").FilterResult & {
-                        filesystem: Filesystem;
-                    }>>;
-                    files: () => Promise<Filesystem>;
-                    filter: (callback: (Specification: AnyObject) => boolean) => any;
-                    toJson: () => Promise<string>;
-                    toYaml: () => Promise<string>;
-                };
-                toJson: () => Promise<string>;
-                toYaml: () => Promise<string>;
-            };
-            validate: (validateOptions?: ThrowOnErrorOption) => {
-                filter: (callback: (Specification: AnyObject) => boolean) => any;
-                get: () => Promise<Partial<import("../types").LoadResult & import("../types").DereferenceResult & import("../types").ValidateResult & import("../types").UpgradeResult & import("../types").FilterResult & {
-                    filesystem: Filesystem;
-                }>>;
-                files: () => Promise<Filesystem>;
-                details: () => Promise<DetailsResult>;
-                dereference: (dereferenceOptions?: ThrowOnErrorOption) => {
-                    get: () => Promise<Partial<import("../types").LoadResult & import("../types").DereferenceResult & import("../types").ValidateResult & import("../types").UpgradeResult & import("../types").FilterResult & {
-                        filesystem: Filesystem;
-                    }>>;
-                    files: () => Promise<Filesystem>;
-                    filter: (callback: (Specification: AnyObject) => boolean) => any;
-                    toJson: () => Promise<string>;
-                    toYaml: () => Promise<string>;
-                };
-                toJson: () => Promise<string>;
-                toYaml: () => Promise<string>;
-            };
-            dereference: (dereferenceOptions?: ThrowOnErrorOption) => {
-                get: () => Promise<Partial<import("../types").LoadResult & import("../types").DereferenceResult & import("../types").ValidateResult & import("../types").UpgradeResult & import("../types").FilterResult & {
-                    filesystem: Filesystem;
-                }>>;
-                files: () => Promise<Filesystem>;
-                filter: (callback: (Specification: AnyObject) => boolean) => any;
-                toJson: () => Promise<string>;
-                toYaml: () => Promise<string>;
-            };
-            toJson: () => Promise<string>;
-            toYaml: () => Promise<string>;
-        };
-        upgrade: () => {
-            get: () => Promise<Partial<import("../types").LoadResult & import("../types").DereferenceResult & import("../types").ValidateResult & import("../types").UpgradeResult & import("../types").FilterResult & {
-                filesystem: Filesystem;
-            }>>;
-            files: () => Promise<Filesystem>;
-            details: () => Promise<DetailsResult>;
-            filter: (callback: (Specification: AnyObject) => boolean) => any;
-            validate: (validateOptions?: ThrowOnErrorOption) => {
-                filter: (callback: (Specification: AnyObject) => boolean) => any;
-                get: () => Promise<Partial<import("../types").LoadResult & import("../types").DereferenceResult & import("../types").ValidateResult & import("../types").UpgradeResult & import("../types").FilterResult & {
-                    filesystem: Filesystem;
-                }>>;
-                files: () => Promise<Filesystem>;
-                details: () => Promise<DetailsResult>;
-                dereference: (dereferenceOptions?: ThrowOnErrorOption) => {
-                    get: () => Promise<Partial<import("../types").LoadResult & import("../types").DereferenceResult & import("../types").ValidateResult & import("../types").UpgradeResult & import("../types").FilterResult & {
-                        filesystem: Filesystem;
-                    }>>;
-                    files: () => Promise<Filesystem>;
-                    filter: (callback: (Specification: AnyObject) => boolean) => any;
-                    toJson: () => Promise<string>;
-                    toYaml: () => Promise<string>;
-                };
-                toJson: () => Promise<string>;
-                toYaml: () => Promise<string>;
-            };
-            dereference: (dereferenceOptions?: ThrowOnErrorOption) => {
-                get: () => Promise<Partial<import("../types").LoadResult & import("../types").DereferenceResult & import("../types").ValidateResult & import("../types").UpgradeResult & import("../types").FilterResult & {
-                    filesystem: Filesystem;
-                }>>;
-                files: () => Promise<Filesystem>;
-                filter: (callback: (Specification: AnyObject) => boolean) => any;
-                toJson: () => Promise<string>;
-                toYaml: () => Promise<string>;
-            };
-            toJson: () => Promise<string>;
-            toYaml: () => Promise<string>;
-        };
-        validate: (validateOptions?: ThrowOnErrorOption) => {
-            filter: (callback: (Specification: AnyObject) => boolean) => any;
-            get: () => Promise<Partial<import("../types").LoadResult & import("../types").DereferenceResult & import("../types").ValidateResult & import("../types").UpgradeResult & import("../types").FilterResult & {
-                filesystem: Filesystem;
-            }>>;
-            files: () => Promise<Filesystem>;
-            details: () => Promise<DetailsResult>;
-            dereference: (dereferenceOptions?: ThrowOnErrorOption) => {
-                get: () => Promise<Partial<import("../types").LoadResult & import("../types").DereferenceResult & import("../types").ValidateResult & import("../types").UpgradeResult & import("../types").FilterResult & {
-                    filesystem: Filesystem;
-                }>>;
-                files: () => Promise<Filesystem>;
-                filter: (callback: (Specification: AnyObject) => boolean) => any;
-                toJson: () => Promise<string>;
-                toYaml: () => Promise<string>;
-            };
-            toJson: () => Promise<string>;
-            toYaml: () => Promise<string>;
-        };
-        dereference: (dereferenceOptions?: ThrowOnErrorOption) => {
-            get: () => Promise<Partial<import("../types").LoadResult & import("../types").DereferenceResult & import("../types").ValidateResult & import("../types").UpgradeResult & import("../types").FilterResult & {
-                filesystem: Filesystem;
-            }>>;
-            files: () => Promise<Filesystem>;
-            filter: (callback: (Specification: AnyObject) => boolean) => any;
-            toJson: () => Promise<string>;
-            toYaml: () => Promise<string>;
-        };
-        toJson: () => Promise<string>;
-        toYaml: () => Promise<string>;
-    };
-};
-//# sourceMappingURL=openapi.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"openapi.d.ts","sourceRoot":"","sources":["../../src/utils/openapi.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,SAAS,EACT,aAAa,EACb,UAAU,EACV,kBAAkB,EACnB,MAAM,UAAU,CAAA;AACjB,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAE3C,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AAEjC,OAAO,EAAE,KAAK,UAAU,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAG9C,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AACnC,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAGrC;;GAEG;AACH,MAAM,MAAM,MAAM,GAAG;IACnB,MAAM,EACF,OAAO,IAAI,GACX,OAAO,OAAO,GACd,OAAO,MAAM,GACb,OAAO,WAAW,GAClB,OAAO,QAAQ,CAAA;IACnB,OAAO,CAAC,EAAE,SAAS,CAAA;CACpB,CAAA;AAED;;GAEG;AACH,MAAM,MAAM,KAAK,GAAG;IAClB,aAAa,EAAE,sBAAsB,CAAA;IACrC,KAAK,EAAE,MAAM,EAAE,CAAA;CAChB,CAAA;AAED;;GAEG;AACH,MAAM,MAAM,sBAAsB,GAAG,MAAM,GAAG,SAAS,CAAA;AAEvD;;GAEG;AACH,wBAAgB,OAAO,CAAC,aAAa,CAAC,EAAE,kBAAkB;0BAGrC,sBAAsB,YAC3B;QACR,OAAO,CAAC,EAAE,UAAU,EAAE,CAAA;KACvB;;;;;;2BAqCgB,CAAC,aAAa,EAAE,SAAS,KAAK,OAAO;;;;;;;;;;;;;mCAkCrC,CAAC,aAAa,EAAE,SAAS,KAAK,OAAO;6CAI3B,kBAAkB;uCA0B5B,CAAC,aAAa,EAAE,SAAS,KAAK,OAAO;;;;;;uDAOrB,kBAAkB;;;;;2CAwBlC,CAAC,aAAa,EAAE,SAAS,KAAK,OAAO;;;;;;;mDArDrB,kBAAkB;;;;;uCAqDlC,CAAC,aAAa,EAAE,SAAS,KAAK,OAAO;;;;;;;yCA4B3B,kBAAkB;mCA3D5B,CAAC,aAAa,EAAE,SAAS,KAAK,OAAO;;;;;;mDAOrB,kBAAkB;;;;;uCAwBlC,CAAC,aAAa,EAAE,SAAS,KAAK,OAAO;;;;;;;+CAgCrB,kBAAkB;;;;;mCAhClC,CAAC,aAAa,EAAE,SAAS,KAAK,OAAO;;;;;;;;;;;;;+BA7DrC,CAAC,aAAa,EAAE,SAAS,KAAK,OAAO;yCAI3B,kBAAkB;mCA0B5B,CAAC,aAAa,EAAE,SAAS,KAAK,OAAO;;;;;;mDAOrB,kBAAkB;;;;;uCAwBlC,CAAC,aAAa,EAAE,SAAS,KAAK,OAAO;;;;;;;+CArDrB,kBAAkB;;;;;mCAqDlC,CAAC,aAAa,EAAE,SAAS,KAAK,OAAO;;;;;;;qCAvF3B,kBAAkB;+BAwD5B,CAAC,aAAa,EAAE,SAAS,KAAK,OAAO;;;;;;+CAOrB,kBAAkB;;;;;mCAwBlC,CAAC,aAAa,EAAE,SAAS,KAAK,OAAO;;;;;;;2CAnFrB,kBAAkB;;;;;+BAmFlC,CAAC,aAAa,EAAE,SAAS,KAAK,OAAO;;;;;;;EA7H3D"}

package/dist/utils/openapi.js

@@ -1 +0,0 @@
-import{dereference as r}from"./dereference.js";import{details as o}from"./details.js";import{filter as t}from"./filter.js";import{getEntrypoint as n}from"./getEntrypoint.js";import{load as e}from"./load/load.js";import{toJson as i}from"./toJson.js";import{toYaml as s}from"./toYaml.js";import{upgrade as a}from"./upgrade.js";import{validate as f}from"./validate.js";import{workThroughQueue as c}from"./workThroughQueue.js";function l(r){return{load:(o,t)=>function(r,o){const t={specification:r,tasks:[{action:e,options:{plugins:o?.plugins}}]};return{get:()=>w(t),files:()=>E(t),details:()=>O(t),filter:r=>h(t,r,{throwOnError:o?.throwOnError}),upgrade:()=>u(t,{throwOnError:o?.throwOnError}),validate:r=>p(t,{throwOnError:r?.throwOnError??o?.throwOnError}),dereference:r=>m(t,{...o??{},...r??{}}),toJson:()=>d(t),toYaml:()=>g(t)}}(o,{...r??{},...t??{}})}}function u(r,o){return r.tasks.push({action:a}),{get:()=>w(r),files:()=>E(r),details:()=>O(r),filter:t=>h(r,t,{throwOnError:o?.throwOnError}),validate:t=>p(r,{throwOnError:t?.throwOnError??o?.throwOnError}),dereference:t=>m(r,{...o??{},...t??{}}),toJson:()=>d(r),toYaml:()=>g(r)}}function p(r,o){return r.tasks.push({action:f,options:{throwOnError:o?.throwOnError}}),{filter:t=>h(r,t,{throwOnError:o?.throwOnError}),get:()=>w(r),files:()=>E(r),details:()=>O(r),dereference:t=>m(r,{...o??{},...t??{}}),toJson:()=>d(r),toYaml:()=>g(r)}}function m(o,t){return o.tasks.push({action:r,options:{throwOnError:t?.throwOnError}}),{get:()=>w(o),files:()=>E(o),filter:r=>h(o,r,{throwOnError:t?.throwOnError}),toJson:()=>d(o),toYaml:()=>g(o)}}function h(r,o,n){return r.tasks.push({action:t,options:o}),{get:()=>w(r),files:()=>E(r),details:()=>O(r),filter:()=>h(r,o,n),upgrade:()=>u(r,n),validate:o=>p(r,{throwOnError:o?.throwOnError??n?.throwOnError}),dereference:o=>m(r,{...n??{},...o??{}}),toJson:()=>d(r),toYaml:()=>g(r)}}async function w(r){const o=await c(r);return void 0===o.specification&&(o.specification=n(o.filesystem).specification),o}async function E(r){const{filesystem:o}=await c(r);return o}async function O(r){const{filesystem:t}=await c(r);return o(n(t).specification)}async function d(r){const{filesystem:o}=await c(r);return i(n(o).specification)}async function g(r){const{filesystem:o}=await c(r);return s(n(o).specification)}export{l as openapi};

package/dist/utils/workThroughQueue.d.ts

@@ -1,11 +0,0 @@
-import type { DereferenceResult, Filesystem, FilterResult, LoadResult, UpgradeResult, ValidateResult } from '../types';
-import type { Queue } from './openapi.js';
-type WorkThroughQueueResult = Partial<LoadResult & DereferenceResult & ValidateResult & UpgradeResult & FilterResult & {
-    filesystem: Filesystem;
-}>;
-/**
- * Run through a queue of tasks
- */
-export declare function workThroughQueue(queue: Queue): Promise<WorkThroughQueueResult>;
-export {};
-//# sourceMappingURL=workThroughQueue.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"workThroughQueue.d.ts","sourceRoot":"","sources":["../../src/utils/workThroughQueue.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,iBAAiB,EACjB,UAAU,EACV,YAAY,EACZ,UAAU,EACV,aAAa,EACb,cAAc,EACf,MAAM,UAAU,CAAA;AACjB,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,WAAW,CAAA;AAEtC,KAAK,sBAAsB,GAAG,OAAO,CACnC,UAAU,GACR,iBAAiB,GACjB,cAAc,GACd,aAAa,GACb,YAAY,GAAG;IACb,UAAU,EAAE,UAAU,CAAA;CACvB,CACJ,CAAA;AAED;;GAEG;AACH,wBAAsB,gBAAgB,CAAC,KAAK,EAAE,KAAK,GACnD,OAAO,CAAC,sBAAsB,CAAC,CA4B9B"}

package/dist/utils/workThroughQueue.js

@@ -1 +0,0 @@
-async function n(n){const t=n.specification;let o;for(const{action:c,options:e}of n.tasks)"function"==typeof c?o="AsyncFunction"===c.constructor.name?{...o,...await c(o?.filesystem??t,e)}:{...o,...c(o?.filesystem??t,e)}:console.warn("[queue] The given action is not a function:",c);return o}export{n as workThroughQueue};