@kubb/plugin-ts 3.0.0-alpha.15 → 3.0.0-alpha.16

package/dist/{chunk-DFNEDDSF.js → chunk-UNKUJK3W.js}

@@ -1,15 +1,44 @@
-import { __commonJS, init_esm_shims, __toESM } from './chunk-NBQSWLEF.js';
-import path from 'node:path';
-import { createPlugin, FileManager, PluginManager } from '@kubb/core';
-import transformers2, { camelCase, pascalCase } from '@kubb/core/transformers';
-import { renderTemplate } from '@kubb/core/utils';
-import { pluginOasName, schemaKeywords, SchemaGenerator, OperationGenerator as OperationGenerator$1, isKeyword } from '@kubb/plugin-oas';
-import { Oas } from '@kubb/plugin-oas/components';
-import { useApp, File, createRoot, App, Type } from '@kubb/react';
-import { useOas, useSchema, useOperationManager, useOperation } from '@kubb/plugin-oas/hooks';
-import { jsx, jsxs, Fragment } from '@kubb/react/jsx-runtime';
+import { File, Type } from '@kubb/react';
+import { jsxs, Fragment, jsx } from '@kubb/react/jsx-runtime';
+import transformers2 from '@kubb/core/transformers';
 import { print } from '@kubb/parser-ts';
 import * as factory from '@kubb/parser-ts/factory';
+import { schemaKeywords, SchemaGenerator, isKeyword } from '@kubb/plugin-oas';
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  __defProp(target, "default", { value: mod, enumerable: true }) ,
+  mod
+));
+
+// ../../node_modules/.pnpm/tsup@8.2.4_@microsoft+api-extractor@7.47.7_@types+node@20.16.5__@swc+core@1.7.22_jiti@1.21.6__vgec2xea2cg5zleragji3g6qgq/node_modules/tsup/assets/esm_shims.js
+var init_esm_shims = __esm({
+  "../../node_modules/.pnpm/tsup@8.2.4_@microsoft+api-extractor@7.47.7_@types+node@20.16.5__@swc+core@1.7.22_jiti@1.21.6__vgec2xea2cg5zleragji3g6qgq/node_modules/tsup/assets/esm_shims.js"() {
+  }
+});
 
 // ../../node_modules/.pnpm/react@18.3.1/node_modules/react/cjs/react.production.min.js
 var require_react_production_min = __commonJS({
@@ -2169,52 +2198,22 @@ var require_react = __commonJS({
   }
 });
 
-// src/index.ts
-init_esm_shims();
-
-// src/plugin.ts
-init_esm_shims();
-
-// src/OperationGenerator.tsx
+// src/components/index.ts
 init_esm_shims();
 
 // src/components/OasType.tsx
 init_esm_shims();
-function Template({ name, typeName, api }) {
+function OasType({ name, typeName, api }) {
   return /* @__PURE__ */ jsxs(Fragment, { children: [
     /* @__PURE__ */ jsx(File.Source, { name, isExportable: true, isIndexable: true, children: `export const ${name} = ${JSON.stringify(api, void 0, 2)} as const` }),
     /* @__PURE__ */ jsx("br", {}),
     /* @__PURE__ */ jsx(File.Source, { name: typeName, isExportable: true, isIndexable: true, isTypeOnly: true, children: /* @__PURE__ */ jsx(Type, { name: typeName, export: true, children: `Infer<typeof ${name}>` }) })
   ] });
 }
-var defaultTemplates = { default: Template };
-function OasType({ name, typeName, Template: Template2 = defaultTemplates.default }) {
-  const oas = useOas();
-  return /* @__PURE__ */ jsx(Template2, { name, typeName, api: oas.api });
-}
-OasType.File = function({ name, typeName, templates = defaultTemplates }) {
-  const {
-    pluginManager,
-    plugin: { key: pluginKey }
-  } = useApp();
-  const file = pluginManager.getFile({ name, extName: ".ts", pluginKey });
-  const Template2 = templates.default;
-  return /* @__PURE__ */ jsxs(File, { baseName: file.baseName, path: file.path, meta: file.meta, children: [
-    /* @__PURE__ */ jsx(File.Import, { name: ["Infer"], path: "@kubb/oas", isTypeOnly: true }),
-    /* @__PURE__ */ jsx(OasType, { Template: Template2, name, typeName })
-  ] });
-};
-OasType.templates = defaultTemplates;
-
-// src/components/OperationSchema.tsx
-init_esm_shims();
-
-// src/SchemaGenerator.tsx
-init_esm_shims();
 
-// src/components/Schema.tsx
+// src/components/Type.tsx
 init_esm_shims();
-var import_react3 = __toESM(require_react(), 1);
+var import_react3 = __toESM(require_react());
 
 // src/parser/index.ts
 init_esm_shims();
@@ -2411,28 +2410,7 @@ function parse(parent, current, options) {
   }
   return void 0;
 }
-function Schema(props) {
-  const { keysToOmit, description } = props;
-  const { tree, name } = useSchema();
-  const {
-    pluginManager,
-    plugin: {
-      options: { mapper, enumType, optionalType }
-    }
-  } = useApp();
-  if (enumType === "asPascalConst") {
-    pluginManager.logger.emit("warning", `enumType '${enumType}' is deprecated`);
-  }
-  const resolvedName = pluginManager.resolveName({
-    name,
-    pluginKey: [pluginTsName],
-    type: "function"
-  });
-  const typeName = pluginManager.resolveName({
-    name,
-    pluginKey: [pluginTsName],
-    type: "type"
-  });
+function Type2({ name, typedName, tree, keysToOmit, optionalType, enumType, mapper, description }) {
   const typeNodes = [];
   if (!tree.length) {
     return "";
@@ -2442,8 +2420,8 @@ function Schema(props) {
   const isOptional = tree.some((item) => item.keyword === schemaKeywords.optional);
   let type = tree.map(
     (schema) => parse(void 0, schema, {
-      name: resolvedName,
-      typeName,
+      name,
+      typeName: typedName,
       description,
       keysToOmit,
       optionalType,
@@ -2468,7 +2446,7 @@ function Schema(props) {
   }
   const node = factory.createTypeAliasDeclaration({
     modifiers: [factory.modifiers.export],
-    name: resolvedName,
+    name,
     type: keysToOmit?.length ? factory.createOmitDeclaration({
       keys: keysToOmit,
       type,
@@ -2478,10 +2456,10 @@ function Schema(props) {
   const enumSchemas = SchemaGenerator.deepSearch(tree, schemaKeywords.enum);
   const enums = enumSchemas.map((enumSchema) => {
     const name2 = enumType === "asPascalConst" ? transformers2.pascalCase(enumSchema.args.name) : transformers2.camelCase(enumSchema.args.name);
-    const typeName2 = enumSchema.args.typeName;
+    const typeName = enumSchema.args.typeName;
     const [nameNode, typeNode] = factory.createEnumDeclaration({
       name: name2,
-      typeName: typeName2,
+      typeName,
       enums: enumSchema.args.items.map((item) => item.value === void 0 ? void 0 : [transformers2.trimQuotes(item.name?.toString()), item.value]).filter(Boolean),
       type: enumType
     });
@@ -2489,7 +2467,7 @@ function Schema(props) {
       nameNode,
       typeNode,
       name: name2,
-      typeName: typeName2
+      typeName
     };
   });
   typeNodes.push(
@@ -2499,266 +2477,13 @@ function Schema(props) {
     })
   );
   return /* @__PURE__ */ jsxs(import_react3.Fragment, { children: [
-    enums.map(({ name: name2, nameNode, typeName: typeName2, typeNode }, index) => /* @__PURE__ */ jsxs(import_react3.Fragment, { children: [
+    enums.map(({ name: name2, nameNode, typeName, typeNode }, index) => /* @__PURE__ */ jsxs(import_react3.Fragment, { children: [
       nameNode && /* @__PURE__ */ jsx(File.Source, { name: name2, isExportable: true, isIndexable: true, children: print([nameNode]) }),
-      /* @__PURE__ */ jsx(File.Source, { name: typeName2, isIndexable: true, isExportable: ["enum", "asConst", "constEnum", "literal", void 0].includes(enumType), isTypeOnly: true, children: print([typeNode]) })
+      /* @__PURE__ */ jsx(File.Source, { name: typeName, isIndexable: true, isExportable: ["enum", "asConst", "constEnum", "literal", void 0].includes(enumType), isTypeOnly: true, children: print([typeNode]) })
     ] }, [name2, nameNode].join("-"))),
-    enums.every((item) => item.typeName !== resolvedName) && /* @__PURE__ */ jsx(File.Source, { name: typeName, isTypeOnly: true, isExportable: true, isIndexable: true, children: print(typeNodes) })
+    enums.every((item) => item.typeName !== name) && /* @__PURE__ */ jsx(File.Source, { name: typedName, isTypeOnly: true, isExportable: true, isIndexable: true, children: print(typeNodes) })
   ] });
 }
-Schema.File = function({}) {
-  const { pluginManager } = useApp();
-  const { schema } = useSchema();
-  return /* @__PURE__ */ jsx(Oas.Schema.File, { isTypeOnly: true, output: pluginManager.config.output.path, children: /* @__PURE__ */ jsx(Schema, { description: schema?.description }) });
-};
-var SchemaGenerator2 = class extends SchemaGenerator {
-  async schema(name, schema, options) {
-    const { oas, pluginManager, plugin, mode, output } = this.context;
-    const root = createRoot({
-      logger: pluginManager.logger
-    });
-    const tree = this.parse({ schema, name });
-    const Component = () => /* @__PURE__ */ jsx(App, { pluginManager, plugin: { ...plugin, options }, mode, children: /* @__PURE__ */ jsx(Oas, { oas, children: /* @__PURE__ */ jsx(Oas.Schema, { name, value: schema, tree, children: /* @__PURE__ */ jsx(Schema.File, {}) }) }) });
-    Component.displayName = pascalCase(name);
-    root.render(/* @__PURE__ */ jsx(Component, {}));
-    return root.files;
-  }
-};
-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"] = factory.createTypeReferenceNode(factory.createIdentifier(identifier), void 0);
-  }
-  if (schemas.request) {
-    const identifier = pluginManager.resolveName({
-      name: schemas.request.name,
-      pluginKey: [pluginTsName],
-      type: "function"
-    });
-    properties["request"] = factory.createTypeReferenceNode(factory.createIdentifier(identifier), void 0);
-  }
-  if (schemas.pathParams) {
-    const identifier = pluginManager.resolveName({
-      name: schemas.pathParams.name,
-      pluginKey: [pluginTsName],
-      type: "function"
-    });
-    properties["pathParams"] = factory.createTypeReferenceNode(factory.createIdentifier(identifier), void 0);
-  }
-  if (schemas.queryParams) {
-    const identifier = pluginManager.resolveName({
-      name: schemas.queryParams.name,
-      pluginKey: [pluginTsName],
-      type: "function"
-    });
-    properties["queryParams"] = factory.createTypeReferenceNode(factory.createIdentifier(identifier), void 0);
-  }
-  if (schemas.headerParams) {
-    const identifier = pluginManager.resolveName({
-      name: schemas.headerParams.name,
-      pluginKey: [pluginTsName],
-      type: "function"
-    });
-    properties["headerParams"] = factory.createTypeReferenceNode(factory.createIdentifier(identifier), void 0);
-  }
-  if (schemas.errors) {
-    properties["errors"] = factory.createUnionDeclaration({
-      nodes: schemas.errors.map((error) => {
-        const identifier = pluginManager.resolveName({
-          name: error.name,
-          pluginKey: [pluginTsName],
-          type: "function"
-        });
-        return factory.createTypeReferenceNode(factory.createIdentifier(identifier), void 0);
-      })
-    });
-  }
-  const namespaceNode = factory.createTypeAliasDeclaration({
-    name,
-    type: factory.createTypeLiteralNode(
-      Object.keys(properties).map((key) => {
-        const type = properties[key];
-        if (!type) {
-          return void 0;
-        }
-        return factory.createPropertySignature({
-          name: transformers2.pascalCase(key),
-          type
-        });
-      }).filter(Boolean)
-    ),
-    modifiers: [factory.modifiers.export]
-  });
-  return print([namespaceNode]);
-}
-function OperationSchema({ keysToOmit, description }) {
-  return /* @__PURE__ */ jsx(Schema, { keysToOmit, description });
-}
-OperationSchema.File = function({}) {
-  const { pluginManager, plugin, mode } = useApp();
-  const oas = useOas();
-  const { getSchemas, getFile, getName } = useOperationManager();
-  const operation = useOperation();
-  const file = getFile(operation);
-  const schemas = getSchemas(operation);
-  const factoryName = getName(operation, { type: "type" });
-  const generator = new SchemaGenerator2(plugin.options, {
-    oas,
-    plugin,
-    pluginManager,
-    mode,
-    override: plugin.options.override
-  });
-  const items = [schemas.pathParams, schemas.queryParams, schemas.headerParams, schemas.statusCodes, schemas.request, schemas.response].flat().filter(Boolean);
-  const mapItem = ({ name, schema, description, keysToOmit, ...options }, i) => {
-    const tree = generator.parse({ schema, name });
-    return /* @__PURE__ */ jsxs(Oas.Schema, { name, value: schema, tree, children: [
-      mode === "split" && /* @__PURE__ */ jsx(Oas.Schema.Imports, { isTypeOnly: true }),
-      /* @__PURE__ */ jsx(OperationSchema, { description, keysToOmit })
-    ] }, i);
-  };
-  const combinedSchemaName = operation.method === "get" ? `${factoryName}Query` : `${factoryName}Mutation`;
-  return /* @__PURE__ */ jsxs(File, { baseName: file.baseName, path: file.path, meta: file.meta, children: [
-    items.map(mapItem),
-    /* @__PURE__ */ jsx(File.Source, { name: combinedSchemaName, isExportable: true, isIndexable: true, isTypeOnly: true, children: printCombinedSchema({ name: combinedSchemaName, operation, schemas, pluginManager }) })
-  ] });
-};
-var OperationGenerator = class extends OperationGenerator$1 {
-  async all(operations) {
-    const { oas, pluginManager, plugin, mode } = this.context;
-    const root = createRoot({
-      logger: pluginManager.logger
-    });
-    const Component = () => /* @__PURE__ */ jsx(App, { pluginManager, plugin, mode, children: /* @__PURE__ */ jsx(Oas, { oas, operations, generator: this, children: plugin.options.oasType && /* @__PURE__ */ jsx(OasType.File, { name: "oas", typeName: "Oas" }) }) });
-    Component.displayName = pascalCase("operations");
-    root.render(/* @__PURE__ */ jsx(Component, {}));
-    return root.files;
-  }
-  async operation(operation, options) {
-    const { oas, pluginManager, plugin, mode } = this.context;
-    const root = createRoot({
-      logger: pluginManager.logger
-    });
-    const Component = () => /* @__PURE__ */ jsx(App, { pluginManager, plugin: { ...plugin, options }, mode, children: /* @__PURE__ */ jsx(Oas, { oas, operations: [operation], generator: this, children: /* @__PURE__ */ jsx(Oas.Operation, { operation, children: /* @__PURE__ */ jsx(OperationSchema.File, {}) }) }) });
-    Component.displayName = pascalCase(operation.getOperationId());
-    root.render(/* @__PURE__ */ jsx(Component, {}));
-    return root.files;
-  }
-};
-
-// src/plugin.ts
-var pluginTsName = "plugin-ts";
-var pluginTs = createPlugin((options) => {
-  const {
-    output = { path: "types" },
-    group,
-    exclude = [],
-    include,
-    override = [],
-    enumType = "asConst",
-    enumSuffix = "",
-    dateType = "string",
-    unknownType = "any",
-    optionalType = "questionToken",
-    transformers: transformers4 = {},
-    oasType = false,
-    mapper = {}
-  } = options;
-  const template = group?.output ? group.output : `${output.path}/{{tag}}Controller`;
-  return {
-    name: pluginTsName,
-    output: {
-      exportType: "barrelNamed",
-      ...output
-    },
-    options: {
-      extName: output.extName,
-      transformers: transformers4,
-      dateType,
-      optionalType,
-      oasType,
-      enumType,
-      enumSuffix,
-      // keep the used enumnames between SchemaGenerator and OperationGenerator per plugin(pluginKey)
-      usedEnumNames: {},
-      unknownType,
-      override,
-      mapper
-    },
-    pre: [pluginOasName],
-    resolvePath(baseName, pathMode, options2) {
-      const root = path.resolve(this.config.root, this.config.output.path);
-      const mode = pathMode ?? FileManager.getMode(path.resolve(root, output.path));
-      if (mode === "single") {
-        return path.resolve(root, output.path);
-      }
-      if (options2?.tag && group?.type === "tag") {
-        const tag = camelCase(options2.tag);
-        return path.resolve(root, renderTemplate(template, { tag }), baseName);
-      }
-      return path.resolve(root, output.path, baseName);
-    },
-    resolveName(name, type) {
-      const resolvedName = pascalCase(name, { isFile: type === "file" });
-      if (type) {
-        return transformers4?.name?.(resolvedName, type) || resolvedName;
-      }
-      return resolvedName;
-    },
-    async buildStart() {
-      const [swaggerPlugin] = PluginManager.getDependedPlugins(this.plugins, [pluginOasName]);
-      const oas = await swaggerPlugin.context.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.context.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.context.contentType,
-        exclude,
-        include,
-        override,
-        mode
-      });
-      const operationFiles = await operationGenerator.build();
-      await this.addFile(...operationFiles);
-      if (this.config.output.exportType) {
-        const barrelFiles = await this.fileManager.getBarrelFiles({
-          root,
-          output,
-          files: this.fileManager.files,
-          meta: {
-            pluginKey: this.plugin.key
-          },
-          logger: this.logger
-        });
-        await this.addFile(...barrelFiles);
-      }
-    }
-  };
-});
 /*! Bundled license information:
 
 react/cjs/react.production.min.js:
@@ -2784,6 +2509,6 @@ react/cjs/react.development.js:
    *)
 */
 
-export { OasType, OperationSchema, Schema, pluginTs, pluginTsName };
-//# sourceMappingURL=chunk-DFNEDDSF.js.map
-//# sourceMappingURL=chunk-DFNEDDSF.js.map
+export { OasType, Type2 as Type, init_esm_shims };
+//# sourceMappingURL=chunk-UNKUJK3W.js.map
+//# sourceMappingURL=chunk-UNKUJK3W.js.map