@kubb/plugin-oas 0.0.0-canary-20240509211223

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Stijn Van Hulle
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,44 @@
+<div align="center">
+
+<!-- <img src="assets/logo.png" alt="logo" width="200" height="auto" /> -->
+<h1>@kubb/plugin-oas</h1>
+
+<p>
+   Swagger package.
+  </p>
+  <img src="https://raw.githubusercontent.com/kubb-labs/kubb/main/assets/banner.png" alt="logo"  height="auto" />
+
+[![npm version][npm-version-src]][npm-version-href]
+[![npm downloads][npm-downloads-src]][npm-downloads-href]
+[![Coverage][coverage-src]][coverage-href]
+[![License][license-src]][license-href]
+
+<!-- ALL-CONTRIBUTORS-BADGE:START - Do not remove or modify this section -->
+<!-- ALL-CONTRIBUTORS-BADGE:END -->
+</p>
+
+<h4>
+    <a href="https://codesandbox.io/s/github/kubb-labs/kubb/tree/alpha/examples/typescript" target="_blank">View Demo</a>
+    <span> · </span>
+      <a href="https://kubb.dev/" target="_blank">Documentation</a>
+    <span> · </span>
+      <a href="https://github.com/kubb-labs/kubb/issues/" target="_blank">Report Bug</a>
+    <span> · </span>
+      <a href="https://github.com/kubb-labs/kubb/issues/" target="_blank">Request Feature</a>
+  </h4>
+</div>
+
+<!-- Badges -->
+
+[npm-version-src]: https://img.shields.io/npm/v/@kubb/plugin-oas?flat&colorA=18181B&colorB=f58517
+[npm-version-href]: https://npmjs.com/package/@kubb/plugin-oas
+[npm-downloads-src]: https://img.shields.io/npm/dm/@kubb/plugin-oas?flat&colorA=18181B&colorB=f58517
+[npm-downloads-href]: https://npmjs.com/package/@kubb/plugin-oas
+[license-src]: https://img.shields.io/github/license/kubb-labs/kubb.svg?flat&colorA=18181B&colorB=f58517
+[license-href]: https://github.com/kubb-labs/kubb/blob/main/LICENSE
+[build-src]: https://img.shields.io/github/actions/workflow/status/kubb-labs/kubb/ci.yaml?style=flat&colorA=18181B&colorB=f58517
+[build-href]: https://www.npmjs.com/package/@kubb/plugin-oas
+[minified-src]: https://img.shields.io/bundlephobia/min/@kubb/plugin-oas?style=flat&colorA=18181B&colorB=f58517
+[minified-href]: https://www.npmjs.com/package/@kubb/plugin-oas
+[coverage-src]: https://img.shields.io/codecov/c/github/kubb-labs/kubb?style=flat&colorA=18181B&colorB=f58517
+[coverage-href]: https://www.npmjs.com/package/@kubb/plugin-oas

package/dist/OperationGenerator-DvnXUUp4.d.ts

@@ -0,0 +1,56 @@
+import { KubbFile, PluginFactoryOptions, Generator, PluginManager, Plugin } from '@kubb/core';
+import { Operation, Oas, contentType } from '@kubb/oas';
+import { f as OperationsByMethod, e as OperationSchemas, E as Exclude, I as Include, g as Override } from './types-n5zV4Q3s.js';
+
+type GetOperationGeneratorOptions<T extends OperationGenerator<any, any, any>> = T extends OperationGenerator<infer Options, any, any> ? Options : never;
+type OperationMethodResult<TFileMeta extends KubbFile.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 abstract class OperationGenerator<TOptions = unknown, TPluginOptions extends PluginFactoryOptions = PluginFactoryOptions, TFileMeta extends KubbFile.FileMetaBase = KubbFile.FileMetaBase> extends Generator<TOptions, Context<TOptions, TPluginOptions>> {
+    #private;
+    get operationsByMethod(): OperationsByMethod;
+    set operationsByMethod(paths: OperationsByMethod);
+    getSchemas(operation: Operation, forStatusCode?: string | number): OperationSchemas;
+    build(): Promise<Array<KubbFile.File<TFileMeta>>>;
+    /**
+     * Operation
+     */
+    abstract operation(operation: Operation, options: TOptions): OperationMethodResult<TFileMeta>;
+    /**
+     * GET
+     */
+    abstract get(operation: Operation, options: TOptions): OperationMethodResult<TFileMeta>;
+    /**
+     * POST
+     */
+    abstract post(operation: Operation, options: TOptions): OperationMethodResult<TFileMeta>;
+    /**
+     * PATCH
+     */
+    abstract patch(operation: Operation, options: TOptions): OperationMethodResult<TFileMeta>;
+    /**
+     * PUT
+     */
+    abstract put(operation: Operation, options: TOptions): OperationMethodResult<TFileMeta>;
+    /**
+     * DELETE
+     */
+    abstract delete(operation: Operation, options: TOptions): OperationMethodResult<TFileMeta>;
+    /**
+     * Combination of GET, POST, PATCH, PUT, DELETE
+     */
+    abstract all(operations: Operation[], paths: OperationsByMethod): OperationMethodResult<TFileMeta>;
+}
+
+export { type GetOperationGeneratorOptions as G, type OperationMethodResult as O, OperationGenerator as a };

package/dist/OperationGenerator-X6CTMfhG.d.cts

@@ -0,0 +1,56 @@
+import { KubbFile, PluginFactoryOptions, Generator, PluginManager, Plugin } from '@kubb/core';
+import { Operation, Oas, contentType } from '@kubb/oas';
+import { f as OperationsByMethod, e as OperationSchemas, E as Exclude, I as Include, g as Override } from './types-n5zV4Q3s.cjs';
+
+type GetOperationGeneratorOptions<T extends OperationGenerator<any, any, any>> = T extends OperationGenerator<infer Options, any, any> ? Options : never;
+type OperationMethodResult<TFileMeta extends KubbFile.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 abstract class OperationGenerator<TOptions = unknown, TPluginOptions extends PluginFactoryOptions = PluginFactoryOptions, TFileMeta extends KubbFile.FileMetaBase = KubbFile.FileMetaBase> extends Generator<TOptions, Context<TOptions, TPluginOptions>> {
+    #private;
+    get operationsByMethod(): OperationsByMethod;
+    set operationsByMethod(paths: OperationsByMethod);
+    getSchemas(operation: Operation, forStatusCode?: string | number): OperationSchemas;
+    build(): Promise<Array<KubbFile.File<TFileMeta>>>;
+    /**
+     * Operation
+     */
+    abstract operation(operation: Operation, options: TOptions): OperationMethodResult<TFileMeta>;
+    /**
+     * GET
+     */
+    abstract get(operation: Operation, options: TOptions): OperationMethodResult<TFileMeta>;
+    /**
+     * POST
+     */
+    abstract post(operation: Operation, options: TOptions): OperationMethodResult<TFileMeta>;
+    /**
+     * PATCH
+     */
+    abstract patch(operation: Operation, options: TOptions): OperationMethodResult<TFileMeta>;
+    /**
+     * PUT
+     */
+    abstract put(operation: Operation, options: TOptions): OperationMethodResult<TFileMeta>;
+    /**
+     * DELETE
+     */
+    abstract delete(operation: Operation, options: TOptions): OperationMethodResult<TFileMeta>;
+    /**
+     * Combination of GET, POST, PATCH, PUT, DELETE
+     */
+    abstract all(operations: Operation[], paths: OperationsByMethod): OperationMethodResult<TFileMeta>;
+}
+
+export { type GetOperationGeneratorOptions as G, type OperationMethodResult as O, OperationGenerator as a };

package/dist/Schema-BWPWyiQO.d.cts

@@ -0,0 +1,39 @@
+import * as react from 'react';
+import { ReactNode } from 'react';
+import { SchemaObject } from '@kubb/oas';
+import { KubbNode } from '@kubb/react';
+import { S as SchemaGeneratorBuildOptions, d as Schema$1, c as SchemaGenerator } from './SchemaGenerator-z_7YrAAB.cjs';
+
+type SchemaContextProps = {
+    name: string;
+    object?: SchemaObject;
+    generator?: SchemaGenerator;
+    schemas: Schema$1[];
+};
+type Props = {
+    name: string;
+    object?: SchemaObject;
+    generator: SchemaGenerator<any, any, any>;
+    children?: KubbNode;
+};
+declare function Schema({ name, object, generator, children }: Props): KubbNode;
+declare namespace Schema {
+    var File: ({ output, isTypeOnly, children }: FileProps) => ReactNode;
+    var Imports: ({ isTypeOnly }: SchemaImportsProps) => ReactNode;
+    var Source: <TOptions extends SchemaGeneratorBuildOptions = SchemaGeneratorBuildOptions>({ options, extraSchemas, }: SchemaSourceProps<TOptions>) => ReactNode;
+    var Context: react.Context<SchemaContextProps>;
+}
+type FileProps = {
+    isTypeOnly?: boolean;
+    output: string | undefined;
+    children?: KubbNode;
+};
+type SchemaImportsProps = {
+    isTypeOnly?: boolean;
+};
+type SchemaSourceProps<TOptions extends SchemaGeneratorBuildOptions = SchemaGeneratorBuildOptions> = {
+    extraSchemas?: Schema$1[];
+    options?: TOptions;
+};
+
+export { Schema as S, type SchemaContextProps as a };

package/dist/Schema-DFZBfjF2.d.ts

@@ -0,0 +1,39 @@
+import * as react from 'react';
+import { ReactNode } from 'react';
+import { SchemaObject } from '@kubb/oas';
+import { KubbNode } from '@kubb/react';
+import { S as SchemaGeneratorBuildOptions, d as Schema$1, c as SchemaGenerator } from './SchemaGenerator-hK5SHxTI.js';
+
+type SchemaContextProps = {
+    name: string;
+    object?: SchemaObject;
+    generator?: SchemaGenerator;
+    schemas: Schema$1[];
+};
+type Props = {
+    name: string;
+    object?: SchemaObject;
+    generator: SchemaGenerator<any, any, any>;
+    children?: KubbNode;
+};
+declare function Schema({ name, object, generator, children }: Props): KubbNode;
+declare namespace Schema {
+    var File: ({ output, isTypeOnly, children }: FileProps) => ReactNode;
+    var Imports: ({ isTypeOnly }: SchemaImportsProps) => ReactNode;
+    var Source: <TOptions extends SchemaGeneratorBuildOptions = SchemaGeneratorBuildOptions>({ options, extraSchemas, }: SchemaSourceProps<TOptions>) => ReactNode;
+    var Context: react.Context<SchemaContextProps>;
+}
+type FileProps = {
+    isTypeOnly?: boolean;
+    output: string | undefined;
+    children?: KubbNode;
+};
+type SchemaImportsProps = {
+    isTypeOnly?: boolean;
+};
+type SchemaSourceProps<TOptions extends SchemaGeneratorBuildOptions = SchemaGeneratorBuildOptions> = {
+    extraSchemas?: Schema$1[];
+    options?: TOptions;
+};
+
+export { Schema as S, type SchemaContextProps as a };

package/dist/SchemaGenerator-hK5SHxTI.d.ts

@@ -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.js';
+
+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 };