@kubb/plugin-ts 5.0.4 → 5.0.6

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { n as __name } from "./rolldown-runtime-CNktS9qV.js";
+import { n as __name } from "./rolldown-runtime-CthDji9g.js";
 import { KubbReactNode } from "kubb/jsx";
 import { Exclude, Group, Include, Output, OutputOptions, Override, PluginFactoryOptions, Resolver, ResolverPatch, ast } from "kubb/kit";
 import ts from "typescript";
@@ -298,7 +298,6 @@ type EnumOptions$1 = {
    * site (`'inlineLiteral'`).
    *
    * @default 'asConst'
-   * @note In Kubb v5, 'inlineLiteral' becomes the default.
    */
   type?: 'literal' | 'inlineLiteral';
   /**

package/dist/index.js

@@ -1,8 +1,8 @@
-import { n as __name, t as __exportAll } from "./rolldown-runtime-CNktS9qV.js";
+import { n as __name, t as __exportAll } from "./rolldown-runtime-CthDji9g.js";
+import { createRequire } from "node:module";
 import { parserTs } from "@kubb/parser-ts";
 import { File, jsxRenderer } from "kubb/jsx";
-import { Resolver, ast, createResolver, defineGenerator, definePlugin, isStringType, syncSchemaRef } from "kubb/kit";
-import ts from "typescript";
+import { Resolver, assertPluginOption, ast, createResolver, defineGenerator, definePlugin, isStringType, syncSchemaRef } from "kubb/kit";
 import { Fragment, jsx, jsxs } from "kubb/jsx/jsx-runtime";
 //#region ../../internals/utils/src/casing.ts
 /**
@@ -362,7 +362,12 @@ var factory_exports = /* @__PURE__ */ __exportAll({
 	modifiers: () => modifiers,
 	syntaxKind: () => syntaxKind
 });
-const { SyntaxKind, factory } = ts;
+/**
+* Loaded with `require`, not `import`. When ESM imports a CommonJS package, Node keeps a second
+* copy of its source to detect named exports, and for TypeScript that copy is about 9 MB.
+*/
+const typescript = createRequire(import.meta.url)("typescript");
+const { SyntaxKind, factory } = typescript;
 /**
 * Compares two strings by UTF-16 code unit, keeping sorted output identical across platforms
 * regardless of locale.
@@ -379,10 +384,10 @@ function isNumber(value) {
 * TypeScript AST modifiers for common keywords (async, export, const, static).
 */
 const modifiers = {
-	async: factory.createModifier(ts.SyntaxKind.AsyncKeyword),
-	export: factory.createModifier(ts.SyntaxKind.ExportKeyword),
-	const: factory.createModifier(ts.SyntaxKind.ConstKeyword),
-	static: factory.createModifier(ts.SyntaxKind.StaticKeyword)
+	async: factory.createModifier(typescript.SyntaxKind.AsyncKeyword),
+	export: factory.createModifier(typescript.SyntaxKind.ExportKeyword),
+	const: factory.createModifier(typescript.SyntaxKind.ConstKeyword),
+	static: factory.createModifier(typescript.SyntaxKind.StaticKeyword)
 };
 /**
 * TypeScript syntax kind constants for union, literal, and string types.
@@ -399,10 +404,10 @@ __name(isNonNullable$1, "isNonNullable");
 function isValidIdentifier(str) {
 	if (!str.length || str.trim() !== str) return false;
 	let ch = str.codePointAt(0);
-	if (!ts.isIdentifierStart(ch, ts.ScriptTarget.Latest)) return false;
+	if (!typescript.isIdentifierStart(ch, typescript.ScriptTarget.Latest)) return false;
 	for (let i = ch > 65535 ? 2 : 1; i < str.length; i += ch > 65535 ? 2 : 1) {
 		ch = str.codePointAt(i);
-		if (!ts.isIdentifierPart(ch, ts.ScriptTarget.Latest)) return false;
+		if (!typescript.isIdentifierPart(ch, typescript.ScriptTarget.Latest)) return false;
 	}
 	return true;
 }
@@ -410,7 +415,7 @@ function propertyName(name) {
 	if (typeof name === "string") return isValidIdentifier(name) ? factory.createIdentifier(name) : factory.createStringLiteral(name);
 	return name;
 }
-const questionToken = factory.createToken(ts.SyntaxKind.QuestionToken);
+const questionToken = factory.createToken(typescript.SyntaxKind.QuestionToken);
 /**
 * Creates a question token for optional type annotations.
 * Pass `true` to use the cached token, or provide a pre-created token.
@@ -470,7 +475,7 @@ function createUnionDeclaration({ nodes, withParentheses }) {
 * Supports optional markers, readonly modifiers, and type annotations.
 */
 function createPropertySignature({ readOnly, modifiers = [], name, questionToken, type }) {
-	return factory.createPropertySignature([...modifiers, readOnly ? factory.createToken(ts.SyntaxKind.ReadonlyKeyword) : void 0].filter((modifier) => modifier !== void 0), propertyName(name), createQuestionToken(questionToken), type);
+	return factory.createPropertySignature([...modifiers, readOnly ? factory.createToken(typescript.SyntaxKind.ReadonlyKeyword) : void 0].filter((modifier) => modifier !== void 0), propertyName(name), createQuestionToken(questionToken), type);
 }
 /**
 * Creates a function parameter declaration with optional markers, rest parameters, and type annotations.
@@ -501,13 +506,13 @@ function appendJSDocToNode({ node, comments }) {
 	const text = filteredComments.reduce((acc = "", comment = "") => {
 		return `${acc}\n * ${comment.replaceAll("*/", "*\\/")}`;
 	}, "*");
-	return ts.addSyntheticLeadingComment(node, ts.SyntaxKind.MultiLineCommentTrivia, `${text || "*"}\n`, true);
+	return typescript.addSyntheticLeadingComment(node, typescript.SyntaxKind.MultiLineCommentTrivia, `${text || "*"}\n`, true);
 }
 /**
 * Creates a TypeScript index signature for dynamic property access.
 * Defines the key type (default: `string`) and value type on an object.
 */
-function createIndexSignature(type, { modifiers, indexName = "key", indexType = factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword) } = {}) {
+function createIndexSignature(type, { modifiers, indexName = "key", indexType = factory.createKeywordTypeNode(typescript.SyntaxKind.StringKeyword) } = {}) {
 	return factory.createIndexSignature(modifiers, [createParameterSignature(indexName, { type: indexType })], type);
 }
 /**
@@ -527,7 +532,7 @@ function createInterfaceDeclaration({ modifiers, name, typeParameters, members }
 * Intelligently selects the syntax based on the type structure and attaches JSDoc comments.
 */
 function createTypeDeclaration({ syntax, isExportable, comments, name, type }) {
-	if (syntax === "interface" && ts.isTypeLiteralNode(type)) return appendJSDocToNode({
+	if (syntax === "interface" && typescript.isTypeLiteralNode(type)) return appendJSDocToNode({
 		node: createInterfaceDeclaration({
 			members: [...type.members],
 			modifiers: isExportable ? [modifiers.export] : [],
@@ -616,18 +621,18 @@ function applyEnumKeyCasing(key, casing = "none") {
 * ```
 */
 function createEnumDeclaration({ type = "enum", name, typeName, enums, enumKeyCasing = "none" }) {
-	if (type === "literal" || type === "inlineLiteral") return [void 0, factory.createTypeAliasDeclaration([factory.createToken(ts.SyntaxKind.ExportKeyword)], factory.createIdentifier(typeName), void 0, factory.createUnionTypeNode(enums.map(([_key, value]) => {
+	if (type === "literal" || type === "inlineLiteral") return [void 0, factory.createTypeAliasDeclaration([factory.createToken(typescript.SyntaxKind.ExportKeyword)], factory.createIdentifier(typeName), void 0, factory.createUnionTypeNode(enums.map(([_key, value]) => {
 		if (isNumber(value)) {
-			if (value < 0) return factory.createLiteralTypeNode(factory.createPrefixUnaryExpression(ts.SyntaxKind.MinusToken, factory.createNumericLiteral(Math.abs(value))));
+			if (value < 0) return factory.createLiteralTypeNode(factory.createPrefixUnaryExpression(typescript.SyntaxKind.MinusToken, factory.createNumericLiteral(Math.abs(value))));
 			return factory.createLiteralTypeNode(factory.createNumericLiteral(value?.toString()));
 		}
 		if (typeof value === "boolean") return factory.createLiteralTypeNode(value ? factory.createTrue() : factory.createFalse());
 		if (value !== null && value !== void 0) return factory.createLiteralTypeNode(factory.createStringLiteral(value.toString()));
 	}).filter((node) => node !== void 0)))];
-	if (type === "enum" || type === "constEnum") return [void 0, factory.createEnumDeclaration([factory.createToken(ts.SyntaxKind.ExportKeyword), type === "constEnum" ? factory.createToken(ts.SyntaxKind.ConstKeyword) : void 0].filter((modifier) => modifier !== void 0), factory.createIdentifier(typeName), enums.map(([key, value, description]) => {
+	if (type === "enum" || type === "constEnum") return [void 0, factory.createEnumDeclaration([factory.createToken(typescript.SyntaxKind.ExportKeyword), type === "constEnum" ? factory.createToken(typescript.SyntaxKind.ConstKeyword) : void 0].filter((modifier) => modifier !== void 0), factory.createIdentifier(typeName), enums.map(([key, value, description]) => {
 		let initializer = factory.createStringLiteral(value?.toString());
 		if (Number.parseInt(value.toString(), 10) === value && isNumber(value)) {
-			if (value < 0) initializer = factory.createPrefixUnaryExpression(ts.SyntaxKind.MinusToken, factory.createNumericLiteral(Math.abs(value)));
+			if (value < 0) initializer = factory.createPrefixUnaryExpression(typescript.SyntaxKind.MinusToken, factory.createNumericLiteral(Math.abs(value)));
 			else initializer = factory.createNumericLiteral(value);
 		}
 		if (typeof value === "boolean") initializer = value ? factory.createTrue() : factory.createFalse();
@@ -647,11 +652,11 @@ function createEnumDeclaration({ type = "enum", name, typeName, enums, enumKeyCa
 		}
 	}).filter((member) => member !== void 0))];
 	const identifierName = name;
-	if (enums.length === 0) return [void 0, factory.createTypeAliasDeclaration([factory.createToken(ts.SyntaxKind.ExportKeyword)], factory.createIdentifier(typeName), void 0, factory.createKeywordTypeNode(ts.SyntaxKind.NeverKeyword))];
-	return [factory.createVariableStatement([factory.createToken(ts.SyntaxKind.ExportKeyword)], factory.createVariableDeclarationList([factory.createVariableDeclaration(factory.createIdentifier(identifierName), void 0, void 0, factory.createAsExpression(factory.createObjectLiteralExpression(enums.map(([key, value, description]) => {
+	if (enums.length === 0) return [void 0, factory.createTypeAliasDeclaration([factory.createToken(typescript.SyntaxKind.ExportKeyword)], factory.createIdentifier(typeName), void 0, factory.createKeywordTypeNode(typescript.SyntaxKind.NeverKeyword))];
+	return [factory.createVariableStatement([factory.createToken(typescript.SyntaxKind.ExportKeyword)], factory.createVariableDeclarationList([factory.createVariableDeclaration(factory.createIdentifier(identifierName), void 0, void 0, factory.createAsExpression(factory.createObjectLiteralExpression(enums.map(([key, value, description]) => {
 		let initializer = factory.createStringLiteral(value?.toString());
 		if (isNumber(value)) {
-			if (value < 0) initializer = factory.createPrefixUnaryExpression(ts.SyntaxKind.MinusToken, factory.createNumericLiteral(Math.abs(value)));
+			if (value < 0) initializer = factory.createPrefixUnaryExpression(typescript.SyntaxKind.MinusToken, factory.createNumericLiteral(Math.abs(value)));
 			else initializer = factory.createNumericLiteral(value);
 		}
 		if (typeof value === "boolean") initializer = value ? factory.createTrue() : factory.createFalse();
@@ -662,7 +667,7 @@ function createEnumDeclaration({ type = "enum", name, typeName, enums, enumKeyCa
 				comments: [description]
 			});
 		}
-	}).filter((property) => property !== void 0), true), factory.createTypeReferenceNode(factory.createIdentifier("const"), void 0)))], ts.NodeFlags.Const)), factory.createTypeAliasDeclaration([factory.createToken(ts.SyntaxKind.ExportKeyword)], factory.createIdentifier(typeName), void 0, factory.createIndexedAccessTypeNode(factory.createParenthesizedType(factory.createTypeQueryNode(factory.createIdentifier(identifierName), void 0)), factory.createTypeOperatorNode(ts.SyntaxKind.KeyOfKeyword, factory.createTypeQueryNode(factory.createIdentifier(identifierName), void 0))))];
+	}).filter((property) => property !== void 0), true), factory.createTypeReferenceNode(factory.createIdentifier("const"), void 0)))], typescript.NodeFlags.Const)), factory.createTypeAliasDeclaration([factory.createToken(typescript.SyntaxKind.ExportKeyword)], factory.createIdentifier(typeName), void 0, factory.createIndexedAccessTypeNode(factory.createParenthesizedType(factory.createTypeQueryNode(factory.createIdentifier(identifierName), void 0)), factory.createTypeOperatorNode(typescript.SyntaxKind.KeyOfKeyword, factory.createTypeQueryNode(factory.createIdentifier(identifierName), void 0))))];
 }
 /**
 * Creates a TypeScript `Omit<T, Keys>` type reference node.
@@ -680,18 +685,18 @@ function createOmitDeclaration({ keys, type, nonNullable }) {
 * Use these to avoid repeatedly creating the same type nodes.
 */
 const keywordTypeNodes = {
-	any: factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
-	unknown: factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword),
-	void: factory.createKeywordTypeNode(ts.SyntaxKind.VoidKeyword),
-	number: factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword),
-	integer: factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword),
-	bigint: factory.createKeywordTypeNode(ts.SyntaxKind.BigIntKeyword),
-	object: factory.createKeywordTypeNode(ts.SyntaxKind.ObjectKeyword),
-	string: factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),
-	boolean: factory.createKeywordTypeNode(ts.SyntaxKind.BooleanKeyword),
-	undefined: factory.createKeywordTypeNode(ts.SyntaxKind.UndefinedKeyword),
-	null: factory.createLiteralTypeNode(factory.createToken(ts.SyntaxKind.NullKeyword)),
-	never: factory.createKeywordTypeNode(ts.SyntaxKind.NeverKeyword)
+	any: factory.createKeywordTypeNode(typescript.SyntaxKind.AnyKeyword),
+	unknown: factory.createKeywordTypeNode(typescript.SyntaxKind.UnknownKeyword),
+	void: factory.createKeywordTypeNode(typescript.SyntaxKind.VoidKeyword),
+	number: factory.createKeywordTypeNode(typescript.SyntaxKind.NumberKeyword),
+	integer: factory.createKeywordTypeNode(typescript.SyntaxKind.NumberKeyword),
+	bigint: factory.createKeywordTypeNode(typescript.SyntaxKind.BigIntKeyword),
+	object: factory.createKeywordTypeNode(typescript.SyntaxKind.ObjectKeyword),
+	string: factory.createKeywordTypeNode(typescript.SyntaxKind.StringKeyword),
+	boolean: factory.createKeywordTypeNode(typescript.SyntaxKind.BooleanKeyword),
+	undefined: factory.createKeywordTypeNode(typescript.SyntaxKind.UndefinedKeyword),
+	null: factory.createLiteralTypeNode(factory.createToken(typescript.SyntaxKind.NullKeyword)),
+	never: factory.createKeywordTypeNode(typescript.SyntaxKind.NeverKeyword)
 };
 /**
 * Converts a path like '/pet/{petId}/uploadImage' to a template literal type
@@ -714,15 +719,15 @@ function createUrlTemplateType(path) {
 			parts.push(segment);
 		} else if (segment) parts.push(segment);
 	});
-	const head = ts.factory.createTemplateHead(parts[0] || "");
+	const head = typescript.factory.createTemplateHead(parts[0] || "");
 	const templateSpans = [];
 	parameterIndices.forEach((paramIndex, i) => {
 		const isLast = i === parameterIndices.length - 1;
 		const nextPart = parts[paramIndex + 1] || "";
-		const literal = isLast ? ts.factory.createTemplateTail(nextPart) : ts.factory.createTemplateMiddle(nextPart);
-		templateSpans.push(ts.factory.createTemplateLiteralTypeSpan(keywordTypeNodes.string, literal));
+		const literal = isLast ? typescript.factory.createTemplateTail(nextPart) : typescript.factory.createTemplateMiddle(nextPart);
+		templateSpans.push(typescript.factory.createTemplateLiteralTypeSpan(keywordTypeNodes.string, literal));
 	});
-	return ts.factory.createTemplateLiteralType(head, templateSpans);
+	return typescript.factory.createTemplateLiteralType(head, templateSpans);
 }
 /**
 * Creates a TypeScript type literal node (anonymous object type).
@@ -827,8 +832,8 @@ function buildPropertyType(schema, baseType, optionalType, optional) {
 	if ((optional || meta.nullish || meta.optional) && addsUndefined) type = createUnionDeclaration({ nodes: [type, keywordTypeNodes.undefined] });
 	return type;
 }
-const indexSignaturePrinter = ts.createPrinter();
-const indexSignatureSource = ts.createSourceFile("", "", ts.ScriptTarget.Latest);
+const indexSignaturePrinter = typescript.createPrinter();
+const indexSignatureSource = typescript.createSourceFile("", "", typescript.ScriptTarget.Latest);
 /**
 * Creates a TypeScript index signature for `additionalProperties` and `patternProperties` on an
 * object schema node. TypeScript allows only one string index signature and its value must be
@@ -847,7 +852,7 @@ function buildIndexSignatures(node, propertyCount, print) {
 	if (valueTypes.length === 0) return [];
 	const seen = /* @__PURE__ */ new Set();
 	const distinct = valueTypes.filter((type) => {
-		const key = indexSignaturePrinter.printNode(ts.EmitHint.Unspecified, type, indexSignatureSource);
+		const key = indexSignaturePrinter.printNode(typescript.EmitHint.Unspecified, type, indexSignatureSource);
 		return seen.has(key) ? false : (seen.add(key), true);
 	});
 	return [createIndexSignature(propertyCount > 0 ? keywordTypeNodes.unknown : createUnionDeclaration({ nodes: distinct }))];
@@ -1312,7 +1317,7 @@ function buildPropertyJSDocComments(schema, optional) {
 		!isArray && meta && "min" in meta && meta.min !== void 0 ? `@minLength ${meta.min}` : null,
 		!isArray && meta && "max" in meta && meta.max !== void 0 ? `@maxLength ${meta.max}` : null,
 		meta && "pattern" in meta && meta.pattern ? `@pattern ${meta.pattern}` : null,
-		meta && "default" in meta && meta.default !== void 0 ? `@default ${"primitive" in meta && meta.primitive === "string" && typeof meta.default === "string" ? stringify(meta.default) : meta.default}` : null,
+		meta && "default" in meta && meta.default !== void 0 ? `@default ${"primitive" in meta && meta.primitive === "string" && typeof meta.default === "string" ? stringify(meta.default) : formatExample(meta.default)}` : null,
 		...exampleValues.map((example) => `@example ${formatExample(example)}`)
 	].filter(Boolean);
 	const typeTag = comments.length && meta && "primitive" in meta && meta.primitive ? [`@type ${meta.primitive}`, optional ?? isSchemaOptional(schema) ? " | undefined" : null].filter(Boolean).join("") : null;
@@ -1870,6 +1875,53 @@ const resolverTs = createResolver({
 * cross-plugin dependency references.
 */
 const pluginTsName = "plugin-ts";
+const allowedEnumTypes = [
+	"asConst",
+	"enum",
+	"constEnum",
+	"literal",
+	"inlineLiteral"
+];
+const allowedSyntaxTypes = ["type", "interface"];
+const allowedArrayTypes = ["array", "generic"];
+const allowedOptionalTypes = [
+	"questionToken",
+	"undefined",
+	"questionTokenAndUndefined"
+];
+/**
+* Throws when an enum-like option holds a value outside its allowed set. Options left out are skipped.
+*/
+function assertEnumLikeOptions({ prefix, options }) {
+	const checks = [
+		{
+			option: "enum.type",
+			value: options.enum?.type,
+			allowed: allowedEnumTypes
+		},
+		{
+			option: "syntaxType",
+			value: options.syntaxType,
+			allowed: allowedSyntaxTypes
+		},
+		{
+			option: "arrayType",
+			value: options.arrayType,
+			allowed: allowedArrayTypes
+		},
+		{
+			option: "optionalType",
+			value: options.optionalType,
+			allowed: allowedOptionalTypes
+		}
+	];
+	for (const { option, value, allowed } of checks) if (value !== void 0) assertPluginOption({
+		plugin: pluginTsName,
+		option: `${prefix}${option}`,
+		value,
+		allowed
+	});
+}
 /**
 * Generates TypeScript `type` aliases and `interface` declarations from an
 * OpenAPI spec. The foundation that every other Kubb plugin builds on:
@@ -1910,6 +1962,19 @@ const pluginTs = definePlugin((options) => {
 		name: pluginTsName,
 		options,
 		hooks: { "kubb:plugin:setup"(ctx) {
+			assertEnumLikeOptions({
+				prefix: "",
+				options: {
+					enum: resolvedEnum,
+					syntaxType,
+					arrayType,
+					optionalType
+				}
+			});
+			for (const [index, entry] of override.entries()) assertEnumLikeOptions({
+				prefix: `override[${index}].options.`,
+				options: entry.options
+			});
 			ctx.setOptions({
 				output,
 				exclude,