@kubb/plugin-oas 3.0.0-alpha.8 → 3.0.0-beta.1

package/dist/OperationGenerator-BgQeGRzk.d.ts

@@ -0,0 +1,550 @@
+import { Plugin, ResolveNameParams, Output, PluginFactoryOptions, FileMetaBase, BaseGenerator, PluginManager } from '@kubb/core';
+import * as KubbFile from '@kubb/fs/types';
+import { Oas, contentType, OasTypes, SchemaObject, Operation, HttpMethod } from '@kubb/oas';
+import { KubbNode } from '@kubb/react/types';
+
+type SchemaKeywordMapper = {
+    object: {
+        keyword: 'object';
+        args: {
+            properties: {
+                [x: string]: Schema[];
+            };
+            additionalProperties: Schema[];
+            strict?: boolean;
+        };
+    };
+    strict: {
+        keyword: 'strict';
+    };
+    url: {
+        keyword: 'url';
+    };
+    readOnly: {
+        keyword: 'readOnly';
+    };
+    writeOnly: {
+        keyword: 'writeOnly';
+    };
+    uuid: {
+        keyword: 'uuid';
+    };
+    email: {
+        keyword: 'email';
+    };
+    firstName: {
+        keyword: 'firstName';
+    };
+    lastName: {
+        keyword: 'lastName';
+    };
+    phone: {
+        keyword: 'phone';
+    };
+    password: {
+        keyword: 'password';
+    };
+    date: {
+        keyword: 'date';
+        args: {
+            type?: 'date' | 'string';
+        };
+    };
+    time: {
+        keyword: 'time';
+        args: {
+            type?: 'date' | 'string';
+        };
+    };
+    datetime: {
+        keyword: 'datetime';
+        args: {
+            offset?: boolean;
+            local?: boolean;
+        };
+    };
+    tuple: {
+        keyword: 'tuple';
+        args: {
+            items: Schema[];
+            min?: number;
+            max?: number;
+        };
+    };
+    array: {
+        keyword: 'array';
+        args: {
+            items: Schema[];
+            min?: number;
+            max?: number;
+        };
+    };
+    enum: {
+        keyword: 'enum';
+        args: {
+            name: string;
+            typeName: string;
+            asConst: boolean;
+            items: Array<{
+                name: string | number;
+                format: 'string' | 'number' | 'boolean';
+                value?: string | number | boolean;
+            }>;
+        };
+    };
+    and: {
+        keyword: 'and';
+        args: Schema[];
+    };
+    const: {
+        keyword: 'const';
+        args: {
+            name: string | number;
+            format: 'string' | 'number' | 'boolean';
+            value?: string | number | boolean;
+        };
+    };
+    union: {
+        keyword: 'union';
+        args: Schema[];
+    };
+    ref: {
+        keyword: 'ref';
+        args: {
+            name: string;
+            path: KubbFile.OptionalPath;
+        };
+    };
+    matches: {
+        keyword: 'matches';
+        args?: string;
+    };
+    boolean: {
+        keyword: 'boolean';
+    };
+    default: {
+        keyword: 'default';
+        args: string | number | boolean;
+    };
+    string: {
+        keyword: 'string';
+    };
+    integer: {
+        keyword: 'integer';
+    };
+    number: {
+        keyword: 'number';
+    };
+    max: {
+        keyword: 'max';
+        args: number;
+    };
+    min: {
+        keyword: 'min';
+        args: number;
+    };
+    describe: {
+        keyword: 'describe';
+        args: string;
+    };
+    example: {
+        keyword: 'example';
+        args: string;
+    };
+    deprecated: {
+        keyword: 'deprecated';
+    };
+    optional: {
+        keyword: 'optional';
+    };
+    undefined: {
+        keyword: 'undefined';
+    };
+    nullish: {
+        keyword: 'nullish';
+    };
+    nullable: {
+        keyword: 'nullable';
+    };
+    null: {
+        keyword: 'null';
+    };
+    any: {
+        keyword: 'any';
+    };
+    unknown: {
+        keyword: 'unknown';
+    };
+    blob: {
+        keyword: 'blob';
+    };
+    schema: {
+        keyword: 'schema';
+        args: {
+            type: 'string' | 'number' | 'integer' | 'boolean' | 'array' | 'object';
+            format?: string;
+        };
+    };
+    name: {
+        keyword: 'name';
+        args: string;
+    };
+    catchall: {
+        keyword: 'catchall';
+    };
+};
+declare const schemaKeywords: {
+    any: "any";
+    strict: "strict";
+    unknown: "unknown";
+    number: "number";
+    integer: "integer";
+    string: "string";
+    boolean: "boolean";
+    undefined: "undefined";
+    nullable: "nullable";
+    null: "null";
+    nullish: "nullish";
+    array: "array";
+    tuple: "tuple";
+    enum: "enum";
+    union: "union";
+    datetime: "datetime";
+    date: "date";
+    email: "email";
+    uuid: "uuid";
+    url: "url";
+    default: "default";
+    const: "const";
+    and: "and";
+    describe: "describe";
+    min: "min";
+    max: "max";
+    optional: "optional";
+    readOnly: "readOnly";
+    writeOnly: "writeOnly";
+    object: "object";
+    ref: "ref";
+    matches: "matches";
+    firstName: "firstName";
+    lastName: "lastName";
+    password: "password";
+    phone: "phone";
+    blob: "blob";
+    deprecated: "deprecated";
+    example: "example";
+    schema: "schema";
+    catchall: "catchall";
+    time: "time";
+    name: "name";
+};
+type SchemaKeyword = keyof SchemaKeywordMapper;
+type SchemaMapper<T = string | null | undefined> = {
+    [K in keyof SchemaKeywordMapper]: (() => T | undefined) | undefined;
+};
+type SchemaKeywordBase<T> = {
+    keyword: SchemaKeyword;
+    args: T;
+};
+type Schema = {
+    keyword: string;
+} | SchemaKeywordMapper[keyof SchemaKeywordMapper];
+declare function isKeyword<T extends Schema, K extends keyof SchemaKeywordMapper>(meta: T, keyword: K): meta is Extract<T, SchemaKeywordMapper[K]>;
+
+type Mode = 'schemas' | 'responses' | 'requestBodies';
+type GetSchemasProps = {
+    oas: Oas;
+    contentType?: contentType;
+    includes?: Mode[];
+};
+declare function getSchemas({ oas, contentType, includes }: GetSchemasProps): Record<string, OasTypes.SchemaObject>;
+
+type ResolvePathOptions = {
+    pluginKey?: Plugin['key'];
+    tag?: string;
+    type?: ResolveNameParams['type'];
+};
+type API = {
+    getOas: () => Promise<Oas>;
+    getSchemas: (options?: Pick<GetSchemasProps, 'includes'>) => Promise<Record<string, SchemaObject>>;
+    getBaseURL: () => Promise<string | undefined>;
+    contentType?: contentType;
+};
+type Options = {
+    /**
+     * Validate your input(see kubb.config) based on '@readme/openapi-parser'.
+     * @default true
+     */
+    validate?: boolean;
+    /**
+     * @default 'schemas'
+     */
+    output?: Output;
+    /**
+     * Which server to use from the array of `servers.url[serverIndex]`
+     * @example
+     * - `0` will return `http://petstore.swagger.io/api`
+     * - `1` will return `http://localhost:3000`
+     * @default 0
+     */
+    serverIndex?: number;
+    /**
+     * Define which contentType should be used.
+     * By default, this is set based on the first used contentType..
+     */
+    contentType?: contentType;
+    /**
+     * Override some behaviour of the Oas class instance, see '@kubb/oas'
+     */
+    oasClass?: typeof Oas;
+    /**
+     * Define some generators next to the JSON generation
+     */
+    generators?: Array<Generator<PluginOas>>;
+};
+/**
+ * `propertyName` is the ref name + resolved with the nameResolver
+ *  @example `import { Pet } from './Pet'`
+ *
+ * `originalName` is the original name used(in PascalCase), only used to remove duplicates
+ *
+ * `pluginKey` can be used to override the current plugin being used, handy when you want to import a type/schema out of another plugin
+ * @example import a type(plugin-ts) for a mock file(swagger-faker)
+ */
+type Ref = {
+    propertyName: string;
+    originalName: string;
+    path: KubbFile.OptionalPath;
+    pluginKey?: Plugin['key'];
+};
+type Refs = Record<string, Ref>;
+type Resolver = {
+    /**
+     * Original name or name resolved by `resolveName({ name: operation?.getOperationId() as string, pluginName })`
+     */
+    name: string;
+    baseName: KubbFile.BaseName;
+    path: KubbFile.Path;
+};
+type OperationSchema = {
+    /**
+     * Converted name, contains already `PathParams`, `QueryParams`, ...
+     */
+    name: string;
+    schema: SchemaObject;
+    operation?: Operation;
+    /**
+     * OperationName in PascalCase, only being used in OperationGenerator
+     */
+    operationName?: string;
+    description?: string;
+    statusCode?: number;
+    keys?: string[];
+    keysToOmit?: string[];
+    withData?: boolean;
+};
+type OperationSchemas = {
+    pathParams?: OperationSchema & {
+        keysToOmit?: never;
+    };
+    queryParams?: OperationSchema & {
+        keysToOmit?: never;
+    };
+    headerParams?: OperationSchema & {
+        keysToOmit?: never;
+    };
+    request?: OperationSchema;
+    response: OperationSchema;
+    statusCodes?: Array<OperationSchema>;
+    errors?: Array<OperationSchema>;
+};
+type OperationsByMethod = Record<string, Record<HttpMethod, {
+    operation: Operation;
+    schemas: OperationSchemas;
+}>>;
+type ByTag = {
+    type: 'tag';
+    pattern: string | RegExp;
+};
+type ByOperationId = {
+    type: 'operationId';
+    pattern: string | RegExp;
+};
+type ByPath = {
+    type: 'path';
+    pattern: string | RegExp;
+};
+type ByMethod = {
+    type: 'method';
+    pattern: HttpMethod | RegExp;
+};
+type BySchemaName = {
+    type: 'schemaName';
+    pattern: string | RegExp;
+};
+type Exclude = ByTag | ByOperationId | ByPath | ByMethod;
+type Include = ByTag | ByOperationId | ByPath | ByMethod;
+type Override<TOptions> = (ByTag | ByOperationId | ByPath | ByMethod | BySchemaName) & {
+    options: Partial<TOptions>;
+};
+type ResolvedOptions = Options & {
+    output: Output;
+};
+type PluginOas = PluginFactoryOptions<'plugin-oas', Options, ResolvedOptions, API, never>;
+
+type GetSchemaGeneratorOptions<T extends SchemaGenerator<any, any, any>> = T extends SchemaGenerator<infer Options, any, any> ? Options : never;
+type SchemaMethodResult<TFileMeta extends FileMetaBase> = Promise<KubbFile.File<TFileMeta> | Array<KubbFile.File<TFileMeta>> | null>;
+type Context$1<TOptions, TPluginOptions extends PluginFactoryOptions> = {
+    oas: Oas;
+    pluginManager: PluginManager;
+    /**
+     * Current plugin
+     */
+    plugin: Plugin<TPluginOptions>;
+    mode: KubbFile.Mode;
+    include?: Array<'schemas' | 'responses' | 'requestBodies'>;
+    override: Array<Override<TOptions>> | undefined;
+    contentType?: contentType;
+    output?: string;
+};
+type SchemaGeneratorOptions = {
+    dateType: false | 'string' | 'stringOffset' | 'stringLocal' | 'date';
+    unknownType: 'any' | 'unknown';
+    enumType?: 'enum' | 'asConst' | 'asPascalConst' | 'constEnum' | 'literal';
+    enumSuffix?: string;
+    usedEnumNames?: Record<string, number>;
+    mapper?: Record<string, string>;
+    typed?: boolean;
+    transformers: {
+        /**
+         * Customize the names based on the type that is provided by the plugin.
+         */
+        name?: (name: ResolveNameParams['name'], type?: ResolveNameParams['type']) => string;
+        /**
+         * Receive schema and name(propertName) and return FakerMeta array
+         * TODO TODO add docs
+         * @beta
+         */
+        schema?: (schemaProps: SchemaProps$1, defaultSchemas: Schema[]) => Schema[] | undefined;
+    };
+};
+type SchemaGeneratorBuildOptions = Omit<OperationSchema, 'name' | 'schema'>;
+type SchemaProps$1 = {
+    schema?: SchemaObject;
+    name?: string;
+    parentName?: string;
+};
+declare class SchemaGenerator<TOptions extends SchemaGeneratorOptions = SchemaGeneratorOptions, TPluginOptions extends PluginFactoryOptions = PluginFactoryOptions, TFileMeta extends FileMetaBase = FileMetaBase> extends BaseGenerator<TOptions, Context$1<TOptions, TPluginOptions>> {
+    #private;
+    refs: Refs;
+    /**
+     * Creates a type node from a given schema.
+     * Delegates to getBaseTypeFromSchema internally and
+     * optionally adds a union with null.
+     */
+    parse(props: SchemaProps$1): Schema[];
+    deepSearch<T extends keyof SchemaKeywordMapper>(tree: Schema[] | undefined, keyword: T): SchemaKeywordMapper[T][];
+    find<T extends keyof SchemaKeywordMapper>(tree: Schema[] | undefined, keyword: T): SchemaKeywordMapper[T] | undefined;
+    static deepSearch<T extends keyof SchemaKeywordMapper>(tree: Schema[] | undefined, keyword: T): SchemaKeywordMapper[T][];
+    static findInObject<T extends keyof SchemaKeywordMapper>(tree: Schema[] | undefined, keyword: T): SchemaKeywordMapper[T] | undefined;
+    static find<T extends keyof SchemaKeywordMapper>(tree: Schema[] | undefined, keyword: T): SchemaKeywordMapper[T] | undefined;
+    build(...generators: Array<Generator<TPluginOptions>>): Promise<Array<KubbFile.File<TFileMeta>>>;
+    /**
+     * Schema
+     */
+    schema(name: string, object: SchemaObject, options: TOptions): SchemaMethodResult<TFileMeta>;
+}
+
+type OperationsProps<TOptions extends PluginFactoryOptions> = {
+    instance: Omit<OperationGenerator<TOptions>, 'build'>;
+    options: TOptions['resolvedOptions'];
+    operations: Array<Operation>;
+    operationsByMethod: OperationsByMethod;
+};
+type OperationProps<TOptions extends PluginFactoryOptions> = {
+    instance: Omit<OperationGenerator<TOptions>, 'build'>;
+    options: TOptions['resolvedOptions'];
+    operation: Operation;
+};
+type SchemaProps<TOptions extends PluginFactoryOptions> = {
+    instance: Omit<SchemaGenerator<SchemaGeneratorOptions, TOptions>, 'build'>;
+    schema: {
+        name: string;
+        tree: Array<Schema>;
+        value: SchemaObject;
+    };
+    options: TOptions['resolvedOptions'];
+};
+type GeneratorOptions<TOptions extends PluginFactoryOptions> = {
+    name: string;
+    operations?: (this: GeneratorOptions<TOptions>, props: OperationsProps<TOptions>) => Promise<KubbFile.File[]>;
+    operation?: (this: GeneratorOptions<TOptions>, props: OperationProps<TOptions>) => Promise<KubbFile.File[]>;
+    schema?: (this: GeneratorOptions<TOptions>, props: SchemaProps<TOptions>) => Promise<KubbFile.File[]>;
+};
+type Generator<TOptions extends PluginFactoryOptions> = GeneratorOptions<TOptions>;
+declare function createGenerator<TOptions extends PluginFactoryOptions>(parseOptions: GeneratorOptions<TOptions>): Generator<TOptions>;
+type ReactGeneratorOptions<TOptions extends PluginFactoryOptions> = {
+    name: string;
+    Operations?: (this: ReactGeneratorOptions<TOptions>, props: OperationsProps<TOptions>) => KubbNode;
+    Operation?: (this: ReactGeneratorOptions<TOptions>, props: OperationProps<TOptions>) => KubbNode;
+    Schema?: (this: ReactGeneratorOptions<TOptions>, props: SchemaProps<TOptions>) => KubbNode;
+};
+declare function createReactGenerator<TOptions extends PluginFactoryOptions>(parseOptions: ReactGeneratorOptions<TOptions>): Generator<TOptions>;
+
+/**
+ * @deprecated
+ */
+type GetOperationGeneratorOptions<T = any> = any;
+type OperationMethodResult<TFileMeta extends FileMetaBase> = Promise<KubbFile.File<TFileMeta> | Array<KubbFile.File<TFileMeta>> | null>;
+type Context<TOptions, TPluginOptions extends PluginFactoryOptions> = {
+    oas: Oas;
+    exclude: Array<Exclude> | undefined;
+    include: Array<Include> | undefined;
+    override: Array<Override<TOptions>> | undefined;
+    contentType: contentType | undefined;
+    pluginManager: PluginManager;
+    /**
+     * Current plugin
+     */
+    plugin: Plugin<TPluginOptions>;
+    mode: KubbFile.Mode;
+};
+declare class OperationGenerator<TPluginOptions extends PluginFactoryOptions = PluginFactoryOptions, TFileMeta extends FileMetaBase = FileMetaBase> extends BaseGenerator<TPluginOptions['resolvedOptions'], Context<TPluginOptions['resolvedOptions'], TPluginOptions>> {
+    #private;
+    get operationsByMethod(): OperationsByMethod;
+    set operationsByMethod(paths: OperationsByMethod);
+    getSchemas(operation: Operation, { resolveName, }?: {
+        resolveName?: (name: string) => string;
+    }): OperationSchemas;
+    build(...generators: Array<Generator<TPluginOptions>>): Promise<Array<KubbFile.File<TFileMeta>>>;
+    /**
+     * Operation
+     */
+    operation(operation: Operation, options: TPluginOptions['resolvedOptions']): OperationMethodResult<TFileMeta>;
+    /**
+     * GET
+     */
+    get(operation: Operation, options: TPluginOptions['resolvedOptions']): OperationMethodResult<TFileMeta>;
+    /**
+     * POST
+     */
+    post(operation: Operation, options: TPluginOptions['resolvedOptions']): OperationMethodResult<TFileMeta>;
+    /**
+     * PATCH
+     */
+    patch(operation: Operation, options: TPluginOptions['resolvedOptions']): OperationMethodResult<TFileMeta>;
+    /**
+     * PUT
+     */
+    put(operation: Operation, options: TPluginOptions['resolvedOptions']): OperationMethodResult<TFileMeta>;
+    /**
+     * DELETE
+     */
+    delete(operation: Operation, options: TPluginOptions['resolvedOptions']): OperationMethodResult<TFileMeta>;
+    /**
+     * Combination of GET, POST, PATCH, PUT, DELETE
+     */
+    all(operations: Operation[], paths: OperationsByMethod): OperationMethodResult<TFileMeta>;
+}
+
+export { type API as A, getSchemas as B, type Exclude as E, type GetOperationGeneratorOptions as G, type Include as I, type Options as O, type PluginOas as P, type ReactGeneratorOptions as R, type SchemaGeneratorBuildOptions as S, type OperationMethodResult as a, OperationGenerator as b, type GetSchemaGeneratorOptions as c, type SchemaGeneratorOptions as d, type SchemaMethodResult as e, SchemaGenerator as f, type Schema as g, type SchemaKeyword as h, type SchemaKeywordBase as i, type SchemaKeywordMapper as j, type SchemaMapper as k, isKeyword as l, createGenerator as m, createReactGenerator as n, type Generator as o, type GeneratorOptions as p, type ResolvePathOptions as q, type Ref as r, schemaKeywords as s, type Refs as t, type Resolver as u, type OperationSchema as v, type OperationSchemas as w, type OperationsByMethod as x, type Override as y, type GetSchemasProps as z };

package/dist/{Schema-B1vcPGiK.d.ts → Schema-1iM2I0dK.d.ts}

@@ -1,8 +1,7 @@
 import * as react from 'react';
-import { ReactNode } from 'react';
 import { SchemaObject } from '@kubb/oas';
 import { KubbNode } from '@kubb/react/types';
-import { S as Schema$1 } from './SchemaMapper-sGcY1xL5.js';
+import { g as Schema$1 } from './OperationGenerator-BgQeGRzk.js';
 
 type SchemaContextProps = {
     name: string;
@@ -17,17 +16,7 @@ type Props = {
 };
 declare function Schema({ name, value, tree, children }: Props): KubbNode;
 declare namespace Schema {
-    var File: ({ output, isTypeOnly, children }: FileProps) => ReactNode;
-    var Imports: ({ isTypeOnly }: SchemaImportsProps) => ReactNode;
     var Context: react.Context<SchemaContextProps>;
 }
-type FileProps = {
-    isTypeOnly?: boolean;
-    output: string | undefined;
-    children?: KubbNode;
-};
-type SchemaImportsProps = {
-    isTypeOnly?: boolean;
-};
 
 export { Schema as S, type SchemaContextProps as a };

package/dist/{Schema-DoSFh7Qd.d.cts → Schema-5o-c5UOy.d.cts}

@@ -1,8 +1,7 @@
 import * as react from 'react';
-import { ReactNode } from 'react';
 import { SchemaObject } from '@kubb/oas';
 import { KubbNode } from '@kubb/react/types';
-import { S as Schema$1 } from './SchemaMapper-sGcY1xL5.cjs';
+import { g as Schema$1 } from './OperationGenerator-BgQeGRzk.cjs';
 
 type SchemaContextProps = {
     name: string;
@@ -17,17 +16,7 @@ type Props = {
 };
 declare function Schema({ name, value, tree, children }: Props): KubbNode;
 declare namespace Schema {
-    var File: ({ output, isTypeOnly, children }: FileProps) => ReactNode;
-    var Imports: ({ isTypeOnly }: SchemaImportsProps) => ReactNode;
     var Context: react.Context<SchemaContextProps>;
 }
-type FileProps = {
-    isTypeOnly?: boolean;
-    output: string | undefined;
-    children?: KubbNode;
-};
-type SchemaImportsProps = {
-    isTypeOnly?: boolean;
-};
 
 export { Schema as S, type SchemaContextProps as a };

package/dist/chunk-ABOQ73FL.cjs

@@ -0,0 +1,36 @@
+'use strict';
+
+var path = require('path');
+var utils = require('@kubb/core/utils');
+var parser = require('@kubb/oas/parser');
+var oas = require('@kubb/oas');
+var yaml = require('@stoplight/yaml');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var yaml__default = /*#__PURE__*/_interopDefault(yaml);
+
+// src/utils/parseFromConfig.ts
+function parseFromConfig(config, oasClass = oas.Oas) {
+  if ("data" in config.input) {
+    if (typeof config.input.data === "object") {
+      const api2 = JSON.parse(JSON.stringify(config.input.data));
+      return parser.parse(api2, oasClass);
+    }
+    try {
+      const api2 = yaml__default.default.parse(config.input.data);
+      return parser.parse(api2, oasClass);
+    } catch (e) {
+    }
+    const api = JSON.parse(JSON.stringify(config.input.data));
+    return parser.parse(api, oasClass);
+  }
+  if (new utils.URLPath(config.input.path).isURL) {
+    return parser.parse(config.input.path, oasClass);
+  }
+  return parser.parse(path.resolve(config.root, config.input.path), oasClass);
+}
+
+exports.parseFromConfig = parseFromConfig;
+//# sourceMappingURL=chunk-ABOQ73FL.cjs.map
+//# sourceMappingURL=chunk-ABOQ73FL.cjs.map

package/dist/chunk-ABOQ73FL.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils/parseFromConfig.ts"],"names":["Oas","api","parse","yaml","URLPath","resolve"],"mappings":";;;;;;;;;;;;;AAUO,SAAS,eAAA,CAAgB,MAAgB,EAAA,QAAA,GAAuBA,OAAmB,EAAA;AACxF,EAAI,IAAA,MAAA,IAAU,OAAO,KAAO,EAAA;AAC1B,IAAA,IAAI,OAAO,MAAA,CAAO,KAAM,CAAA,IAAA,KAAS,QAAU,EAAA;AACzC,MAAMC,MAAAA,IAAAA,GAA4B,KAAK,KAAM,CAAA,IAAA,CAAK,UAAU,MAAO,CAAA,KAAA,CAAM,IAAI,CAAC,CAAA,CAAA;AAC9E,MAAO,OAAAC,YAAA,CAAMD,MAAK,QAAQ,CAAA,CAAA;AAAA,KAC5B;AAEA,IAAI,IAAA;AACF,MAAA,MAAMA,IAAc,GAAAE,qBAAA,CAAK,KAAM,CAAA,MAAA,CAAO,MAAM,IAAc,CAAA,CAAA;AAE1D,MAAO,OAAAD,YAAA,CAAMD,MAAK,QAAQ,CAAA,CAAA;AAAA,aACnB,CAAG,EAAA;AAAA,KAEZ;AAEA,IAAM,MAAA,GAAA,GAA4B,KAAK,KAAM,CAAA,IAAA,CAAK,UAAU,MAAO,CAAA,KAAA,CAAM,IAAI,CAAC,CAAA,CAAA;AAE9E,IAAO,OAAAC,YAAA,CAAM,KAAK,QAAQ,CAAA,CAAA;AAAA,GAC5B;AAEA,EAAA,IAAI,IAAIE,aAAQ,CAAA,MAAA,CAAO,KAAM,CAAA,IAAI,EAAE,KAAO,EAAA;AACxC,IAAA,OAAOF,YAAM,CAAA,MAAA,CAAO,KAAM,CAAA,IAAA,EAAM,QAAQ,CAAA,CAAA;AAAA,GAC1C;AAEA,EAAO,OAAAA,YAAA,CAAMG,aAAQ,MAAO,CAAA,IAAA,EAAM,OAAO,KAAM,CAAA,IAAI,GAAG,QAAQ,CAAA,CAAA;AAChE","file":"chunk-ABOQ73FL.cjs","sourcesContent":["import { resolve } from 'node:path'\n\nimport { URLPath } from '@kubb/core/utils'\n\nimport { parse } from '@kubb/oas/parser'\n\nimport type { Config } from '@kubb/core'\nimport { Oas, type OasTypes } from '@kubb/oas'\nimport yaml from '@stoplight/yaml'\n\nexport function parseFromConfig(config: Config, oasClass: typeof Oas = Oas): Promise<Oas> {\n  if ('data' in config.input) {\n    if (typeof config.input.data === 'object') {\n      const api: OasTypes.OASDocument = JSON.parse(JSON.stringify(config.input.data)) as OasTypes.OASDocument\n      return parse(api, oasClass)\n    }\n\n    try {\n      const api: string = yaml.parse(config.input.data as string) as string\n\n      return parse(api, oasClass)\n    } catch (e) {\n      /* empty */\n    }\n\n    const api: OasTypes.OASDocument = JSON.parse(JSON.stringify(config.input.data)) as OasTypes.OASDocument\n\n    return parse(api, oasClass)\n  }\n\n  if (new URLPath(config.input.path).isURL) {\n    return parse(config.input.path, oasClass)\n  }\n\n  return parse(resolve(config.root, config.input.path), oasClass)\n}\n"]}

package/dist/chunk-BG77DP54.js

@@ -0,0 +1,30 @@
+import { resolve } from 'node:path';
+import { URLPath } from '@kubb/core/utils';
+import { parse } from '@kubb/oas/parser';
+import { Oas } from '@kubb/oas';
+import yaml from '@stoplight/yaml';
+
+// src/utils/parseFromConfig.ts
+function parseFromConfig(config, oasClass = Oas) {
+  if ("data" in config.input) {
+    if (typeof config.input.data === "object") {
+      const api2 = JSON.parse(JSON.stringify(config.input.data));
+      return parse(api2, oasClass);
+    }
+    try {
+      const api2 = yaml.parse(config.input.data);
+      return parse(api2, oasClass);
+    } catch (e) {
+    }
+    const api = JSON.parse(JSON.stringify(config.input.data));
+    return parse(api, oasClass);
+  }
+  if (new URLPath(config.input.path).isURL) {
+    return parse(config.input.path, oasClass);
+  }
+  return parse(resolve(config.root, config.input.path), oasClass);
+}
+
+export { parseFromConfig };
+//# sourceMappingURL=chunk-BG77DP54.js.map
+//# sourceMappingURL=chunk-BG77DP54.js.map

package/dist/chunk-BG77DP54.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils/parseFromConfig.ts"],"names":["api"],"mappings":";;;;;;;AAUO,SAAS,eAAA,CAAgB,MAAgB,EAAA,QAAA,GAAuB,GAAmB,EAAA;AACxF,EAAI,IAAA,MAAA,IAAU,OAAO,KAAO,EAAA;AAC1B,IAAA,IAAI,OAAO,MAAA,CAAO,KAAM,CAAA,IAAA,KAAS,QAAU,EAAA;AACzC,MAAMA,MAAAA,IAAAA,GAA4B,KAAK,KAAM,CAAA,IAAA,CAAK,UAAU,MAAO,CAAA,KAAA,CAAM,IAAI,CAAC,CAAA,CAAA;AAC9E,MAAO,OAAA,KAAA,CAAMA,MAAK,QAAQ,CAAA,CAAA;AAAA,KAC5B;AAEA,IAAI,IAAA;AACF,MAAA,MAAMA,IAAc,GAAA,IAAA,CAAK,KAAM,CAAA,MAAA,CAAO,MAAM,IAAc,CAAA,CAAA;AAE1D,MAAO,OAAA,KAAA,CAAMA,MAAK,QAAQ,CAAA,CAAA;AAAA,aACnB,CAAG,EAAA;AAAA,KAEZ;AAEA,IAAM,MAAA,GAAA,GAA4B,KAAK,KAAM,CAAA,IAAA,CAAK,UAAU,MAAO,CAAA,KAAA,CAAM,IAAI,CAAC,CAAA,CAAA;AAE9E,IAAO,OAAA,KAAA,CAAM,KAAK,QAAQ,CAAA,CAAA;AAAA,GAC5B;AAEA,EAAA,IAAI,IAAI,OAAQ,CAAA,MAAA,CAAO,KAAM,CAAA,IAAI,EAAE,KAAO,EAAA;AACxC,IAAA,OAAO,KAAM,CAAA,MAAA,CAAO,KAAM,CAAA,IAAA,EAAM,QAAQ,CAAA,CAAA;AAAA,GAC1C;AAEA,EAAO,OAAA,KAAA,CAAM,QAAQ,MAAO,CAAA,IAAA,EAAM,OAAO,KAAM,CAAA,IAAI,GAAG,QAAQ,CAAA,CAAA;AAChE","file":"chunk-BG77DP54.js","sourcesContent":["import { resolve } from 'node:path'\n\nimport { URLPath } from '@kubb/core/utils'\n\nimport { parse } from '@kubb/oas/parser'\n\nimport type { Config } from '@kubb/core'\nimport { Oas, type OasTypes } from '@kubb/oas'\nimport yaml from '@stoplight/yaml'\n\nexport function parseFromConfig(config: Config, oasClass: typeof Oas = Oas): Promise<Oas> {\n  if ('data' in config.input) {\n    if (typeof config.input.data === 'object') {\n      const api: OasTypes.OASDocument = JSON.parse(JSON.stringify(config.input.data)) as OasTypes.OASDocument\n      return parse(api, oasClass)\n    }\n\n    try {\n      const api: string = yaml.parse(config.input.data as string) as string\n\n      return parse(api, oasClass)\n    } catch (e) {\n      /* empty */\n    }\n\n    const api: OasTypes.OASDocument = JSON.parse(JSON.stringify(config.input.data)) as OasTypes.OASDocument\n\n    return parse(api, oasClass)\n  }\n\n  if (new URLPath(config.input.path).isURL) {\n    return parse(config.input.path, oasClass)\n  }\n\n  return parse(resolve(config.root, config.input.path), oasClass)\n}\n"]}