@kubb/swagger-ts 2.18.4 → 2.18.6

package/dist/{chunk-H35DL3CM.cjs → chunk-DRW5SRC6.cjs}

@@ -1,5 +1,17 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } 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; }// src/components/OasType.tsx
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } 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; }// src/plugin.ts
+var _path = require('path'); var _path2 = _interopRequireDefault(_path);
+var _core = require('@kubb/core');
+var _transformers = require('@kubb/core/transformers'); var _transformers2 = _interopRequireDefault(_transformers);
+var _utils = require('@kubb/core/utils');
+var _pluginoas = require('@kubb/plugin-oas');
+
+// src/OperationGenerator.tsx
+
+var _components = require('@kubb/plugin-oas/components');
 var _react = require('@kubb/react');
+
+// src/components/OasType.tsx
+
 var _hooks = require('@kubb/plugin-oas/hooks');
 var _jsxruntime = require('@kubb/react/jsx-runtime');
 function Template({ name, typeName, api }) {
@@ -29,173 +41,28 @@ OasType.File = function({ name, typeName, templates = defaultTemplates }) {
 OasType.templates = defaultTemplates;
 
 // src/components/OperationSchema.tsx
-var _transformers = require('@kubb/core/transformers'); var _transformers2 = _interopRequireDefault(_transformers);
+
 var _parserts = require('@kubb/parser-ts');
-var _factory = require('@kubb/parser-ts/factory'); var factory2 = _interopRequireWildcard(_factory); var factory = _interopRequireWildcard(_factory);
+var _factory = require('@kubb/parser-ts/factory'); var factory3 = _interopRequireWildcard(_factory); var factory2 = _interopRequireWildcard(_factory); var factory = _interopRequireWildcard(_factory);
+
 
-var _components = require('@kubb/plugin-oas/components');
 
 
 // src/SchemaGenerator.tsx
 
-var _pluginoas = require('@kubb/plugin-oas');
 
 
-// src/plugin.ts
-var _path = require('path'); var _path2 = _interopRequireDefault(_path);
-var _core = require('@kubb/core');
 
-var _utils = require('@kubb/core/utils');
+// src/components/Schema.tsx
 
 
-// src/OperationGenerator.tsx
 
 
 
 
-var OperationGenerator = class extends _pluginoas.OperationGenerator {
-  async all(operations) {
-    const { oas, pluginManager, plugin, mode } = this.context;
-    const root = _react.createRoot.call(void 0, {
-      logger: pluginManager.logger
-    });
-    root.render(
-      /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _react.App, { pluginManager, plugin, mode, children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _components.Oas, { oas, operations, generator: this, children: plugin.options.oasType && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, OasType.File, { name: "oas", typeName: "Oas" }) }) })
-    );
-    return root.files;
-  }
-  async operation(operation, options) {
-    const { oas, pluginManager, plugin, mode } = this.context;
-    const root = _react.createRoot.call(void 0, {
-      logger: pluginManager.logger
-    });
-    root.render(
-      /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _react.App, { pluginManager, plugin: { ...plugin, options }, mode, children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _components.Oas, { oas, operations: [operation], generator: this, children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _components.Oas.Operation, { operation, children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 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 = _core.createPlugin.call(void 0, (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 = _optionalChain([group, 'optionalAccess', _ => _.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: [_pluginoas.pluginOasName],
-    resolvePath(baseName, pathMode, options2) {
-      const root = _path2.default.resolve(this.config.root, this.config.output.path);
-      const mode = _nullishCoalesce(pathMode, () => ( _core.FileManager.getMode(_path2.default.resolve(root, output.path))));
-      if (mode === "single") {
-        return _path2.default.resolve(root, output.path);
-      }
-      if (_optionalChain([options2, 'optionalAccess', _2 => _2.tag]) && _optionalChain([group, 'optionalAccess', _3 => _3.type]) === "tag") {
-        const tag = _transformers.camelCase.call(void 0, options2.tag);
-        return _path2.default.resolve(root, _utils.renderTemplate.call(void 0, template, { tag }), baseName);
-      }
-      return _path2.default.resolve(root, output.path, baseName);
-    },
-    resolveName(name, type) {
-      const resolvedName = _transformers.pascalCase.call(void 0, name, { isFile: type === "file" });
-      if (type) {
-        return _optionalChain([transformers3, 'optionalAccess', _4 => _4.name, 'optionalCall', _5 => _5(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] = _core.PluginManager.getDependedPlugins(this.plugins, [_pluginoas.pluginOasName]);
-      const oas = await swaggerPlugin.api.getOas();
-      const root = _path2.default.resolve(this.config.root, this.config.output.path);
-      const mode = _core.FileManager.getMode(_path2.default.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 = _path2.default.resolve(this.config.root, this.config.output.path);
-      await this.fileManager.addIndexes({
-        root,
-        output,
-        meta: { pluginKey: this.plugin.key },
-        logger: this.logger
-      });
-    }
-  };
-});
-
-// src/typeParser.ts
 
+// src/parser/index.ts
 
 
 
@@ -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 (_pluginoas.isKeyword.call(void 0, current, _pluginoas.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 (_pluginoas.isKeyword.call(void 0, current, _pluginoas.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 (_pluginoas.isKeyword.call(void 0, current, _pluginoas.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 (_pluginoas.isKeyword.call(void 0, current, _pluginoas.schemaKeywords.enum)) {
     return typeKeywordMapper.enum(current.args.typeName);
@@ -316,13 +183,13 @@ function parseTypeMeta(parent, current, options) {
     return value();
   }
   if (_pluginoas.isKeyword.call(void 0, current, _pluginoas.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 (_pluginoas.isKeyword.call(void 0, current, _pluginoas.schemaKeywords.const)) {
     return typeKeywordMapper.const(current.args.name, current.args.format);
   }
   if (_pluginoas.isKeyword.call(void 0, current, _pluginoas.schemaKeywords.object)) {
-    const properties = Object.entries(_optionalChain([current, 'access', _6 => _6.args, 'optionalAccess', _7 => _7.properties]) || {}).filter((item) => {
+    const properties = Object.entries(_optionalChain([current, 'access', _ => _.args, 'optionalAccess', _2 => _2.properties]) || {}).filter((item) => {
       const schemas = item[1];
       return schemas && typeof schemas.map === "function";
     }).map(([_name, schemas]) => {
@@ -340,7 +207,7 @@ function parseTypeMeta(parent, current, options) {
       const defaultSchema = schemas.find((schema) => schema.keyword === _pluginoas.schemaKeywords.default);
       const exampleSchema = schemas.find((schema) => schema.keyword === _pluginoas.schemaKeywords.example);
       const schemaSchema = schemas.find((schema) => schema.keyword === _pluginoas.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]
@@ -369,12 +236,12 @@ function parseTypeMeta(parent, current, options) {
           deprecatedSchema ? "@deprecated" : void 0,
           defaultSchema ? `@default ${defaultSchema.args}` : void 0,
           exampleSchema ? `@example ${exampleSchema.args}` : void 0,
-          _optionalChain([schemaSchema, 'optionalAccess', _8 => _8.args, 'optionalAccess', _9 => _9.type]) || _optionalChain([schemaSchema, 'optionalAccess', _10 => _10.args, 'optionalAccess', _11 => _11.format]) ? [`@type ${_optionalChain([schemaSchema, 'optionalAccess', _12 => _12.args, 'optionalAccess', _13 => _13.type]) || "unknown"}${!isOptional ? "" : " | undefined"}`, _optionalChain([schemaSchema, 'optionalAccess', _14 => _14.args, 'optionalAccess', _15 => _15.format])].filter(Boolean).join(", ") : void 0
+          _optionalChain([schemaSchema, 'optionalAccess', _3 => _3.args, 'optionalAccess', _4 => _4.type]) || _optionalChain([schemaSchema, 'optionalAccess', _5 => _5.args, 'optionalAccess', _6 => _6.format]) ? [`@type ${_optionalChain([schemaSchema, 'optionalAccess', _7 => _7.args, 'optionalAccess', _8 => _8.type]) || "unknown"}${!isOptional ? "" : " | undefined"}`, _optionalChain([schemaSchema, 'optionalAccess', _9 => _9.args, 'optionalAccess', _10 => _10.format])].filter(Boolean).join(", ") : void 0
         ].filter(Boolean)
       });
     });
-    const additionalProperties = _optionalChain([current, 'access', _16 => _16.args, 'optionalAccess', _17 => _17.additionalProperties, 'optionalAccess', _18 => _18.length]) ? factory.createIndexSignature(
-      current.args.additionalProperties.map((schema) => parseTypeMeta(current, schema, options)).filter(Boolean).at(0)
+    const additionalProperties = _optionalChain([current, 'access', _11 => _11.args, 'optionalAccess', _12 => _12.additionalProperties, 'optionalAccess', _13 => _13.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));
   }
@@ -392,159 +259,190 @@ function parseTypeMeta(parent, current, options) {
   }
   return void 0;
 }
-function typeParser(schemas, options) {
+
+// src/components/Schema.tsx
+
+function Schema(props) {
+  const { keysToOmit, description } = props;
+  const { tree, name } = _hooks.useSchema.call(void 0, );
+  const {
+    pluginManager,
+    plugin: {
+      options: { enumType, optionalType }
+    }
+  } = _react.useApp.call(void 0, );
+  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 === _pluginoas.schemaKeywords.nullish);
-  const isNullable = schemas.some((item) => item.keyword === _pluginoas.schemaKeywords.nullable);
-  const isOptional = schemas.some((item) => item.keyword === _pluginoas.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 === _pluginoas.schemaKeywords.nullish);
+  const isNullable = tree.some((item) => item.keyword === _pluginoas.schemaKeywords.nullable);
+  const isOptional = tree.some((item) => item.keyword === _pluginoas.schemaKeywords.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: _optionalChain([options, 'access', _19 => _19.keysToOmit, 'optionalAccess', _20 => _20.length]) ? factory.createOmitDeclaration({
-      keys: options.keysToOmit,
+  const node = factory2.createTypeAliasDeclaration({
+    modifiers: [factory2.modifiers.export],
+    name: resolvedName,
+    type: _optionalChain([keysToOmit, 'optionalAccess', _14 => _14.length]) ? factory2.createOmitDeclaration({
+      keys: keysToOmit,
       type,
       nonNullable: true
     }) : type
   });
-  const enumSchemas = _pluginoas.SchemaGenerator.deepSearch(schemas, _pluginoas.schemaKeywords.enum);
+  const enumSchemas = _pluginoas.SchemaGenerator.deepSearch(tree, _pluginoas.schemaKeywords.enum);
   if (enumSchemas) {
     enumSchemas.forEach((enumSchema) => {
       extraNodes.push(
-        ...factory.createEnumDeclaration({
+        ...factory2.createEnumDeclaration({
           name: _transformers2.default.camelCase(enumSchema.args.name),
           typeName: enumSchema.args.typeName,
-          enums: enumSchema.args.items.map((item) => item.value === void 0 ? void 0 : [_transformers2.default.trimQuotes(_optionalChain([item, 'access', _21 => _21.name, 'optionalAccess', _22 => _22.toString, 'call', _23 => _23()])), item.value]).filter(Boolean),
-          type: options.enumType
+          enums: enumSchema.args.items.map((item) => item.value === void 0 ? void 0 : [_transformers2.default.trimQuotes(_optionalChain([item, 'access', _15 => _15.name, 'optionalAccess', _16 => _16.toString, 'call', _17 => _17()])), item.value]).filter(Boolean),
+          type: enumType
         })
       );
     });
   }
   nodes.push(
-    factory.appendJSDocToNode({
+    factory2.appendJSDocToNode({
       node,
-      comments: [options.description ? `@description ${_transformers2.default.jsStringEscape(options.description)}` : void 0].filter(Boolean)
+      comments: [description ? `@description ${_transformers2.default.jsStringEscape(description)}` : void 0].filter(Boolean)
     })
   );
   const filterdNodes = nodes.filter(
     (node2) => !extraNodes.some(
-      (extraNode) => _optionalChain([extraNode, 'optionalAccess', _24 => _24.name, 'optionalAccess', _25 => _25.escapedText]) === _optionalChain([node2, 'optionalAccess', _26 => _26.name, 'optionalAccess', _27 => _27.escapedText])
+      (extraNode) => _optionalChain([extraNode, 'optionalAccess', _18 => _18.name, 'optionalAccess', _19 => _19.escapedText]) === _optionalChain([node2, 'optionalAccess', _20 => _20.name, 'optionalAccess', _21 => _21.escapedText])
     )
   );
   return _parserts.print.call(void 0, [...extraNodes, ...filterdNodes]);
 }
+Schema.File = function({}) {
+  const { pluginManager } = _react.useApp.call(void 0, );
+  const { schema } = _hooks.useSchema.call(void 0, );
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _components.Oas.Schema.File, { output: pluginManager.config.output.path, children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _react.File.Source, { children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, Schema, { description: _optionalChain([schema, 'optionalAccess', _22 => _22.description]) }) }) });
+};
 
 // src/SchemaGenerator.tsx
 
-var SchemaGenerator = class extends _pluginoas.SchemaGenerator {
-  async schema(name, object) {
-    const { oas, pluginManager, mode, plugin, output } = this.context;
+var SchemaGenerator2 = class extends _pluginoas.SchemaGenerator {
+  async schema(name, schema) {
+    const { oas, pluginManager, plugin, mode, output } = this.context;
     const root = _react.createRoot.call(void 0, {
       logger: pluginManager.logger
     });
+    const tree = this.parse({ schema, name });
     root.render(
-      /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _react.App, { pluginManager, plugin, mode, children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _components.Oas, { oas, children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _components.Oas.Schema, { generator: this, name, object, children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _components.Oas.Schema.File, { isTypeOnly: true, output }) }) }) })
+      /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _react.App, { pluginManager, plugin, mode, children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _components.Oas, { oas, children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _components.Oas.Schema, { name, value: schema, tree, children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 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
 
-function printCombinedSchema(name, operation, schemas) {
+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({
+        return factory3.createPropertySignature({
           name: _transformers2.default.pascalCase(key),
           type
         });
       }).filter(Boolean)
     ),
-    modifiers: [factory2.modifiers.export]
+    modifiers: [factory3.modifiers.export]
   });
   return _parserts.print.call(void 0, namespaceNode);
 }
-function OperationSchema({}) {
-  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _jsxruntime.Fragment, {});
+function OperationSchema({ keysToOmit, description }) {
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, Schema, { keysToOmit, description });
 }
 OperationSchema.File = function({}) {
   const { pluginManager, plugin, mode, fileManager } = _react.useApp.call(void 0, );
@@ -554,7 +452,7 @@ OperationSchema.File = function({}) {
   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__ */ _jsxruntime.jsxs.call(void 0, _components.Oas.Schema, { generator, name, object, children: [
+  const mapItem = ({ name, schema, description, keysToOmit, ...options }, i) => {
+    const tree = generator.parse({ schema, name });
+    return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _components.Oas.Schema, { name, value: schema, tree, children: [
       mode === "split" && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _components.Oas.Schema.Imports, { isTypeOnly: true }),
-      /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _react.File.Source, { children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _components.Oas.Schema.Source, { options }) })
+      /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _react.File.Source, { children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, OperationSchema, { description, keysToOmit }) })
     ] }, i);
   };
   return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _react.Parser, { language: "typescript", children: /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _react.File, { baseName: file.baseName, path: file.path, meta: file.meta, children: [
     items.map(mapItem),
-    /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _react.File.Source, { children: printCombinedSchema(factoryName, operation, schemas) })
+    /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _react.File.Source, { children: printCombinedSchema({ name: factoryName, operation, schemas, pluginManager }) })
   ] }) });
 };
 
+// src/OperationGenerator.tsx
+
+var OperationGenerator = class extends _pluginoas.OperationGenerator {
+  async all(operations) {
+    const { oas, pluginManager, plugin, mode } = this.context;
+    const root = _react.createRoot.call(void 0, {
+      logger: pluginManager.logger
+    });
+    root.render(
+      /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _react.App, { pluginManager, plugin, mode, children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _components.Oas, { oas, operations, generator: this, children: plugin.options.oasType && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, OasType.File, { name: "oas", typeName: "Oas" }) }) })
+    );
+    return root.files;
+  }
+  async operation(operation, options) {
+    const { oas, pluginManager, plugin, mode } = this.context;
+    const root = _react.createRoot.call(void 0, {
+      logger: pluginManager.logger
+    });
+    root.render(
+      /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _react.App, { pluginManager, plugin: { ...plugin, options }, mode, children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _components.Oas, { oas, operations: [operation], generator: this, children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _components.Oas.Operation, { operation, children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, OperationSchema.File, {}) }) }) })
+    );
+    return root.files;
+  }
+};
+
+// src/plugin.ts
+var pluginTsName = "plugin-ts";
+var pluginTs = _core.createPlugin.call(void 0, (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 = _optionalChain([group, 'optionalAccess', _23 => _23.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: [_pluginoas.pluginOasName],
+    resolvePath(baseName, pathMode, options2) {
+      const root = _path2.default.resolve(this.config.root, this.config.output.path);
+      const mode = _nullishCoalesce(pathMode, () => ( _core.FileManager.getMode(_path2.default.resolve(root, output.path))));
+      if (mode === "single") {
+        return _path2.default.resolve(root, output.path);
+      }
+      if (_optionalChain([options2, 'optionalAccess', _24 => _24.tag]) && _optionalChain([group, 'optionalAccess', _25 => _25.type]) === "tag") {
+        const tag = _transformers.camelCase.call(void 0, options2.tag);
+        return _path2.default.resolve(root, _utils.renderTemplate.call(void 0, template, { tag }), baseName);
+      }
+      return _path2.default.resolve(root, output.path, baseName);
+    },
+    resolveName(name, type) {
+      const resolvedName = _transformers.pascalCase.call(void 0, name, { isFile: type === "file" });
+      if (type) {
+        return _optionalChain([transformers4, 'optionalAccess', _26 => _26.name, 'optionalCall', _27 => _27(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] = _core.PluginManager.getDependedPlugins(this.plugins, [_pluginoas.pluginOasName]);
+      const oas = await swaggerPlugin.api.getOas();
+      const root = _path2.default.resolve(this.config.root, this.config.output.path);
+      const mode = _core.FileManager.getMode(_path2.default.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 = _path2.default.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;
+
+
+
+
 
 
 
 
 
-exports.OasType = OasType; exports.OperationSchema = OperationSchema; exports.pluginTsName = pluginTsName; exports.pluginTs = pluginTs;
-//# sourceMappingURL=chunk-H35DL3CM.cjs.map
+exports.OasType = OasType; exports.Schema = Schema; exports.OperationSchema = OperationSchema; exports.pluginTsName = pluginTsName; exports.pluginTs = pluginTs; exports.definePlugin = definePlugin; exports.src_default = src_default;
+//# sourceMappingURL=chunk-DRW5SRC6.cjs.map