@kubb/plugin-oas 0.0.0-canary-20240509211223

package/dist/SchemaGenerator-z_7YrAAB.d.cts

@@ -0,0 +1,316 @@
+import { KubbFile, ResolveNameParams, PluginFactoryOptions, Generator, PluginManager, Plugin } from '@kubb/core';
+import { SchemaObject, Oas, contentType } from '@kubb/oas';
+import { d as OperationSchema, b as Refs, g as Override } from './types-n5zV4Q3s.cjs';
+
+type SchemaKeywordMapper = {
+    object: {
+        keyword: 'object';
+        args: {
+            properties: {
+                [x: string]: Schema[];
+            };
+            additionalProperties: Schema[];
+            strict?: boolean;
+        };
+    };
+    strict: {
+        keyword: 'strict';
+    };
+    url: {
+        keyword: 'url';
+    };
+    readOnly: {
+        keyword: 'readOnly';
+    };
+    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: Schema[];
+    };
+    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';
+                value?: string | number;
+            }>;
+        };
+    };
+    and: {
+        keyword: 'and';
+        args: Schema[];
+    };
+    const: {
+        keyword: 'const';
+        args: {
+            name: string | number;
+            format: 'string' | 'number';
+            value?: string | number;
+        };
+    };
+    union: {
+        keyword: 'union';
+        args: Schema[];
+    };
+    ref: {
+        keyword: 'ref';
+        args: {
+            name: string;
+            path: KubbFile.OptionalPath;
+            isTypeOnly?: boolean;
+        };
+    };
+    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";
+    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 SchemaMethodResult<TFileMeta extends KubbFile.FileMetaBase> = Promise<KubbFile.File<TFileMeta> | Array<KubbFile.File<TFileMeta>> | null>;
+type Context<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, defaultSchemas: Schema[]) => Schema[] | undefined;
+    };
+};
+type SchemaGeneratorBuildOptions = Omit<OperationSchema, 'name' | 'schema'>;
+type SchemaProps = {
+    schema?: SchemaObject;
+    name?: string;
+    parentName?: string;
+};
+declare abstract class SchemaGenerator<TOptions extends SchemaGeneratorOptions = SchemaGeneratorOptions, TPluginOptions extends PluginFactoryOptions = PluginFactoryOptions, TFileMeta extends KubbFile.FileMetaBase = KubbFile.FileMetaBase> extends Generator<TOptions, Context<TOptions, TPluginOptions>> {
+    #private;
+    refs: Refs;
+    /**
+     * Creates a type node from a given schema.
+     * Delegates to getBaseTypeFromSchema internally and
+     * optionally adds a union with null.
+     */
+    buildSchemas(props: SchemaProps): Schema[];
+    deepSearch<T extends keyof SchemaKeywordMapper>(schemas: Schema[] | undefined, keyword: T): SchemaKeywordMapper[T][];
+    find<T extends keyof SchemaKeywordMapper>(schemas: Schema[] | undefined, keyword: T): SchemaKeywordMapper[T] | undefined;
+    static deepSearch<T extends keyof SchemaKeywordMapper>(schemas: Schema[] | undefined, keyword: T): SchemaKeywordMapper[T][];
+    static findInObject<T extends keyof SchemaKeywordMapper>(schemas: Schema[] | undefined, keyword: T): SchemaKeywordMapper[T] | undefined;
+    static find<T extends keyof SchemaKeywordMapper>(schemas: Schema[] | undefined, keyword: T): SchemaKeywordMapper[T] | undefined;
+    build(): Promise<Array<KubbFile.File<TFileMeta>>>;
+    /**
+     * Schema
+     */
+    abstract schema(name: string, object: SchemaObject): SchemaMethodResult<TFileMeta>;
+    /**
+     * Returns the source, in the future it will return a React component
+     */
+    abstract getSource<TOptions extends SchemaGeneratorBuildOptions = SchemaGeneratorBuildOptions>(name: string, schemas: Schema[], options?: TOptions): string[];
+    /**
+     * @deprecated only used for testing
+     */
+    abstract buildSource(name: string, object: SchemaObject | undefined, options?: SchemaGeneratorBuildOptions): string[];
+}
+
+export { type SchemaGeneratorBuildOptions as S, type SchemaGeneratorOptions as a, type SchemaMethodResult as b, SchemaGenerator as c, type Schema as d, type SchemaKeyword as e, type SchemaKeywordBase as f, type SchemaKeywordMapper as g, type SchemaMapper as h, isKeyword as i, schemaKeywords as s };

package/dist/chunk-2MJ2CQMI.js

@@ -0,0 +1,61 @@
+import {
+  init_esm_shims
+} from "./chunk-LQ6IAWRX.js";
+
+// src/SchemaMapper.ts
+init_esm_shims();
+var 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",
+  /* intersection */
+  default: "default",
+  const: "const",
+  and: "and",
+  describe: "describe",
+  min: "min",
+  max: "max",
+  optional: "optional",
+  readOnly: "readOnly",
+  // custom ones
+  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"
+};
+function isKeyword(meta, keyword) {
+  return meta.keyword === keyword;
+}
+
+export {
+  schemaKeywords,
+  isKeyword
+};
+//# sourceMappingURL=chunk-2MJ2CQMI.js.map

package/dist/chunk-2MJ2CQMI.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/SchemaMapper.ts"],"sourcesContent":["import type { KubbFile } from '@kubb/core'\n\nexport type SchemaKeywordMapper = {\n  object: {\n    keyword: 'object'\n    args: {\n      properties: { [x: string]: Schema[] }\n      additionalProperties: Schema[]\n      strict?: boolean\n    }\n  }\n  strict: { keyword: 'strict' }\n  url: { keyword: 'url' }\n  readOnly: { keyword: 'readOnly' }\n  uuid: { keyword: 'uuid' }\n  email: { keyword: 'email' }\n  firstName: { keyword: 'firstName' }\n  lastName: { keyword: 'lastName' }\n  phone: { keyword: 'phone' }\n  password: { keyword: 'password' }\n  date: { keyword: 'date'; args: { type?: 'date' | 'string' } }\n  time: { keyword: 'time'; args: { type?: 'date' | 'string' } }\n  datetime: { keyword: 'datetime'; args: { offset?: boolean; local?: boolean } }\n  tuple: { keyword: 'tuple'; args: Schema[] }\n  array: {\n    keyword: 'array'\n    args: { items: Schema[]; min?: number; max?: number }\n  }\n  enum: {\n    keyword: 'enum'\n    args: {\n      name: string\n      typeName: string\n      asConst: boolean\n      items: Array<{\n        name: string | number\n        format: 'string' | 'number'\n        value?: string | number\n      }>\n    }\n  }\n  and: { keyword: 'and'; args: Schema[] }\n  const: {\n    keyword: 'const'\n    args: {\n      name: string | number\n      format: 'string' | 'number'\n      value?: string | number\n    }\n  }\n  union: { keyword: 'union'; args: Schema[] }\n  ref: {\n    keyword: 'ref'\n    args: { name: string; path: KubbFile.OptionalPath; isTypeOnly?: boolean }\n  }\n  matches: { keyword: 'matches'; args?: string }\n  boolean: { keyword: 'boolean' }\n  default: { keyword: 'default'; args: string | number | boolean }\n  string: { keyword: 'string' }\n  integer: { keyword: 'integer' }\n  number: { keyword: 'number' }\n  max: { keyword: 'max'; args: number }\n  min: { keyword: 'min'; args: number }\n  describe: { keyword: 'describe'; args: string }\n  example: { keyword: 'example'; args: string }\n  deprecated: { keyword: 'deprecated' }\n  optional: { keyword: 'optional' }\n  undefined: { keyword: 'undefined' }\n  nullish: { keyword: 'nullish' }\n  nullable: { keyword: 'nullable' }\n  null: { keyword: 'null' }\n  any: { keyword: 'any' }\n  unknown: { keyword: 'unknown' }\n  blob: { keyword: 'blob' }\n  schema: { keyword: 'schema'; args: { type: 'string' | 'number' | 'integer' | 'boolean' | 'array' | 'object'; format?: string } }\n  name: { keyword: 'name'; args: string }\n  catchall: { keyword: 'catchall' }\n}\n\nexport const schemaKeywords = {\n  any: 'any',\n  strict: 'strict',\n  unknown: 'unknown',\n  number: 'number',\n  integer: 'integer',\n  string: 'string',\n  boolean: 'boolean',\n  undefined: 'undefined',\n  nullable: 'nullable',\n  null: 'null',\n  nullish: 'nullish',\n  array: 'array',\n  tuple: 'tuple',\n  enum: 'enum',\n  union: 'union',\n  datetime: 'datetime',\n  date: 'date',\n  email: 'email',\n  uuid: 'uuid',\n  url: 'url',\n  /* intersection */\n  default: 'default',\n  const: 'const',\n  and: 'and',\n  describe: 'describe',\n  min: 'min',\n  max: 'max',\n  optional: 'optional',\n  readOnly: 'readOnly',\n\n  // custom ones\n  object: 'object',\n  ref: 'ref',\n  matches: 'matches',\n  firstName: 'firstName',\n  lastName: 'lastName',\n  password: 'password',\n  phone: 'phone',\n  blob: 'blob',\n  deprecated: 'deprecated',\n  example: 'example',\n  schema: 'schema',\n  catchall: 'catchall',\n  time: 'time',\n  name: 'name',\n} satisfies {\n  [K in keyof SchemaKeywordMapper]: SchemaKeywordMapper[K]['keyword']\n}\n\nexport type SchemaKeyword = keyof SchemaKeywordMapper\n\nexport type SchemaMapper<T = string | null | undefined> = {\n  [K in keyof SchemaKeywordMapper]: (() => T | undefined) | undefined\n}\n\nexport type SchemaKeywordBase<T> = {\n  keyword: SchemaKeyword\n  args: T\n}\n\nexport type Schema = { keyword: string } | SchemaKeywordMapper[keyof SchemaKeywordMapper]\n\nexport function isKeyword<T extends Schema, K extends keyof SchemaKeywordMapper>(meta: T, keyword: K): meta is Extract<T, SchemaKeywordMapper[K]> {\n  return meta.keyword === keyword\n}\n"],"mappings":";;;;;AAAA;AA+EO,IAAM,iBAAiB;AAAA,EAC5B,KAAK;AAAA,EACL,QAAQ;AAAA,EACR,SAAS;AAAA,EACT,QAAQ;AAAA,EACR,SAAS;AAAA,EACT,QAAQ;AAAA,EACR,SAAS;AAAA,EACT,WAAW;AAAA,EACX,UAAU;AAAA,EACV,MAAM;AAAA,EACN,SAAS;AAAA,EACT,OAAO;AAAA,EACP,OAAO;AAAA,EACP,MAAM;AAAA,EACN,OAAO;AAAA,EACP,UAAU;AAAA,EACV,MAAM;AAAA,EACN,OAAO;AAAA,EACP,MAAM;AAAA,EACN,KAAK;AAAA;AAAA,EAEL,SAAS;AAAA,EACT,OAAO;AAAA,EACP,KAAK;AAAA,EACL,UAAU;AAAA,EACV,KAAK;AAAA,EACL,KAAK;AAAA,EACL,UAAU;AAAA,EACV,UAAU;AAAA;AAAA,EAGV,QAAQ;AAAA,EACR,KAAK;AAAA,EACL,SAAS;AAAA,EACT,WAAW;AAAA,EACX,UAAU;AAAA,EACV,UAAU;AAAA,EACV,OAAO;AAAA,EACP,MAAM;AAAA,EACN,YAAY;AAAA,EACZ,SAAS;AAAA,EACT,QAAQ;AAAA,EACR,UAAU;AAAA,EACV,MAAM;AAAA,EACN,MAAM;AACR;AAiBO,SAAS,UAAiE,MAAS,SAAwD;AAChJ,SAAO,KAAK,YAAY;AAC1B;","names":[]}

package/dist/chunk-3RCQ2LNT.js

@@ -0,0 +1,81 @@
+import {
+  init_esm_shims
+} from "./chunk-LQ6IAWRX.js";
+
+// src/utils/getSchemas.ts
+init_esm_shims();
+function getSchemas({ oas, contentType, includes = ["schemas", "requestBodies", "responses"] }) {
+  const components = oas.getDefinition().components;
+  let schemas = {};
+  if (includes.includes("schemas")) {
+    schemas = {
+      ...schemas,
+      ...components?.schemas || {}
+    };
+  }
+  const requestBodies = components?.requestBodies || {};
+  if (includes.includes("responses")) {
+    const responses = components?.responses || {};
+    Object.entries(responses).forEach(([name, response]) => {
+      if (response.content && !schemas[name]) {
+        const firstContentType = Object.keys(response.content)[0] || "application/json";
+        schemas[name] = response.content?.[contentType || firstContentType]?.schema;
+      }
+    });
+  }
+  if (includes.includes("requestBodies")) {
+    Object.entries(requestBodies).forEach(([name, request]) => {
+      if (request.content && !schemas[name]) {
+        const firstContentType = Object.keys(request.content)[0] || "application/json";
+        schemas[name] = request.content?.[contentType || firstContentType]?.schema;
+      }
+    });
+  }
+  return schemas;
+}
+
+// src/utils/parseFromConfig.ts
+init_esm_shims();
+import { resolve } from "path";
+import { URLPath } from "@kubb/core/utils";
+import { parse } from "@kubb/oas/parser";
+import yaml from "@stoplight/yaml";
+function parseFromConfig(config, options = {}) {
+  if ("data" in config.input) {
+    if (typeof config.input.data === "object") {
+      const api2 = JSON.parse(JSON.stringify(config.input.data));
+      return parse(api2, options);
+    }
+    try {
+      const api2 = yaml.parse(config.input.data);
+      return parse(api2, options);
+    } catch (e) {
+    }
+    const api = JSON.parse(JSON.stringify(config.input.data));
+    return parse(api, options);
+  }
+  if (new URLPath(config.input.path).isURL) {
+    return parse(config.input.path, options);
+  }
+  return parse(resolve(config.root, config.input.path), options);
+}
+
+// src/utils/getSchemaFactory.ts
+init_esm_shims();
+import { isOpenApiV3_1Document } from "@kubb/oas";
+function getSchemaFactory(oas) {
+  return (schema) => {
+    const version = isOpenApiV3_1Document(oas.api) ? "3.1" : "3.0";
+    return {
+      schema,
+      version
+    };
+  };
+}
+
+export {
+  getSchemas,
+  parseFromConfig,
+  getSchemaFactory
+};
+//# sourceMappingURL=chunk-3RCQ2LNT.js.map

package/dist/chunk-3RCQ2LNT.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils/getSchemas.ts","../src/utils/parseFromConfig.ts","../src/utils/getSchemaFactory.ts"],"sourcesContent":["import type { Oas, OasTypes, contentType } from '@kubb/oas'\n\ntype Mode = 'schemas' | 'responses' | 'requestBodies'\n\nexport type GetSchemasProps = {\n  oas: Oas\n  contentType?: contentType\n  includes?: Mode[]\n}\n\nexport function getSchemas({ oas, contentType, includes = ['schemas', 'requestBodies', 'responses'] }: GetSchemasProps): Record<string, OasTypes.SchemaObject> {\n  const components = oas.getDefinition().components\n\n  let schemas: Record<string, OasTypes.SchemaObject> = {}\n\n  if (includes.includes('schemas')) {\n    schemas = {\n      ...schemas,\n      ...((components?.schemas as Record<string, OasTypes.SchemaObject>) || {}),\n    }\n  }\n\n  const requestBodies = components?.requestBodies || {}\n  if (includes.includes('responses')) {\n    const responses = components?.responses || {}\n\n    Object.entries(responses).forEach(([name, response]: [string, OasTypes.ResponseObject]) => {\n      if (response.content && !schemas[name]) {\n        const firstContentType = Object.keys(response.content)[0] || 'application/json'\n        schemas[name] = response.content?.[contentType || firstContentType]?.schema as OasTypes.SchemaObject\n      }\n    })\n  }\n\n  if (includes.includes('requestBodies')) {\n    Object.entries(requestBodies).forEach(([name, request]: [string, OasTypes.RequestBodyObject]) => {\n      if (request.content && !schemas[name]) {\n        const firstContentType = Object.keys(request.content)[0] || 'application/json'\n        schemas[name] = request.content?.[contentType || firstContentType]?.schema as OasTypes.SchemaObject\n      }\n    })\n  }\n\n  return schemas\n}\n","import { resolve } from 'node:path'\n\nimport { URLPath } from '@kubb/core/utils'\n\nimport { type FormatOptions, parse } from '@kubb/oas/parser'\n\nimport type { Config } from '@kubb/core'\nimport type { Oas, OasTypes } from '@kubb/oas'\nimport yaml from '@stoplight/yaml'\n\nexport function parseFromConfig(config: Config, options: FormatOptions = {}): 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, options)\n    }\n\n    try {\n      const api: string = yaml.parse(config.input.data as string) as string\n\n      return parse(api, options)\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, options)\n  }\n\n  if (new URLPath(config.input.path).isURL) {\n    return parse(config.input.path, options)\n  }\n\n  return parse(resolve(config.root, config.input.path), options)\n}\n","import { isOpenApiV3_1Document } from '@kubb/oas'\n\nimport type { Oas, OpenAPIV3, OpenAPIV3_1, SchemaObject } from '@kubb/oas'\n\n/**\n * Make it possible to narrow down the schema based on a specific version(3 or 3.1)\n */\ntype SchemaResult<TWithRef extends boolean = false> =\n  | {\n      schema?: (TWithRef extends true ? OpenAPIV3.SchemaObject | OpenAPIV3.ReferenceObject : OpenAPIV3.SchemaObject) & {\n        nullable?: boolean\n        'x-nullable'?: boolean\n      }\n      version: '3.0'\n    }\n  | {\n      schema?: (TWithRef extends true ? OpenAPIV3_1.SchemaObject | OpenAPIV3_1.ReferenceObject : OpenAPIV3_1.SchemaObject) & {\n        nullable?: boolean\n        'x-nullable'?: boolean\n      }\n      version: '3.1'\n    }\n\nexport function getSchemaFactory<TWithRef extends boolean = false>(oas: Oas): (schema?: SchemaObject) => SchemaResult<TWithRef> {\n  return (schema?: SchemaObject) => {\n    const version = isOpenApiV3_1Document(oas.api) ? '3.1' : '3.0'\n\n    return {\n      schema,\n      version,\n    } as SchemaResult<TWithRef>\n  }\n}\n"],"mappings":";;;;;AAAA;AAUO,SAAS,WAAW,EAAE,KAAK,aAAa,WAAW,CAAC,WAAW,iBAAiB,WAAW,EAAE,GAA2D;AAC7J,QAAM,aAAa,IAAI,cAAc,EAAE;AAEvC,MAAI,UAAiD,CAAC;AAEtD,MAAI,SAAS,SAAS,SAAS,GAAG;AAChC,cAAU;AAAA,MACR,GAAG;AAAA,MACH,GAAK,YAAY,WAAqD,CAAC;AAAA,IACzE;AAAA,EACF;AAEA,QAAM,gBAAgB,YAAY,iBAAiB,CAAC;AACpD,MAAI,SAAS,SAAS,WAAW,GAAG;AAClC,UAAM,YAAY,YAAY,aAAa,CAAC;AAE5C,WAAO,QAAQ,SAAS,EAAE,QAAQ,CAAC,CAAC,MAAM,QAAQ,MAAyC;AACzF,UAAI,SAAS,WAAW,CAAC,QAAQ,IAAI,GAAG;AACtC,cAAM,mBAAmB,OAAO,KAAK,SAAS,OAAO,EAAE,CAAC,KAAK;AAC7D,gBAAQ,IAAI,IAAI,SAAS,UAAU,eAAe,gBAAgB,GAAG;AAAA,MACvE;AAAA,IACF,CAAC;AAAA,EACH;AAEA,MAAI,SAAS,SAAS,eAAe,GAAG;AACtC,WAAO,QAAQ,aAAa,EAAE,QAAQ,CAAC,CAAC,MAAM,OAAO,MAA4C;AAC/F,UAAI,QAAQ,WAAW,CAAC,QAAQ,IAAI,GAAG;AACrC,cAAM,mBAAmB,OAAO,KAAK,QAAQ,OAAO,EAAE,CAAC,KAAK;AAC5D,gBAAQ,IAAI,IAAI,QAAQ,UAAU,eAAe,gBAAgB,GAAG;AAAA,MACtE;AAAA,IACF,CAAC;AAAA,EACH;AAEA,SAAO;AACT;;;AC5CA;AAAA,SAAS,eAAe;AAExB,SAAS,eAAe;AAExB,SAA6B,aAAa;AAI1C,OAAO,UAAU;AAEV,SAAS,gBAAgB,QAAgB,UAAyB,CAAC,GAAiB;AACzF,MAAI,UAAU,OAAO,OAAO;AAC1B,QAAI,OAAO,OAAO,MAAM,SAAS,UAAU;AACzC,YAAMA,OAA4B,KAAK,MAAM,KAAK,UAAU,OAAO,MAAM,IAAI,CAAC;AAC9E,aAAO,MAAMA,MAAK,OAAO;AAAA,IAC3B;AAEA,QAAI;AACF,YAAMA,OAAc,KAAK,MAAM,OAAO,MAAM,IAAc;AAE1D,aAAO,MAAMA,MAAK,OAAO;AAAA,IAC3B,SAAS,GAAG;AAAA,IAEZ;AAEA,UAAM,MAA4B,KAAK,MAAM,KAAK,UAAU,OAAO,MAAM,IAAI,CAAC;AAE9E,WAAO,MAAM,KAAK,OAAO;AAAA,EAC3B;AAEA,MAAI,IAAI,QAAQ,OAAO,MAAM,IAAI,EAAE,OAAO;AACxC,WAAO,MAAM,OAAO,MAAM,MAAM,OAAO;AAAA,EACzC;AAEA,SAAO,MAAM,QAAQ,OAAO,MAAM,OAAO,MAAM,IAAI,GAAG,OAAO;AAC/D;;;ACnCA;AAAA,SAAS,6BAA6B;AAuB/B,SAAS,iBAAmD,KAA6D;AAC9H,SAAO,CAAC,WAA0B;AAChC,UAAM,UAAU,sBAAsB,IAAI,GAAG,IAAI,QAAQ;AAEzD,WAAO;AAAA,MACL;AAAA,MACA;AAAA,IACF;AAAA,EACF;AACF;","names":["api"]}

package/dist/chunk-55NUFNT6.cjs

@@ -0,0 +1,68 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet = (obj, member, value, setter) => {
+  __accessCheck(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var __privateMethod = (obj, member, method) => {
+  __accessCheck(obj, member, "access private method");
+  return method;
+};
+
+// ../../node_modules/.pnpm/tsup@8.0.2_@microsoft+api-extractor@7.43.3_@types+node@20.12.11__postcss@8.4.38_ts-node@10.9._m3ved7kneisj6uq6vsf2lw6r5q/node_modules/tsup/assets/cjs_shims.js
+var init_cjs_shims = __esm({
+  "../../node_modules/.pnpm/tsup@8.0.2_@microsoft+api-extractor@7.43.3_@types+node@20.12.11__postcss@8.4.38_ts-node@10.9._m3ved7kneisj6uq6vsf2lw6r5q/node_modules/tsup/assets/cjs_shims.js"() {
+    "use strict";
+  }
+});
+
+
+
+
+
+
+
+
+
+exports.__commonJS = __commonJS; exports.__toESM = __toESM; exports.__privateGet = __privateGet; exports.__privateAdd = __privateAdd; exports.__privateSet = __privateSet; exports.__privateMethod = __privateMethod; exports.init_cjs_shims = init_cjs_shims;
+//# sourceMappingURL=chunk-55NUFNT6.cjs.map

package/dist/chunk-55NUFNT6.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../node_modules/.pnpm/tsup@8.0.2_@microsoft+api-extractor@7.43.3_@types+node@20.12.11__postcss@8.4.38_ts-node@10.9._m3ved7kneisj6uq6vsf2lw6r5q/node_modules/tsup/assets/cjs_shims.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA","sourcesContent":["// Shim globals in cjs bundle\n// There's a weird bug that esbuild will always inject importMetaUrl\n// if we export it as `const importMetaUrl = ... __filename ...`\n// But using a function will not cause this issue\n\nconst getImportMetaUrl = () =>\n  typeof document === 'undefined'\n    ? new URL('file:' + __filename).href\n    : (document.currentScript && document.currentScript.src) ||\n      new URL('main.js', document.baseURI).href\n\nexport const importMetaUrl = /* @__PURE__ */ getImportMetaUrl()\n"]}

package/dist/chunk-ECXSQTMV.cjs

@@ -0,0 +1,81 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunk55NUFNT6cjs = require('./chunk-55NUFNT6.cjs');
+
+// src/utils/getSchemas.ts
+_chunk55NUFNT6cjs.init_cjs_shims.call(void 0, );
+function getSchemas({ oas, contentType, includes = ["schemas", "requestBodies", "responses"] }) {
+  const components = oas.getDefinition().components;
+  let schemas = {};
+  if (includes.includes("schemas")) {
+    schemas = {
+      ...schemas,
+      ..._optionalChain([components, 'optionalAccess', _ => _.schemas]) || {}
+    };
+  }
+  const requestBodies = _optionalChain([components, 'optionalAccess', _2 => _2.requestBodies]) || {};
+  if (includes.includes("responses")) {
+    const responses = _optionalChain([components, 'optionalAccess', _3 => _3.responses]) || {};
+    Object.entries(responses).forEach(([name, response]) => {
+      if (response.content && !schemas[name]) {
+        const firstContentType = Object.keys(response.content)[0] || "application/json";
+        schemas[name] = _optionalChain([response, 'access', _4 => _4.content, 'optionalAccess', _5 => _5[contentType || firstContentType], 'optionalAccess', _6 => _6.schema]);
+      }
+    });
+  }
+  if (includes.includes("requestBodies")) {
+    Object.entries(requestBodies).forEach(([name, request]) => {
+      if (request.content && !schemas[name]) {
+        const firstContentType = Object.keys(request.content)[0] || "application/json";
+        schemas[name] = _optionalChain([request, 'access', _7 => _7.content, 'optionalAccess', _8 => _8[contentType || firstContentType], 'optionalAccess', _9 => _9.schema]);
+      }
+    });
+  }
+  return schemas;
+}
+
+// src/utils/parseFromConfig.ts
+_chunk55NUFNT6cjs.init_cjs_shims.call(void 0, );
+var _path = require('path');
+var _utils = require('@kubb/core/utils');
+var _parser = require('@kubb/oas/parser');
+var _yaml = require('@stoplight/yaml'); var _yaml2 = _interopRequireDefault(_yaml);
+function parseFromConfig(config, options = {}) {
+  if ("data" in config.input) {
+    if (typeof config.input.data === "object") {
+      const api2 = JSON.parse(JSON.stringify(config.input.data));
+      return _parser.parse.call(void 0, api2, options);
+    }
+    try {
+      const api2 = _yaml2.default.parse(config.input.data);
+      return _parser.parse.call(void 0, api2, options);
+    } catch (e) {
+    }
+    const api = JSON.parse(JSON.stringify(config.input.data));
+    return _parser.parse.call(void 0, api, options);
+  }
+  if (new (0, _utils.URLPath)(config.input.path).isURL) {
+    return _parser.parse.call(void 0, config.input.path, options);
+  }
+  return _parser.parse.call(void 0, _path.resolve.call(void 0, config.root, config.input.path), options);
+}
+
+// src/utils/getSchemaFactory.ts
+_chunk55NUFNT6cjs.init_cjs_shims.call(void 0, );
+var _oas = require('@kubb/oas');
+function getSchemaFactory(oas) {
+  return (schema) => {
+    const version = _oas.isOpenApiV3_1Document.call(void 0, oas.api) ? "3.1" : "3.0";
+    return {
+      schema,
+      version
+    };
+  };
+}
+
+
+
+
+
+exports.getSchemas = getSchemas; exports.parseFromConfig = parseFromConfig; exports.getSchemaFactory = getSchemaFactory;
+//# sourceMappingURL=chunk-ECXSQTMV.cjs.map

package/dist/chunk-ECXSQTMV.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils/getSchemas.ts","../src/utils/parseFromConfig.ts","../src/utils/getSchemaFactory.ts"],"names":["api"],"mappings":";;;;;AAAA;AAUO,SAAS,WAAW,EAAE,KAAK,aAAa,WAAW,CAAC,WAAW,iBAAiB,WAAW,EAAE,GAA2D;AAC7J,QAAM,aAAa,IAAI,cAAc,EAAE;AAEvC,MAAI,UAAiD,CAAC;AAEtD,MAAI,SAAS,SAAS,SAAS,GAAG;AAChC,cAAU;AAAA,MACR,GAAG;AAAA,MACH,GAAK,YAAY,WAAqD,CAAC;AAAA,IACzE;AAAA,EACF;AAEA,QAAM,gBAAgB,YAAY,iBAAiB,CAAC;AACpD,MAAI,SAAS,SAAS,WAAW,GAAG;AAClC,UAAM,YAAY,YAAY,aAAa,CAAC;AAE5C,WAAO,QAAQ,SAAS,EAAE,QAAQ,CAAC,CAAC,MAAM,QAAQ,MAAyC;AACzF,UAAI,SAAS,WAAW,CAAC,QAAQ,IAAI,GAAG;AACtC,cAAM,mBAAmB,OAAO,KAAK,SAAS,OAAO,EAAE,CAAC,KAAK;AAC7D,gBAAQ,IAAI,IAAI,SAAS,UAAU,eAAe,gBAAgB,GAAG;AAAA,MACvE;AAAA,IACF,CAAC;AAAA,EACH;AAEA,MAAI,SAAS,SAAS,eAAe,GAAG;AACtC,WAAO,QAAQ,aAAa,EAAE,QAAQ,CAAC,CAAC,MAAM,OAAO,MAA4C;AAC/F,UAAI,QAAQ,WAAW,CAAC,QAAQ,IAAI,GAAG;AACrC,cAAM,mBAAmB,OAAO,KAAK,QAAQ,OAAO,EAAE,CAAC,KAAK;AAC5D,gBAAQ,IAAI,IAAI,QAAQ,UAAU,eAAe,gBAAgB,GAAG;AAAA,MACtE;AAAA,IACF,CAAC;AAAA,EACH;AAEA,SAAO;AACT;;;AC5CA;AAAA,SAAS,eAAe;AAExB,SAAS,eAAe;AAExB,SAA6B,aAAa;AAI1C,OAAO,UAAU;AAEV,SAAS,gBAAgB,QAAgB,UAAyB,CAAC,GAAiB;AACzF,MAAI,UAAU,OAAO,OAAO;AAC1B,QAAI,OAAO,OAAO,MAAM,SAAS,UAAU;AACzC,YAAMA,OAA4B,KAAK,MAAM,KAAK,UAAU,OAAO,MAAM,IAAI,CAAC;AAC9E,aAAO,MAAMA,MAAK,OAAO;AAAA,IAC3B;AAEA,QAAI;AACF,YAAMA,OAAc,KAAK,MAAM,OAAO,MAAM,IAAc;AAE1D,aAAO,MAAMA,MAAK,OAAO;AAAA,IAC3B,SAAS,GAAG;AAAA,IAEZ;AAEA,UAAM,MAA4B,KAAK,MAAM,KAAK,UAAU,OAAO,MAAM,IAAI,CAAC;AAE9E,WAAO,MAAM,KAAK,OAAO;AAAA,EAC3B;AAEA,MAAI,IAAI,QAAQ,OAAO,MAAM,IAAI,EAAE,OAAO;AACxC,WAAO,MAAM,OAAO,MAAM,MAAM,OAAO;AAAA,EACzC;AAEA,SAAO,MAAM,QAAQ,OAAO,MAAM,OAAO,MAAM,IAAI,GAAG,OAAO;AAC/D;;;ACnCA;AAAA,SAAS,6BAA6B;AAuB/B,SAAS,iBAAmD,KAA6D;AAC9H,SAAO,CAAC,WAA0B;AAChC,UAAM,UAAU,sBAAsB,IAAI,GAAG,IAAI,QAAQ;AAEzD,WAAO;AAAA,MACL;AAAA,MACA;AAAA,IACF;AAAA,EACF;AACF","sourcesContent":["import type { Oas, OasTypes, contentType } from '@kubb/oas'\n\ntype Mode = 'schemas' | 'responses' | 'requestBodies'\n\nexport type GetSchemasProps = {\n  oas: Oas\n  contentType?: contentType\n  includes?: Mode[]\n}\n\nexport function getSchemas({ oas, contentType, includes = ['schemas', 'requestBodies', 'responses'] }: GetSchemasProps): Record<string, OasTypes.SchemaObject> {\n  const components = oas.getDefinition().components\n\n  let schemas: Record<string, OasTypes.SchemaObject> = {}\n\n  if (includes.includes('schemas')) {\n    schemas = {\n      ...schemas,\n      ...((components?.schemas as Record<string, OasTypes.SchemaObject>) || {}),\n    }\n  }\n\n  const requestBodies = components?.requestBodies || {}\n  if (includes.includes('responses')) {\n    const responses = components?.responses || {}\n\n    Object.entries(responses).forEach(([name, response]: [string, OasTypes.ResponseObject]) => {\n      if (response.content && !schemas[name]) {\n        const firstContentType = Object.keys(response.content)[0] || 'application/json'\n        schemas[name] = response.content?.[contentType || firstContentType]?.schema as OasTypes.SchemaObject\n      }\n    })\n  }\n\n  if (includes.includes('requestBodies')) {\n    Object.entries(requestBodies).forEach(([name, request]: [string, OasTypes.RequestBodyObject]) => {\n      if (request.content && !schemas[name]) {\n        const firstContentType = Object.keys(request.content)[0] || 'application/json'\n        schemas[name] = request.content?.[contentType || firstContentType]?.schema as OasTypes.SchemaObject\n      }\n    })\n  }\n\n  return schemas\n}\n","import { resolve } from 'node:path'\n\nimport { URLPath } from '@kubb/core/utils'\n\nimport { type FormatOptions, parse } from '@kubb/oas/parser'\n\nimport type { Config } from '@kubb/core'\nimport type { Oas, OasTypes } from '@kubb/oas'\nimport yaml from '@stoplight/yaml'\n\nexport function parseFromConfig(config: Config, options: FormatOptions = {}): 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, options)\n    }\n\n    try {\n      const api: string = yaml.parse(config.input.data as string) as string\n\n      return parse(api, options)\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, options)\n  }\n\n  if (new URLPath(config.input.path).isURL) {\n    return parse(config.input.path, options)\n  }\n\n  return parse(resolve(config.root, config.input.path), options)\n}\n","import { isOpenApiV3_1Document } from '@kubb/oas'\n\nimport type { Oas, OpenAPIV3, OpenAPIV3_1, SchemaObject } from '@kubb/oas'\n\n/**\n * Make it possible to narrow down the schema based on a specific version(3 or 3.1)\n */\ntype SchemaResult<TWithRef extends boolean = false> =\n  | {\n      schema?: (TWithRef extends true ? OpenAPIV3.SchemaObject | OpenAPIV3.ReferenceObject : OpenAPIV3.SchemaObject) & {\n        nullable?: boolean\n        'x-nullable'?: boolean\n      }\n      version: '3.0'\n    }\n  | {\n      schema?: (TWithRef extends true ? OpenAPIV3_1.SchemaObject | OpenAPIV3_1.ReferenceObject : OpenAPIV3_1.SchemaObject) & {\n        nullable?: boolean\n        'x-nullable'?: boolean\n      }\n      version: '3.1'\n    }\n\nexport function getSchemaFactory<TWithRef extends boolean = false>(oas: Oas): (schema?: SchemaObject) => SchemaResult<TWithRef> {\n  return (schema?: SchemaObject) => {\n    const version = isOpenApiV3_1Document(oas.api) ? '3.1' : '3.0'\n\n    return {\n      schema,\n      version,\n    } as SchemaResult<TWithRef>\n  }\n}\n"]}