@kubb/plugin-ts 3.0.0-alpha.0

package/dist/chunk-XCNZFEPR.cjs

@@ -0,0 +1,621 @@
+"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 }) {
+  return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _jsxruntime.Fragment, { children: [
+    `export const ${name} = ${JSON.stringify(api, void 0, 2)} as const`,
+    /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "br", {}),
+    /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _react.Type, { name: typeName, export: true, children: `Infer<typeof ${name}>` })
+  ] });
+}
+var defaultTemplates = { default: Template };
+function OasType({ name, typeName, Template: Template2 = defaultTemplates.default }) {
+  const oas = _hooks.useOas.call(void 0, );
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, Template2, { name, typeName, api: oas.api });
+}
+OasType.File = function({ name, typeName, templates = defaultTemplates }) {
+  const {
+    pluginManager,
+    plugin: { key: pluginKey }
+  } = _react.useApp.call(void 0, );
+  const file = pluginManager.getFile({ name, extName: ".ts", pluginKey });
+  const Template2 = templates.default;
+  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: [
+    /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _react.File.Import, { name: ["Infer"], path: "@kubb/oas", isTypeOnly: true }),
+    /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _react.File.Source, { children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, OasType, { Template: Template2, name, typeName }) })
+  ] }) });
+};
+OasType.templates = defaultTemplates;
+
+// src/components/OperationSchema.tsx
+
+var _parserts = require('@kubb/parser-ts');
+var _factory = require('@kubb/parser-ts/factory'); var factory3 = _interopRequireWildcard(_factory); var factory2 = _interopRequireWildcard(_factory); var factory = _interopRequireWildcard(_factory);
+
+
+
+
+// src/SchemaGenerator.tsx
+
+
+
+
+// src/components/Schema.tsx
+
+
+
+
+
+
+
+
+// src/parser/index.ts
+
+
+
+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 (_pluginoas.isKeyword.call(void 0, current, _pluginoas.schemaKeywords.union)) {
+    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) => parse(current, schema, options)).filter(Boolean));
+  }
+  if (_pluginoas.isKeyword.call(void 0, current, _pluginoas.schemaKeywords.array)) {
+    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);
+  }
+  if (_pluginoas.isKeyword.call(void 0, current, _pluginoas.schemaKeywords.ref)) {
+    return typeKeywordMapper.ref(current.args.name);
+  }
+  if (_pluginoas.isKeyword.call(void 0, current, _pluginoas.schemaKeywords.blob)) {
+    return value();
+  }
+  if (_pluginoas.isKeyword.call(void 0, current, _pluginoas.schemaKeywords.tuple)) {
+    return typeKeywordMapper.tuple(current.args.items.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', _ => _.args, 'optionalAccess', _2 => _2.properties]) || {}).filter((item) => {
+      const schemas = item[1];
+      return schemas && typeof schemas.map === "function";
+    }).map(([name, schemas]) => {
+      const nameSchema = schemas.find((schema) => schema.keyword === _pluginoas.schemaKeywords.name);
+      const mappedName = _optionalChain([nameSchema, 'optionalAccess', _3 => _3.args]) || name;
+      if (_optionalChain([options, 'access', _4 => _4.mapper, 'optionalAccess', _5 => _5[mappedName]])) {
+        return _optionalChain([options, 'access', _6 => _6.mapper, 'optionalAccess', _7 => _7[mappedName]]);
+      }
+      const isNullish = schemas.some((schema) => schema.keyword === _pluginoas.schemaKeywords.nullish);
+      const isNullable = schemas.some((schema) => schema.keyword === _pluginoas.schemaKeywords.nullable);
+      const isOptional = schemas.some((schema) => schema.keyword === _pluginoas.schemaKeywords.optional);
+      const isReadonly = schemas.some((schema) => schema.keyword === _pluginoas.schemaKeywords.readOnly);
+      const describeSchema = schemas.find((schema) => schema.keyword === _pluginoas.schemaKeywords.describe);
+      const deprecatedSchema = schemas.find((schema) => schema.keyword === _pluginoas.schemaKeywords.deprecated);
+      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) => 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 ${_transformers2.default.jsStringEscape(describeSchema.args)}` : void 0,
+          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
+        ].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) => parse(current, schema, options)).filter(Boolean).at(0)
+    ) : void 0;
+    return typeKeywordMapper.object([...properties, additionalProperties].filter(Boolean));
+  }
+  if (_pluginoas.isKeyword.call(void 0, current, _pluginoas.schemaKeywords.datetime)) {
+    return typeKeywordMapper.datetime();
+  }
+  if (_pluginoas.isKeyword.call(void 0, current, _pluginoas.schemaKeywords.date)) {
+    return typeKeywordMapper.date(current.args.type);
+  }
+  if (_pluginoas.isKeyword.call(void 0, current, _pluginoas.schemaKeywords.time)) {
+    return typeKeywordMapper.time(current.args.type);
+  }
+  if (current.keyword in typeKeywordMapper) {
+    return value();
+  }
+  return void 0;
+}
+
+// src/components/Schema.tsx
+
+function Schema(props) {
+  const { keysToOmit, description } = props;
+  const { tree, name } = _hooks.useSchema.call(void 0, );
+  const {
+    pluginManager,
+    plugin: {
+      options: { mapper, 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 (!tree.length) {
+    return "";
+  }
+  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, 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: _optionalChain([keysToOmit, 'optionalAccess', _19 => _19.length]) ? factory2.createOmitDeclaration({
+      keys: keysToOmit,
+      type,
+      nonNullable: true
+    }) : type
+  });
+  const enumSchemas = _pluginoas.SchemaGenerator.deepSearch(tree, _pluginoas.schemaKeywords.enum);
+  if (enumSchemas) {
+    enumSchemas.forEach((enumSchema) => {
+      extraNodes.push(
+        ...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', _20 => _20.name, 'optionalAccess', _21 => _21.toString, 'call', _22 => _22()])), item.value]).filter(Boolean),
+          type: enumType
+        })
+      );
+    });
+  }
+  nodes.push(
+    factory2.appendJSDocToNode({
+      node,
+      comments: [description ? `@description ${_transformers2.default.jsStringEscape(description)}` : void 0].filter(Boolean)
+    })
+  );
+  const filterdNodes = nodes.filter(
+    (node2) => !extraNodes.some(
+      (extraNode) => _optionalChain([extraNode, 'optionalAccess', _23 => _23.name, 'optionalAccess', _24 => _24.escapedText]) === _optionalChain([node2, 'optionalAccess', _25 => _25.name, 'optionalAccess', _26 => _26.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', _27 => _27.description]) }) }) });
+};
+
+// src/SchemaGenerator.tsx
+
+var SchemaGenerator2 = class extends _pluginoas.SchemaGenerator {
+  async schema(name, schema, options) {
+    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: { ...plugin, options }, 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;
+  }
+};
+
+// src/components/OperationSchema.tsx
+
+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: _transformers2.default.pascalCase(key),
+          type
+        });
+      }).filter(Boolean)
+    ),
+    modifiers: [factory3.modifiers.export]
+  });
+  return _parserts.print.call(void 0, namespaceNode);
+}
+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, );
+  const oas = _hooks.useOas.call(void 0, );
+  const { getSchemas, getFile, getName } = _hooks.useOperationManager.call(void 0, );
+  const operation = _hooks.useOperation.call(void 0, );
+  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__ */ _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, { extName: plugin.options.extName, isTypeOnly: true }),
+      /* @__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({ 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,
+    mapper = {}
+  } = options;
+  const template = _optionalChain([group, 'optionalAccess', _28 => _28.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: [_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', _29 => _29.tag]) && _optionalChain([group, 'optionalAccess', _30 => _30.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', _31 => _31.name, 'optionalCall', _32 => _32(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.Schema = Schema; exports.OperationSchema = OperationSchema; exports.pluginTsName = pluginTsName; exports.pluginTs = pluginTs; exports.definePlugin = definePlugin; exports.src_default = src_default;
+//# sourceMappingURL=chunk-XCNZFEPR.cjs.map