@kubb/plugin-ts 3.0.0-alpha.0

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,45 @@
+<div align="center">
+
+<!-- <img src="assets/logo.png" alt="logo" width="200" height="auto" /> -->
+<h1>@kubb/plugin-ts</h1>
+
+<p>
+   Swagger integration for TypeScript to generate all the different types based on an OpenAPI specification.
+  </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-ts?flat&colorA=18181B&colorB=f58517
+[npm-version-href]: https://npmjs.com/package/@kubb/plugin-ts
+[npm-downloads-src]: https://img.shields.io/npm/dm/@kubb/plugin-ts?flat&colorA=18181B&colorB=f58517
+[npm-downloads-href]: https://npmjs.com/package/@kubb/plugin-ts
+[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-ts
+[minified-src]: https://img.shields.io/bundlephobia/min/@kubb/plugin-ts?style=flat&colorA=18181B&colorB=f58517
+[minified-href]: https://www.npmjs.com/package/@kubb/plugin-ts
+[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-ts

package/dist/chunk-WOQIHEJC.js

@@ -0,0 +1,621 @@
+// src/plugin.ts
+import path from "path";
+import { FileManager, PluginManager, createPlugin } from "@kubb/core";
+import { camelCase, pascalCase } from "@kubb/core/transformers";
+import { renderTemplate } from "@kubb/core/utils";
+import { pluginOasName } from "@kubb/plugin-oas";
+
+// src/OperationGenerator.tsx
+import { OperationGenerator as Generator2 } from "@kubb/plugin-oas";
+import { Oas as Oas4 } from "@kubb/plugin-oas/components";
+import { App as App2, createRoot as createRoot2 } from "@kubb/react";
+
+// src/components/OasType.tsx
+import { Parser, File, Type, useApp } from "@kubb/react";
+import { useOas } from "@kubb/plugin-oas/hooks";
+import { Fragment, jsx, jsxs } from "@kubb/react/jsx-runtime";
+function Template({ name, typeName, api }) {
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    `export const ${name} = ${JSON.stringify(api, void 0, 2)} as const`,
+    /* @__PURE__ */ jsx("br", {}),
+    /* @__PURE__ */ jsx(Type, { name: typeName, export: true, children: `Infer<typeof ${name}>` })
+  ] });
+}
+var defaultTemplates = { default: Template };
+function OasType({ name, typeName, Template: Template2 = defaultTemplates.default }) {
+  const oas = useOas();
+  return /* @__PURE__ */ jsx(Template2, { name, typeName, api: oas.api });
+}
+OasType.File = function({ name, typeName, templates = defaultTemplates }) {
+  const {
+    pluginManager,
+    plugin: { key: pluginKey }
+  } = useApp();
+  const file = pluginManager.getFile({ name, extName: ".ts", pluginKey });
+  const Template2 = templates.default;
+  return /* @__PURE__ */ jsx(Parser, { language: "typescript", children: /* @__PURE__ */ jsxs(File, { baseName: file.baseName, path: file.path, meta: file.meta, children: [
+    /* @__PURE__ */ jsx(File.Import, { name: ["Infer"], path: "@kubb/oas", isTypeOnly: true }),
+    /* @__PURE__ */ jsx(File.Source, { children: /* @__PURE__ */ jsx(OasType, { Template: Template2, name, typeName }) })
+  ] }) });
+};
+OasType.templates = defaultTemplates;
+
+// src/components/OperationSchema.tsx
+import transformers3 from "@kubb/core/transformers";
+import { print as print2 } from "@kubb/parser-ts";
+import * as factory3 from "@kubb/parser-ts/factory";
+import { Oas as Oas3 } from "@kubb/plugin-oas/components";
+import { useOas as useOas2, useOperation, useOperationManager } from "@kubb/plugin-oas/hooks";
+import { File as File3, Parser as Parser2, useApp as useApp3 } from "@kubb/react";
+
+// src/SchemaGenerator.tsx
+import { SchemaGenerator as Generator } from "@kubb/plugin-oas";
+import { Oas as Oas2 } from "@kubb/plugin-oas/components";
+import { App, createRoot } from "@kubb/react";
+
+// src/components/Schema.tsx
+import { Oas } from "@kubb/plugin-oas/components";
+import { File as File2, useApp as useApp2 } from "@kubb/react";
+import transformers2 from "@kubb/core/transformers";
+import { print } from "@kubb/parser-ts";
+import * as factory2 from "@kubb/parser-ts/factory";
+import { SchemaGenerator, schemaKeywords as schemaKeywords2 } from "@kubb/plugin-oas";
+import { useSchema } from "@kubb/plugin-oas/hooks";
+
+// src/parser/index.ts
+import transformers from "@kubb/core/transformers";
+import * as factory from "@kubb/parser-ts/factory";
+import { isKeyword, schemaKeywords } from "@kubb/plugin-oas";
+var typeKeywordMapper = {
+  any: () => factory.keywordTypeNodes.any,
+  unknown: () => factory.keywordTypeNodes.unknown,
+  number: () => factory.keywordTypeNodes.number,
+  integer: () => factory.keywordTypeNodes.number,
+  object: (nodes) => {
+    if (!nodes || !nodes.length) {
+      return factory.keywordTypeNodes.object;
+    }
+    return factory.createTypeLiteralNode(nodes);
+  },
+  string: () => factory.keywordTypeNodes.string,
+  boolean: () => factory.keywordTypeNodes.boolean,
+  undefined: () => factory.keywordTypeNodes.undefined,
+  nullable: void 0,
+  null: () => factory.keywordTypeNodes.null,
+  nullish: void 0,
+  array: (nodes) => {
+    if (!nodes) {
+      return void 0;
+    }
+    return factory.createArrayDeclaration({ nodes });
+  },
+  tuple: (nodes) => {
+    if (!nodes) {
+      return void 0;
+    }
+    return factory.createTupleTypeNode(nodes);
+  },
+  enum: (name) => {
+    if (!name) {
+      return void 0;
+    }
+    return factory.createTypeReferenceNode(name, void 0);
+  },
+  union: (nodes) => {
+    if (!nodes) {
+      return void 0;
+    }
+    return factory.createUnionDeclaration({
+      withParentheses: true,
+      nodes
+    });
+  },
+  const: (name, format) => {
+    if (!name) {
+      return void 0;
+    }
+    if (format === "number") {
+      return factory.createLiteralTypeNode(factory.createNumericLiteral(name));
+    }
+    return factory.createLiteralTypeNode(factory.createStringLiteral(name.toString()));
+  },
+  datetime: () => factory.keywordTypeNodes.string,
+  date: (type = "string") => type === "string" ? factory.keywordTypeNodes.string : factory.createTypeReferenceNode(factory.createIdentifier("Date")),
+  time: (type = "string") => type === "string" ? factory.keywordTypeNodes.string : factory.createTypeReferenceNode(factory.createIdentifier("Date")),
+  uuid: void 0,
+  url: void 0,
+  strict: void 0,
+  default: void 0,
+  and: (nodes) => {
+    if (!nodes) {
+      return void 0;
+    }
+    return factory.createIntersectionDeclaration({
+      withParentheses: true,
+      nodes
+    });
+  },
+  describe: void 0,
+  min: void 0,
+  max: void 0,
+  optional: void 0,
+  matches: void 0,
+  email: void 0,
+  firstName: void 0,
+  lastName: void 0,
+  password: void 0,
+  phone: void 0,
+  readOnly: void 0,
+  ref: (propertyName) => {
+    if (!propertyName) {
+      return void 0;
+    }
+    return factory.createTypeReferenceNode(propertyName, void 0);
+  },
+  blob: () => factory.createTypeReferenceNode("Blob", []),
+  deprecated: void 0,
+  example: void 0,
+  schema: void 0,
+  catchall: void 0,
+  name: void 0
+};
+function parse(parent, current, options) {
+  const value = typeKeywordMapper[current.keyword];
+  if (!value) {
+    return void 0;
+  }
+  if (isKeyword(current, schemaKeywords.union)) {
+    return typeKeywordMapper.union(current.args.map((schema) => parse(current, schema, options)).filter(Boolean));
+  }
+  if (isKeyword(current, schemaKeywords.and)) {
+    return typeKeywordMapper.and(current.args.map((schema) => parse(current, schema, options)).filter(Boolean));
+  }
+  if (isKeyword(current, schemaKeywords.array)) {
+    return typeKeywordMapper.array(current.args.items.map((schema) => parse(current, schema, options)).filter(Boolean));
+  }
+  if (isKeyword(current, schemaKeywords.enum)) {
+    return typeKeywordMapper.enum(current.args.typeName);
+  }
+  if (isKeyword(current, schemaKeywords.ref)) {
+    return typeKeywordMapper.ref(current.args.name);
+  }
+  if (isKeyword(current, schemaKeywords.blob)) {
+    return value();
+  }
+  if (isKeyword(current, schemaKeywords.tuple)) {
+    return typeKeywordMapper.tuple(current.args.items.map((schema) => parse(current, schema, options)).filter(Boolean));
+  }
+  if (isKeyword(current, schemaKeywords.const)) {
+    return typeKeywordMapper.const(current.args.name, current.args.format);
+  }
+  if (isKeyword(current, schemaKeywords.object)) {
+    const properties = Object.entries(current.args?.properties || {}).filter((item) => {
+      const schemas = item[1];
+      return schemas && typeof schemas.map === "function";
+    }).map(([name, schemas]) => {
+      const nameSchema = schemas.find((schema) => schema.keyword === schemaKeywords.name);
+      const mappedName = nameSchema?.args || name;
+      if (options.mapper?.[mappedName]) {
+        return options.mapper?.[mappedName];
+      }
+      const isNullish = schemas.some((schema) => schema.keyword === schemaKeywords.nullish);
+      const isNullable = schemas.some((schema) => schema.keyword === schemaKeywords.nullable);
+      const isOptional = schemas.some((schema) => schema.keyword === schemaKeywords.optional);
+      const isReadonly = schemas.some((schema) => schema.keyword === schemaKeywords.readOnly);
+      const describeSchema = schemas.find((schema) => schema.keyword === schemaKeywords.describe);
+      const deprecatedSchema = schemas.find((schema) => schema.keyword === schemaKeywords.deprecated);
+      const defaultSchema = schemas.find((schema) => schema.keyword === schemaKeywords.default);
+      const exampleSchema = schemas.find((schema) => schema.keyword === schemaKeywords.example);
+      const schemaSchema = schemas.find((schema) => schema.keyword === schemaKeywords.schema);
+      let type = schemas.map((schema) => parse(current, schema, options)).filter(Boolean)[0];
+      if (isNullable) {
+        type = factory.createUnionDeclaration({
+          nodes: [type, factory.keywordTypeNodes.null]
+        });
+      }
+      if (isNullish && ["undefined", "questionTokenAndUndefined"].includes(options.optionalType)) {
+        type = factory.createUnionDeclaration({
+          nodes: [type, factory.keywordTypeNodes.undefined]
+        });
+      }
+      if (isOptional && ["undefined", "questionTokenAndUndefined"].includes(options.optionalType)) {
+        type = factory.createUnionDeclaration({
+          nodes: [type, factory.keywordTypeNodes.undefined]
+        });
+      }
+      const propertySignature = factory.createPropertySignature({
+        questionToken: isOptional || isNullish ? ["questionToken", "questionTokenAndUndefined"].includes(options.optionalType) : false,
+        name: mappedName,
+        type,
+        readOnly: isReadonly
+      });
+      return factory.appendJSDocToNode({
+        node: propertySignature,
+        comments: [
+          describeSchema ? `@description ${transformers.jsStringEscape(describeSchema.args)}` : void 0,
+          deprecatedSchema ? "@deprecated" : void 0,
+          defaultSchema ? `@default ${defaultSchema.args}` : void 0,
+          exampleSchema ? `@example ${exampleSchema.args}` : void 0,
+          schemaSchema?.args?.type || schemaSchema?.args?.format ? [`@type ${schemaSchema?.args?.type || "unknown"}${!isOptional ? "" : " | undefined"}`, schemaSchema?.args?.format].filter(Boolean).join(", ") : void 0
+        ].filter(Boolean)
+      });
+    });
+    const additionalProperties = current.args?.additionalProperties?.length ? factory.createIndexSignature(
+      current.args.additionalProperties.map((schema) => parse(current, schema, options)).filter(Boolean).at(0)
+    ) : void 0;
+    return typeKeywordMapper.object([...properties, additionalProperties].filter(Boolean));
+  }
+  if (isKeyword(current, schemaKeywords.datetime)) {
+    return typeKeywordMapper.datetime();
+  }
+  if (isKeyword(current, schemaKeywords.date)) {
+    return typeKeywordMapper.date(current.args.type);
+  }
+  if (isKeyword(current, schemaKeywords.time)) {
+    return typeKeywordMapper.time(current.args.type);
+  }
+  if (current.keyword in typeKeywordMapper) {
+    return value();
+  }
+  return void 0;
+}
+
+// src/components/Schema.tsx
+import { jsx as jsx2 } from "@kubb/react/jsx-runtime";
+function Schema(props) {
+  const { keysToOmit, description } = props;
+  const { tree, name } = useSchema();
+  const {
+    pluginManager,
+    plugin: {
+      options: { mapper, enumType, optionalType }
+    }
+  } = useApp2();
+  const resolvedName = pluginManager.resolveName({
+    name,
+    pluginKey: [pluginTsName],
+    type: "function"
+  });
+  const typeName = pluginManager.resolveName({
+    name,
+    pluginKey: [pluginTsName],
+    type: "type"
+  });
+  const nodes = [];
+  const extraNodes = [];
+  if (!tree.length) {
+    return "";
+  }
+  const isNullish = tree.some((item) => item.keyword === schemaKeywords2.nullish);
+  const isNullable = tree.some((item) => item.keyword === schemaKeywords2.nullable);
+  const isOptional = tree.some((item) => item.keyword === schemaKeywords2.optional);
+  let type = tree.map((schema) => parse(void 0, schema, { name: resolvedName, typeName, description, keysToOmit, optionalType, enumType, mapper })).filter(Boolean).at(0) || typeKeywordMapper.undefined();
+  if (isNullable) {
+    type = factory2.createUnionDeclaration({
+      nodes: [type, factory2.keywordTypeNodes.null]
+    });
+  }
+  if (isNullish && ["undefined", "questionTokenAndUndefined"].includes(optionalType)) {
+    type = factory2.createUnionDeclaration({
+      nodes: [type, factory2.keywordTypeNodes.undefined]
+    });
+  }
+  if (isOptional && ["undefined", "questionTokenAndUndefined"].includes(optionalType)) {
+    type = factory2.createUnionDeclaration({
+      nodes: [type, factory2.keywordTypeNodes.undefined]
+    });
+  }
+  const node = factory2.createTypeAliasDeclaration({
+    modifiers: [factory2.modifiers.export],
+    name: resolvedName,
+    type: keysToOmit?.length ? factory2.createOmitDeclaration({
+      keys: keysToOmit,
+      type,
+      nonNullable: true
+    }) : type
+  });
+  const enumSchemas = SchemaGenerator.deepSearch(tree, schemaKeywords2.enum);
+  if (enumSchemas) {
+    enumSchemas.forEach((enumSchema) => {
+      extraNodes.push(
+        ...factory2.createEnumDeclaration({
+          name: transformers2.camelCase(enumSchema.args.name),
+          typeName: enumSchema.args.typeName,
+          enums: enumSchema.args.items.map((item) => item.value === void 0 ? void 0 : [transformers2.trimQuotes(item.name?.toString()), item.value]).filter(Boolean),
+          type: enumType
+        })
+      );
+    });
+  }
+  nodes.push(
+    factory2.appendJSDocToNode({
+      node,
+      comments: [description ? `@description ${transformers2.jsStringEscape(description)}` : void 0].filter(Boolean)
+    })
+  );
+  const filterdNodes = nodes.filter(
+    (node2) => !extraNodes.some(
+      (extraNode) => extraNode?.name?.escapedText === node2?.name?.escapedText
+    )
+  );
+  return print([...extraNodes, ...filterdNodes]);
+}
+Schema.File = function({}) {
+  const { pluginManager } = useApp2();
+  const { schema } = useSchema();
+  return /* @__PURE__ */ jsx2(Oas.Schema.File, { output: pluginManager.config.output.path, children: /* @__PURE__ */ jsx2(File2.Source, { children: /* @__PURE__ */ jsx2(Schema, { description: schema?.description }) }) });
+};
+
+// src/SchemaGenerator.tsx
+import { jsx as jsx3 } from "@kubb/react/jsx-runtime";
+var SchemaGenerator2 = class extends Generator {
+  async schema(name, schema, options) {
+    const { oas, pluginManager, plugin, mode, output } = this.context;
+    const root = createRoot({
+      logger: pluginManager.logger
+    });
+    const tree = this.parse({ schema, name });
+    root.render(
+      /* @__PURE__ */ jsx3(App, { pluginManager, plugin: { ...plugin, options }, mode, children: /* @__PURE__ */ jsx3(Oas2, { oas, children: /* @__PURE__ */ jsx3(Oas2.Schema, { name, value: schema, tree, children: /* @__PURE__ */ jsx3(Schema.File, {}) }) }) })
+    );
+    return root.files;
+  }
+};
+
+// src/components/OperationSchema.tsx
+import { jsx as jsx4, jsxs as jsxs2 } from "@kubb/react/jsx-runtime";
+function printCombinedSchema({
+  name,
+  operation,
+  schemas,
+  pluginManager
+}) {
+  const properties = {};
+  if (schemas.response) {
+    const identifier = pluginManager.resolveName({
+      name: schemas.response.name,
+      pluginKey: [pluginTsName],
+      type: "function"
+    });
+    properties["response"] = factory3.createTypeReferenceNode(factory3.createIdentifier(identifier), void 0);
+  }
+  if (schemas.request) {
+    const identifier = pluginManager.resolveName({
+      name: schemas.request.name,
+      pluginKey: [pluginTsName],
+      type: "function"
+    });
+    properties["request"] = factory3.createTypeReferenceNode(factory3.createIdentifier(identifier), void 0);
+  }
+  if (schemas.pathParams) {
+    const identifier = pluginManager.resolveName({
+      name: schemas.pathParams.name,
+      pluginKey: [pluginTsName],
+      type: "function"
+    });
+    properties["pathParams"] = factory3.createTypeReferenceNode(factory3.createIdentifier(identifier), void 0);
+  }
+  if (schemas.queryParams) {
+    const identifier = pluginManager.resolveName({
+      name: schemas.queryParams.name,
+      pluginKey: [pluginTsName],
+      type: "function"
+    });
+    properties["queryParams"] = factory3.createTypeReferenceNode(factory3.createIdentifier(identifier), void 0);
+  }
+  if (schemas.headerParams) {
+    const identifier = pluginManager.resolveName({
+      name: schemas.headerParams.name,
+      pluginKey: [pluginTsName],
+      type: "function"
+    });
+    properties["headerParams"] = factory3.createTypeReferenceNode(factory3.createIdentifier(identifier), void 0);
+  }
+  if (schemas.errors) {
+    properties["errors"] = factory3.createUnionDeclaration({
+      nodes: schemas.errors.map((error) => {
+        const identifier = pluginManager.resolveName({
+          name: error.name,
+          pluginKey: [pluginTsName],
+          type: "function"
+        });
+        return factory3.createTypeReferenceNode(factory3.createIdentifier(identifier), void 0);
+      })
+    });
+  }
+  const namespaceNode = factory3.createTypeAliasDeclaration({
+    name: operation.method === "get" ? `${name}Query` : `${name}Mutation`,
+    type: factory3.createTypeLiteralNode(
+      Object.keys(properties).map((key) => {
+        const type = properties[key];
+        if (!type) {
+          return void 0;
+        }
+        return factory3.createPropertySignature({
+          name: transformers3.pascalCase(key),
+          type
+        });
+      }).filter(Boolean)
+    ),
+    modifiers: [factory3.modifiers.export]
+  });
+  return print2(namespaceNode);
+}
+function OperationSchema({ keysToOmit, description }) {
+  return /* @__PURE__ */ jsx4(Schema, { keysToOmit, description });
+}
+OperationSchema.File = function({}) {
+  const { pluginManager, plugin, mode, fileManager } = useApp3();
+  const oas = useOas2();
+  const { getSchemas, getFile, getName } = useOperationManager();
+  const operation = useOperation();
+  const file = getFile(operation);
+  const schemas = getSchemas(operation);
+  const factoryName = getName(operation, { type: "type" });
+  const generator = new SchemaGenerator2(plugin.options, {
+    oas,
+    plugin,
+    pluginManager,
+    mode,
+    override: plugin.options.override
+  });
+  const items = [schemas.pathParams, schemas.queryParams, schemas.headerParams, schemas.statusCodes, schemas.request, schemas.response].flat().filter(Boolean);
+  const mapItem = ({ name, schema, description, keysToOmit, ...options }, i) => {
+    const tree = generator.parse({ schema, name });
+    return /* @__PURE__ */ jsxs2(Oas3.Schema, { name, value: schema, tree, children: [
+      mode === "split" && /* @__PURE__ */ jsx4(Oas3.Schema.Imports, { extName: plugin.options.extName, isTypeOnly: true }),
+      /* @__PURE__ */ jsx4(File3.Source, { children: /* @__PURE__ */ jsx4(OperationSchema, { description, keysToOmit }) })
+    ] }, i);
+  };
+  return /* @__PURE__ */ jsx4(Parser2, { language: "typescript", children: /* @__PURE__ */ jsxs2(File3, { baseName: file.baseName, path: file.path, meta: file.meta, children: [
+    items.map(mapItem),
+    /* @__PURE__ */ jsx4(File3.Source, { children: printCombinedSchema({ name: factoryName, operation, schemas, pluginManager }) })
+  ] }) });
+};
+
+// src/OperationGenerator.tsx
+import { jsx as jsx5 } from "@kubb/react/jsx-runtime";
+var OperationGenerator = class extends Generator2 {
+  async all(operations) {
+    const { oas, pluginManager, plugin, mode } = this.context;
+    const root = createRoot2({
+      logger: pluginManager.logger
+    });
+    root.render(
+      /* @__PURE__ */ jsx5(App2, { pluginManager, plugin, mode, children: /* @__PURE__ */ jsx5(Oas4, { oas, operations, generator: this, children: plugin.options.oasType && /* @__PURE__ */ jsx5(OasType.File, { name: "oas", typeName: "Oas" }) }) })
+    );
+    return root.files;
+  }
+  async operation(operation, options) {
+    const { oas, pluginManager, plugin, mode } = this.context;
+    const root = createRoot2({
+      logger: pluginManager.logger
+    });
+    root.render(
+      /* @__PURE__ */ jsx5(App2, { pluginManager, plugin: { ...plugin, options }, mode, children: /* @__PURE__ */ jsx5(Oas4, { oas, operations: [operation], generator: this, children: /* @__PURE__ */ jsx5(Oas4.Operation, { operation, children: /* @__PURE__ */ jsx5(OperationSchema.File, {}) }) }) })
+    );
+    return root.files;
+  }
+};
+
+// src/plugin.ts
+var pluginTsName = "plugin-ts";
+var pluginTs = createPlugin((options) => {
+  const {
+    output = { path: "types" },
+    group,
+    exclude = [],
+    include,
+    override = [],
+    enumType = "asConst",
+    enumSuffix = "",
+    dateType = "string",
+    unknownType = "any",
+    optionalType = "questionToken",
+    transformers: transformers4 = {},
+    oasType = false,
+    mapper = {}
+  } = options;
+  const template = group?.output ? group.output : `${output.path}/{{tag}}Controller`;
+  return {
+    name: pluginTsName,
+    options: {
+      extName: output.extName,
+      transformers: transformers4,
+      dateType,
+      optionalType,
+      oasType,
+      enumType,
+      enumSuffix,
+      // keep the used enumnames between SchemaGenerator and OperationGenerator per plugin(pluginKey)
+      usedEnumNames: {},
+      unknownType,
+      override,
+      mapper
+    },
+    pre: [pluginOasName],
+    resolvePath(baseName, pathMode, options2) {
+      const root = path.resolve(this.config.root, this.config.output.path);
+      const mode = pathMode ?? FileManager.getMode(path.resolve(root, output.path));
+      if (mode === "single") {
+        return path.resolve(root, output.path);
+      }
+      if (options2?.tag && group?.type === "tag") {
+        const tag = camelCase(options2.tag);
+        return path.resolve(root, renderTemplate(template, { tag }), baseName);
+      }
+      return path.resolve(root, output.path, baseName);
+    },
+    resolveName(name, type) {
+      const resolvedName = pascalCase(name, { isFile: type === "file" });
+      if (type) {
+        return transformers4?.name?.(resolvedName, type) || resolvedName;
+      }
+      return resolvedName;
+    },
+    async writeFile(path2, source) {
+      if (!path2.endsWith(".ts") || !source) {
+        return;
+      }
+      return this.fileManager.write(path2, source, { sanity: false });
+    },
+    async buildStart() {
+      const [swaggerPlugin] = PluginManager.getDependedPlugins(this.plugins, [pluginOasName]);
+      const oas = await swaggerPlugin.api.getOas();
+      const root = path.resolve(this.config.root, this.config.output.path);
+      const mode = FileManager.getMode(path.resolve(root, output.path));
+      const schemaGenerator = new SchemaGenerator2(this.plugin.options, {
+        oas,
+        pluginManager: this.pluginManager,
+        plugin: this.plugin,
+        contentType: swaggerPlugin.api.contentType,
+        include: void 0,
+        override,
+        mode,
+        output: output.path
+      });
+      const schemaFiles = await schemaGenerator.build();
+      await this.addFile(...schemaFiles);
+      const operationGenerator = new OperationGenerator(this.plugin.options, {
+        oas,
+        pluginManager: this.pluginManager,
+        plugin: this.plugin,
+        contentType: swaggerPlugin.api.contentType,
+        exclude,
+        include,
+        override,
+        mode
+      });
+      const operationFiles = await operationGenerator.build();
+      await this.addFile(...operationFiles);
+    },
+    async buildEnd() {
+      if (this.config.output.write === false) {
+        return;
+      }
+      const root = path.resolve(this.config.root, this.config.output.path);
+      await this.fileManager.addIndexes({
+        root,
+        output,
+        meta: { pluginKey: this.plugin.key },
+        logger: this.logger
+      });
+    }
+  };
+});
+
+// src/index.ts
+var definePluginDefault = pluginTs;
+var definePlugin = pluginTs;
+var src_default = definePluginDefault;
+
+export {
+  OasType,
+  Schema,
+  OperationSchema,
+  pluginTsName,
+  pluginTs,
+  definePlugin,
+  src_default
+};
+//# sourceMappingURL=chunk-WOQIHEJC.js.map