@kubb/swagger-ts 2.10.0 → 2.11.1

package/dist/chunk-Y5R6DTFD.cjs

@@ -0,0 +1,613 @@
+"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 _swagger = require('@kubb/swagger');
+
+// src/OperationGenerator.tsx
+var _react = require('@kubb/react');
+
+var _components = require('@kubb/swagger/components');
+
+// src/components/OasType.tsx
+
+
+var _hooks = require('@kubb/swagger/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 { key: pluginKey2 } = _react.usePlugin.call(void 0, );
+  const file = _react.useGetFile.call(void 0, { name, extName: ".ts", pluginKey: pluginKey2 });
+  const Template2 = templates.default;
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _react.Editor, { 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/swagger-ts/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 _parser = require('@kubb/parser');
+var _factory = require('@kubb/parser/factory'); var factory2 = _interopRequireWildcard(_factory); var factory = _interopRequireWildcard(_factory);
+
+
+
+
+// src/SchemaGenerator.tsx
+
+
+
+
+// src/typeParser.ts
+
+
+
+
+var typeKeywordMapper = {
+  any: () => factory.keywordTypeNodes.any,
+  unknown: () => factory.keywordTypeNodes.unknown,
+  number: () => factory.keywordTypeNodes.number,
+  integer: () => factory.keywordTypeNodes.number,
+  object: (nodes) => {
+    if (!nodes) {
+      return factory.keywordTypeNodes.object;
+    }
+    return factory.createTypeLiteralNode(nodes);
+  },
+  lazy: void 0,
+  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: () => 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,
+  type: void 0,
+  format: void 0,
+  catchall: void 0
+};
+function parseTypeMeta(item, options) {
+  const mapper = options.mapper || typeKeywordMapper;
+  const value = mapper[item.keyword];
+  if (!value) {
+    return void 0;
+  }
+  if (_swagger.isKeyword.call(void 0, item, _swagger.schemaKeywords.union)) {
+    const value2 = mapper[item.keyword];
+    return value2(item.args.map((orItem) => parseTypeMeta(orItem, options)).filter(Boolean));
+  }
+  if (_swagger.isKeyword.call(void 0, item, _swagger.schemaKeywords.and)) {
+    const value2 = mapper[item.keyword];
+    return value2(item.args.map((orItem) => parseTypeMeta(orItem, options)).filter(Boolean));
+  }
+  if (_swagger.isKeyword.call(void 0, item, _swagger.schemaKeywords.array)) {
+    const value2 = mapper[item.keyword];
+    return value2(item.args.items.map((orItem) => parseTypeMeta(orItem, options)).filter(Boolean));
+  }
+  if (_swagger.isKeyword.call(void 0, item, _swagger.schemaKeywords.enum)) {
+    const value2 = mapper[item.keyword];
+    return value2(item.args.typeName);
+  }
+  if (_swagger.isKeyword.call(void 0, item, _swagger.schemaKeywords.ref)) {
+    const value2 = mapper[item.keyword];
+    return value2(item.args.name);
+  }
+  if (_swagger.isKeyword.call(void 0, item, _swagger.schemaKeywords.blob)) {
+    return value();
+  }
+  if (_swagger.isKeyword.call(void 0, item, _swagger.schemaKeywords.tuple)) {
+    const value2 = mapper[item.keyword];
+    return value2(
+      item.args.map((tupleItem) => parseTypeMeta(tupleItem, options)).filter(Boolean)
+    );
+  }
+  if (_swagger.isKeyword.call(void 0, item, _swagger.schemaKeywords.const)) {
+    const value2 = mapper[item.keyword];
+    return value2(item.args.name, item.args.format);
+  }
+  if (_swagger.isKeyword.call(void 0, item, _swagger.schemaKeywords.object)) {
+    const value2 = mapper[item.keyword];
+    const properties = Object.entries(_optionalChain([item, 'access', _ => _.args, 'optionalAccess', _2 => _2.properties]) || {}).filter((item2) => {
+      const schemas = item2[1];
+      return schemas && typeof schemas.map === "function";
+    }).map((item2) => {
+      const name = item2[0];
+      const schemas = item2[1];
+      const isNullish = schemas.some((item3) => item3.keyword === _swagger.schemaKeywords.nullish);
+      const isNullable = schemas.some((item3) => item3.keyword === _swagger.schemaKeywords.nullable);
+      const isOptional = schemas.some((item3) => item3.keyword === _swagger.schemaKeywords.optional);
+      const isReadonly = schemas.some((item3) => item3.keyword === _swagger.schemaKeywords.readOnly);
+      const describeSchema = schemas.find((item3) => item3.keyword === _swagger.schemaKeywords.describe);
+      const deprecatedSchema = schemas.find((item3) => item3.keyword === _swagger.schemaKeywords.deprecated);
+      const defaultSchema = schemas.find((item3) => item3.keyword === _swagger.schemaKeywords.default);
+      const exampleSchema = schemas.find((item3) => item3.keyword === _swagger.schemaKeywords.example);
+      const typeSchema = schemas.find((item3) => item3.keyword === _swagger.schemaKeywords.type);
+      const formatSchema = schemas.find((item3) => item3.keyword === _swagger.schemaKeywords.format);
+      let type = schemas.map((item3) => parseTypeMeta(item3, 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 && ["questionToken", "questionTokenAndUndefined"].includes(options.optionalType),
+        name,
+        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,
+          typeSchema ? `@type ${typeSchema.args}${!isOptional ? "" : " | undefined"} ${_optionalChain([formatSchema, 'optionalAccess', _3 => _3.args]) || ""}` : void 0
+        ].filter(Boolean)
+      });
+    });
+    const additionalProperties = _optionalChain([item, 'access', _4 => _4.args, 'optionalAccess', _5 => _5.additionalProperties, 'optionalAccess', _6 => _6.length]) ? factory.createIndexSignature(item.args.additionalProperties.map((schema) => parseTypeMeta(schema, options)).filter(Boolean).at(0)) : void 0;
+    return value2([...properties, additionalProperties].filter(Boolean));
+  }
+  if (item.keyword in mapper) {
+    return value();
+  }
+  return void 0;
+}
+function typeParser(schemas, options) {
+  const nodes = [];
+  const extraNodes = [];
+  if (!schemas.length) {
+    return "";
+  }
+  const isNullish = schemas.some((item) => item.keyword === _swagger.schemaKeywords.nullish);
+  const isNullable = schemas.some((item) => item.keyword === _swagger.schemaKeywords.nullable);
+  const isOptional = schemas.some((item) => item.keyword === _swagger.schemaKeywords.optional);
+  let type = schemas.map((schema) => parseTypeMeta(schema, options)).filter(Boolean).at(0) || typeKeywordMapper.undefined();
+  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 node = factory.createTypeAliasDeclaration({
+    modifiers: [factory.modifiers.export],
+    name: options.name,
+    type: _optionalChain([options, 'access', _7 => _7.keysToOmit, 'optionalAccess', _8 => _8.length]) ? factory.createOmitDeclaration({ keys: options.keysToOmit, type, nonNullable: true }) : type
+  });
+  const enumSchemas = _swagger.SchemaGenerator.deepSearch(schemas, _swagger.schemaKeywords.enum);
+  if (enumSchemas) {
+    enumSchemas.forEach((enumSchema) => {
+      extraNodes.push(...factory.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', _9 => _9.name, 'optionalAccess', _10 => _10.toString, 'call', _11 => _11()])), item.value]).filter(
+          Boolean
+        ),
+        type: options.enumType
+      }));
+    });
+  }
+  nodes.push(
+    factory.appendJSDocToNode({
+      node,
+      comments: [
+        options.description ? `@description ${_transformers2.default.jsStringEscape(options.description)}` : void 0
+      ].filter(Boolean)
+    })
+  );
+  const filterdNodes = nodes.filter(
+    (node2) => !extraNodes.some(
+      (extraNode) => _optionalChain([extraNode, 'optionalAccess', _12 => _12.name, 'optionalAccess', _13 => _13.escapedText]) === _optionalChain([node2, 'optionalAccess', _14 => _14.name, 'optionalAccess', _15 => _15.escapedText])
+    )
+  );
+  return _parser.print.call(void 0, [...extraNodes, ...filterdNodes]);
+}
+
+// src/SchemaGenerator.tsx
+
+var SchemaGenerator2 = class extends _swagger.SchemaGenerator {
+  async schema(name, object) {
+    const { oas, pluginManager, mode, plugin, output } = this.context;
+    const root = _react.createRoot.call(void 0, { logger: pluginManager.logger });
+    root.render(
+      /* @__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.Schema.File, { isTypeOnly: true, output, mode }) }) }),
+      { meta: { pluginManager, plugin } }
+    );
+    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, type: "function" });
+    const resvoledTypeName = this.context.pluginManager.resolveName({ name, pluginKey, type: "type" });
+    const typeOutput = typeParser(schemas, {
+      name: resolvedName,
+      typeName: resvoledTypeName,
+      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) {
+  const properties = {
+    "response": factory2.createTypeReferenceNode(
+      factory2.createIdentifier(schemas.response.name),
+      void 0
+    )
+  };
+  if (schemas.request) {
+    properties["request"] = factory2.createTypeReferenceNode(
+      factory2.createIdentifier(schemas.request.name),
+      void 0
+    );
+  }
+  if (schemas.pathParams) {
+    properties["pathParams"] = factory2.createTypeReferenceNode(
+      factory2.createIdentifier(schemas.pathParams.name),
+      void 0
+    );
+  }
+  if (schemas.queryParams) {
+    properties["queryParams"] = factory2.createTypeReferenceNode(
+      factory2.createIdentifier(schemas.queryParams.name),
+      void 0
+    );
+  }
+  if (schemas.headerParams) {
+    properties["headerParams"] = factory2.createTypeReferenceNode(
+      factory2.createIdentifier(schemas.headerParams.name),
+      void 0
+    );
+  }
+  if (schemas.errors) {
+    properties["errors"] = factory2.createUnionDeclaration({
+      nodes: schemas.errors.map((error) => {
+        return factory2.createTypeReferenceNode(
+          factory2.createIdentifier(error.name),
+          void 0
+        );
+      })
+    });
+  }
+  const namespaceNode = factory2.createTypeAliasDeclaration({
+    name: operation.method === "get" ? `${name}Query` : `${name}Mutation`,
+    type: factory2.createTypeLiteralNode(
+      Object.keys(properties).map((key) => {
+        const type = properties[key];
+        if (!type) {
+          return void 0;
+        }
+        return factory2.createPropertySignature(
+          {
+            name: _transformers2.default.pascalCase(key),
+            type
+          }
+        );
+      }).filter(Boolean)
+    ),
+    modifiers: [factory2.modifiers.export]
+  });
+  return _parser.print.call(void 0, namespaceNode);
+}
+function OperationSchema({}) {
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _jsxruntime.Fragment, {});
+}
+OperationSchema.File = function({ mode = "directory" }) {
+  const plugin = _react.usePlugin.call(void 0, );
+  const pluginManager = _react.usePluginManager.call(void 0, );
+  const oas = _hooks.useOas.call(void 0, );
+  const schemas = _hooks.useOperationSchemas.call(void 0, );
+  const file = _hooks.useGetOperationFile.call(void 0, );
+  const factoryName = _hooks.useOperationName.call(void 0, { type: "type" });
+  const operation = _hooks.useOperation.call(void 0, );
+  const generator = new SchemaGenerator2(plugin.options, { oas, plugin, pluginManager });
+  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: [
+      mode === "directory" && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _components.Schema.Imports, { isTypeOnly: true }),
+      /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _react.File.Source, { children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _components.Schema.Source, { options }) })
+    ] }, i);
+  };
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _react.Editor, { 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) })
+      ]
+    }
+  ) });
+};
+
+// src/OperationGenerator.tsx
+
+var OperationGenerator = class extends _swagger.OperationGenerator {
+  async all(operations) {
+    const { oas, pluginManager, plugin } = this.context;
+    const root = _react.createRoot.call(void 0, { logger: pluginManager.logger });
+    root.render(
+      /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _components.Oas, { oas, operations, getOperationSchemas: (...props) => this.getSchemas(...props), children: plugin.options.oasType && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, OasType.File, { name: "oas", typeName: "Oas" }) }),
+      { meta: { pluginManager, plugin } }
+    );
+    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, _components.Oas, { oas, operations: [operation], getOperationSchemas: (...props) => this.getSchemas(...props), children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _components.Oas.Operation, { operation, children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, OperationSchema.File, { mode }) }) }),
+      { meta: { pluginManager, plugin: { ...plugin, options } } }
+    );
+    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 pluginName = "swagger-ts";
+var pluginKey = [pluginName];
+var definePlugin = _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', _16 => _16.output]) ? group.output : `${output.path}/{{tag}}Controller`;
+  return {
+    name: pluginName,
+    options: {
+      transformers: transformers3,
+      dateType,
+      optionalType,
+      oasType,
+      enumType,
+      enumSuffix,
+      // keep the used enumnames between SchemaGenerator and OperationGenerator per plugin(pluginKey)
+      usedEnumNames: {},
+      unknownType
+    },
+    pre: [_swagger.pluginName],
+    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 === "file") {
+        return _path2.default.resolve(root, output.path);
+      }
+      if (_optionalChain([options2, 'optionalAccess', _17 => _17.tag]) && _optionalChain([group, 'optionalAccess', _18 => _18.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', _19 => _19.name, 'optionalCall', _20 => _20(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, [_swagger.pluginName]);
+      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,
+          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 }
+      });
+    }
+  };
+});
+
+// src/index.ts
+var definePluginDefault = definePlugin;
+var src_default = definePluginDefault;
+
+
+
+
+
+
+
+
+exports.OasType = OasType; exports.OperationSchema = OperationSchema; exports.pluginName = pluginName; exports.pluginKey = pluginKey; exports.definePlugin = definePlugin; exports.src_default = src_default;
+//# sourceMappingURL=chunk-Y5R6DTFD.cjs.map