@kubb/swagger-ts 2.18.4 → 2.18.6

package/dist/{chunk-NOXQZTV4.js → chunk-UJR52JIE.js}

@@ -1,3 +1,15 @@
+// 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";
@@ -29,176 +41,31 @@ OasType.File = function({ name, typeName, templates = defaultTemplates }) {
 OasType.templates = defaultTemplates;
 
 // src/components/OperationSchema.tsx
-import transformers2 from "@kubb/core/transformers";
+import transformers3 from "@kubb/core/transformers";
 import { print as print2 } from "@kubb/parser-ts";
-import * as factory2 from "@kubb/parser-ts/factory";
-import { Parser as Parser2, File as File2, useApp as useApp2 } from "@kubb/react";
+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 { App as App2, createRoot as createRoot2 } from "@kubb/react";
-import { SchemaGenerator as Generator2 } from "@kubb/plugin-oas";
+import { SchemaGenerator as Generator } from "@kubb/plugin-oas";
 import { Oas as Oas2 } from "@kubb/plugin-oas/components";
-
-// 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 { App, createRoot } from "@kubb/react";
-import { OperationGenerator as Generator } from "@kubb/plugin-oas";
-import { Oas } from "@kubb/plugin-oas/components";
-import { jsx as jsx2 } from "@kubb/react/jsx-runtime";
-var OperationGenerator = class extends Generator {
-  async all(operations) {
-    const { oas, pluginManager, plugin, mode } = this.context;
-    const root = createRoot({
-      logger: pluginManager.logger
-    });
-    root.render(
-      /* @__PURE__ */ jsx2(App, { pluginManager, plugin, mode, children: /* @__PURE__ */ jsx2(Oas, { oas, operations, generator: this, children: plugin.options.oasType && /* @__PURE__ */ jsx2(OasType.File, { name: "oas", typeName: "Oas" }) }) })
-    );
-    return root.files;
-  }
-  async operation(operation, options) {
-    const { oas, pluginManager, plugin, mode } = this.context;
-    const root = createRoot({
-      logger: pluginManager.logger
-    });
-    root.render(
-      /* @__PURE__ */ jsx2(App, { pluginManager, plugin: { ...plugin, options }, mode, children: /* @__PURE__ */ jsx2(Oas, { oas, operations: [operation], generator: this, children: /* @__PURE__ */ jsx2(Oas.Operation, { operation, children: /* @__PURE__ */ jsx2(OperationSchema.File, {}) }) }) })
-    );
-    return root.files;
-  }
-  async get() {
-    return null;
-  }
-  async post() {
-    return null;
-  }
-  async put() {
-    return null;
-  }
-  async patch() {
-    return null;
-  }
-  async delete() {
-    return null;
-  }
-};
 
-// 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: transformers3 = {},
-    oasType = false
-  } = options;
-  const template = group?.output ? group.output : `${output.path}/{{tag}}Controller`;
-  return {
-    name: pluginTsName,
-    options: {
-      transformers: transformers3,
-      dateType,
-      optionalType,
-      oasType,
-      enumType,
-      enumSuffix,
-      // keep the used enumnames between SchemaGenerator and OperationGenerator per plugin(pluginKey)
-      usedEnumNames: {},
-      unknownType,
-      override
-    },
-    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 transformers3?.name?.(resolvedName, type) || resolvedName;
-      }
-      return resolvedName;
-    },
-    async writeFile(source, writePath) {
-      if (!writePath.endsWith(".ts") || !source) {
-        return;
-      }
-      return this.fileManager.write(source, writePath, { 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 SchemaGenerator(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/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/typeParser.ts
+// src/parser/index.ts
 import transformers from "@kubb/core/transformers";
-import { print } from "@kubb/parser-ts";
 import * as factory from "@kubb/parser-ts/factory";
-import { SchemaGenerator as SchemaGenerator2, isKeyword, schemaKeywords } from "@kubb/plugin-oas";
+import { isKeyword, schemaKeywords } from "@kubb/plugin-oas";
 var typeKeywordMapper = {
   any: () => factory.keywordTypeNodes.any,
   unknown: () => factory.keywordTypeNodes.unknown,
@@ -292,19 +159,19 @@ var typeKeywordMapper = {
   catchall: void 0,
   name: void 0
 };
-function parseTypeMeta(parent, current, options) {
+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) => parseTypeMeta(current, schema, options)).filter(Boolean));
+    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) => parseTypeMeta(current, schema, options)).filter(Boolean));
+    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) => parseTypeMeta(current, schema, options)).filter(Boolean));
+    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);
@@ -316,7 +183,7 @@ function parseTypeMeta(parent, current, options) {
     return value();
   }
   if (isKeyword(current, schemaKeywords.tuple)) {
-    return typeKeywordMapper.tuple(current.args.map((schema) => parseTypeMeta(current, schema, options)).filter(Boolean));
+    return typeKeywordMapper.tuple(current.args.map((schema) => parse(current, schema, options)).filter(Boolean));
   }
   if (isKeyword(current, schemaKeywords.const)) {
     return typeKeywordMapper.const(current.args.name, current.args.format);
@@ -340,7 +207,7 @@ function parseTypeMeta(parent, current, options) {
       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) => parseTypeMeta(current, schema, options)).filter(Boolean)[0];
+      let type = schemas.map((schema) => parse(current, schema, options)).filter(Boolean)[0];
       if (isNullable) {
         type = factory.createUnionDeclaration({
           nodes: [type, factory.keywordTypeNodes.null]
@@ -374,7 +241,7 @@ function parseTypeMeta(parent, current, options) {
       });
     });
     const additionalProperties = current.args?.additionalProperties?.length ? factory.createIndexSignature(
-      current.args.additionalProperties.map((schema) => parseTypeMeta(current, schema, options)).filter(Boolean).at(0)
+      current.args.additionalProperties.map((schema) => parse(current, schema, options)).filter(Boolean).at(0)
     ) : void 0;
     return typeKeywordMapper.object([...properties, additionalProperties].filter(Boolean));
   }
@@ -392,57 +259,78 @@ function parseTypeMeta(parent, current, options) {
   }
   return void 0;
 }
-function typeParser(schemas, options) {
+
+// 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: { 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 (!schemas.length) {
+  if (!tree.length) {
     return "";
   }
-  const isNullish = schemas.some((item) => item.keyword === schemaKeywords.nullish);
-  const isNullable = schemas.some((item) => item.keyword === schemaKeywords.nullable);
-  const isOptional = schemas.some((item) => item.keyword === schemaKeywords.optional);
-  let type = schemas.map((schema) => parseTypeMeta(void 0, schema, options)).filter(Boolean).at(0) || typeKeywordMapper.undefined();
+  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 })).filter(Boolean).at(0) || typeKeywordMapper.undefined();
   if (isNullable) {
-    type = factory.createUnionDeclaration({
-      nodes: [type, factory.keywordTypeNodes.null]
+    type = factory2.createUnionDeclaration({
+      nodes: [type, factory2.keywordTypeNodes.null]
     });
   }
-  if (isNullish && ["undefined", "questionTokenAndUndefined"].includes(options.optionalType)) {
-    type = factory.createUnionDeclaration({
-      nodes: [type, factory.keywordTypeNodes.undefined]
+  if (isNullish && ["undefined", "questionTokenAndUndefined"].includes(optionalType)) {
+    type = factory2.createUnionDeclaration({
+      nodes: [type, factory2.keywordTypeNodes.undefined]
     });
   }
-  if (isOptional && ["undefined", "questionTokenAndUndefined"].includes(options.optionalType)) {
-    type = factory.createUnionDeclaration({
-      nodes: [type, factory.keywordTypeNodes.undefined]
+  if (isOptional && ["undefined", "questionTokenAndUndefined"].includes(optionalType)) {
+    type = factory2.createUnionDeclaration({
+      nodes: [type, factory2.keywordTypeNodes.undefined]
     });
   }
-  const node = factory.createTypeAliasDeclaration({
-    modifiers: [factory.modifiers.export],
-    name: options.name,
-    type: options.keysToOmit?.length ? factory.createOmitDeclaration({
-      keys: options.keysToOmit,
+  const node = factory2.createTypeAliasDeclaration({
+    modifiers: [factory2.modifiers.export],
+    name: resolvedName,
+    type: keysToOmit?.length ? factory2.createOmitDeclaration({
+      keys: keysToOmit,
       type,
       nonNullable: true
     }) : type
   });
-  const enumSchemas = SchemaGenerator2.deepSearch(schemas, schemaKeywords.enum);
+  const enumSchemas = SchemaGenerator.deepSearch(tree, schemaKeywords2.enum);
   if (enumSchemas) {
     enumSchemas.forEach((enumSchema) => {
       extraNodes.push(
-        ...factory.createEnumDeclaration({
-          name: transformers.camelCase(enumSchema.args.name),
+        ...factory2.createEnumDeclaration({
+          name: transformers2.camelCase(enumSchema.args.name),
           typeName: enumSchema.args.typeName,
-          enums: enumSchema.args.items.map((item) => item.value === void 0 ? void 0 : [transformers.trimQuotes(item.name?.toString()), item.value]).filter(Boolean),
-          type: options.enumType
+          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(
-    factory.appendJSDocToNode({
+    factory2.appendJSDocToNode({
       node,
-      comments: [options.description ? `@description ${transformers.jsStringEscape(options.description)}` : void 0].filter(Boolean)
+      comments: [description ? `@description ${transformers2.jsStringEscape(description)}` : void 0].filter(Boolean)
     })
   );
   const filterdNodes = nodes.filter(
@@ -452,109 +340,119 @@ function typeParser(schemas, options) {
   );
   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 SchemaGenerator = class extends Generator2 {
-  async schema(name, object) {
-    const { oas, pluginManager, mode, plugin, output } = this.context;
-    const root = createRoot2({
+var SchemaGenerator2 = class extends Generator {
+  async schema(name, schema) {
+    const { oas, pluginManager, plugin, mode, output } = this.context;
+    const root = createRoot({
       logger: pluginManager.logger
     });
+    const tree = this.parse({ schema, name });
     root.render(
-      /* @__PURE__ */ jsx3(App2, { pluginManager, plugin, mode, children: /* @__PURE__ */ jsx3(Oas2, { oas, children: /* @__PURE__ */ jsx3(Oas2.Schema, { generator: this, name, object, children: /* @__PURE__ */ jsx3(Oas2.Schema.File, { isTypeOnly: true, output }) }) }) })
+      /* @__PURE__ */ jsx3(App, { pluginManager, plugin, mode, children: /* @__PURE__ */ jsx3(Oas2, { oas, children: /* @__PURE__ */ jsx3(Oas2.Schema, { name, value: schema, tree, children: /* @__PURE__ */ jsx3(Schema.File, {}) }) }) })
     );
     return root.files;
   }
-  // TODO convert to a react component called `Schema.Parser` with props parser as part of the SchemaContext
-  getSource(name, schemas, { keysToOmit, description } = {}) {
-    const texts = [];
-    const resolvedName = this.context.pluginManager.resolveName({
-      name,
-      pluginKey: [pluginTsName],
-      type: "function"
-    });
-    const resolvedTypeName = this.context.pluginManager.resolveName({
-      name,
-      pluginKey: [pluginTsName],
-      type: "type"
-    });
-    const typeOutput = typeParser(schemas, {
-      name: resolvedName,
-      typeName: resolvedTypeName,
-      description,
-      enumType: this.options.enumType || "asConst",
-      optionalType: this.options.optionalType,
-      keysToOmit
-    });
-    texts.push(typeOutput);
-    return texts;
-  }
-  /**
-   * @deprecated only used for testing
-   */
-  buildSource(name, schema, options = {}) {
-    const schemas = this.buildSchemas({ schema, name });
-    return this.getSource(name, schemas, options);
-  }
 };
 
 // src/components/OperationSchema.tsx
-import { Fragment as Fragment2, jsx as jsx4, jsxs as jsxs2 } from "@kubb/react/jsx-runtime";
-function printCombinedSchema(name, operation, schemas) {
+import { jsx as jsx4, jsxs as jsxs2 } from "@kubb/react/jsx-runtime";
+function printCombinedSchema({
+  name,
+  operation,
+  schemas,
+  pluginManager
+}) {
   const properties = {};
   if (schemas.response) {
-    properties["response"] = factory2.createTypeReferenceNode(factory2.createIdentifier(schemas.response.name), void 0);
+    const identifier = pluginManager.resolveName({
+      name: schemas.response.name,
+      pluginKey: [pluginTsName],
+      type: "function"
+    });
+    properties["response"] = factory3.createTypeReferenceNode(factory3.createIdentifier(identifier), void 0);
   }
   if (schemas.request) {
-    properties["request"] = factory2.createTypeReferenceNode(factory2.createIdentifier(schemas.request.name), void 0);
+    const identifier = pluginManager.resolveName({
+      name: schemas.request.name,
+      pluginKey: [pluginTsName],
+      type: "function"
+    });
+    properties["request"] = factory3.createTypeReferenceNode(factory3.createIdentifier(identifier), void 0);
   }
   if (schemas.pathParams) {
-    properties["pathParams"] = factory2.createTypeReferenceNode(factory2.createIdentifier(schemas.pathParams.name), void 0);
+    const identifier = pluginManager.resolveName({
+      name: schemas.pathParams.name,
+      pluginKey: [pluginTsName],
+      type: "function"
+    });
+    properties["pathParams"] = factory3.createTypeReferenceNode(factory3.createIdentifier(identifier), void 0);
   }
   if (schemas.queryParams) {
-    properties["queryParams"] = factory2.createTypeReferenceNode(factory2.createIdentifier(schemas.queryParams.name), void 0);
+    const identifier = pluginManager.resolveName({
+      name: schemas.queryParams.name,
+      pluginKey: [pluginTsName],
+      type: "function"
+    });
+    properties["queryParams"] = factory3.createTypeReferenceNode(factory3.createIdentifier(identifier), void 0);
   }
   if (schemas.headerParams) {
-    properties["headerParams"] = factory2.createTypeReferenceNode(factory2.createIdentifier(schemas.headerParams.name), void 0);
+    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"] = factory2.createUnionDeclaration({
+    properties["errors"] = factory3.createUnionDeclaration({
       nodes: schemas.errors.map((error) => {
-        return factory2.createTypeReferenceNode(factory2.createIdentifier(error.name), void 0);
+        const identifier = pluginManager.resolveName({
+          name: error.name,
+          pluginKey: [pluginTsName],
+          type: "function"
+        });
+        return factory3.createTypeReferenceNode(factory3.createIdentifier(identifier), void 0);
       })
     });
   }
-  const namespaceNode = factory2.createTypeAliasDeclaration({
+  const namespaceNode = factory3.createTypeAliasDeclaration({
     name: operation.method === "get" ? `${name}Query` : `${name}Mutation`,
-    type: factory2.createTypeLiteralNode(
+    type: factory3.createTypeLiteralNode(
       Object.keys(properties).map((key) => {
         const type = properties[key];
         if (!type) {
           return void 0;
         }
-        return factory2.createPropertySignature({
-          name: transformers2.pascalCase(key),
+        return factory3.createPropertySignature({
+          name: transformers3.pascalCase(key),
           type
         });
       }).filter(Boolean)
     ),
-    modifiers: [factory2.modifiers.export]
+    modifiers: [factory3.modifiers.export]
   });
   return print2(namespaceNode);
 }
-function OperationSchema({}) {
-  return /* @__PURE__ */ jsx4(Fragment2, {});
+function OperationSchema({ keysToOmit, description }) {
+  return /* @__PURE__ */ jsx4(Schema, { keysToOmit, description });
 }
 OperationSchema.File = function({}) {
-  const { pluginManager, plugin, mode, fileManager } = useApp2();
+  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 SchemaGenerator(plugin.options, {
+  const generator = new SchemaGenerator2(plugin.options, {
     oas,
     plugin,
     pluginManager,
@@ -562,22 +460,159 @@ OperationSchema.File = function({}) {
     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: object, ...options }, i) => {
-    return /* @__PURE__ */ jsxs2(Oas3.Schema, { generator, name, object, children: [
+  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, { isTypeOnly: true }),
-      /* @__PURE__ */ jsx4(File2.Source, { children: /* @__PURE__ */ jsx4(Oas3.Schema.Source, { options }) })
+      /* @__PURE__ */ jsx4(File3.Source, { children: /* @__PURE__ */ jsx4(OperationSchema, { description, keysToOmit }) })
     ] }, i);
   };
-  return /* @__PURE__ */ jsx4(Parser2, { language: "typescript", children: /* @__PURE__ */ jsxs2(File2, { baseName: file.baseName, path: file.path, meta: file.meta, children: [
+  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(File2.Source, { children: printCombinedSchema(factoryName, operation, schemas) })
+    /* @__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
+  } = options;
+  const template = group?.output ? group.output : `${output.path}/{{tag}}Controller`;
+  return {
+    name: pluginTsName,
+    options: {
+      transformers: transformers4,
+      dateType,
+      optionalType,
+      oasType,
+      enumType,
+      enumSuffix,
+      // keep the used enumnames between SchemaGenerator and OperationGenerator per plugin(pluginKey)
+      usedEnumNames: {},
+      unknownType,
+      override
+    },
+    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
+  pluginTs,
+  definePlugin,
+  src_default
 };
-//# sourceMappingURL=chunk-NOXQZTV4.js.map
+//# sourceMappingURL=chunk-UJR52JIE.js.map