@kubb/plugin-ts 5.0.0-beta.94 → 5.0.0-beta.95

package/dist/index.d.ts

@@ -77,11 +77,6 @@ type PrinterTsOptions = {
    * Schema names that represent enums for suffixed key references.
    */
   enumSchemaNames?: Set<string>;
-  /**
-   * Maps a component `$ref` path to its collision-resolved name, so a reference to a renamed
-   * component (e.g. `#/components/schemas/Order` → `OrderSchema`) emits the renamed name.
-   */
-  nameMapping?: ReadonlyMap<string, string>;
   /**
    * Custom handler map for node type overrides.
    */

package/dist/index.js

@@ -335,7 +335,6 @@ const PARAM_RANK = {
 //#endregion
 //#region src/factory.ts
 var factory_exports = /* @__PURE__ */ __exportAll({
-	SyntaxKind: () => SyntaxKind,
 	appendJSDocToNode: () => appendJSDocToNode,
 	buildIndexSignatures: () => buildIndexSignatures,
 	buildMemberNodes: () => buildMemberNodes,
@@ -343,29 +342,15 @@ var factory_exports = /* @__PURE__ */ __exportAll({
 	buildTupleNode: () => buildTupleNode,
 	constToTypeNode: () => constToTypeNode,
 	createArrayDeclaration: () => createArrayDeclaration,
-	createArrayTypeNode: () => createArrayTypeNode,
 	createEnumDeclaration: () => createEnumDeclaration,
 	createExportDeclaration: () => createExportDeclaration,
-	createFalse: () => createFalse,
-	createIdentifier: () => createIdentifier,
 	createImportDeclaration: () => createImportDeclaration,
-	createIndexSignature: () => createIndexSignature,
-	createInterfaceDeclaration: () => createInterfaceDeclaration,
 	createIntersectionDeclaration: () => createIntersectionDeclaration,
 	createJSDoc: () => createJSDoc,
-	createLiteralTypeNode: () => createLiteralTypeNode,
-	createNumericLiteral: () => createNumericLiteral,
 	createOmitDeclaration: () => createOmitDeclaration,
-	createOptionalTypeNode: () => createOptionalTypeNode,
 	createParameterSignature: () => createParameterSignature,
-	createPrefixUnaryExpression: () => createPrefixUnaryExpression,
 	createPropertySignature: () => createPropertySignature,
 	createQuestionToken: () => createQuestionToken,
-	createRestTypeNode: () => createRestTypeNode,
-	createStringLiteral: () => createStringLiteral,
-	createTrue: () => createTrue,
-	createTupleTypeNode: () => createTupleTypeNode,
-	createTypeAliasDeclaration: () => createTypeAliasDeclaration,
 	createTypeDeclaration: () => createTypeDeclaration,
 	createTypeLiteralNode: () => createTypeLiteralNode,
 	createTypeReferenceNode: () => createTypeReferenceNode,
@@ -1023,22 +1008,93 @@ function getOperationParameters(node, options = {}) {
 	};
 }
 //#endregion
-//#region ../../internals/shared/src/adapter.ts
+//#region ../../internals/shared/src/resolver.ts
 /**
-* Narrows the generic `Adapter` from a generator context to the OpenAPI adapter,
-* so OAS-only options (`dateType`, `nameMapping`) and the parsed `document` are typed.
+* Resolves a single operation parameter name with the
+* `<operationId> <in> <name>` template.
 *
-* Throws when a non-OAS adapter is configured, turning a silently wrong cast into a
-* clear, actionable error at the point of use.
+* @example
+* `operationParamName.call(resolver, node, param) // → 'DeletePetPathPetId'`
+*/
+function operationParamName(node, param) {
+	return this.name(`${node.operationId} ${param.in} ${param.name}`);
+}
+/**
+* Builds the shared `param` namespace. Spread the result into `createResolver`
+* and override individual methods next to it when a plugin deviates.
+*
+* @example
+* ```ts
+* createResolver<PluginTs>({ param: createOperationParamResolver(), ... })
+* ```
+*/
+function createOperationParamResolver() {
+	return {
+		name: operationParamName,
+		path(node) {
+			return this.name(`${node.operationId} Path`);
+		},
+		query(node) {
+			return this.name(`${node.operationId} Query`);
+		},
+		headers(node) {
+			return this.name(`${node.operationId} Headers`);
+		}
+	};
+}
+/**
+* Builds the shared `response` namespace. Spread the result into
+* `createResolver` and add plugin-specific methods (`options`, `error`) next
+* to it.
 *
 * @example
 * ```ts
-* const { dateType } = getOasAdapter(ctx.adapter).options
+* createResolver<PluginTs>({ response: { ...createOperationResponseResolver(), options(node) {...} }, ... })
 * ```
 */
-function getOasAdapter(adapter) {
-	if (adapter.name !== "oas") throw new Error(`Expected the OpenAPI adapter (adapterOas), but received "${adapter.name}". Configure \`adapter: adapterOas()\` in your Kubb config.`);
-	return adapter;
+function createOperationResponseResolver() {
+	return {
+		status(node, statusCode) {
+			return this.name(`${node.operationId} Status ${statusCode}`);
+		},
+		body(node) {
+			return this.name(`${node.operationId} Body`);
+		},
+		responses(node) {
+			return this.name(`${node.operationId} Responses`);
+		},
+		response(node) {
+			return this.name(`${node.operationId} Response`);
+		}
+	};
+}
+/**
+* Builds a resolver `file` override whose base name runs every path segment
+* through `toFilePath`, casing the final segment with `caseLast`.
+*
+* @example
+* ```ts
+* createResolver<PluginTs>({ file: createCasedFile(pascalCase), ... })
+* ```
+*/
+function createCasedFile(caseLast) {
+	return { baseName({ name, extname }) {
+		return `${toFilePath(name, caseLast)}${extname}`;
+	} };
+}
+//#endregion
+//#region ../../internals/shared/src/refs.ts
+/**
+* Collects the resolved target name of every pointer-carrying ref in a schema tree, in
+* first-occurrence order. Use this for name-only checks (e.g. redeclaration detection) where
+* `resolver.imports` would resolve file paths that are then discarded.
+*/
+function collectRefNames(schema) {
+	return ast.collect(schema, { schema: (node) => {
+		const refNode = ast.narrowSchema(node, "ref");
+		if (!refNode?.ref) return null;
+		return ast.resolveRefName(refNode);
+	} });
 }
 //#endregion
 //#region ../../internals/shared/src/group.ts
@@ -1340,7 +1396,8 @@ const printerTs = ast.createPrinter((options) => {
 			time: dateOrStringNode,
 			ref(node) {
 				if (!node.name) return null;
-				const refName = node.ref ? this.options.nameMapping?.get(node.ref) ?? ast.extractRefName(node.ref) ?? node.name : node.name;
+				const refName = ast.resolveRefName(node);
+				if (!refName) return null;
 				return createTypeReferenceNode(node.ref && ENUM_TYPES_WITH_KEY_SUFFIX.has(this.options.enum.type) && this.options.enum.typeSuffix && this.options.enumSchemaNames?.has(refName) ? this.options.resolver.enum.keyName({ name: refName }, this.options.enum.typeSuffix) : node.ref ? this.options.resolver.name(refName) : refName, void 0);
 			},
 			enum(node) {
@@ -1466,24 +1523,22 @@ const typeGenerator = defineGenerator({
 	renderer: jsxRenderer,
 	schema(node, ctx) {
 		const { enum: enumOptions, syntaxType, optionalType, arrayType, output, group, printer } = ctx.options;
-		const { adapter, config, resolver, root } = ctx;
+		const { config, resolver, root } = ctx;
 		if (!node.name) return;
 		const enumSchemaNames = new Set(ctx.meta.enumNames);
-		const imports = adapter.getImports(node, (schemaName) => ({
-			name: resolveImportName({
-				schemaName,
-				enumOptions,
-				enumSchemaNames,
-				resolver
-			}),
-			path: resolver.file({
-				name: schemaName,
-				extname: ".ts",
-				root,
-				output,
-				group: group ?? void 0
-			}).path
-		}));
+		const importName = (schemaName) => resolveImportName({
+			schemaName,
+			enumOptions,
+			enumSchemaNames,
+			resolver
+		});
+		const imports = resolver.imports({
+			node,
+			root,
+			output,
+			group: group ?? void 0,
+			name: importName
+		});
 		const enumNode = ast.narrowSchema(node, ast.schemaTypes.enum);
 		const isEnumSchema = !!enumNode && !isInlineConstEnum(enumNode, enumSchemaNames);
 		const meta = {
@@ -1505,7 +1560,6 @@ const typeGenerator = defineGenerator({
 			description: node.description,
 			resolver,
 			enumSchemaNames,
-			nameMapping: getOasAdapter(adapter).options.nameMapping,
 			nodes: printer?.nodes
 		});
 		return /* @__PURE__ */ jsxs(File, {
@@ -1548,7 +1602,7 @@ const typeGenerator = defineGenerator({
 	},
 	operation(node, ctx) {
 		const { enum: enumOptions, optionalType, arrayType, syntaxType, group, output, printer } = ctx.options;
-		const { adapter, config, resolver, root } = ctx;
+		const { config, resolver, root } = ctx;
 		const params = caseParams(node.parameters, "camelcase");
 		const meta = { file: resolver.file({
 			name: node.operationId,
@@ -1560,23 +1614,21 @@ const typeGenerator = defineGenerator({
 			group: group ?? void 0
 		}) };
 		const enumSchemaNames = new Set(ctx.meta.enumNames);
+		const importName = (schemaName) => resolveImportName({
+			schemaName,
+			enumOptions,
+			enumSchemaNames,
+			resolver
+		});
 		function renderSchemaType({ schema, name, keysToOmit }) {
 			if (!schema) return null;
-			const imports = adapter.getImports(schema, (schemaName) => ({
-				name: resolveImportName({
-					schemaName,
-					enumOptions,
-					enumSchemaNames,
-					resolver
-				}),
-				path: resolver.file({
-					name: schemaName,
-					extname: ".ts",
-					root,
-					output,
-					group: group ?? void 0
-				}).path
-			}));
+			const imports = resolver.imports({
+				node: schema,
+				root,
+				output,
+				group: group ?? void 0,
+				name: importName
+			});
 			const schemaPrinter = printerTs({
 				optionalType,
 				arrayType,
@@ -1587,7 +1639,6 @@ const typeGenerator = defineGenerator({
 				keysToOmit,
 				resolver,
 				enumSchemaNames,
-				nameMapping: getOasAdapter(adapter).options.nameMapping,
 				nodes: printer?.nodes
 			});
 			return /* @__PURE__ */ jsxs(Fragment, { children: [imports.map((imp) => /* @__PURE__ */ jsx(File.Import, {
@@ -1696,15 +1747,7 @@ const typeGenerator = defineGenerator({
 			if (!node.responses.some(hasSchema)) return null;
 			const responseName = resolver.response.response(node);
 			const responsesWithSchema = node.responses.filter(hasSchema);
-			if (new Set(responsesWithSchema.flatMap((res) => (res.content ?? []).flatMap((entry) => entry.schema ? adapter.getImports(entry.schema, (schemaName) => ({
-				name: resolveImportName({
-					schemaName,
-					enumOptions,
-					enumSchemaNames,
-					resolver
-				}),
-				path: ""
-			})).flatMap((imp) => Array.isArray(imp.name) ? imp.name : [imp.name]) : []))).has(responseName)) return null;
+			if (new Set(responsesWithSchema.flatMap((res) => (res.content ?? []).flatMap((entry) => entry.schema ? collectRefNames(entry.schema).map(importName) : []))).has(responseName)) return null;
 			return renderSchemaType({
 				schema: {
 					...buildResponseUnion(node, { resolver }),
@@ -1771,38 +1814,12 @@ const resolverTs = createResolver({
 	name(name) {
 		return ensureValidVarName(pascalCase(name));
 	},
-	file: { baseName({ name, extname }) {
-		return `${toFilePath(name, pascalCase)}${extname}`;
-	} },
-	param: {
-		name(node, param) {
-			return this.name(`${node.operationId} ${param.in} ${param.name}`);
-		},
-		path(node) {
-			return this.name(`${node.operationId} Path`);
-		},
-		query(node) {
-			return this.name(`${node.operationId} Query`);
-		},
-		headers(node) {
-			return this.name(`${node.operationId} Headers`);
-		}
-	},
+	file: createCasedFile(pascalCase),
+	param: createOperationParamResolver(),
 	response: {
-		status(node, statusCode) {
-			return this.name(`${node.operationId} Status ${statusCode}`);
-		},
+		...createOperationResponseResolver(),
 		options(node) {
 			return this.name(`${node.operationId} Options`);
-		},
-		responses(node) {
-			return this.name(`${node.operationId} Responses`);
-		},
-		response(node) {
-			return this.name(`${node.operationId} Response`);
-		},
-		body(node) {
-			return this.name(`${node.operationId} Body`);
 		}
 	},
 	enum: { keyName(node, enumTypeSuffix = "key") {