npm - @kubb/parser-ts - Versions diffs - 3.18.0 → 3.18.2 - Mend

@kubb/parser-ts 3.18.0 → 3.18.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (12) hide show

package/dist/factory-BSd2OjFQ.cjs.map +1 -1
package/dist/factory-CDjjCkNo.js.map +1 -1
package/dist/index.cjs +32 -4
package/dist/index.cjs.map +1 -1
package/dist/index.d.cts +6 -2
package/dist/index.d.ts +6 -2
package/dist/index.js +32 -5
package/dist/index.js.map +1 -1
package/package.json +4 -3
package/src/format.ts +25 -0
package/src/index.ts +1 -0
package/src/print.ts +13 -4

package/dist/factory-BSd2OjFQ.cjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"factory-BSd2OjFQ.cjs","names":["ts","modifiers","questionToken","node","importPropertyName: ts.Identifier \| undefined","importName: ts.NamedImportBindings \| undefined","propertyName","initializer: ts.Expression"],"sources":["../src/factory.ts"],"sourcesContent":["import { isNumber } from 'remeda'\nimport ts from 'typescript'\n\nconst { SyntaxKind, factory } = ts\n\n// https://ts-ast-viewer.com/\n\nexport const modifiers = {\n async: factory.createModifier(ts.SyntaxKind.AsyncKeyword),\n export: factory.createModifier(ts.SyntaxKind.ExportKeyword),\n const: factory.createModifier(ts.SyntaxKind.ConstKeyword),\n static: factory.createModifier(ts.SyntaxKind.StaticKeyword),\n} as const\n\nexport const syntaxKind = {\n union: SyntaxKind.UnionType as 192,\n} as const\n\nfunction isValidIdentifier(str: string): boolean {\n if (!str.length \|\| str.trim() !== str) {\n return false\n }\n const node = ts.parseIsolatedEntityName(str, ts.ScriptTarget.Latest)\n\n return !!node && node.kind === ts.SyntaxKind.Identifier && ts.identifierToKeywordKind(node.kind as unknown as ts.Identifier) === undefined\n}\n\nfunction propertyName(name: string \| ts.PropertyName): ts.PropertyName {\n if (typeof name === 'string') {\n return isValidIdentifier(name) ? factory.createIdentifier(name) : factory.createStringLiteral(name)\n }\n return name\n}\n\nconst questionToken = factory.createToken(ts.SyntaxKind.QuestionToken)\n\nexport function createQuestionToken(token?: boolean \| ts.QuestionToken) {\n if (!token) {\n return undefined\n }\n if (token === true) {\n return questionToken\n }\n return token\n}\n\nexport function createIntersectionDeclaration({ nodes, withParentheses }: { nodes: Array<ts.TypeNode>; withParentheses?: boolean }): ts.TypeNode \| null {\n if (!nodes.length) {\n return null\n }\n\n if (nodes.length === 1) {\n return nodes[0] \|\| null\n }\n\n const node = factory.createIntersectionTypeNode(nodes)\n\n if (withParentheses) {\n return factory.createParenthesizedType(node)\n }\n\n return node\n}\n\n/*\n Minimum nodes length of 2\n * @example `string & number`\n /\nexport function createTupleDeclaration({ nodes, withParentheses }: { nodes: Array<ts.TypeNode>; withParentheses?: boolean }): ts.TypeNode \| null {\n if (!nodes.length) {\n return null\n }\n\n if (nodes.length === 1) {\n return nodes[0] \|\| null\n }\n\n const node = factory.createTupleTypeNode(nodes)\n\n if (withParentheses) {\n return factory.createParenthesizedType(node)\n }\n\n return node\n}\n\nexport function createArrayDeclaration({ nodes }: { nodes: Array<ts.TypeNode> }): ts.TypeNode \| null {\n if (!nodes.length) {\n return factory.createTupleTypeNode([])\n }\n\n if (nodes.length === 1) {\n return factory.createArrayTypeNode(nodes.at(0)!)\n }\n\n return factory.createExpressionWithTypeArguments(factory.createIdentifier('Array'), [factory.createUnionTypeNode(nodes)])\n}\n\n/\n Minimum nodes length of 2\n * @example `string \| number`\n /\nexport function createUnionDeclaration({ nodes, withParentheses }: { nodes: Array<ts.TypeNode>; withParentheses?: boolean }): ts.TypeNode {\n if (!nodes.length) {\n return keywordTypeNodes.any\n }\n\n if (nodes.length === 1) {\n return nodes[0] as ts.TypeNode\n }\n\n const node = factory.createUnionTypeNode(nodes)\n\n if (withParentheses) {\n return factory.createParenthesizedType(node)\n }\n\n return node\n}\n\nexport function createPropertySignature({\n readOnly,\n modifiers = [],\n name,\n questionToken,\n type,\n}: {\n readOnly?: boolean\n modifiers?: Array<ts.Modifier>\n name: ts.PropertyName \| string\n questionToken?: ts.QuestionToken \| boolean\n type?: ts.TypeNode\n}) {\n return factory.createPropertySignature(\n [...modifiers, readOnly ? factory.createToken(ts.SyntaxKind.ReadonlyKeyword) : undefined].filter(Boolean),\n propertyName(name),\n createQuestionToken(questionToken),\n type,\n )\n}\n\nexport function createParameterSignature(\n name: string \| ts.BindingName,\n {\n modifiers,\n dotDotDotToken,\n questionToken,\n type,\n initializer,\n }: {\n decorators?: Array<ts.Decorator>\n modifiers?: Array<ts.Modifier>\n dotDotDotToken?: ts.DotDotDotToken\n questionToken?: ts.QuestionToken \| boolean\n type?: ts.TypeNode\n initializer?: ts.Expression\n },\n): ts.ParameterDeclaration {\n return factory.createParameterDeclaration(modifiers, dotDotDotToken, name, createQuestionToken(questionToken), type, initializer)\n}\n\nexport function createJSDoc({ comments }: { comments: string[] }) {\n if (!comments.length) {\n return null\n }\n return factory.createJSDocComment(\n factory.createNodeArray(\n comments.map((comment, i) => {\n if (i === comments.length - 1) {\n return factory.createJSDocText(comment)\n }\n\n return factory.createJSDocText(`${comment}\\n`)\n }),\n ),\n )\n}\n\n/\n @link https://github.com/microsoft/TypeScript/issues/44151\n /\nexport function appendJSDocToNode<TNode extends ts.Node>({ node, comments }: { node: TNode; comments: Array<string \| undefined> }) {\n const filteredComments = comments.filter(Boolean)\n\n if (!filteredComments.length) {\n return node\n }\n\n const text = filteredComments.reduce((acc = '', comment = '') => {\n return `${acc}\\n ${comment.replaceAll('/', '\\\\/')}`\n }, '')\n\n // node: {...node}, with that ts.addSyntheticLeadingComment is appending\n return ts.addSyntheticLeadingComment({ ...node }, ts.SyntaxKind.MultiLineCommentTrivia, `${text \|\| ''}\\n`, true)\n}\n\nexport function createIndexSignature(\n type: ts.TypeNode,\n {\n modifiers,\n indexName = 'key',\n indexType = factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),\n }: {\n indexName?: string\n indexType?: ts.TypeNode\n decorators?: Array<ts.Decorator>\n modifiers?: Array<ts.Modifier>\n } = {},\n) {\n return factory.createIndexSignature(modifiers, [createParameterSignature(indexName, { type: indexType })], type)\n}\n\nexport function createTypeAliasDeclaration({\n modifiers,\n name,\n typeParameters,\n type,\n}: {\n modifiers?: Array<ts.Modifier>\n name: string \| ts.Identifier\n typeParameters?: Array<ts.TypeParameterDeclaration>\n type: ts.TypeNode\n}) {\n return factory.createTypeAliasDeclaration(modifiers, name, typeParameters, type)\n}\n\nexport function createInterfaceDeclaration({\n modifiers,\n name,\n typeParameters,\n members,\n}: {\n modifiers?: Array<ts.Modifier>\n name: string \| ts.Identifier\n typeParameters?: Array<ts.TypeParameterDeclaration>\n members: Array<ts.TypeElement>\n}) {\n return factory.createInterfaceDeclaration(modifiers, name, typeParameters, undefined, members)\n}\n\nexport function createTypeDeclaration({\n syntax,\n isExportable,\n comments,\n name,\n type,\n}: {\n syntax: 'type' \| 'interface'\n comments: Array<string \| undefined>\n isExportable?: boolean\n name: string \| ts.Identifier\n type: ts.TypeNode\n}) {\n if (syntax === 'interface' && 'members' in type) {\n const node = createInterfaceDeclaration({\n members: type.members as Array<ts.TypeElement>,\n modifiers: isExportable ? [modifiers.export] : [],\n name,\n typeParameters: undefined,\n })\n\n return appendJSDocToNode({\n node,\n comments,\n })\n }\n\n const node = createTypeAliasDeclaration({\n type,\n modifiers: isExportable ? [modifiers.export] : [],\n name,\n typeParameters: undefined,\n })\n\n return appendJSDocToNode({\n node,\n comments,\n })\n}\n\nexport function createNamespaceDeclaration({ statements, name }: { name: string; statements: ts.Statement[] }) {\n return factory.createModuleDeclaration(\n [factory.createToken(ts.SyntaxKind.ExportKeyword)],\n factory.createIdentifier(name),\n factory.createModuleBlock(statements),\n ts.NodeFlags.Namespace,\n )\n}\n\n/*\n In { propertyName: string; name?: string } is `name` being used to make the type more unique when multiple same names are used.\n * @example `import { Pet as Cat } from './Pet'`\n /\nexport function createImportDeclaration({\n name,\n path,\n isTypeOnly = false,\n isNameSpace = false,\n}: {\n name: string \| Array<string \| { propertyName: string; name?: string }>\n path: string\n isTypeOnly?: boolean\n isNameSpace?: boolean\n}) {\n if (!Array.isArray(name)) {\n let importPropertyName: ts.Identifier \| undefined = factory.createIdentifier(name)\n let importName: ts.NamedImportBindings \| undefined\n\n if (isNameSpace) {\n importPropertyName = undefined\n importName = factory.createNamespaceImport(factory.createIdentifier(name))\n }\n\n return factory.createImportDeclaration(\n undefined,\n factory.createImportClause(isTypeOnly, importPropertyName, importName),\n factory.createStringLiteral(path),\n undefined,\n )\n }\n\n return factory.createImportDeclaration(\n undefined,\n factory.createImportClause(\n isTypeOnly,\n undefined,\n factory.createNamedImports(\n name.map((item) => {\n if (typeof item === 'object') {\n const obj = item as { propertyName: string; name?: string }\n if (obj.name) {\n return factory.createImportSpecifier(false, factory.createIdentifier(obj.propertyName), factory.createIdentifier(obj.name))\n }\n\n return factory.createImportSpecifier(false, undefined, factory.createIdentifier(obj.propertyName))\n }\n\n return factory.createImportSpecifier(false, undefined, factory.createIdentifier(item))\n }),\n ),\n ),\n factory.createStringLiteral(path),\n undefined,\n )\n}\n\nexport function createExportDeclaration({\n path,\n asAlias,\n isTypeOnly = false,\n name,\n}: {\n path: string\n asAlias?: boolean\n isTypeOnly?: boolean\n name?: string \| Array<ts.Identifier \| string>\n}) {\n if (name && !Array.isArray(name) && !asAlias) {\n console.warn(`When using name as string, asAlias should be true ${name}`)\n }\n\n if (!Array.isArray(name)) {\n const parsedName = name?.match(/^\\d/) ? `_${name?.slice(1)}` : name\n\n return factory.createExportDeclaration(\n undefined,\n isTypeOnly,\n asAlias && parsedName ? factory.createNamespaceExport(factory.createIdentifier(parsedName)) : undefined,\n factory.createStringLiteral(path),\n undefined,\n )\n }\n\n return factory.createExportDeclaration(\n undefined,\n isTypeOnly,\n factory.createNamedExports(\n name.map((propertyName) => {\n return factory.createExportSpecifier(false, undefined, typeof propertyName === 'string' ? factory.createIdentifier(propertyName) : propertyName)\n }),\n ),\n factory.createStringLiteral(path),\n undefined,\n )\n}\n\nexport function createEnumDeclaration({\n type = 'enum',\n name,\n typeName,\n enums,\n}: {\n /\n @default `'enum'`\n /\n type?: 'enum' \| 'asConst' \| 'asPascalConst' \| 'constEnum' \| 'literal'\n /\n Enum name in camelCase.\n /\n name: string\n /\n Enum name in PascalCase.\n */\n typeName: string\n enums: [key: string \| number, value: string \| number \| boolean][]\n}): [name: ts.Node \| undefined, type: ts.Node] {\n if (type === 'literal') {\n return [\n undefined,\n factory.createTypeAliasDeclaration(\n [factory.createToken(ts.SyntaxKind.ExportKeyword)],\n factory.createIdentifier(typeName),\n undefined,\n factory.createUnionTypeNode(\n enums\n .map(([_key, value]) => {\n if (isNumber(value)) {\n return factory.createLiteralTypeNode(factory.createNumericLiteral(value?.toString()))\n }\n\n if (typeof value === 'boolean') {\n return factory.createLiteralTypeNode(value ? factory.createTrue() : factory.createFalse())\n }\n if (value) {\n return factory.createLiteralTypeNode(factory.createStringLiteral(value.toString()))\n }\n\n return undefined\n })\n .filter(Boolean),\n ),\n ),\n ]\n }\n\n if (type === 'enum' \|\| type === 'constEnum') {\n return [\n undefined,\n factory.createEnumDeclaration(\n [factory.createToken(ts.SyntaxKind.ExportKeyword), type === 'constEnum' ? factory.createToken(ts.SyntaxKind.ConstKeyword) : undefined].filter(Boolean),\n factory.createIdentifier(typeName),\n enums\n .map(([key, value]) => {\n let initializer: ts.Expression = factory.createStringLiteral(value?.toString())\n const isExactNumber = Number.parseInt(value.toString(), 10) === value\n\n if (isExactNumber && isNumber(Number.parseInt(value.toString(), 10))) {\n initializer = factory.createNumericLiteral(value as number)\n }\n\n if (typeof value === 'boolean') {\n initializer = value ? factory.createTrue() : factory.createFalse()\n }\n\n if (isNumber(Number.parseInt(key.toString(), 10))) {\n return factory.createEnumMember(factory.createStringLiteral(`${typeName}_${key}`), initializer)\n }\n\n if (key) {\n return factory.createEnumMember(factory.createStringLiteral(`${key}`), initializer)\n }\n\n return undefined\n })\n .filter(Boolean),\n ),\n ]\n }\n\n // used when using `as const` instead of an TypeScript enum.\n const identifierName = type === 'asPascalConst' ? typeName : name\n\n return [\n factory.createVariableStatement(\n [factory.createToken(ts.SyntaxKind.ExportKeyword)],\n factory.createVariableDeclarationList(\n [\n factory.createVariableDeclaration(\n factory.createIdentifier(identifierName),\n undefined,\n undefined,\n factory.createAsExpression(\n factory.createObjectLiteralExpression(\n enums\n .map(([key, value]) => {\n let initializer: ts.Expression = factory.createStringLiteral(value?.toString())\n\n if (isNumber(value)) {\n // Error: Negative numbers should be created in combination with createPrefixUnaryExpression factory.\n // The method createNumericLiteral only accepts positive numbers\n // or those combined with createPrefixUnaryExpression.\n // Therefore, we need to ensure that the number is not negative.\n if (value < 0) {\n initializer = factory.createPrefixUnaryExpression(ts.SyntaxKind.MinusToken, factory.createNumericLiteral(Math.abs(value)))\n } else {\n initializer = factory.createNumericLiteral(value)\n }\n }\n\n if (typeof value === 'boolean') {\n initializer = value ? factory.createTrue() : factory.createFalse()\n }\n\n if (key) {\n return factory.createPropertyAssignment(factory.createStringLiteral(`${key}`), initializer)\n }\n\n return undefined\n })\n .filter(Boolean),\n true,\n ),\n factory.createTypeReferenceNode(factory.createIdentifier('const'), undefined),\n ),\n ),\n ],\n ts.NodeFlags.Const,\n ),\n ),\n factory.createTypeAliasDeclaration(\n type === 'asPascalConst' ? [] : [factory.createToken(ts.SyntaxKind.ExportKeyword)],\n factory.createIdentifier(typeName),\n undefined,\n factory.createIndexedAccessTypeNode(\n factory.createParenthesizedType(factory.createTypeQueryNode(factory.createIdentifier(identifierName), undefined)),\n factory.createTypeOperatorNode(ts.SyntaxKind.KeyOfKeyword, factory.createTypeQueryNode(factory.createIdentifier(identifierName), undefined)),\n ),\n ),\n ]\n}\n\nexport function createOmitDeclaration({ keys, type, nonNullable }: { keys: Array<string> \| string; type: ts.TypeNode; nonNullable?: boolean }) {\n const node = nonNullable ? factory.createTypeReferenceNode(factory.createIdentifier('NonNullable'), [type]) : type\n\n if (Array.isArray(keys)) {\n return factory.createTypeReferenceNode(factory.createIdentifier('Omit'), [\n node,\n factory.createUnionTypeNode(\n keys.map((key) => {\n return factory.createLiteralTypeNode(factory.createStringLiteral(key))\n }),\n ),\n ])\n }\n\n return factory.createTypeReferenceNode(factory.createIdentifier('Omit'), [node, factory.createLiteralTypeNode(factory.createStringLiteral(keys))])\n}\n\nexport const keywordTypeNodes = {\n any: factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),\n unknown: factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword),\n void: factory.createKeywordTypeNode(ts.SyntaxKind.VoidKeyword),\n number: factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword),\n integer: factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword),\n object: factory.createKeywordTypeNode(ts.SyntaxKind.ObjectKeyword),\n string: factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),\n boolean: factory.createKeywordTypeNode(ts.SyntaxKind.BooleanKeyword),\n undefined: factory.createKeywordTypeNode(ts.SyntaxKind.UndefinedKeyword),\n null: factory.createLiteralTypeNode(factory.createToken(ts.SyntaxKind.NullKeyword)),\n} as const\n\nexport const createTypeLiteralNode = factory.createTypeLiteralNode\n\nexport const createTypeReferenceNode = factory.createTypeReferenceNode\nexport const createNumericLiteral = factory.createNumericLiteral\nexport const createStringLiteral = factory.createStringLiteral\n\nexport const createArrayTypeNode = factory.createArrayTypeNode\n\nexport const createLiteralTypeNode = factory.createLiteralTypeNode\nexport const createNull = factory.createNull\nexport const createIdentifier = factory.createIdentifier\n\nexport const createOptionalTypeNode = factory.createOptionalTypeNode\nexport const createTupleTypeNode = factory.createTupleTypeNode\nexport const createRestTypeNode = factory.createRestTypeNode\nexport const createTrue = factory.createTrue\nexport const createFalse = factory.createFalse\n"],"mappings":"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"}
1	+ {"version":3,"file":"factory-BSd2OjFQ.cjs","names":["ts","modifiers","questionToken","node","importPropertyName: ts.Identifier \| undefined","importName: ts.NamedImportBindings \| undefined","propertyName","initializer: ts.Expression"],"sources":["../src/factory.ts"],"sourcesContent":["import { isNumber } from 'remeda'\nimport ts from 'typescript'\n\nconst { SyntaxKind, factory } = ts\n\n// https://ts-ast-viewer.com/\n\nexport const modifiers = {\n async: factory.createModifier(ts.SyntaxKind.AsyncKeyword),\n export: factory.createModifier(ts.SyntaxKind.ExportKeyword),\n const: factory.createModifier(ts.SyntaxKind.ConstKeyword),\n static: factory.createModifier(ts.SyntaxKind.StaticKeyword),\n} as const\n\nexport const syntaxKind = {\n union: SyntaxKind.UnionType as 192,\n} as const\n\nfunction isValidIdentifier(str: string): boolean {\n if (!str.length \|\| str.trim() !== str) {\n return false\n }\n const node = ts.parseIsolatedEntityName(str, ts.ScriptTarget.Latest)\n\n return !!node && node.kind === ts.SyntaxKind.Identifier && ts.identifierToKeywordKind(node.kind as unknown as ts.Identifier) === undefined\n}\n\nfunction propertyName(name: string \| ts.PropertyName): ts.PropertyName {\n if (typeof name === 'string') {\n return isValidIdentifier(name) ? factory.createIdentifier(name) : factory.createStringLiteral(name)\n }\n return name\n}\n\nconst questionToken = factory.createToken(ts.SyntaxKind.QuestionToken)\n\nexport function createQuestionToken(token?: boolean \| ts.QuestionToken) {\n if (!token) {\n return undefined\n }\n if (token === true) {\n return questionToken\n }\n return token\n}\n\nexport function createIntersectionDeclaration({ nodes, withParentheses }: { nodes: Array<ts.TypeNode>; withParentheses?: boolean }): ts.TypeNode \| null {\n if (!nodes.length) {\n return null\n }\n\n if (nodes.length === 1) {\n return nodes[0] \|\| null\n }\n\n const node = factory.createIntersectionTypeNode(nodes)\n\n if (withParentheses) {\n return factory.createParenthesizedType(node)\n }\n\n return node\n}\n\n/*\n Minimum nodes length of 2\n * @example `string & number`\n /\nexport function createTupleDeclaration({ nodes, withParentheses }: { nodes: Array<ts.TypeNode>; withParentheses?: boolean }): ts.TypeNode \| null {\n if (!nodes.length) {\n return null\n }\n\n if (nodes.length === 1) {\n return nodes[0] \|\| null\n }\n\n const node = factory.createTupleTypeNode(nodes)\n\n if (withParentheses) {\n return factory.createParenthesizedType(node)\n }\n\n return node\n}\n\nexport function createArrayDeclaration({ nodes }: { nodes: Array<ts.TypeNode> }): ts.TypeNode \| null {\n if (!nodes.length) {\n return factory.createTupleTypeNode([])\n }\n\n if (nodes.length === 1) {\n return factory.createArrayTypeNode(nodes.at(0)!)\n }\n\n return factory.createExpressionWithTypeArguments(factory.createIdentifier('Array'), [factory.createUnionTypeNode(nodes)])\n}\n\n/\n Minimum nodes length of 2\n * @example `string \| number`\n /\nexport function createUnionDeclaration({ nodes, withParentheses }: { nodes: Array<ts.TypeNode>; withParentheses?: boolean }): ts.TypeNode {\n if (!nodes.length) {\n return keywordTypeNodes.any\n }\n\n if (nodes.length === 1) {\n return nodes[0] as ts.TypeNode\n }\n\n const node = factory.createUnionTypeNode(nodes)\n\n if (withParentheses) {\n return factory.createParenthesizedType(node)\n }\n\n return node\n}\n\nexport function createPropertySignature({\n readOnly,\n modifiers = [],\n name,\n questionToken,\n type,\n}: {\n readOnly?: boolean\n modifiers?: Array<ts.Modifier>\n name: ts.PropertyName \| string\n questionToken?: ts.QuestionToken \| boolean\n type?: ts.TypeNode\n}) {\n return factory.createPropertySignature(\n [...modifiers, readOnly ? factory.createToken(ts.SyntaxKind.ReadonlyKeyword) : undefined].filter(Boolean),\n propertyName(name),\n createQuestionToken(questionToken),\n type,\n )\n}\n\nexport function createParameterSignature(\n name: string \| ts.BindingName,\n {\n modifiers,\n dotDotDotToken,\n questionToken,\n type,\n initializer,\n }: {\n decorators?: Array<ts.Decorator>\n modifiers?: Array<ts.Modifier>\n dotDotDotToken?: ts.DotDotDotToken\n questionToken?: ts.QuestionToken \| boolean\n type?: ts.TypeNode\n initializer?: ts.Expression\n },\n): ts.ParameterDeclaration {\n return factory.createParameterDeclaration(modifiers, dotDotDotToken, name, createQuestionToken(questionToken), type, initializer)\n}\n\nexport function createJSDoc({ comments }: { comments: string[] }) {\n if (!comments.length) {\n return null\n }\n return factory.createJSDocComment(\n factory.createNodeArray(\n comments.map((comment, i) => {\n if (i === comments.length - 1) {\n return factory.createJSDocText(comment)\n }\n\n return factory.createJSDocText(`${comment}\\n`)\n }),\n ),\n )\n}\n\n/\n @link https://github.com/microsoft/TypeScript/issues/44151\n /\nexport function appendJSDocToNode<TNode extends ts.Node>({ node, comments }: { node: TNode; comments: Array<string \| undefined> }) {\n const filteredComments = comments.filter(Boolean)\n\n if (!filteredComments.length) {\n return node\n }\n\n const text = filteredComments.reduce((acc = '', comment = '') => {\n return `${acc}\\n ${comment.replaceAll('/', '\\\\/')}`\n }, '')\n\n // node: {...node}, with that ts.addSyntheticLeadingComment is appending\n return ts.addSyntheticLeadingComment({ ...node }, ts.SyntaxKind.MultiLineCommentTrivia, `${text \|\| ''}\\n`, true)\n}\n\nexport function createIndexSignature(\n type: ts.TypeNode,\n {\n modifiers,\n indexName = 'key',\n indexType = factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),\n }: {\n indexName?: string\n indexType?: ts.TypeNode\n decorators?: Array<ts.Decorator>\n modifiers?: Array<ts.Modifier>\n } = {},\n) {\n return factory.createIndexSignature(modifiers, [createParameterSignature(indexName, { type: indexType })], type)\n}\n\nexport function createTypeAliasDeclaration({\n modifiers,\n name,\n typeParameters,\n type,\n}: {\n modifiers?: Array<ts.Modifier>\n name: string \| ts.Identifier\n typeParameters?: Array<ts.TypeParameterDeclaration>\n type: ts.TypeNode\n}) {\n return factory.createTypeAliasDeclaration(modifiers, name, typeParameters, type)\n}\n\nexport function createInterfaceDeclaration({\n modifiers,\n name,\n typeParameters,\n members,\n}: {\n modifiers?: Array<ts.Modifier>\n name: string \| ts.Identifier\n typeParameters?: Array<ts.TypeParameterDeclaration>\n members: Array<ts.TypeElement>\n}) {\n return factory.createInterfaceDeclaration(modifiers, name, typeParameters, undefined, members)\n}\n\nexport function createTypeDeclaration({\n syntax,\n isExportable,\n comments,\n name,\n type,\n}: {\n syntax: 'type' \| 'interface'\n comments: Array<string \| undefined>\n isExportable?: boolean\n name: string \| ts.Identifier\n type: ts.TypeNode\n}) {\n if (syntax === 'interface' && 'members' in type) {\n const node = createInterfaceDeclaration({\n members: type.members as Array<ts.TypeElement>,\n modifiers: isExportable ? [modifiers.export] : [],\n name,\n typeParameters: undefined,\n })\n\n return appendJSDocToNode({\n node,\n comments,\n })\n }\n\n const node = createTypeAliasDeclaration({\n type,\n modifiers: isExportable ? [modifiers.export] : [],\n name,\n typeParameters: undefined,\n })\n\n return appendJSDocToNode({\n node,\n comments,\n })\n}\n\nexport function createNamespaceDeclaration({ statements, name }: { name: string; statements: ts.Statement[] }) {\n return factory.createModuleDeclaration(\n [factory.createToken(ts.SyntaxKind.ExportKeyword)],\n factory.createIdentifier(name),\n factory.createModuleBlock(statements),\n ts.NodeFlags.Namespace,\n )\n}\n\n/*\n In { propertyName: string; name?: string } is `name` being used to make the type more unique when multiple same names are used.\n * @example `import { Pet as Cat } from './Pet'`\n /\nexport function createImportDeclaration({\n name,\n path,\n isTypeOnly = false,\n isNameSpace = false,\n}: {\n name: string \| Array<string \| { propertyName: string; name?: string }>\n path: string\n isTypeOnly?: boolean\n isNameSpace?: boolean\n}) {\n if (!Array.isArray(name)) {\n let importPropertyName: ts.Identifier \| undefined = factory.createIdentifier(name)\n let importName: ts.NamedImportBindings \| undefined\n\n if (isNameSpace) {\n importPropertyName = undefined\n importName = factory.createNamespaceImport(factory.createIdentifier(name))\n }\n\n return factory.createImportDeclaration(\n undefined,\n factory.createImportClause(isTypeOnly, importPropertyName, importName),\n factory.createStringLiteral(path),\n undefined,\n )\n }\n\n return factory.createImportDeclaration(\n undefined,\n factory.createImportClause(\n isTypeOnly,\n undefined,\n factory.createNamedImports(\n name.map((item) => {\n if (typeof item === 'object') {\n const obj = item as { propertyName: string; name?: string }\n if (obj.name) {\n return factory.createImportSpecifier(false, factory.createIdentifier(obj.propertyName), factory.createIdentifier(obj.name))\n }\n\n return factory.createImportSpecifier(false, undefined, factory.createIdentifier(obj.propertyName))\n }\n\n return factory.createImportSpecifier(false, undefined, factory.createIdentifier(item))\n }),\n ),\n ),\n factory.createStringLiteral(path),\n undefined,\n )\n}\n\nexport function createExportDeclaration({\n path,\n asAlias,\n isTypeOnly = false,\n name,\n}: {\n path: string\n asAlias?: boolean\n isTypeOnly?: boolean\n name?: string \| Array<ts.Identifier \| string>\n}) {\n if (name && !Array.isArray(name) && !asAlias) {\n console.warn(`When using name as string, asAlias should be true ${name}`)\n }\n\n if (!Array.isArray(name)) {\n const parsedName = name?.match(/^\\d/) ? `_${name?.slice(1)}` : name\n\n return factory.createExportDeclaration(\n undefined,\n isTypeOnly,\n asAlias && parsedName ? factory.createNamespaceExport(factory.createIdentifier(parsedName)) : undefined,\n factory.createStringLiteral(path),\n undefined,\n )\n }\n\n return factory.createExportDeclaration(\n undefined,\n isTypeOnly,\n factory.createNamedExports(\n name.map((propertyName) => {\n return factory.createExportSpecifier(false, undefined, typeof propertyName === 'string' ? factory.createIdentifier(propertyName) : propertyName)\n }),\n ),\n factory.createStringLiteral(path),\n undefined,\n )\n}\n\nexport function createEnumDeclaration({\n type = 'enum',\n name,\n typeName,\n enums,\n}: {\n /\n @default `'enum'`\n /\n type?: 'enum' \| 'asConst' \| 'asPascalConst' \| 'constEnum' \| 'literal'\n /\n Enum name in camelCase.\n /\n name: string\n /\n Enum name in PascalCase.\n */\n typeName: string\n enums: [key: string \| number, value: string \| number \| boolean][]\n}): [name: ts.Node \| undefined, type: ts.Node] {\n if (type === 'literal') {\n return [\n undefined,\n factory.createTypeAliasDeclaration(\n [factory.createToken(ts.SyntaxKind.ExportKeyword)],\n factory.createIdentifier(typeName),\n undefined,\n factory.createUnionTypeNode(\n enums\n .map(([_key, value]) => {\n if (isNumber(value)) {\n return factory.createLiteralTypeNode(factory.createNumericLiteral(value?.toString()))\n }\n\n if (typeof value === 'boolean') {\n return factory.createLiteralTypeNode(value ? factory.createTrue() : factory.createFalse())\n }\n if (value) {\n return factory.createLiteralTypeNode(factory.createStringLiteral(value.toString()))\n }\n\n return undefined\n })\n .filter(Boolean),\n ),\n ),\n ]\n }\n\n if (type === 'enum' \|\| type === 'constEnum') {\n return [\n undefined,\n factory.createEnumDeclaration(\n [factory.createToken(ts.SyntaxKind.ExportKeyword), type === 'constEnum' ? factory.createToken(ts.SyntaxKind.ConstKeyword) : undefined].filter(Boolean),\n factory.createIdentifier(typeName),\n enums\n .map(([key, value]) => {\n let initializer: ts.Expression = factory.createStringLiteral(value?.toString())\n const isExactNumber = Number.parseInt(value.toString(), 10) === value\n\n if (isExactNumber && isNumber(Number.parseInt(value.toString(), 10))) {\n initializer = factory.createNumericLiteral(value as number)\n }\n\n if (typeof value === 'boolean') {\n initializer = value ? factory.createTrue() : factory.createFalse()\n }\n\n if (isNumber(Number.parseInt(key.toString(), 10))) {\n return factory.createEnumMember(factory.createStringLiteral(`${typeName}_${key}`), initializer)\n }\n\n if (key) {\n return factory.createEnumMember(factory.createStringLiteral(`${key}`), initializer)\n }\n\n return undefined\n })\n .filter(Boolean),\n ),\n ]\n }\n\n // used when using `as const` instead of an TypeScript enum.\n const identifierName = type === 'asPascalConst' ? typeName : name\n\n return [\n factory.createVariableStatement(\n [factory.createToken(ts.SyntaxKind.ExportKeyword)],\n factory.createVariableDeclarationList(\n [\n factory.createVariableDeclaration(\n factory.createIdentifier(identifierName),\n undefined,\n undefined,\n factory.createAsExpression(\n factory.createObjectLiteralExpression(\n enums\n .map(([key, value]) => {\n let initializer: ts.Expression = factory.createStringLiteral(value?.toString())\n\n if (isNumber(value)) {\n // Error: Negative numbers should be created in combination with createPrefixUnaryExpression factory.\n // The method createNumericLiteral only accepts positive numbers\n // or those combined with createPrefixUnaryExpression.\n // Therefore, we need to ensure that the number is not negative.\n if (value < 0) {\n initializer = factory.createPrefixUnaryExpression(ts.SyntaxKind.MinusToken, factory.createNumericLiteral(Math.abs(value)))\n } else {\n initializer = factory.createNumericLiteral(value)\n }\n }\n\n if (typeof value === 'boolean') {\n initializer = value ? factory.createTrue() : factory.createFalse()\n }\n\n if (key) {\n return factory.createPropertyAssignment(factory.createStringLiteral(`${key}`), initializer)\n }\n\n return undefined\n })\n .filter(Boolean),\n true,\n ),\n factory.createTypeReferenceNode(factory.createIdentifier('const'), undefined),\n ),\n ),\n ],\n ts.NodeFlags.Const,\n ),\n ),\n factory.createTypeAliasDeclaration(\n type === 'asPascalConst' ? [] : [factory.createToken(ts.SyntaxKind.ExportKeyword)],\n factory.createIdentifier(typeName),\n undefined,\n factory.createIndexedAccessTypeNode(\n factory.createParenthesizedType(factory.createTypeQueryNode(factory.createIdentifier(identifierName), undefined)),\n factory.createTypeOperatorNode(ts.SyntaxKind.KeyOfKeyword, factory.createTypeQueryNode(factory.createIdentifier(identifierName), undefined)),\n ),\n ),\n ]\n}\n\nexport function createOmitDeclaration({ keys, type, nonNullable }: { keys: Array<string> \| string; type: ts.TypeNode; nonNullable?: boolean }) {\n const node = nonNullable ? factory.createTypeReferenceNode(factory.createIdentifier('NonNullable'), [type]) : type\n\n if (Array.isArray(keys)) {\n return factory.createTypeReferenceNode(factory.createIdentifier('Omit'), [\n node,\n factory.createUnionTypeNode(\n keys.map((key) => {\n return factory.createLiteralTypeNode(factory.createStringLiteral(key))\n }),\n ),\n ])\n }\n\n return factory.createTypeReferenceNode(factory.createIdentifier('Omit'), [node, factory.createLiteralTypeNode(factory.createStringLiteral(keys))])\n}\n\nexport const keywordTypeNodes = {\n any: factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),\n unknown: factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword),\n void: factory.createKeywordTypeNode(ts.SyntaxKind.VoidKeyword),\n number: factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword),\n integer: factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword),\n object: factory.createKeywordTypeNode(ts.SyntaxKind.ObjectKeyword),\n string: factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),\n boolean: factory.createKeywordTypeNode(ts.SyntaxKind.BooleanKeyword),\n undefined: factory.createKeywordTypeNode(ts.SyntaxKind.UndefinedKeyword),\n null: factory.createLiteralTypeNode(factory.createToken(ts.SyntaxKind.NullKeyword)),\n} as const\n\nexport const createTypeLiteralNode = factory.createTypeLiteralNode\n\nexport const createTypeReferenceNode = factory.createTypeReferenceNode\nexport const createNumericLiteral = factory.createNumericLiteral\nexport const createStringLiteral = factory.createStringLiteral\n\nexport const createArrayTypeNode = factory.createArrayTypeNode\n\nexport const createLiteralTypeNode = factory.createLiteralTypeNode\nexport const createNull = factory.createNull\nexport const createIdentifier = factory.createIdentifier\n\nexport const createOptionalTypeNode = factory.createOptionalTypeNode\nexport const createTupleTypeNode = factory.createTupleTypeNode\nexport const createRestTypeNode = factory.createRestTypeNode\nexport const createTrue = factory.createTrue\nexport const createFalse = factory.createFalse\n"],"mappings":"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"}

package/dist/factory-CDjjCkNo.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"factory-CDjjCkNo.js","names":["modifiers","questionToken","node","importPropertyName: ts.Identifier \| undefined","importName: ts.NamedImportBindings \| undefined","propertyName","initializer: ts.Expression"],"sources":["../src/factory.ts"],"sourcesContent":["import { isNumber } from 'remeda'\nimport ts from 'typescript'\n\nconst { SyntaxKind, factory } = ts\n\n// https://ts-ast-viewer.com/\n\nexport const modifiers = {\n async: factory.createModifier(ts.SyntaxKind.AsyncKeyword),\n export: factory.createModifier(ts.SyntaxKind.ExportKeyword),\n const: factory.createModifier(ts.SyntaxKind.ConstKeyword),\n static: factory.createModifier(ts.SyntaxKind.StaticKeyword),\n} as const\n\nexport const syntaxKind = {\n union: SyntaxKind.UnionType as 192,\n} as const\n\nfunction isValidIdentifier(str: string): boolean {\n if (!str.length \|\| str.trim() !== str) {\n return false\n }\n const node = ts.parseIsolatedEntityName(str, ts.ScriptTarget.Latest)\n\n return !!node && node.kind === ts.SyntaxKind.Identifier && ts.identifierToKeywordKind(node.kind as unknown as ts.Identifier) === undefined\n}\n\nfunction propertyName(name: string \| ts.PropertyName): ts.PropertyName {\n if (typeof name === 'string') {\n return isValidIdentifier(name) ? factory.createIdentifier(name) : factory.createStringLiteral(name)\n }\n return name\n}\n\nconst questionToken = factory.createToken(ts.SyntaxKind.QuestionToken)\n\nexport function createQuestionToken(token?: boolean \| ts.QuestionToken) {\n if (!token) {\n return undefined\n }\n if (token === true) {\n return questionToken\n }\n return token\n}\n\nexport function createIntersectionDeclaration({ nodes, withParentheses }: { nodes: Array<ts.TypeNode>; withParentheses?: boolean }): ts.TypeNode \| null {\n if (!nodes.length) {\n return null\n }\n\n if (nodes.length === 1) {\n return nodes[0] \|\| null\n }\n\n const node = factory.createIntersectionTypeNode(nodes)\n\n if (withParentheses) {\n return factory.createParenthesizedType(node)\n }\n\n return node\n}\n\n/*\n Minimum nodes length of 2\n * @example `string & number`\n /\nexport function createTupleDeclaration({ nodes, withParentheses }: { nodes: Array<ts.TypeNode>; withParentheses?: boolean }): ts.TypeNode \| null {\n if (!nodes.length) {\n return null\n }\n\n if (nodes.length === 1) {\n return nodes[0] \|\| null\n }\n\n const node = factory.createTupleTypeNode(nodes)\n\n if (withParentheses) {\n return factory.createParenthesizedType(node)\n }\n\n return node\n}\n\nexport function createArrayDeclaration({ nodes }: { nodes: Array<ts.TypeNode> }): ts.TypeNode \| null {\n if (!nodes.length) {\n return factory.createTupleTypeNode([])\n }\n\n if (nodes.length === 1) {\n return factory.createArrayTypeNode(nodes.at(0)!)\n }\n\n return factory.createExpressionWithTypeArguments(factory.createIdentifier('Array'), [factory.createUnionTypeNode(nodes)])\n}\n\n/\n Minimum nodes length of 2\n * @example `string \| number`\n /\nexport function createUnionDeclaration({ nodes, withParentheses }: { nodes: Array<ts.TypeNode>; withParentheses?: boolean }): ts.TypeNode {\n if (!nodes.length) {\n return keywordTypeNodes.any\n }\n\n if (nodes.length === 1) {\n return nodes[0] as ts.TypeNode\n }\n\n const node = factory.createUnionTypeNode(nodes)\n\n if (withParentheses) {\n return factory.createParenthesizedType(node)\n }\n\n return node\n}\n\nexport function createPropertySignature({\n readOnly,\n modifiers = [],\n name,\n questionToken,\n type,\n}: {\n readOnly?: boolean\n modifiers?: Array<ts.Modifier>\n name: ts.PropertyName \| string\n questionToken?: ts.QuestionToken \| boolean\n type?: ts.TypeNode\n}) {\n return factory.createPropertySignature(\n [...modifiers, readOnly ? factory.createToken(ts.SyntaxKind.ReadonlyKeyword) : undefined].filter(Boolean),\n propertyName(name),\n createQuestionToken(questionToken),\n type,\n )\n}\n\nexport function createParameterSignature(\n name: string \| ts.BindingName,\n {\n modifiers,\n dotDotDotToken,\n questionToken,\n type,\n initializer,\n }: {\n decorators?: Array<ts.Decorator>\n modifiers?: Array<ts.Modifier>\n dotDotDotToken?: ts.DotDotDotToken\n questionToken?: ts.QuestionToken \| boolean\n type?: ts.TypeNode\n initializer?: ts.Expression\n },\n): ts.ParameterDeclaration {\n return factory.createParameterDeclaration(modifiers, dotDotDotToken, name, createQuestionToken(questionToken), type, initializer)\n}\n\nexport function createJSDoc({ comments }: { comments: string[] }) {\n if (!comments.length) {\n return null\n }\n return factory.createJSDocComment(\n factory.createNodeArray(\n comments.map((comment, i) => {\n if (i === comments.length - 1) {\n return factory.createJSDocText(comment)\n }\n\n return factory.createJSDocText(`${comment}\\n`)\n }),\n ),\n )\n}\n\n/\n @link https://github.com/microsoft/TypeScript/issues/44151\n /\nexport function appendJSDocToNode<TNode extends ts.Node>({ node, comments }: { node: TNode; comments: Array<string \| undefined> }) {\n const filteredComments = comments.filter(Boolean)\n\n if (!filteredComments.length) {\n return node\n }\n\n const text = filteredComments.reduce((acc = '', comment = '') => {\n return `${acc}\\n ${comment.replaceAll('/', '\\\\/')}`\n }, '')\n\n // node: {...node}, with that ts.addSyntheticLeadingComment is appending\n return ts.addSyntheticLeadingComment({ ...node }, ts.SyntaxKind.MultiLineCommentTrivia, `${text \|\| ''}\\n`, true)\n}\n\nexport function createIndexSignature(\n type: ts.TypeNode,\n {\n modifiers,\n indexName = 'key',\n indexType = factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),\n }: {\n indexName?: string\n indexType?: ts.TypeNode\n decorators?: Array<ts.Decorator>\n modifiers?: Array<ts.Modifier>\n } = {},\n) {\n return factory.createIndexSignature(modifiers, [createParameterSignature(indexName, { type: indexType })], type)\n}\n\nexport function createTypeAliasDeclaration({\n modifiers,\n name,\n typeParameters,\n type,\n}: {\n modifiers?: Array<ts.Modifier>\n name: string \| ts.Identifier\n typeParameters?: Array<ts.TypeParameterDeclaration>\n type: ts.TypeNode\n}) {\n return factory.createTypeAliasDeclaration(modifiers, name, typeParameters, type)\n}\n\nexport function createInterfaceDeclaration({\n modifiers,\n name,\n typeParameters,\n members,\n}: {\n modifiers?: Array<ts.Modifier>\n name: string \| ts.Identifier\n typeParameters?: Array<ts.TypeParameterDeclaration>\n members: Array<ts.TypeElement>\n}) {\n return factory.createInterfaceDeclaration(modifiers, name, typeParameters, undefined, members)\n}\n\nexport function createTypeDeclaration({\n syntax,\n isExportable,\n comments,\n name,\n type,\n}: {\n syntax: 'type' \| 'interface'\n comments: Array<string \| undefined>\n isExportable?: boolean\n name: string \| ts.Identifier\n type: ts.TypeNode\n}) {\n if (syntax === 'interface' && 'members' in type) {\n const node = createInterfaceDeclaration({\n members: type.members as Array<ts.TypeElement>,\n modifiers: isExportable ? [modifiers.export] : [],\n name,\n typeParameters: undefined,\n })\n\n return appendJSDocToNode({\n node,\n comments,\n })\n }\n\n const node = createTypeAliasDeclaration({\n type,\n modifiers: isExportable ? [modifiers.export] : [],\n name,\n typeParameters: undefined,\n })\n\n return appendJSDocToNode({\n node,\n comments,\n })\n}\n\nexport function createNamespaceDeclaration({ statements, name }: { name: string; statements: ts.Statement[] }) {\n return factory.createModuleDeclaration(\n [factory.createToken(ts.SyntaxKind.ExportKeyword)],\n factory.createIdentifier(name),\n factory.createModuleBlock(statements),\n ts.NodeFlags.Namespace,\n )\n}\n\n/*\n In { propertyName: string; name?: string } is `name` being used to make the type more unique when multiple same names are used.\n * @example `import { Pet as Cat } from './Pet'`\n /\nexport function createImportDeclaration({\n name,\n path,\n isTypeOnly = false,\n isNameSpace = false,\n}: {\n name: string \| Array<string \| { propertyName: string; name?: string }>\n path: string\n isTypeOnly?: boolean\n isNameSpace?: boolean\n}) {\n if (!Array.isArray(name)) {\n let importPropertyName: ts.Identifier \| undefined = factory.createIdentifier(name)\n let importName: ts.NamedImportBindings \| undefined\n\n if (isNameSpace) {\n importPropertyName = undefined\n importName = factory.createNamespaceImport(factory.createIdentifier(name))\n }\n\n return factory.createImportDeclaration(\n undefined,\n factory.createImportClause(isTypeOnly, importPropertyName, importName),\n factory.createStringLiteral(path),\n undefined,\n )\n }\n\n return factory.createImportDeclaration(\n undefined,\n factory.createImportClause(\n isTypeOnly,\n undefined,\n factory.createNamedImports(\n name.map((item) => {\n if (typeof item === 'object') {\n const obj = item as { propertyName: string; name?: string }\n if (obj.name) {\n return factory.createImportSpecifier(false, factory.createIdentifier(obj.propertyName), factory.createIdentifier(obj.name))\n }\n\n return factory.createImportSpecifier(false, undefined, factory.createIdentifier(obj.propertyName))\n }\n\n return factory.createImportSpecifier(false, undefined, factory.createIdentifier(item))\n }),\n ),\n ),\n factory.createStringLiteral(path),\n undefined,\n )\n}\n\nexport function createExportDeclaration({\n path,\n asAlias,\n isTypeOnly = false,\n name,\n}: {\n path: string\n asAlias?: boolean\n isTypeOnly?: boolean\n name?: string \| Array<ts.Identifier \| string>\n}) {\n if (name && !Array.isArray(name) && !asAlias) {\n console.warn(`When using name as string, asAlias should be true ${name}`)\n }\n\n if (!Array.isArray(name)) {\n const parsedName = name?.match(/^\\d/) ? `_${name?.slice(1)}` : name\n\n return factory.createExportDeclaration(\n undefined,\n isTypeOnly,\n asAlias && parsedName ? factory.createNamespaceExport(factory.createIdentifier(parsedName)) : undefined,\n factory.createStringLiteral(path),\n undefined,\n )\n }\n\n return factory.createExportDeclaration(\n undefined,\n isTypeOnly,\n factory.createNamedExports(\n name.map((propertyName) => {\n return factory.createExportSpecifier(false, undefined, typeof propertyName === 'string' ? factory.createIdentifier(propertyName) : propertyName)\n }),\n ),\n factory.createStringLiteral(path),\n undefined,\n )\n}\n\nexport function createEnumDeclaration({\n type = 'enum',\n name,\n typeName,\n enums,\n}: {\n /\n @default `'enum'`\n /\n type?: 'enum' \| 'asConst' \| 'asPascalConst' \| 'constEnum' \| 'literal'\n /\n Enum name in camelCase.\n /\n name: string\n /\n Enum name in PascalCase.\n */\n typeName: string\n enums: [key: string \| number, value: string \| number \| boolean][]\n}): [name: ts.Node \| undefined, type: ts.Node] {\n if (type === 'literal') {\n return [\n undefined,\n factory.createTypeAliasDeclaration(\n [factory.createToken(ts.SyntaxKind.ExportKeyword)],\n factory.createIdentifier(typeName),\n undefined,\n factory.createUnionTypeNode(\n enums\n .map(([_key, value]) => {\n if (isNumber(value)) {\n return factory.createLiteralTypeNode(factory.createNumericLiteral(value?.toString()))\n }\n\n if (typeof value === 'boolean') {\n return factory.createLiteralTypeNode(value ? factory.createTrue() : factory.createFalse())\n }\n if (value) {\n return factory.createLiteralTypeNode(factory.createStringLiteral(value.toString()))\n }\n\n return undefined\n })\n .filter(Boolean),\n ),\n ),\n ]\n }\n\n if (type === 'enum' \|\| type === 'constEnum') {\n return [\n undefined,\n factory.createEnumDeclaration(\n [factory.createToken(ts.SyntaxKind.ExportKeyword), type === 'constEnum' ? factory.createToken(ts.SyntaxKind.ConstKeyword) : undefined].filter(Boolean),\n factory.createIdentifier(typeName),\n enums\n .map(([key, value]) => {\n let initializer: ts.Expression = factory.createStringLiteral(value?.toString())\n const isExactNumber = Number.parseInt(value.toString(), 10) === value\n\n if (isExactNumber && isNumber(Number.parseInt(value.toString(), 10))) {\n initializer = factory.createNumericLiteral(value as number)\n }\n\n if (typeof value === 'boolean') {\n initializer = value ? factory.createTrue() : factory.createFalse()\n }\n\n if (isNumber(Number.parseInt(key.toString(), 10))) {\n return factory.createEnumMember(factory.createStringLiteral(`${typeName}_${key}`), initializer)\n }\n\n if (key) {\n return factory.createEnumMember(factory.createStringLiteral(`${key}`), initializer)\n }\n\n return undefined\n })\n .filter(Boolean),\n ),\n ]\n }\n\n // used when using `as const` instead of an TypeScript enum.\n const identifierName = type === 'asPascalConst' ? typeName : name\n\n return [\n factory.createVariableStatement(\n [factory.createToken(ts.SyntaxKind.ExportKeyword)],\n factory.createVariableDeclarationList(\n [\n factory.createVariableDeclaration(\n factory.createIdentifier(identifierName),\n undefined,\n undefined,\n factory.createAsExpression(\n factory.createObjectLiteralExpression(\n enums\n .map(([key, value]) => {\n let initializer: ts.Expression = factory.createStringLiteral(value?.toString())\n\n if (isNumber(value)) {\n // Error: Negative numbers should be created in combination with createPrefixUnaryExpression factory.\n // The method createNumericLiteral only accepts positive numbers\n // or those combined with createPrefixUnaryExpression.\n // Therefore, we need to ensure that the number is not negative.\n if (value < 0) {\n initializer = factory.createPrefixUnaryExpression(ts.SyntaxKind.MinusToken, factory.createNumericLiteral(Math.abs(value)))\n } else {\n initializer = factory.createNumericLiteral(value)\n }\n }\n\n if (typeof value === 'boolean') {\n initializer = value ? factory.createTrue() : factory.createFalse()\n }\n\n if (key) {\n return factory.createPropertyAssignment(factory.createStringLiteral(`${key}`), initializer)\n }\n\n return undefined\n })\n .filter(Boolean),\n true,\n ),\n factory.createTypeReferenceNode(factory.createIdentifier('const'), undefined),\n ),\n ),\n ],\n ts.NodeFlags.Const,\n ),\n ),\n factory.createTypeAliasDeclaration(\n type === 'asPascalConst' ? [] : [factory.createToken(ts.SyntaxKind.ExportKeyword)],\n factory.createIdentifier(typeName),\n undefined,\n factory.createIndexedAccessTypeNode(\n factory.createParenthesizedType(factory.createTypeQueryNode(factory.createIdentifier(identifierName), undefined)),\n factory.createTypeOperatorNode(ts.SyntaxKind.KeyOfKeyword, factory.createTypeQueryNode(factory.createIdentifier(identifierName), undefined)),\n ),\n ),\n ]\n}\n\nexport function createOmitDeclaration({ keys, type, nonNullable }: { keys: Array<string> \| string; type: ts.TypeNode; nonNullable?: boolean }) {\n const node = nonNullable ? factory.createTypeReferenceNode(factory.createIdentifier('NonNullable'), [type]) : type\n\n if (Array.isArray(keys)) {\n return factory.createTypeReferenceNode(factory.createIdentifier('Omit'), [\n node,\n factory.createUnionTypeNode(\n keys.map((key) => {\n return factory.createLiteralTypeNode(factory.createStringLiteral(key))\n }),\n ),\n ])\n }\n\n return factory.createTypeReferenceNode(factory.createIdentifier('Omit'), [node, factory.createLiteralTypeNode(factory.createStringLiteral(keys))])\n}\n\nexport const keywordTypeNodes = {\n any: factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),\n unknown: factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword),\n void: factory.createKeywordTypeNode(ts.SyntaxKind.VoidKeyword),\n number: factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword),\n integer: factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword),\n object: factory.createKeywordTypeNode(ts.SyntaxKind.ObjectKeyword),\n string: factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),\n boolean: factory.createKeywordTypeNode(ts.SyntaxKind.BooleanKeyword),\n undefined: factory.createKeywordTypeNode(ts.SyntaxKind.UndefinedKeyword),\n null: factory.createLiteralTypeNode(factory.createToken(ts.SyntaxKind.NullKeyword)),\n} as const\n\nexport const createTypeLiteralNode = factory.createTypeLiteralNode\n\nexport const createTypeReferenceNode = factory.createTypeReferenceNode\nexport const createNumericLiteral = factory.createNumericLiteral\nexport const createStringLiteral = factory.createStringLiteral\n\nexport const createArrayTypeNode = factory.createArrayTypeNode\n\nexport const createLiteralTypeNode = factory.createLiteralTypeNode\nexport const createNull = factory.createNull\nexport const createIdentifier = factory.createIdentifier\n\nexport const createOptionalTypeNode = factory.createOptionalTypeNode\nexport const createTupleTypeNode = factory.createTupleTypeNode\nexport const createRestTypeNode = factory.createRestTypeNode\nexport const createTrue = factory.createTrue\nexport const createFalse = factory.createFalse\n"],"mappings":"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"}
1	+ {"version":3,"file":"factory-CDjjCkNo.js","names":["modifiers","questionToken","node","importPropertyName: ts.Identifier \| undefined","importName: ts.NamedImportBindings \| undefined","propertyName","initializer: ts.Expression"],"sources":["../src/factory.ts"],"sourcesContent":["import { isNumber } from 'remeda'\nimport ts from 'typescript'\n\nconst { SyntaxKind, factory } = ts\n\n// https://ts-ast-viewer.com/\n\nexport const modifiers = {\n async: factory.createModifier(ts.SyntaxKind.AsyncKeyword),\n export: factory.createModifier(ts.SyntaxKind.ExportKeyword),\n const: factory.createModifier(ts.SyntaxKind.ConstKeyword),\n static: factory.createModifier(ts.SyntaxKind.StaticKeyword),\n} as const\n\nexport const syntaxKind = {\n union: SyntaxKind.UnionType as 192,\n} as const\n\nfunction isValidIdentifier(str: string): boolean {\n if (!str.length \|\| str.trim() !== str) {\n return false\n }\n const node = ts.parseIsolatedEntityName(str, ts.ScriptTarget.Latest)\n\n return !!node && node.kind === ts.SyntaxKind.Identifier && ts.identifierToKeywordKind(node.kind as unknown as ts.Identifier) === undefined\n}\n\nfunction propertyName(name: string \| ts.PropertyName): ts.PropertyName {\n if (typeof name === 'string') {\n return isValidIdentifier(name) ? factory.createIdentifier(name) : factory.createStringLiteral(name)\n }\n return name\n}\n\nconst questionToken = factory.createToken(ts.SyntaxKind.QuestionToken)\n\nexport function createQuestionToken(token?: boolean \| ts.QuestionToken) {\n if (!token) {\n return undefined\n }\n if (token === true) {\n return questionToken\n }\n return token\n}\n\nexport function createIntersectionDeclaration({ nodes, withParentheses }: { nodes: Array<ts.TypeNode>; withParentheses?: boolean }): ts.TypeNode \| null {\n if (!nodes.length) {\n return null\n }\n\n if (nodes.length === 1) {\n return nodes[0] \|\| null\n }\n\n const node = factory.createIntersectionTypeNode(nodes)\n\n if (withParentheses) {\n return factory.createParenthesizedType(node)\n }\n\n return node\n}\n\n/*\n Minimum nodes length of 2\n * @example `string & number`\n /\nexport function createTupleDeclaration({ nodes, withParentheses }: { nodes: Array<ts.TypeNode>; withParentheses?: boolean }): ts.TypeNode \| null {\n if (!nodes.length) {\n return null\n }\n\n if (nodes.length === 1) {\n return nodes[0] \|\| null\n }\n\n const node = factory.createTupleTypeNode(nodes)\n\n if (withParentheses) {\n return factory.createParenthesizedType(node)\n }\n\n return node\n}\n\nexport function createArrayDeclaration({ nodes }: { nodes: Array<ts.TypeNode> }): ts.TypeNode \| null {\n if (!nodes.length) {\n return factory.createTupleTypeNode([])\n }\n\n if (nodes.length === 1) {\n return factory.createArrayTypeNode(nodes.at(0)!)\n }\n\n return factory.createExpressionWithTypeArguments(factory.createIdentifier('Array'), [factory.createUnionTypeNode(nodes)])\n}\n\n/\n Minimum nodes length of 2\n * @example `string \| number`\n /\nexport function createUnionDeclaration({ nodes, withParentheses }: { nodes: Array<ts.TypeNode>; withParentheses?: boolean }): ts.TypeNode {\n if (!nodes.length) {\n return keywordTypeNodes.any\n }\n\n if (nodes.length === 1) {\n return nodes[0] as ts.TypeNode\n }\n\n const node = factory.createUnionTypeNode(nodes)\n\n if (withParentheses) {\n return factory.createParenthesizedType(node)\n }\n\n return node\n}\n\nexport function createPropertySignature({\n readOnly,\n modifiers = [],\n name,\n questionToken,\n type,\n}: {\n readOnly?: boolean\n modifiers?: Array<ts.Modifier>\n name: ts.PropertyName \| string\n questionToken?: ts.QuestionToken \| boolean\n type?: ts.TypeNode\n}) {\n return factory.createPropertySignature(\n [...modifiers, readOnly ? factory.createToken(ts.SyntaxKind.ReadonlyKeyword) : undefined].filter(Boolean),\n propertyName(name),\n createQuestionToken(questionToken),\n type,\n )\n}\n\nexport function createParameterSignature(\n name: string \| ts.BindingName,\n {\n modifiers,\n dotDotDotToken,\n questionToken,\n type,\n initializer,\n }: {\n decorators?: Array<ts.Decorator>\n modifiers?: Array<ts.Modifier>\n dotDotDotToken?: ts.DotDotDotToken\n questionToken?: ts.QuestionToken \| boolean\n type?: ts.TypeNode\n initializer?: ts.Expression\n },\n): ts.ParameterDeclaration {\n return factory.createParameterDeclaration(modifiers, dotDotDotToken, name, createQuestionToken(questionToken), type, initializer)\n}\n\nexport function createJSDoc({ comments }: { comments: string[] }) {\n if (!comments.length) {\n return null\n }\n return factory.createJSDocComment(\n factory.createNodeArray(\n comments.map((comment, i) => {\n if (i === comments.length - 1) {\n return factory.createJSDocText(comment)\n }\n\n return factory.createJSDocText(`${comment}\\n`)\n }),\n ),\n )\n}\n\n/\n @link https://github.com/microsoft/TypeScript/issues/44151\n /\nexport function appendJSDocToNode<TNode extends ts.Node>({ node, comments }: { node: TNode; comments: Array<string \| undefined> }) {\n const filteredComments = comments.filter(Boolean)\n\n if (!filteredComments.length) {\n return node\n }\n\n const text = filteredComments.reduce((acc = '', comment = '') => {\n return `${acc}\\n ${comment.replaceAll('/', '\\\\/')}`\n }, '')\n\n // node: {...node}, with that ts.addSyntheticLeadingComment is appending\n return ts.addSyntheticLeadingComment({ ...node }, ts.SyntaxKind.MultiLineCommentTrivia, `${text \|\| ''}\\n`, true)\n}\n\nexport function createIndexSignature(\n type: ts.TypeNode,\n {\n modifiers,\n indexName = 'key',\n indexType = factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),\n }: {\n indexName?: string\n indexType?: ts.TypeNode\n decorators?: Array<ts.Decorator>\n modifiers?: Array<ts.Modifier>\n } = {},\n) {\n return factory.createIndexSignature(modifiers, [createParameterSignature(indexName, { type: indexType })], type)\n}\n\nexport function createTypeAliasDeclaration({\n modifiers,\n name,\n typeParameters,\n type,\n}: {\n modifiers?: Array<ts.Modifier>\n name: string \| ts.Identifier\n typeParameters?: Array<ts.TypeParameterDeclaration>\n type: ts.TypeNode\n}) {\n return factory.createTypeAliasDeclaration(modifiers, name, typeParameters, type)\n}\n\nexport function createInterfaceDeclaration({\n modifiers,\n name,\n typeParameters,\n members,\n}: {\n modifiers?: Array<ts.Modifier>\n name: string \| ts.Identifier\n typeParameters?: Array<ts.TypeParameterDeclaration>\n members: Array<ts.TypeElement>\n}) {\n return factory.createInterfaceDeclaration(modifiers, name, typeParameters, undefined, members)\n}\n\nexport function createTypeDeclaration({\n syntax,\n isExportable,\n comments,\n name,\n type,\n}: {\n syntax: 'type' \| 'interface'\n comments: Array<string \| undefined>\n isExportable?: boolean\n name: string \| ts.Identifier\n type: ts.TypeNode\n}) {\n if (syntax === 'interface' && 'members' in type) {\n const node = createInterfaceDeclaration({\n members: type.members as Array<ts.TypeElement>,\n modifiers: isExportable ? [modifiers.export] : [],\n name,\n typeParameters: undefined,\n })\n\n return appendJSDocToNode({\n node,\n comments,\n })\n }\n\n const node = createTypeAliasDeclaration({\n type,\n modifiers: isExportable ? [modifiers.export] : [],\n name,\n typeParameters: undefined,\n })\n\n return appendJSDocToNode({\n node,\n comments,\n })\n}\n\nexport function createNamespaceDeclaration({ statements, name }: { name: string; statements: ts.Statement[] }) {\n return factory.createModuleDeclaration(\n [factory.createToken(ts.SyntaxKind.ExportKeyword)],\n factory.createIdentifier(name),\n factory.createModuleBlock(statements),\n ts.NodeFlags.Namespace,\n )\n}\n\n/*\n In { propertyName: string; name?: string } is `name` being used to make the type more unique when multiple same names are used.\n * @example `import { Pet as Cat } from './Pet'`\n /\nexport function createImportDeclaration({\n name,\n path,\n isTypeOnly = false,\n isNameSpace = false,\n}: {\n name: string \| Array<string \| { propertyName: string; name?: string }>\n path: string\n isTypeOnly?: boolean\n isNameSpace?: boolean\n}) {\n if (!Array.isArray(name)) {\n let importPropertyName: ts.Identifier \| undefined = factory.createIdentifier(name)\n let importName: ts.NamedImportBindings \| undefined\n\n if (isNameSpace) {\n importPropertyName = undefined\n importName = factory.createNamespaceImport(factory.createIdentifier(name))\n }\n\n return factory.createImportDeclaration(\n undefined,\n factory.createImportClause(isTypeOnly, importPropertyName, importName),\n factory.createStringLiteral(path),\n undefined,\n )\n }\n\n return factory.createImportDeclaration(\n undefined,\n factory.createImportClause(\n isTypeOnly,\n undefined,\n factory.createNamedImports(\n name.map((item) => {\n if (typeof item === 'object') {\n const obj = item as { propertyName: string; name?: string }\n if (obj.name) {\n return factory.createImportSpecifier(false, factory.createIdentifier(obj.propertyName), factory.createIdentifier(obj.name))\n }\n\n return factory.createImportSpecifier(false, undefined, factory.createIdentifier(obj.propertyName))\n }\n\n return factory.createImportSpecifier(false, undefined, factory.createIdentifier(item))\n }),\n ),\n ),\n factory.createStringLiteral(path),\n undefined,\n )\n}\n\nexport function createExportDeclaration({\n path,\n asAlias,\n isTypeOnly = false,\n name,\n}: {\n path: string\n asAlias?: boolean\n isTypeOnly?: boolean\n name?: string \| Array<ts.Identifier \| string>\n}) {\n if (name && !Array.isArray(name) && !asAlias) {\n console.warn(`When using name as string, asAlias should be true ${name}`)\n }\n\n if (!Array.isArray(name)) {\n const parsedName = name?.match(/^\\d/) ? `_${name?.slice(1)}` : name\n\n return factory.createExportDeclaration(\n undefined,\n isTypeOnly,\n asAlias && parsedName ? factory.createNamespaceExport(factory.createIdentifier(parsedName)) : undefined,\n factory.createStringLiteral(path),\n undefined,\n )\n }\n\n return factory.createExportDeclaration(\n undefined,\n isTypeOnly,\n factory.createNamedExports(\n name.map((propertyName) => {\n return factory.createExportSpecifier(false, undefined, typeof propertyName === 'string' ? factory.createIdentifier(propertyName) : propertyName)\n }),\n ),\n factory.createStringLiteral(path),\n undefined,\n )\n}\n\nexport function createEnumDeclaration({\n type = 'enum',\n name,\n typeName,\n enums,\n}: {\n /\n @default `'enum'`\n /\n type?: 'enum' \| 'asConst' \| 'asPascalConst' \| 'constEnum' \| 'literal'\n /\n Enum name in camelCase.\n /\n name: string\n /\n Enum name in PascalCase.\n */\n typeName: string\n enums: [key: string \| number, value: string \| number \| boolean][]\n}): [name: ts.Node \| undefined, type: ts.Node] {\n if (type === 'literal') {\n return [\n undefined,\n factory.createTypeAliasDeclaration(\n [factory.createToken(ts.SyntaxKind.ExportKeyword)],\n factory.createIdentifier(typeName),\n undefined,\n factory.createUnionTypeNode(\n enums\n .map(([_key, value]) => {\n if (isNumber(value)) {\n return factory.createLiteralTypeNode(factory.createNumericLiteral(value?.toString()))\n }\n\n if (typeof value === 'boolean') {\n return factory.createLiteralTypeNode(value ? factory.createTrue() : factory.createFalse())\n }\n if (value) {\n return factory.createLiteralTypeNode(factory.createStringLiteral(value.toString()))\n }\n\n return undefined\n })\n .filter(Boolean),\n ),\n ),\n ]\n }\n\n if (type === 'enum' \|\| type === 'constEnum') {\n return [\n undefined,\n factory.createEnumDeclaration(\n [factory.createToken(ts.SyntaxKind.ExportKeyword), type === 'constEnum' ? factory.createToken(ts.SyntaxKind.ConstKeyword) : undefined].filter(Boolean),\n factory.createIdentifier(typeName),\n enums\n .map(([key, value]) => {\n let initializer: ts.Expression = factory.createStringLiteral(value?.toString())\n const isExactNumber = Number.parseInt(value.toString(), 10) === value\n\n if (isExactNumber && isNumber(Number.parseInt(value.toString(), 10))) {\n initializer = factory.createNumericLiteral(value as number)\n }\n\n if (typeof value === 'boolean') {\n initializer = value ? factory.createTrue() : factory.createFalse()\n }\n\n if (isNumber(Number.parseInt(key.toString(), 10))) {\n return factory.createEnumMember(factory.createStringLiteral(`${typeName}_${key}`), initializer)\n }\n\n if (key) {\n return factory.createEnumMember(factory.createStringLiteral(`${key}`), initializer)\n }\n\n return undefined\n })\n .filter(Boolean),\n ),\n ]\n }\n\n // used when using `as const` instead of an TypeScript enum.\n const identifierName = type === 'asPascalConst' ? typeName : name\n\n return [\n factory.createVariableStatement(\n [factory.createToken(ts.SyntaxKind.ExportKeyword)],\n factory.createVariableDeclarationList(\n [\n factory.createVariableDeclaration(\n factory.createIdentifier(identifierName),\n undefined,\n undefined,\n factory.createAsExpression(\n factory.createObjectLiteralExpression(\n enums\n .map(([key, value]) => {\n let initializer: ts.Expression = factory.createStringLiteral(value?.toString())\n\n if (isNumber(value)) {\n // Error: Negative numbers should be created in combination with createPrefixUnaryExpression factory.\n // The method createNumericLiteral only accepts positive numbers\n // or those combined with createPrefixUnaryExpression.\n // Therefore, we need to ensure that the number is not negative.\n if (value < 0) {\n initializer = factory.createPrefixUnaryExpression(ts.SyntaxKind.MinusToken, factory.createNumericLiteral(Math.abs(value)))\n } else {\n initializer = factory.createNumericLiteral(value)\n }\n }\n\n if (typeof value === 'boolean') {\n initializer = value ? factory.createTrue() : factory.createFalse()\n }\n\n if (key) {\n return factory.createPropertyAssignment(factory.createStringLiteral(`${key}`), initializer)\n }\n\n return undefined\n })\n .filter(Boolean),\n true,\n ),\n factory.createTypeReferenceNode(factory.createIdentifier('const'), undefined),\n ),\n ),\n ],\n ts.NodeFlags.Const,\n ),\n ),\n factory.createTypeAliasDeclaration(\n type === 'asPascalConst' ? [] : [factory.createToken(ts.SyntaxKind.ExportKeyword)],\n factory.createIdentifier(typeName),\n undefined,\n factory.createIndexedAccessTypeNode(\n factory.createParenthesizedType(factory.createTypeQueryNode(factory.createIdentifier(identifierName), undefined)),\n factory.createTypeOperatorNode(ts.SyntaxKind.KeyOfKeyword, factory.createTypeQueryNode(factory.createIdentifier(identifierName), undefined)),\n ),\n ),\n ]\n}\n\nexport function createOmitDeclaration({ keys, type, nonNullable }: { keys: Array<string> \| string; type: ts.TypeNode; nonNullable?: boolean }) {\n const node = nonNullable ? factory.createTypeReferenceNode(factory.createIdentifier('NonNullable'), [type]) : type\n\n if (Array.isArray(keys)) {\n return factory.createTypeReferenceNode(factory.createIdentifier('Omit'), [\n node,\n factory.createUnionTypeNode(\n keys.map((key) => {\n return factory.createLiteralTypeNode(factory.createStringLiteral(key))\n }),\n ),\n ])\n }\n\n return factory.createTypeReferenceNode(factory.createIdentifier('Omit'), [node, factory.createLiteralTypeNode(factory.createStringLiteral(keys))])\n}\n\nexport const keywordTypeNodes = {\n any: factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),\n unknown: factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword),\n void: factory.createKeywordTypeNode(ts.SyntaxKind.VoidKeyword),\n number: factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword),\n integer: factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword),\n object: factory.createKeywordTypeNode(ts.SyntaxKind.ObjectKeyword),\n string: factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),\n boolean: factory.createKeywordTypeNode(ts.SyntaxKind.BooleanKeyword),\n undefined: factory.createKeywordTypeNode(ts.SyntaxKind.UndefinedKeyword),\n null: factory.createLiteralTypeNode(factory.createToken(ts.SyntaxKind.NullKeyword)),\n} as const\n\nexport const createTypeLiteralNode = factory.createTypeLiteralNode\n\nexport const createTypeReferenceNode = factory.createTypeReferenceNode\nexport const createNumericLiteral = factory.createNumericLiteral\nexport const createStringLiteral = factory.createStringLiteral\n\nexport const createArrayTypeNode = factory.createArrayTypeNode\n\nexport const createLiteralTypeNode = factory.createLiteralTypeNode\nexport const createNull = factory.createNull\nexport const createIdentifier = factory.createIdentifier\n\nexport const createOptionalTypeNode = factory.createOptionalTypeNode\nexport const createTupleTypeNode = factory.createTupleTypeNode\nexport const createRestTypeNode = factory.createRestTypeNode\nexport const createTrue = factory.createTrue\nexport const createFalse = factory.createFalse\n"],"mappings":"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"}

package/dist/index.cjs CHANGED Viewed

@@ -1,6 +1,29 @@
 const require_factory = require('./factory-BSd2OjFQ.cjs');
 const typescript = require_factory.__toESM(require("typescript"));
+const prettier = require_factory.__toESM(require("prettier"));
+const prettier_plugins_typescript = require_factory.__toESM(require("prettier/plugins/typescript"));
+//#region src/format.ts
+const formatOptions = {
+	tabWidth: 2,
+	printWidth: 160,
+	parser: "typescript",
+	singleQuote: true,
+	semi: false,
+	bracketSameLine: false,
+	endOfLine: "auto",
+	plugins: [prettier_plugins_typescript.default]
+};
+function format(source) {
+	if (!source) return Promise.resolve("");
+	try {
+		return (0, prettier.format)(source, formatOptions);
+	} catch (_e) {
+		return Promise.resolve(source);
+	}
+}
+//#endregion
 //#region src/print.ts
 const { factory } = typescript.default;
 /**
@@ -14,17 +37,21 @@ const restoreNewLines = (code) => code.replace(/\/\* :newline: \*\//g, "\n");
 /**
 * Convert AST TypeScript/TSX nodes to a string based on the TypeScript printer.
 * Ensures consistent output across environments.
+* Also works as a formatter when `source` is provided without `elements`.
 */
-function print(elements, { source = "", baseName = "print.tsx", scriptKind = typescript.default.ScriptKind.TSX } = {}) {
-	const sourceFile = typescript.default.createSourceFile(baseName, escapeNewLines(source), typescript.default.ScriptTarget.ES2022, false, scriptKind);
+function print(elements = [], { source = "", baseName = "print.tsx", scriptKind = typescript.default.ScriptKind.TSX } = {}) {
+	const sourceFile = typescript.default.createSourceFile(baseName, escapeNewLines(source), typescript.default.ScriptTarget.ES2022, true, scriptKind);
 	const printer = typescript.default.createPrinter({
 		omitTrailingSemicolon: true,
 		newLine: typescript.default.NewLineKind.LineFeed,
 		removeComments: false,
 		noEmitHelpers: true
 	});
-	const nodes = (Array.isArray(elements) ? elements : [elements]).filter(Boolean).sort((a, b) => (a.pos ?? 0) - (b.pos ?? 0));
-	const output = printer.printList(typescript.default.ListFormat.MultiLine, factory.createNodeArray(nodes), sourceFile);
+	let output;
+	if (elements.length > 0) {
+		const nodes = elements.filter(Boolean).sort((a, b) => (a.pos ?? 0) - (b.pos ?? 0));
+		output = printer.printList(typescript.default.ListFormat.MultiLine, factory.createNodeArray(nodes), sourceFile);
+	} else output = printer.printFile(sourceFile);
 	return restoreNewLines(output).replace(/\r\n/g, "\n");
 }
@@ -35,5 +62,6 @@ Object.defineProperty(exports, 'factory', {
     return require_factory.factory_exports;
   }
 });
+exports.format = format;
 exports.print = print;
 //# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"index.cjs","names":["ts"],"sources":["../src/print.ts"],"sourcesContent":["import ts from 'typescript'\n\nconst { factory } = ts\n\nexport type PrintOptions = {\n source?: string\n baseName?: string\n scriptKind?: ts.ScriptKind\n}\n\n/*\n Escaped new lines in code with block comments so they can be restored by {@link restoreNewLines}\n /\nconst escapeNewLines = (code: string) => code.replace(/\\n\\n/g, '\\n/ :newline: /')\n\n/\n Reverses {@link escapeNewLines} and restores new lines\n /\nconst restoreNewLines = (code: string) => code.replace(/\\/\\ :newline: \\\\//g, '\\n')\n\n/\n Convert AST TypeScript/TSX nodes to a string based on the TypeScript printer.\n * Ensures consistent output across environments.\n */\nexport function print(elements: Array<ts.Node>, { source = '', baseName = 'print.tsx', scriptKind = ts.ScriptKind.TSX }: PrintOptions = {}): string {\n const sourceFile = ts.createSourceFile(baseName, escapeNewLines(source), ts.ScriptTarget.ES2022, ~~false~~, scriptKind)\n\n const printer = ts.createPrinter({\n omitTrailingSemicolon: true,\n newLine: ts.NewLineKind.LineFeed,\n removeComments: false,\n noEmitHelpers: true,\n })\n\n ~~const~~ ~~nodes~~ = (~~Array~~.~~isArray(elements~~) ? ~~elements~~ : [elements]).filter(Boolean).sort((a, b) => (a.pos ?? 0) - (b.pos ?? 0))\n ~~const~~ output = printer.printList(ts.ListFormat.MultiLine, factory.createNodeArray(nodes), sourceFile)\n\n return restoreNewLines(output).replace(/\\r\\n/g, '\\n')\n}\n"],"mappings":"~~;;;;AAEA~~,MAAM,~~EAAE~~,SAAS,~~GAAGA~~;;;;AAWpB,MAAM,kBAAkB,SAAiB,KAAK,QAAQ,SAAS;;;;AAK/D,MAAM,mBAAmB,SAAiB,KAAK,QAAQ,wBAAwB~~;;;;;AAM~~/E,SAAgB,MAAM,~~UAA0B~~,EAAE,SAAS,IAAI,WAAW,aAAa,aAAaA,mBAAG,WAAW,~~KAAmB~~,~~GAAG,EAAE,EAAU~~;~~CAClJ~~,MAAM,aAAaA,mBAAG,iBAAiB,UAAU,eAAe,SAASA,mBAAG,aAAa,QAAQ,~~OAAO~~;~~CAExG~~,MAAM,UAAUA,mBAAG,cAAc;EAC/B,uBAAuB;EACvB,SAASA,mBAAG,YAAY;EACxB,gBAAgB;EAChB,eAAe;~~EAChB;CAED~~,~~MAAM~~,SAAS,MAAM,QAAQ,~~YAAY,WAAW,CAAC,~~SAAS,~~EAAE,~~OAAO,SAAS,MAAM,GAAG,OAAO,EAAE,OAAO,MAAM,EAAE,OAAO;~~CACxH~~,~~MAAM~~,~~SAAS,~~QAAQ,~~UAAUA~~,mBAAG,WAAW,WAAW,QAAQ,gBAAgB,QAAQ;~~AAE1F~~,QAAO,gBAAgB,QAAQ,QAAQ,SAAS~~;AACjD~~"}
1	+ {"version":3,"file":"index.cjs","names":["formatOptions: Options","pluginTypescript","ts","output: string"],"sources":["../src/format.ts","../src/print.ts"],"sourcesContent":["import type { Options } from 'prettier'\nimport { format as prettierFormat } from 'prettier'\nimport pluginTypescript from 'prettier/plugins/typescript'\n\nconst formatOptions: Options = {\n tabWidth: 2,\n printWidth: 160,\n parser: 'typescript',\n singleQuote: true,\n semi: false,\n bracketSameLine: false,\n endOfLine: 'auto',\n plugins: [pluginTypescript],\n}\nexport function format(source?: string): Promise<string> {\n if (!source) {\n return Promise.resolve('')\n }\n\n try {\n return prettierFormat(source, formatOptions)\n } catch (_e) {\n return Promise.resolve(source)\n }\n}\n","import ts from 'typescript'\n\nconst { factory } = ts\n\nexport type PrintOptions = {\n source?: string\n baseName?: string\n scriptKind?: ts.ScriptKind\n}\n\n/*\n Escaped new lines in code with block comments so they can be restored by {@link restoreNewLines}\n /\nconst escapeNewLines = (code: string) => code.replace(/\\n\\n/g, '\\n/ :newline: /')\n\n/\n Reverses {@link escapeNewLines} and restores new lines\n /\nconst restoreNewLines = (code: string) => code.replace(/\\/\\ :newline: \\\\//g, '\\n')\n\n/\n Convert AST TypeScript/TSX nodes to a string based on the TypeScript printer.\n * Ensures consistent output across environments.\n * Also works as a formatter when `source` is provided without `elements`.\n */\nexport function print(elements: Array<ts.Node> = [], { source = '', baseName = 'print.tsx', scriptKind = ts.ScriptKind.TSX }: PrintOptions = {}): string {\n const sourceFile = ts.createSourceFile(baseName, escapeNewLines(source), ts.ScriptTarget.ES2022, true, scriptKind)\n\n const printer = ts.createPrinter({\n omitTrailingSemicolon: true,\n newLine: ts.NewLineKind.LineFeed,\n removeComments: false,\n noEmitHelpers: true,\n })\n\n let output: string\n\n if (elements.length > 0) {\n // Print only provided nodes\n const nodes = elements.filter(Boolean).sort((a, b) => (a.pos ?? 0) - (b.pos ?? 0))\n output = printer.printList(ts.ListFormat.MultiLine, factory.createNodeArray(nodes), sourceFile)\n } else {\n // Format the whole file\n output = printer.printFile(sourceFile)\n }\n\n return restoreNewLines(output).replace(/\\r\\n/g, '\\n')\n}\n"],"mappings":";;;;;;AAIA,MAAMA,gBAAyB;CAC7B,UAAU;CACV,YAAY;CACZ,QAAQ;CACR,aAAa;CACb,MAAM;CACN,iBAAiB;CACjB,WAAW;CACX,SAAS,CAACC;;AAEZ,SAAgB,OAAO,QAAkC;AACvD,KAAI,CAAC,OACH,QAAO,QAAQ,QAAQ;AAGzB,KAAI;AACF,8BAAsB,QAAQ;UACvB,IAAI;AACX,SAAO,QAAQ,QAAQ;;;;;;ACpB3B,MAAM,EAAE,YAAYC;;;;AAWpB,MAAM,kBAAkB,SAAiB,KAAK,QAAQ,SAAS;;;;AAK/D,MAAM,mBAAmB,SAAiB,KAAK,QAAQ,wBAAwB;;;;;;AAO/E,SAAgB,MAAM,WAA2B,IAAI,EAAE,SAAS,IAAI,WAAW,aAAa,aAAaA,mBAAG,WAAW,QAAsB,IAAY;CACvJ,MAAM,aAAaA,mBAAG,iBAAiB,UAAU,eAAe,SAASA,mBAAG,aAAa,QAAQ,MAAM;CAEvG,MAAM,UAAUA,mBAAG,cAAc;EAC/B,uBAAuB;EACvB,SAASA,mBAAG,YAAY;EACxB,gBAAgB;EAChB,eAAe;;CAGjB,IAAIC;AAEJ,KAAI,SAAS,SAAS,GAAG;EAEvB,MAAM,QAAQ,SAAS,OAAO,SAAS,MAAM,GAAG,OAAO,EAAE,OAAO,MAAM,EAAE,OAAO;AAC/E,WAAS,QAAQ,UAAUD,mBAAG,WAAW,WAAW,QAAQ,gBAAgB,QAAQ;OAGpF,UAAS,QAAQ,UAAU;AAG7B,QAAO,gBAAgB,QAAQ,QAAQ,SAAS"}

package/dist/index.d.cts CHANGED Viewed

@@ -1,6 +1,9 @@
 import { factory_d_exports } from "./factory-_F-JTqnG.cjs";
 import ts from "typescript";
+//#region src/format.d.ts
+declare function format(source?: string): Promise<string>;
+//#endregion
 //#region src/print.d.ts
 type PrintOptions = {
   source?: string;
@@ -10,12 +13,13 @@ type PrintOptions = {
 /**
  * Convert AST TypeScript/TSX nodes to a string based on the TypeScript printer.
  * Ensures consistent output across environments.
+ * Also works as a formatter when `source` is provided without `elements`.
  */
-declare function print(elements: Array<ts.Node>, {
+declare function print(elements?: Array<ts.Node>, {
   source,
   baseName,
   scriptKind
 }?: PrintOptions): string;
 //#endregion
-export { factory_d_exports as factory, print };
+export { factory_d_exports as factory, format, print };
 //# sourceMappingURL=index.d.cts.map

package/dist/index.d.ts CHANGED Viewed

@@ -1,6 +1,9 @@
 import { factory_d_exports } from "./factory-CUjjpSgy.js";
 import ts from "typescript";
+//#region src/format.d.ts
+declare function format(source?: string): Promise<string>;
+//#endregion
 //#region src/print.d.ts
 type PrintOptions = {
   source?: string;
@@ -10,12 +13,13 @@ type PrintOptions = {
 /**
  * Convert AST TypeScript/TSX nodes to a string based on the TypeScript printer.
  * Ensures consistent output across environments.
+ * Also works as a formatter when `source` is provided without `elements`.
  */
-declare function print(elements: Array<ts.Node>, {
+declare function print(elements?: Array<ts.Node>, {
   source,
   baseName,
   scriptKind
 }?: PrintOptions): string;
 //#endregion
-export { factory_d_exports as factory, print };
+export { factory_d_exports as factory, format, print };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js CHANGED Viewed

@@ -1,6 +1,29 @@
 import { factory_exports } from "./factory-CDjjCkNo.js";
 import ts from "typescript";
+import { format as format$1 } from "prettier";
+import pluginTypescript from "prettier/plugins/typescript";
+//#region src/format.ts
+const formatOptions = {
+	tabWidth: 2,
+	printWidth: 160,
+	parser: "typescript",
+	singleQuote: true,
+	semi: false,
+	bracketSameLine: false,
+	endOfLine: "auto",
+	plugins: [pluginTypescript]
+};
+function format(source) {
+	if (!source) return Promise.resolve("");
+	try {
+		return format$1(source, formatOptions);
+	} catch (_e) {
+		return Promise.resolve(source);
+	}
+}
+//#endregion
 //#region src/print.ts
 const { factory } = ts;
 /**
@@ -14,20 +37,24 @@ const restoreNewLines = (code) => code.replace(/\/\* :newline: \*\//g, "\n");
 /**
 * Convert AST TypeScript/TSX nodes to a string based on the TypeScript printer.
 * Ensures consistent output across environments.
+* Also works as a formatter when `source` is provided without `elements`.
 */
-function print(elements, { source = "", baseName = "print.tsx", scriptKind = ts.ScriptKind.TSX } = {}) {
-	const sourceFile = ts.createSourceFile(baseName, escapeNewLines(source), ts.ScriptTarget.ES2022, false, scriptKind);
+function print(elements = [], { source = "", baseName = "print.tsx", scriptKind = ts.ScriptKind.TSX } = {}) {
+	const sourceFile = ts.createSourceFile(baseName, escapeNewLines(source), ts.ScriptTarget.ES2022, true, scriptKind);
 	const printer = ts.createPrinter({
 		omitTrailingSemicolon: true,
 		newLine: ts.NewLineKind.LineFeed,
 		removeComments: false,
 		noEmitHelpers: true
 	});
-	const nodes = (Array.isArray(elements) ? elements : [elements]).filter(Boolean).sort((a, b) => (a.pos ?? 0) - (b.pos ?? 0));
-	const output = printer.printList(ts.ListFormat.MultiLine, factory.createNodeArray(nodes), sourceFile);
+	let output;
+	if (elements.length > 0) {
+		const nodes = elements.filter(Boolean).sort((a, b) => (a.pos ?? 0) - (b.pos ?? 0));
+		output = printer.printList(ts.ListFormat.MultiLine, factory.createNodeArray(nodes), sourceFile);
+	} else output = printer.printFile(sourceFile);
 	return restoreNewLines(output).replace(/\r\n/g, "\n");
 }
 //#endregion
-export { factory_exports as factory, print };
+export { factory_exports as factory, format, print };
 //# sourceMappingURL=index.js.map

package/dist/index.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"index.js","names":[],"sources":["../src/print.ts"],"sourcesContent":["import ts from 'typescript'\n\nconst { factory } = ts\n\nexport type PrintOptions = {\n source?: string\n baseName?: string\n scriptKind?: ts.ScriptKind\n}\n\n/*\n Escaped new lines in code with block comments so they can be restored by {@link restoreNewLines}\n /\nconst escapeNewLines = (code: string) => code.replace(/\\n\\n/g, '\\n/ :newline: /')\n\n/\n Reverses {@link escapeNewLines} and restores new lines\n /\nconst restoreNewLines = (code: string) => code.replace(/\\/\\ :newline: \\\\//g, '\\n')\n\n/\n Convert AST TypeScript/TSX nodes to a string based on the TypeScript printer.\n * Ensures consistent output across environments.\n */\nexport function print(elements: Array<ts.Node>, { source = '', baseName = 'print.tsx', scriptKind = ts.ScriptKind.TSX }: PrintOptions = {}): string {\n const sourceFile = ts.createSourceFile(baseName, escapeNewLines(source), ts.ScriptTarget.ES2022, ~~false~~, scriptKind)\n\n const printer = ts.createPrinter({\n omitTrailingSemicolon: true,\n newLine: ts.NewLineKind.LineFeed,\n removeComments: false,\n noEmitHelpers: true,\n })\n\n ~~const~~ ~~nodes~~ = (~~Array~~.~~isArray(elements~~) ? ~~elements~~ : [elements]).filter(Boolean).sort((a, b) => (a.pos ?? 0) - (b.pos ?? 0))\n ~~const~~ output = printer.printList(ts.ListFormat.MultiLine, factory.createNodeArray(nodes), sourceFile)\n\n return restoreNewLines(output).replace(/\\r\\n/g, '\\n')\n}\n"],"mappings":"~~;;;;AAEA~~,MAAM,~~EAAE~~,SAAS,~~GAAG~~;;;;AAWpB,MAAM,kBAAkB,SAAiB,KAAK,QAAQ,SAAS;;;;AAK/D,MAAM,mBAAmB,SAAiB,KAAK,QAAQ,wBAAwB~~;;;;;AAM~~/E,SAAgB,MAAM,~~UAA0B~~,EAAE,SAAS,IAAI,WAAW,aAAa,aAAa,GAAG,WAAW,~~KAAmB~~,~~GAAG,EAAE,EAAU~~;~~CAClJ~~,MAAM,aAAa,GAAG,iBAAiB,UAAU,eAAe,SAAS,GAAG,aAAa,QAAQ,~~OAAO~~;~~CAExG~~,MAAM,UAAU,GAAG,cAAc;EAC/B,uBAAuB;EACvB,SAAS,GAAG,YAAY;EACxB,gBAAgB;EAChB,eAAe;~~EAChB;CAED~~,~~MAAM~~,SAAS,MAAM,QAAQ,~~YAAY,WAAW,CAAC,~~SAAS,~~EAAE,~~OAAO,SAAS,MAAM,GAAG,OAAO,EAAE,OAAO,MAAM,EAAE,OAAO;~~CACxH~~,~~MAAM~~,~~SAAS,~~QAAQ,UAAU,GAAG,WAAW,WAAW,QAAQ,gBAAgB,QAAQ;~~AAE1F~~,QAAO,gBAAgB,QAAQ,QAAQ,SAAS~~;AACjD~~"}
1	+ {"version":3,"file":"index.js","names":["formatOptions: Options","prettierFormat","output: string"],"sources":["../src/format.ts","../src/print.ts"],"sourcesContent":["import type { Options } from 'prettier'\nimport { format as prettierFormat } from 'prettier'\nimport pluginTypescript from 'prettier/plugins/typescript'\n\nconst formatOptions: Options = {\n tabWidth: 2,\n printWidth: 160,\n parser: 'typescript',\n singleQuote: true,\n semi: false,\n bracketSameLine: false,\n endOfLine: 'auto',\n plugins: [pluginTypescript],\n}\nexport function format(source?: string): Promise<string> {\n if (!source) {\n return Promise.resolve('')\n }\n\n try {\n return prettierFormat(source, formatOptions)\n } catch (_e) {\n return Promise.resolve(source)\n }\n}\n","import ts from 'typescript'\n\nconst { factory } = ts\n\nexport type PrintOptions = {\n source?: string\n baseName?: string\n scriptKind?: ts.ScriptKind\n}\n\n/*\n Escaped new lines in code with block comments so they can be restored by {@link restoreNewLines}\n /\nconst escapeNewLines = (code: string) => code.replace(/\\n\\n/g, '\\n/ :newline: /')\n\n/\n Reverses {@link escapeNewLines} and restores new lines\n /\nconst restoreNewLines = (code: string) => code.replace(/\\/\\ :newline: \\\\//g, '\\n')\n\n/\n Convert AST TypeScript/TSX nodes to a string based on the TypeScript printer.\n * Ensures consistent output across environments.\n * Also works as a formatter when `source` is provided without `elements`.\n */\nexport function print(elements: Array<ts.Node> = [], { source = '', baseName = 'print.tsx', scriptKind = ts.ScriptKind.TSX }: PrintOptions = {}): string {\n const sourceFile = ts.createSourceFile(baseName, escapeNewLines(source), ts.ScriptTarget.ES2022, true, scriptKind)\n\n const printer = ts.createPrinter({\n omitTrailingSemicolon: true,\n newLine: ts.NewLineKind.LineFeed,\n removeComments: false,\n noEmitHelpers: true,\n })\n\n let output: string\n\n if (elements.length > 0) {\n // Print only provided nodes\n const nodes = elements.filter(Boolean).sort((a, b) => (a.pos ?? 0) - (b.pos ?? 0))\n output = printer.printList(ts.ListFormat.MultiLine, factory.createNodeArray(nodes), sourceFile)\n } else {\n // Format the whole file\n output = printer.printFile(sourceFile)\n }\n\n return restoreNewLines(output).replace(/\\r\\n/g, '\\n')\n}\n"],"mappings":";;;;;;AAIA,MAAMA,gBAAyB;CAC7B,UAAU;CACV,YAAY;CACZ,QAAQ;CACR,aAAa;CACb,MAAM;CACN,iBAAiB;CACjB,WAAW;CACX,SAAS,CAAC;;AAEZ,SAAgB,OAAO,QAAkC;AACvD,KAAI,CAAC,OACH,QAAO,QAAQ,QAAQ;AAGzB,KAAI;AACF,SAAOC,SAAe,QAAQ;UACvB,IAAI;AACX,SAAO,QAAQ,QAAQ;;;;;;ACpB3B,MAAM,EAAE,YAAY;;;;AAWpB,MAAM,kBAAkB,SAAiB,KAAK,QAAQ,SAAS;;;;AAK/D,MAAM,mBAAmB,SAAiB,KAAK,QAAQ,wBAAwB;;;;;;AAO/E,SAAgB,MAAM,WAA2B,IAAI,EAAE,SAAS,IAAI,WAAW,aAAa,aAAa,GAAG,WAAW,QAAsB,IAAY;CACvJ,MAAM,aAAa,GAAG,iBAAiB,UAAU,eAAe,SAAS,GAAG,aAAa,QAAQ,MAAM;CAEvG,MAAM,UAAU,GAAG,cAAc;EAC/B,uBAAuB;EACvB,SAAS,GAAG,YAAY;EACxB,gBAAgB;EAChB,eAAe;;CAGjB,IAAIC;AAEJ,KAAI,SAAS,SAAS,GAAG;EAEvB,MAAM,QAAQ,SAAS,OAAO,SAAS,MAAM,GAAG,OAAO,EAAE,OAAO,MAAM,EAAE,OAAO;AAC/E,WAAS,QAAQ,UAAU,GAAG,WAAW,WAAW,QAAQ,gBAAgB,QAAQ;OAGpF,UAAS,QAAQ,UAAU;AAG7B,QAAO,gBAAgB,QAAQ,QAAQ,SAAS"}

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/parser-ts",
-  "version": "3.18.0",
+  "version": "3.18.2",
   "description": "TypeScript parsing and manipulation utilities for Kubb, enabling code generation with proper TypeScript syntax and formatting.",
   "keywords": [
     "typescript",
@@ -49,12 +49,13 @@
     "!/**/__tests__/**"
   ],
   "dependencies": {
+    "prettier": "^3.6.2",
     "remeda": "^2.30.0",
     "typescript": "5.9.2"
   },
   "devDependencies": {
-    "tsdown": "^0.14.1",
-    "@kubb/config-ts": "3.18.0"
+    "tsdown": "^0.14.2",
+    "@kubb/config-ts": "3.18.2"
   },
   "engines": {
     "node": ">=20"

package/src/format.ts ADDED Viewed

@@ -0,0 +1,25 @@
+import type { Options } from 'prettier'
+import { format as prettierFormat } from 'prettier'
+import pluginTypescript from 'prettier/plugins/typescript'
+const formatOptions: Options = {
+  tabWidth: 2,
+  printWidth: 160,
+  parser: 'typescript',
+  singleQuote: true,
+  semi: false,
+  bracketSameLine: false,
+  endOfLine: 'auto',
+  plugins: [pluginTypescript],
+}
+export function format(source?: string): Promise<string> {
+  if (!source) {
+    return Promise.resolve('')
+  }
+  try {
+    return prettierFormat(source, formatOptions)
+  } catch (_e) {
+    return Promise.resolve(source)
+  }
+}

package/src/index.ts CHANGED Viewed

@@ -1,2 +1,3 @@
 export * as factory from './factory.ts'
+export { format } from './format.ts'
 export { print } from './print.ts'

package/src/print.ts CHANGED Viewed

@@ -21,9 +21,10 @@ const restoreNewLines = (code: string) => code.replace(/\/\* :newline: \*\//g, '
 /**
  * Convert AST TypeScript/TSX nodes to a string based on the TypeScript printer.
  * Ensures consistent output across environments.
+ * Also works as a formatter when `source` is provided without `elements`.
  */
-export function print(elements: Array<ts.Node>, { source = '', baseName = 'print.tsx', scriptKind = ts.ScriptKind.TSX }: PrintOptions = {}): string {
-  const sourceFile = ts.createSourceFile(baseName, escapeNewLines(source), ts.ScriptTarget.ES2022, false, scriptKind)
+export function print(elements: Array<ts.Node> = [], { source = '', baseName = 'print.tsx', scriptKind = ts.ScriptKind.TSX }: PrintOptions = {}): string {
+  const sourceFile = ts.createSourceFile(baseName, escapeNewLines(source), ts.ScriptTarget.ES2022, true, scriptKind)
   const printer = ts.createPrinter({
     omitTrailingSemicolon: true,
@@ -32,8 +33,16 @@ export function print(elements: Array<ts.Node>, { source = '', baseName = 'print
     noEmitHelpers: true,
   })
-  const nodes = (Array.isArray(elements) ? elements : [elements]).filter(Boolean).sort((a, b) => (a.pos ?? 0) - (b.pos ?? 0))
-  const output = printer.printList(ts.ListFormat.MultiLine, factory.createNodeArray(nodes), sourceFile)
+  let output: string
+  if (elements.length > 0) {
+    // Print only provided nodes
+    const nodes = elements.filter(Boolean).sort((a, b) => (a.pos ?? 0) - (b.pos ?? 0))
+    output = printer.printList(ts.ListFormat.MultiLine, factory.createNodeArray(nodes), sourceFile)
+  } else {
+    // Format the whole file
+    output = printer.printFile(sourceFile)
+  }
   return restoreNewLines(output).replace(/\r\n/g, '\n')
 }