@kubb/plugin-ts 5.0.0-alpha.29 → 5.0.0-alpha.30

package/dist/index.d.ts

@@ -368,7 +368,7 @@ type Options = {
    */
   transformer?: Visitor;
   /**
-   * Override individual printer node handlers to customise rendering of specific schema types.
+   * Override individual printer node handlers to customize rendering of specific schema types.
    *
    * Each key is a `SchemaType` (e.g. `'date'`, `'string'`). The function replaces the
    * built-in handler for that type. Use `this.transform` to recurse into nested schema nodes.
@@ -393,6 +393,9 @@ type Options = {
 } & EnumTypeOptions;
 type ResolvedOptions = {
   output: Output;
+  exclude: Array<Exclude>;
+  include: Array<Include> | undefined;
+  override: Array<Override<ResolvedOptions>>;
   group: Group | undefined;
   enumType: NonNullable<Options['enumType']>;
   enumTypeSuffix: NonNullable<Options['enumTypeSuffix']>;
@@ -404,6 +407,13 @@ type ResolvedOptions = {
   printer: Options['printer'];
 };
 type PluginTs = PluginFactoryOptions<'plugin-ts', Options, ResolvedOptions, never, ResolvePathOptions, ResolverTs>;
+declare global {
+  namespace Kubb {
+    interface PluginRegistry {
+      'plugin-ts': PluginTs;
+    }
+  }
+}
 //#endregion
 //#region src/components/Enum.d.ts
 type Props$1 = {
@@ -464,7 +474,7 @@ declare function Type({
 }: Props): FabricReactNode;
 //#endregion
 //#region src/generators/typeGenerator.d.ts
-declare const typeGenerator: _$_kubb_core0.ReactGeneratorV2<PluginTs>;
+declare const typeGenerator: _$_kubb_core0.Generator<PluginTs>;
 //#endregion
 //#region src/plugin.d.ts
 /**

package/dist/index.js

@@ -1,12 +1,11 @@
 import "./chunk--u3MIqq1.js";
-import path from "node:path";
 import { safePrint } from "@kubb/fabric-core/parsers/typescript";
 import { File } from "@kubb/react-fabric";
-import { caseParams, collect, createPrinterFactory, createProperty, createSchema, extractRefName, isStringType, narrowSchema, schemaTypes, syncSchemaRef, transform, walk } from "@kubb/ast";
+import { caseParams, collect, createPrinterFactory, createProperty, createSchema, extractRefName, isStringType, narrowSchema, schemaTypes, syncSchemaRef, transform } from "@kubb/ast";
 import { isNumber } from "remeda";
 import ts from "typescript";
 import { Fragment, jsx, jsxs } from "@kubb/react-fabric/jsx-runtime";
-import { createPlugin, defineGenerator, definePresets, definePrinter, defineResolver, getBarrelFiles, getMode, getPreset, runGeneratorOperation, runGeneratorOperations, runGeneratorSchema } from "@kubb/core";
+import { createPlugin, defineGenerator, definePresets, definePrinter, defineResolver, getPreset, mergeGenerators } from "@kubb/core";
 //#region ../../internals/utils/src/casing.ts
 /**
 * Shared implementation for camelCase and PascalCase conversion.
@@ -858,19 +857,17 @@ const printerTs = definePrinter((options) => {
 //#region src/generators/typeGenerator.tsx
 const typeGenerator = defineGenerator({
 	name: "typescript",
-	type: "react",
-	Schema({ node, adapter, options, config, resolver, plugin }) {
+	schema(node, options) {
 		const { enumType, enumTypeSuffix, enumKeyCasing, syntaxType, optionalType, arrayType, output, group, printer } = options;
-		const transformedNode = plugin.transformer ? transform(node, plugin.transformer) : node;
-		if (!transformedNode.name) return;
-		const root = path.resolve(config.root, config.output.path);
-		const mode = getMode(path.resolve(root, output.path));
+		const { adapter, config, resolver, root } = this;
+		if (!node.name) return;
+		const mode = this.getMode(output);
 		const enumSchemaNames = new Set((adapter.rootNode?.schemas ?? []).filter((s) => narrowSchema(s, schemaTypes.enum) && s.name).map((s) => s.name));
 		function resolveImportName(schemaName) {
 			if (ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && enumTypeSuffix && enumSchemaNames.has(schemaName)) return resolver.resolveEnumKeyName({ name: schemaName }, enumTypeSuffix);
 			return resolver.resolveTypeName(schemaName);
 		}
-		const imports = adapter.getImports(transformedNode, (schemaName) => ({
+		const imports = adapter.getImports(node, (schemaName) => ({
 			name: resolveImportName(schemaName),
 			path: resolver.resolveFile({
 				name: schemaName,
@@ -881,11 +878,11 @@ const typeGenerator = defineGenerator({
 				group
 			}).path
 		}));
-		const isEnumSchema = !!narrowSchema(transformedNode, schemaTypes.enum);
+		const isEnumSchema = !!narrowSchema(node, schemaTypes.enum);
 		const meta = {
-			name: ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && isEnumSchema ? resolver.resolveEnumKeyName(transformedNode, enumTypeSuffix) : resolver.resolveTypeName(transformedNode.name),
+			name: ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && isEnumSchema ? resolver.resolveEnumKeyName(node, enumTypeSuffix) : resolver.resolveTypeName(node.name),
 			file: resolver.resolveFile({
-				name: transformedNode.name,
+				name: node.name,
 				extname: ".ts"
 			}, {
 				root,
@@ -900,7 +897,7 @@ const typeGenerator = defineGenerator({
 			enumTypeSuffix,
 			name: meta.name,
 			syntaxType,
-			description: transformedNode.description,
+			description: node.description,
 			resolver,
 			enumSchemaNames,
 			nodes: printer?.nodes
@@ -923,12 +920,12 @@ const typeGenerator = defineGenerator({
 				name: imp.name,
 				isTypeOnly: true
 			}, [
-				transformedNode.name,
+				node.name,
 				imp.path,
 				imp.isTypeOnly
 			].join("-"))), /* @__PURE__ */ jsx(Type, {
 				name: meta.name,
-				node: transformedNode,
+				node,
 				enumType,
 				enumTypeSuffix,
 				enumKeyCasing,
@@ -937,17 +934,16 @@ const typeGenerator = defineGenerator({
 			})]
 		});
 	},
-	Operation({ node, adapter, options, config, resolver, plugin }) {
+	operation(node, options) {
 		const { enumType, enumTypeSuffix, enumKeyCasing, optionalType, arrayType, syntaxType, paramsCasing, group, output, printer } = options;
-		const transformedNode = plugin.transformer ? transform(node, plugin.transformer) : node;
-		const root = path.resolve(config.root, config.output.path);
-		const mode = getMode(path.resolve(root, output.path));
-		const params = caseParams(transformedNode.parameters, paramsCasing);
+		const { adapter, config, resolver, root } = this;
+		const mode = this.getMode(output);
+		const params = caseParams(node.parameters, paramsCasing);
 		const meta = { file: resolver.resolveFile({
-			name: transformedNode.operationId,
+			name: node.operationId,
 			extname: ".ts",
-			tag: transformedNode.tags[0] ?? "default",
-			path: transformedNode.path
+			tag: node.tags[0] ?? "default",
+			path: node.path
 		}, {
 			root,
 			output,
@@ -1005,38 +1001,38 @@ const typeGenerator = defineGenerator({
 		}
 		const paramTypes = params.map((param) => renderSchemaType({
 			schema: param.schema,
-			name: resolver.resolveParamName(transformedNode, param)
+			name: resolver.resolveParamName(node, param)
 		}));
-		const requestType = transformedNode.requestBody?.schema ? renderSchemaType({
+		const requestType = node.requestBody?.schema ? renderSchemaType({
 			schema: {
-				...transformedNode.requestBody.schema,
-				description: transformedNode.requestBody.description ?? transformedNode.requestBody.schema.description
+				...node.requestBody.schema,
+				description: node.requestBody.description ?? node.requestBody.schema.description
 			},
-			name: resolver.resolveDataName(transformedNode),
-			keysToOmit: transformedNode.requestBody.keysToOmit
+			name: resolver.resolveDataName(node),
+			keysToOmit: node.requestBody.keysToOmit
 		}) : null;
-		const responseTypes = transformedNode.responses.map((res) => renderSchemaType({
+		const responseTypes = node.responses.map((res) => renderSchemaType({
 			schema: res.schema,
-			name: resolver.resolveResponseStatusName(transformedNode, res.statusCode),
+			name: resolver.resolveResponseStatusName(node, res.statusCode),
 			keysToOmit: res.keysToOmit
 		}));
 		const dataType = renderSchemaType({
 			schema: buildData({
-				...transformedNode,
+				...node,
 				parameters: params
 			}, { resolver }),
-			name: resolver.resolveRequestConfigName(transformedNode)
+			name: resolver.resolveRequestConfigName(node)
 		});
 		const responsesType = renderSchemaType({
-			schema: buildResponses(transformedNode, { resolver }),
-			name: resolver.resolveResponsesName(transformedNode)
+			schema: buildResponses(node, { resolver }),
+			name: resolver.resolveResponsesName(node)
 		});
 		const responseType = renderSchemaType({
-			schema: transformedNode.responses.some((res) => res.schema) ? {
-				...buildResponseUnion(transformedNode, { resolver }),
+			schema: node.responses.some((res) => res.schema) ? {
+				...buildResponseUnion(node, { resolver }),
 				description: "Union of all possible responses"
 			} : null,
-			name: resolver.resolveResponseName(transformedNode)
+			name: resolver.resolveResponseName(node)
 		});
 		return /* @__PURE__ */ jsxs(File, {
 			baseName: meta.file.baseName,
@@ -1062,6 +1058,9 @@ const typeGenerator = defineGenerator({
 	}
 });
 //#endregion
+//#region package.json
+var version = "5.0.0-alpha.30";
+//#endregion
 //#region src/resolvers/resolverTs.ts
 /**
 * Resolver for `@kubb/plugin-ts` that provides the default naming and path-resolution
@@ -1335,14 +1334,12 @@ function nameUnnamedEnums(node, parentName) {
 }
 const typeGeneratorLegacy = defineGenerator({
 	name: "typescript-legacy",
-	type: "react",
-	Schema({ node, adapter, options, config, resolver, plugin }) {
+	schema(node, options) {
 		const { enumType, enumTypeSuffix, enumKeyCasing, syntaxType, optionalType, arrayType, output, group } = options;
-		const transformedNode = plugin.transformer ? transform(node, plugin.transformer) : node;
-		if (!transformedNode.name) return;
-		const root = path.resolve(config.root, config.output.path);
-		const mode = getMode(path.resolve(root, output.path));
-		const imports = adapter.getImports(transformedNode, (schemaName) => ({
+		const { adapter, config, resolver, root } = this;
+		if (!node.name) return;
+		const mode = this.getMode(output);
+		const imports = adapter.getImports(node, (schemaName) => ({
 			name: resolver.resolveTypeName(schemaName),
 			path: resolver.resolveFile({
 				name: schemaName,
@@ -1353,11 +1350,11 @@ const typeGeneratorLegacy = defineGenerator({
 				group
 			}).path
 		}));
-		const isEnumSchema = !!narrowSchema(transformedNode, schemaTypes.enum);
+		const isEnumSchema = !!narrowSchema(node, schemaTypes.enum);
 		const meta = {
-			name: ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && isEnumSchema ? resolver.resolveEnumKeyName(transformedNode, enumTypeSuffix) : resolver.resolveTypeName(transformedNode.name),
+			name: ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && isEnumSchema ? resolver.resolveEnumKeyName(node, enumTypeSuffix) : resolver.resolveTypeName(node.name),
 			file: resolver.resolveFile({
-				name: transformedNode.name,
+				name: node.name,
 				extname: ".ts"
 			}, {
 				root,
@@ -1372,7 +1369,7 @@ const typeGeneratorLegacy = defineGenerator({
 			enumTypeSuffix,
 			name: meta.name,
 			syntaxType,
-			description: transformedNode.description,
+			description: node.description,
 			resolver
 		});
 		return /* @__PURE__ */ jsxs(File, {
@@ -1393,12 +1390,12 @@ const typeGeneratorLegacy = defineGenerator({
 				name: imp.name,
 				isTypeOnly: true
 			}, [
-				transformedNode.name,
+				node.name,
 				imp.path,
 				imp.isTypeOnly
 			].join("-"))), /* @__PURE__ */ jsx(Type, {
 				name: meta.name,
-				node: transformedNode,
+				node,
 				enumType,
 				enumTypeSuffix,
 				enumKeyCasing,
@@ -1407,17 +1404,16 @@ const typeGeneratorLegacy = defineGenerator({
 			})]
 		});
 	},
-	Operation({ node, adapter, options, config, resolver, plugin }) {
+	operation(node, options) {
 		const { enumType, enumTypeSuffix, enumKeyCasing, optionalType, arrayType, syntaxType, paramsCasing, group, output } = options;
-		const transformedNode = plugin.transformer ? transform(node, plugin.transformer) : node;
-		const root = path.resolve(config.root, config.output.path);
-		const mode = getMode(path.resolve(root, output.path));
+		const { adapter, config, resolver, root } = this;
+		const mode = this.getMode(output);
 		const params = caseParams(node.parameters, paramsCasing);
 		const meta = { file: resolver.resolveFile({
-			name: transformedNode.operationId,
+			name: node.operationId,
 			extname: ".ts",
-			tag: transformedNode.tags[0] ?? "default",
-			path: transformedNode.path
+			tag: node.tags[0] ?? "default",
+			path: node.path
 		}, {
 			root,
 			output,
@@ -1594,10 +1590,12 @@ const pluginTs = createPlugin((options) => {
 		transformer: userTransformer,
 		generators: userGenerators
 	});
+	const mergedGenerator = mergeGenerators(preset.generators ?? []);
 	let resolveNameWarning = false;
 	let resolvePathWarning = false;
 	return {
 		name: pluginTsName,
+		version,
 		get resolver() {
 			return preset.resolver;
 		},
@@ -1607,6 +1605,9 @@ const pluginTs = createPlugin((options) => {
 		get options() {
 			return {
 				output,
+				exclude,
+				include,
+				override,
 				optionalType,
 				group: group ? {
 					...group,
@@ -1626,7 +1627,7 @@ const pluginTs = createPlugin((options) => {
 		},
 		resolvePath(baseName, pathMode, options) {
 			if (!resolvePathWarning) {
-				this.events.emit("warn", "Do not use resolvePath for pluginTs, use resolverTs.resolvePath instead");
+				this.warn("Do not use resolvePath for pluginTs, use resolverTs.resolvePath instead");
 				resolvePathWarning = true;
 			}
 			return this.plugin.resolver.resolvePath({
@@ -1635,59 +1636,29 @@ const pluginTs = createPlugin((options) => {
 				tag: options?.group?.tag,
 				path: options?.group?.path
 			}, {
-				root: path.resolve(this.config.root, this.config.output.path),
+				root: this.root,
 				output,
 				group: this.plugin.options.group
 			});
 		},
 		resolveName(name, type) {
 			if (!resolveNameWarning) {
-				this.events.emit("warn", "Do not use resolveName for pluginTs, use resolverTs.default instead");
+				this.warn("Do not use resolveName for pluginTs, use resolverTs.default instead");
 				resolveNameWarning = true;
 			}
 			return this.plugin.resolver.default(name, type);
 		},
-		async install() {
-			const { config, fabric, plugin, adapter, rootNode, driver, openInStudio, resolver } = this;
-			const root = path.resolve(config.root, config.output.path);
-			if (!adapter) throw new Error(`[${pluginTsName}] No adapter found. Add an OAS adapter (e.g. pluginOas()) before this plugin in your Kubb config.`);
-			await openInStudio({ ast: true });
-			const collectedOperations = [];
-			const generatorContext = {
-				generators: preset.generators,
-				plugin,
-				resolver,
-				exclude,
-				include,
-				override,
-				fabric,
-				adapter,
-				config,
-				driver
-			};
-			await walk(rootNode, {
-				depth: "shallow",
-				async schema(schemaNode) {
-					await runGeneratorSchema(schemaNode, generatorContext);
-				},
-				async operation(operationNode) {
-					if (resolver.resolveOptions(operationNode, {
-						options: plugin.options,
-						exclude,
-						include,
-						override
-					}) !== null) collectedOperations.push(operationNode);
-					await runGeneratorOperation(operationNode, generatorContext);
-				}
-			});
-			await runGeneratorOperations(collectedOperations, generatorContext);
-			const barrelFiles = await getBarrelFiles(this.fabric.files, {
-				type: output.barrelType ?? "named",
-				root,
-				output,
-				meta: { pluginName: this.plugin.name }
-			});
-			await this.upsertFile(...barrelFiles);
+		async schema(node, options) {
+			return mergedGenerator.schema?.call(this, node, options);
+		},
+		async operation(node, options) {
+			return mergedGenerator.operation?.call(this, node, options);
+		},
+		async operations(nodes, options) {
+			return mergedGenerator.operations?.call(this, nodes, options);
+		},
+		async buildStart() {
+			await this.openInStudio({ ast: true });
 		}
 	};
 });