@kubb/plugin-ts 5.0.1 → 5.0.3

package/dist/index.d.ts

@@ -110,7 +110,7 @@ type PrinterTsFactory = ast.PrinterFactoryOptions<'typescript', PrinterTsOptions
  * const declaration = printer.print(schemaNode) // ts.TypeAliasDeclaration | ts.InterfaceDeclaration
  * ```
  */
-declare const printerTs: (options?: PrinterTsOptions | undefined) => ast.Printer<PrinterTsFactory>;
+export declare const printerTs: (options?: PrinterTsOptions | undefined) => ast.Printer<PrinterTsFactory>;
 //#endregion
 //#region src/types.d.ts
 /**
@@ -457,7 +457,7 @@ type Props$1 = {
  * The emitted `File.Source` nodes carry the resolved names so that the barrel
  * index picks up the correct export identifiers.
  */
-declare function Enum({ node, enum: enumOptions, resolver }: Props$1): KubbReactNode;
+export declare function Enum({ node, enum: enumOptions, resolver }: Props$1): KubbReactNode;
 //#endregion
 //#region src/components/Type.d.ts
 type Props = {
@@ -471,7 +471,7 @@ type Props = {
   enum: PluginTs['resolvedOptions']['enum'];
   resolver: ResolverTs;
 };
-declare function Type({ name, node, printer, enum: enumOptions, resolver }: Props): KubbReactNode;
+export declare function Type({ name, node, printer, enum: enumOptions, resolver }: Props): KubbReactNode;
 //#endregion
 //#region src/generators/typeGenerator.d.ts
 /**
@@ -480,14 +480,14 @@ declare function Type({ name, node, printer, enum: enumOptions, resolver }: Prop
  * types. Drop-replace with a custom `Generator<PluginTs>` to change how
  * TypeScript output is produced.
  */
-declare const typeGenerator: import("kubb/kit").Generator<PluginTs, unknown>;
+export declare const typeGenerator: import("kubb/kit").Generator<PluginTs, unknown>;
 //#endregion
 //#region src/plugin.d.ts
 /**
  * Canonical plugin name for `@kubb/plugin-ts`. Used for driver lookups and
  * cross-plugin dependency references.
  */
-declare const pluginTsName = "plugin-ts";
+export declare const pluginTsName = "plugin-ts";
 /**
  * Generates TypeScript `type` aliases and `interface` declarations from an
  * OpenAPI spec. The foundation that every other Kubb plugin builds on:
@@ -512,7 +512,7 @@ declare const pluginTsName = "plugin-ts";
  * })
  * ```
  */
-declare const pluginTs: (options?: Options | undefined) => import("kubb/kit").Plugin<PluginTs>;
+export declare const pluginTs: (options?: Options | undefined) => import("kubb/kit").Plugin<PluginTs>;
 //#endregion
 //#region src/printers/functionParams.d.ts
 /**
@@ -646,7 +646,7 @@ type FunctionParametersNode = {
  * // { petId: string }
  * ```
  */
-declare function createTypeLiteral(props: Omit<TypeLiteralNode, 'kind'>): TypeLiteralNode;
+export declare function createTypeLiteral(props: Omit<TypeLiteralNode, 'kind'>): TypeLiteralNode;
 /**
  * Creates an {@link IndexedAccessTypeNode} representing a single field accessed from a named type.
  *
@@ -656,7 +656,7 @@ declare function createTypeLiteral(props: Omit<TypeLiteralNode, 'kind'>): TypeLi
  * // DeletePetPathParams['petId']
  * ```
  */
-declare function createIndexedAccessType(props: Omit<IndexedAccessTypeNode, 'kind'>): IndexedAccessTypeNode;
+export declare function createIndexedAccessType(props: Omit<IndexedAccessTypeNode, 'kind'>): IndexedAccessTypeNode;
 /**
  * Creates an {@link ObjectBindingPatternNode} for a destructured parameter binding.
  *
@@ -666,7 +666,7 @@ declare function createIndexedAccessType(props: Omit<IndexedAccessTypeNode, 'kin
  * // { id, name }
  * ```
  */
-declare function createObjectBindingPattern(props: Omit<ObjectBindingPatternNode, 'kind'>): ObjectBindingPatternNode;
+export declare function createObjectBindingPattern(props: Omit<ObjectBindingPatternNode, 'kind'>): ObjectBindingPatternNode;
 /**
  * Plain property descriptor for a destructured group built by {@link createFunctionParameter}.
  */
@@ -703,7 +703,7 @@ type FunctionParameterInput = {
  * // → { id, name }: { id: string; name?: string } = {}
  * ```
  */
-declare function createFunctionParameter(input: FunctionParameterInput): FunctionParameterNode;
+export declare function createFunctionParameter(input: FunctionParameterInput): FunctionParameterNode;
 /**
  * Creates a {@link FunctionParametersNode} from an ordered list of parameters.
  *
@@ -713,7 +713,7 @@ declare function createFunctionParameter(input: FunctionParameterInput): Functio
  * // { params: [] }
  * ```
  */
-declare function createFunctionParameters(props?: Partial<Omit<FunctionParametersNode, 'kind'>>): FunctionParametersNode;
+export declare function createFunctionParameters(props?: Partial<Omit<FunctionParametersNode, 'kind'>>): FunctionParametersNode;
 //#endregion
 //#region src/printers/functionPrinter.d.ts
 /**
@@ -726,7 +726,7 @@ declare function createFunctionParameters(props?: Partial<Omit<FunctionParameter
  * `transformType` is applied once to the fully rendered type, matching how the
  * printer wrapped reference types before the `ts.factory` model.
  */
-declare function renderType(type: TypeExpression, transformType?: (type: string) => string): string;
+export declare function renderType(type: TypeExpression, transformType?: (type: string) => string): string;
 type FunctionPrinterOptions = {
   /**
    * Rendering modes supported by `functionPrinter`.
@@ -764,7 +764,7 @@ type FunctionPrinterOptions = {
  * printer.print(sig)  // → "petId: string, config: Config = {}"
  * ```
  */
-declare function functionPrinter(options: FunctionPrinterOptions): {
+export declare function functionPrinter(options: FunctionPrinterOptions): {
   name: "functionParameters";
   options: FunctionPrinterOptions;
   print(node: FunctionParametersNode): string;
@@ -911,7 +911,7 @@ type CreateOperationParamsOptions = {
  * `pathParamsType` controls how path params render in inline mode. Provide a `resolver` for type
  * name resolution and `extraParams` for plugin-specific trailing parameters such as an `options` object.
  */
-declare function createOperationParams(node: ast.OperationNode, options: CreateOperationParamsOptions): FunctionParametersNode;
+export declare function createOperationParams(node: ast.OperationNode, options: CreateOperationParamsOptions): FunctionParametersNode;
 //#endregion
 //#region src/resolvers/resolverTs.d.ts
 /**
@@ -933,7 +933,7 @@ declare function createOperationParams(node: ast.OperationNode, options: CreateO
  * resolverTs.response.status(node, 200)            // 'ListPetsStatus200'
  * ```
  */
-declare const resolverTs: ResolverTs;
+export declare const resolverTs: ResolverTs;
 //#endregion
 //#region src/utils.d.ts
 type BuildParamsSchemaOptions = {
@@ -944,7 +944,7 @@ type BuildParamsSchemaOptions = {
  * header), embedding each param's own schema (and JSDoc) directly rather than referencing a
  * separate per-param type — the group itself is the only type these params get exported as.
  */
-declare function buildParams({ params }: BuildParamsSchemaOptions): ast.SchemaNode;
+export declare function buildParams({ params }: BuildParamsSchemaOptions): ast.SchemaNode;
 //#endregion
-export { type CreateOperationParamsOptions, Enum, type FunctionParameterNode, type FunctionParametersNode, type IndexedAccessTypeNode, type ObjectBindingPatternNode, type PluginTs, type PrinterTsFactory, type PrinterTsNodes, type PrinterTsOptions, type ResolverTs, Type, type TypeExpression, type TypeLiteralNode, buildParams, createFunctionParameter, createFunctionParameters, createIndexedAccessType, createObjectBindingPattern, createOperationParams, createTypeLiteral, pluginTs as default, pluginTs, functionPrinter, pluginTsName, printerTs, renderType, resolverTs, typeGenerator };
+export { type CreateOperationParamsOptions, type FunctionParameterNode, type FunctionParametersNode, type IndexedAccessTypeNode, type ObjectBindingPatternNode, type PluginTs, type PrinterTsFactory, type PrinterTsNodes, type PrinterTsOptions, type ResolverTs, type TypeExpression, type TypeLiteralNode, pluginTs as default };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -626,8 +626,10 @@ function createEnumDeclaration({ type = "enum", name, typeName, enums, enumKeyCa
 	}).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]) => {
 		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)));
-		else initializer = factory.createNumericLiteral(value);
+		if (Number.parseInt(value.toString(), 10) === value && isNumber(value)) {
+			if (value < 0) initializer = factory.createPrefixUnaryExpression(ts.SyntaxKind.MinusToken, factory.createNumericLiteral(Math.abs(value)));
+			else initializer = factory.createNumericLiteral(value);
+		}
 		if (typeof value === "boolean") initializer = value ? factory.createTrue() : factory.createFalse();
 		if (isNumber(Number.parseInt(key.toString(), 10))) {
 			const casingKey = applyEnumKeyCasing(`${typeName}_${key}`, enumKeyCasing);
@@ -648,8 +650,10 @@ function createEnumDeclaration({ type = "enum", name, typeName, enums, enumKeyCa
 	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]) => {
 		let initializer = factory.createStringLiteral(value?.toString());
-		if (isNumber(value)) if (value < 0) initializer = factory.createPrefixUnaryExpression(ts.SyntaxKind.MinusToken, factory.createNumericLiteral(Math.abs(value)));
-		else initializer = factory.createNumericLiteral(value);
+		if (isNumber(value)) {
+			if (value < 0) initializer = factory.createPrefixUnaryExpression(ts.SyntaxKind.MinusToken, factory.createNumericLiteral(Math.abs(value)));
+			else initializer = factory.createNumericLiteral(value);
+		}
 		if (typeof value === "boolean") initializer = value ? factory.createTrue() : factory.createFalse();
 		if (key !== null && key !== void 0) {
 			const casingKey = applyEnumKeyCasing(key.toString(), enumKeyCasing);
@@ -1430,7 +1434,7 @@ const printerTs = ast.createPrinter((options) => {
 				return createTypeReferenceNode(name, void 0);
 			},
 			enum(node) {
-				const values = node.namedEnumValues?.map((v) => v.value) ?? node.enumValues ?? [];
+				const values = ast.getSchemaLiteralValues(node);
 				if (this.options.enum.type === "inlineLiteral" || !node.name || isInlineConstEnum(node, this.options.enumSchemaNames)) return createUnionDeclaration({
 					withParentheses: true,
 					nodes: values.filter((v) => v !== null && v !== void 0).map((value) => constToTypeNode(value, typeof value)).filter(isNonNullable)