@kubb/parser-ts 3.17.1 → 3.18.1

package/dist/{factory-DeJMlphM.cjs → factory-BSd2OjFQ.cjs}

@@ -27,8 +27,8 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 }) : target, mod));
 
 //#endregion
-const typescript = __toESM(require("typescript"));
 const remeda = __toESM(require("remeda"));
+const typescript = __toESM(require("typescript"));
 
 //#region src/factory.ts
 var factory_exports = {};
@@ -494,4 +494,4 @@ Object.defineProperty(exports, 'syntaxKind', {
     return syntaxKind;
   }
 });
-//# sourceMappingURL=factory-DeJMlphM.cjs.map
+//# sourceMappingURL=factory-BSd2OjFQ.cjs.map

package/dist/{factory-DeJMlphM.cjs.map → factory-BSd2OjFQ.cjs.map}

@@ -1 +1 @@
-{"version":3,"file":"factory-DeJMlphM.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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"}
+{"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-CTKjALU5.js → factory-CDjjCkNo.js}

@@ -1,6 +1,6 @@
 import { __export } from "./chunk-Cl8Af3a2.js";
-import ts from "typescript";
 import { isNumber } from "remeda";
+import ts from "typescript";
 
 //#region src/factory.ts
 var factory_exports = {};
@@ -251,4 +251,4 @@ const createFalse = factory.createFalse;
 
 //#endregion
 export { appendJSDocToNode, createArrayDeclaration, createArrayTypeNode, createEnumDeclaration, createExportDeclaration, createFalse, createIdentifier, createImportDeclaration, createIndexSignature, createInterfaceDeclaration, createIntersectionDeclaration, createJSDoc, createLiteralTypeNode, createNamespaceDeclaration, createNull, createNumericLiteral, createOmitDeclaration, createOptionalTypeNode, createParameterSignature, createPropertySignature, createQuestionToken, createRestTypeNode, createStringLiteral, createTrue, createTupleDeclaration, createTupleTypeNode, createTypeAliasDeclaration, createTypeDeclaration, createTypeLiteralNode, createTypeReferenceNode, createUnionDeclaration, factory_exports, keywordTypeNodes, modifiers, syntaxKind };
-//# sourceMappingURL=factory-CTKjALU5.js.map
+//# sourceMappingURL=factory-CDjjCkNo.js.map

package/dist/{factory-CTKjALU5.js.map → factory-CDjjCkNo.js.map}

@@ -1 +1 @@
-{"version":3,"file":"factory-CTKjALU5.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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"}
+{"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/factory.cjs

@@ -1,4 +1,4 @@
-const require_factory = require('./factory-DeJMlphM.cjs');
+const require_factory = require('./factory-BSd2OjFQ.cjs');
 
 exports.appendJSDocToNode = require_factory.appendJSDocToNode;
 exports.createArrayDeclaration = require_factory.createArrayDeclaration;

package/dist/factory.js

@@ -1,3 +1,3 @@
-import { appendJSDocToNode, createArrayDeclaration, createArrayTypeNode, createEnumDeclaration, createExportDeclaration, createFalse, createIdentifier, createImportDeclaration, createIndexSignature, createInterfaceDeclaration, createIntersectionDeclaration, createJSDoc, createLiteralTypeNode, createNamespaceDeclaration, createNull, createNumericLiteral, createOmitDeclaration, createOptionalTypeNode, createParameterSignature, createPropertySignature, createQuestionToken, createRestTypeNode, createStringLiteral, createTrue, createTupleDeclaration, createTupleTypeNode, createTypeAliasDeclaration, createTypeDeclaration, createTypeLiteralNode, createTypeReferenceNode, createUnionDeclaration, keywordTypeNodes, modifiers, syntaxKind } from "./factory-CTKjALU5.js";
+import { appendJSDocToNode, createArrayDeclaration, createArrayTypeNode, createEnumDeclaration, createExportDeclaration, createFalse, createIdentifier, createImportDeclaration, createIndexSignature, createInterfaceDeclaration, createIntersectionDeclaration, createJSDoc, createLiteralTypeNode, createNamespaceDeclaration, createNull, createNumericLiteral, createOmitDeclaration, createOptionalTypeNode, createParameterSignature, createPropertySignature, createQuestionToken, createRestTypeNode, createStringLiteral, createTrue, createTupleDeclaration, createTupleTypeNode, createTypeAliasDeclaration, createTypeDeclaration, createTypeLiteralNode, createTypeReferenceNode, createUnionDeclaration, keywordTypeNodes, modifiers, syntaxKind } from "./factory-CDjjCkNo.js";
 
 export { appendJSDocToNode, createArrayDeclaration, createArrayTypeNode, createEnumDeclaration, createExportDeclaration, createFalse, createIdentifier, createImportDeclaration, createIndexSignature, createInterfaceDeclaration, createIntersectionDeclaration, createJSDoc, createLiteralTypeNode, createNamespaceDeclaration, createNull, createNumericLiteral, createOmitDeclaration, createOptionalTypeNode, createParameterSignature, createPropertySignature, createQuestionToken, createRestTypeNode, createStringLiteral, createTrue, createTupleDeclaration, createTupleTypeNode, createTypeAliasDeclaration, createTypeDeclaration, createTypeLiteralNode, createTypeReferenceNode, createUnionDeclaration, keywordTypeNodes, modifiers, syntaxKind };

package/dist/index.cjs

@@ -1,59 +1,60 @@
-const require_factory = require('./factory-DeJMlphM.cjs');
+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;
 /**
 * Escaped new lines in code with block comments so they can be restored by {@link restoreNewLines}
-* @param code The code to escape new lines in
-* @returns The same code but with new lines escaped using block comments
 */
 const escapeNewLines = (code) => code.replace(/\n\n/g, "\n/* :newline: */");
 /**
 * Reverses {@link escapeNewLines} and restores new lines
-* @param code The code with escaped new lines
-* @returns The same code with new lines restored
 */
 const restoreNewLines = (code) => code.replace(/\/\* :newline: \*\//g, "\n");
 /**
-* Convert AST TypeScript nodes to a string based on the TypeScript printer.
+* 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.ts", removeComments, noEmitHelpers, newLine = typescript.default.NewLineKind.LineFeed, scriptKind = typescript.default.ScriptKind.TS } = {}) {
-	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,
-		removeComments,
-		noEmitHelpers
+		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");
 }
 
-//#endregion
-//#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]
-};
-/**
-* Format the generated code based on Prettier
-*/
-async function format(source) {
-	if (!source) return "";
-	return (0, prettier.format)(source, formatOptions);
-}
-
 //#endregion
 Object.defineProperty(exports, 'factory', {
   enumerable: true,

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","names":["ts","formatOptions: Options","pluginTypescript"],"sources":["../src/print.ts","../src/format.ts"],"sourcesContent":["import ts from 'typescript'\n\nimport type { PrinterOptions } from 'typescript'\n\nconst { factory } = ts\n\nexport type PrintOptions = {\n  source?: string\n  baseName?: string\n  scriptKind?: ts.ScriptKind\n} & PrinterOptions\n\n/**\n * Escaped new lines in code with block comments so they can be restored by {@link restoreNewLines}\n * @param code The code to escape new lines in\n * @returns The same code but with new lines escaped using block comments\n */\nconst escapeNewLines = (code: string) => code.replace(/\\n\\n/g, '\\n/* :newline: */')\n\n/**\n * Reverses {@link escapeNewLines} and restores new lines\n * @param code The code with escaped new lines\n * @returns The same code with new lines restored\n */\nconst restoreNewLines = (code: string) => code.replace(/\\/\\* :newline: \\*\\//g, '\\n')\n\n/**\n * Convert AST TypeScript nodes to a string based on the TypeScript printer.\n * Ensures consistent output across environments.\n */\nexport function print(\n  elements: Array<ts.Node>,\n  { source = '', baseName = 'print.ts', removeComments, noEmitHelpers, newLine = ts.NewLineKind.LineFeed, scriptKind = ts.ScriptKind.TS }: PrintOptions = {},\n): 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,\n    removeComments,\n    noEmitHelpers,\n  })\n  // make sure that the nodes have the same order on every machine\n  const nodes = (Array.isArray(elements) ? elements : [elements]).filter(Boolean).sort((a, b) => (a.pos ?? 0) - (b.pos ?? 0))\n\n  const output = printer.printList(ts.ListFormat.MultiLine, factory.createNodeArray(nodes), sourceFile)\n\n  return restoreNewLines(output).replace(/\\r\\n/g, '\\n')\n}\n","import { format as prettierFormat } from 'prettier'\nimport pluginTypescript from 'prettier/plugins/typescript'\n\nimport type { Options } from 'prettier'\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}\n\n/**\n * Format the generated code based on Prettier\n */\nexport async function format(source: string) {\n  // do some basic linting with the ts compiler\n  if (!source) {\n    return ''\n  }\n\n  return prettierFormat(source, formatOptions)\n}\n"],"mappings":";;;;;;AAIA,MAAM,EAAE,SAAS,GAAGA;;;;;;AAapB,MAAM,kBAAkB,SAAiB,KAAK,QAAQ,SAAS;;;;;;AAO/D,MAAM,mBAAmB,SAAiB,KAAK,QAAQ,wBAAwB;;;;;AAM/E,SAAgB,MACd,UACA,EAAE,SAAS,IAAI,WAAW,YAAY,gBAAgB,eAAe,UAAUA,mBAAG,YAAY,UAAU,aAAaA,mBAAG,WAAW,IAAkB,GAAG,EAAE,EAClJ;CACR,MAAM,aAAaA,mBAAG,iBAAiB,UAAU,eAAe,SAASA,mBAAG,aAAa,QAAQ,OAAO;CAExG,MAAM,UAAUA,mBAAG,cAAc;EAC/B,uBAAuB;EACvB;EACA;EACA;EACD;CAED,MAAM,SAAS,MAAM,QAAQ,YAAY,WAAW,CAAC,SAAS,EAAE,OAAO,SAAS,MAAM,GAAG,OAAO,EAAE,OAAO,MAAM,EAAE,OAAO;CAExH,MAAM,SAAS,QAAQ,UAAUA,mBAAG,WAAW,WAAW,QAAQ,gBAAgB,QAAQ;AAE1F,QAAO,gBAAgB,QAAQ,QAAQ,SAAS;AACjD;;;;AC3CD,MAAMC,gBAAyB;CAC7B,UAAU;CACV,YAAY;CACZ,QAAQ;CACR,aAAa;CACb,MAAM;CACN,iBAAiB;CACjB,WAAW;CACX,SAAS,CAACC,oCAAiB;CAC5B;;;;AAKD,eAAsB,OAAO,QAAgB;AAE3C,KAAI,CAAC,OACH,QAAO;AAGT,6BAAsB,QAAQ;AAC/B"}
+{"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,oCAAiB;CAC5B;AACD,SAAgB,OAAO,QAAkC;AACvD,KAAI,CAAC,OACH,QAAO,QAAQ,QAAQ;AAGzB,KAAI;AACF,8BAAsB,QAAQ;CAC/B,SAAQ,IAAI;AACX,SAAO,QAAQ,QAAQ;CACxB;AACF;;;;ACtBD,MAAM,EAAE,SAAS,GAAGC;;;;AAWpB,MAAM,kBAAkB,SAAiB,KAAK,QAAQ,SAAS;;;;AAK/D,MAAM,mBAAmB,SAAiB,KAAK,QAAQ,wBAAwB;;;;;;AAO/E,SAAgB,MAAM,WAA2B,EAAE,EAAE,EAAE,SAAS,IAAI,WAAW,aAAa,aAAaA,mBAAG,WAAW,KAAmB,GAAG,EAAE,EAAU;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;EAChB;CAED,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;CACrF,MAEC,UAAS,QAAQ,UAAU;AAG7B,QAAO,gBAAgB,QAAQ,QAAQ,SAAS;AACjD"}

package/dist/index.d.cts

@@ -1,30 +1,25 @@
 import { factory_d_exports } from "./factory-_F-JTqnG.cjs";
-import ts, { PrinterOptions } from "typescript";
+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;
   baseName?: string;
   scriptKind?: ts.ScriptKind;
-} & PrinterOptions;
+};
 /**
- * Convert AST TypeScript nodes to a string based on the TypeScript printer.
+ * 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,
-  removeComments,
-  noEmitHelpers,
-  newLine,
   scriptKind
 }?: PrintOptions): string;
 //#endregion
-//#region src/format.d.ts
-/**
- * Format the generated code based on Prettier
- */
-declare function format(source: string): Promise<string>;
-//#endregion
 export { factory_d_exports as factory, format, print };
 //# sourceMappingURL=index.d.cts.map

package/dist/index.d.ts

@@ -1,30 +1,25 @@
 import { factory_d_exports } from "./factory-CUjjpSgy.js";
-import ts, { PrinterOptions } from "typescript";
+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;
   baseName?: string;
   scriptKind?: ts.ScriptKind;
-} & PrinterOptions;
+};
 /**
- * Convert AST TypeScript nodes to a string based on the TypeScript printer.
+ * 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,
-  removeComments,
-  noEmitHelpers,
-  newLine,
   scriptKind
 }?: PrintOptions): string;
 //#endregion
-//#region src/format.d.ts
-/**
- * Format the generated code based on Prettier
- */
-declare function format(source: string): Promise<string>;
-//#endregion
 export { factory_d_exports as factory, format, print };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,59 +1,60 @@
-import { factory_exports } from "./factory-CTKjALU5.js";
+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;
 /**
 * Escaped new lines in code with block comments so they can be restored by {@link restoreNewLines}
-* @param code The code to escape new lines in
-* @returns The same code but with new lines escaped using block comments
 */
 const escapeNewLines = (code) => code.replace(/\n\n/g, "\n/* :newline: */");
 /**
 * Reverses {@link escapeNewLines} and restores new lines
-* @param code The code with escaped new lines
-* @returns The same code with new lines restored
 */
 const restoreNewLines = (code) => code.replace(/\/\* :newline: \*\//g, "\n");
 /**
-* Convert AST TypeScript nodes to a string based on the TypeScript printer.
+* 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.ts", removeComments, noEmitHelpers, newLine = ts.NewLineKind.LineFeed, scriptKind = ts.ScriptKind.TS } = {}) {
-	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,
-		removeComments,
-		noEmitHelpers
+		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
-//#region src/format.ts
-const formatOptions = {
-	tabWidth: 2,
-	printWidth: 160,
-	parser: "typescript",
-	singleQuote: true,
-	semi: false,
-	bracketSameLine: false,
-	endOfLine: "auto",
-	plugins: [pluginTypescript]
-};
-/**
-* Format the generated code based on Prettier
-*/
-async function format(source) {
-	if (!source) return "";
-	return format$1(source, formatOptions);
-}
-
 //#endregion
 export { factory_exports as factory, format, print };
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["formatOptions: Options","prettierFormat"],"sources":["../src/print.ts","../src/format.ts"],"sourcesContent":["import ts from 'typescript'\n\nimport type { PrinterOptions } from 'typescript'\n\nconst { factory } = ts\n\nexport type PrintOptions = {\n  source?: string\n  baseName?: string\n  scriptKind?: ts.ScriptKind\n} & PrinterOptions\n\n/**\n * Escaped new lines in code with block comments so they can be restored by {@link restoreNewLines}\n * @param code The code to escape new lines in\n * @returns The same code but with new lines escaped using block comments\n */\nconst escapeNewLines = (code: string) => code.replace(/\\n\\n/g, '\\n/* :newline: */')\n\n/**\n * Reverses {@link escapeNewLines} and restores new lines\n * @param code The code with escaped new lines\n * @returns The same code with new lines restored\n */\nconst restoreNewLines = (code: string) => code.replace(/\\/\\* :newline: \\*\\//g, '\\n')\n\n/**\n * Convert AST TypeScript nodes to a string based on the TypeScript printer.\n * Ensures consistent output across environments.\n */\nexport function print(\n  elements: Array<ts.Node>,\n  { source = '', baseName = 'print.ts', removeComments, noEmitHelpers, newLine = ts.NewLineKind.LineFeed, scriptKind = ts.ScriptKind.TS }: PrintOptions = {},\n): 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,\n    removeComments,\n    noEmitHelpers,\n  })\n  // make sure that the nodes have the same order on every machine\n  const nodes = (Array.isArray(elements) ? elements : [elements]).filter(Boolean).sort((a, b) => (a.pos ?? 0) - (b.pos ?? 0))\n\n  const output = printer.printList(ts.ListFormat.MultiLine, factory.createNodeArray(nodes), sourceFile)\n\n  return restoreNewLines(output).replace(/\\r\\n/g, '\\n')\n}\n","import { format as prettierFormat } from 'prettier'\nimport pluginTypescript from 'prettier/plugins/typescript'\n\nimport type { Options } from 'prettier'\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}\n\n/**\n * Format the generated code based on Prettier\n */\nexport async function format(source: string) {\n  // do some basic linting with the ts compiler\n  if (!source) {\n    return ''\n  }\n\n  return prettierFormat(source, formatOptions)\n}\n"],"mappings":";;;;;;AAIA,MAAM,EAAE,SAAS,GAAG;;;;;;AAapB,MAAM,kBAAkB,SAAiB,KAAK,QAAQ,SAAS;;;;;;AAO/D,MAAM,mBAAmB,SAAiB,KAAK,QAAQ,wBAAwB;;;;;AAM/E,SAAgB,MACd,UACA,EAAE,SAAS,IAAI,WAAW,YAAY,gBAAgB,eAAe,UAAU,GAAG,YAAY,UAAU,aAAa,GAAG,WAAW,IAAkB,GAAG,EAAE,EAClJ;CACR,MAAM,aAAa,GAAG,iBAAiB,UAAU,eAAe,SAAS,GAAG,aAAa,QAAQ,OAAO;CAExG,MAAM,UAAU,GAAG,cAAc;EAC/B,uBAAuB;EACvB;EACA;EACA;EACD;CAED,MAAM,SAAS,MAAM,QAAQ,YAAY,WAAW,CAAC,SAAS,EAAE,OAAO,SAAS,MAAM,GAAG,OAAO,EAAE,OAAO,MAAM,EAAE,OAAO;CAExH,MAAM,SAAS,QAAQ,UAAU,GAAG,WAAW,WAAW,QAAQ,gBAAgB,QAAQ;AAE1F,QAAO,gBAAgB,QAAQ,QAAQ,SAAS;AACjD;;;;AC3CD,MAAMA,gBAAyB;CAC7B,UAAU;CACV,YAAY;CACZ,QAAQ;CACR,aAAa;CACb,MAAM;CACN,iBAAiB;CACjB,WAAW;CACX,SAAS,CAAC,iBAAiB;CAC5B;;;;AAKD,eAAsB,OAAO,QAAgB;AAE3C,KAAI,CAAC,OACH,QAAO;AAGT,QAAOC,SAAe,QAAQ;AAC/B"}
+{"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,iBAAiB;CAC5B;AACD,SAAgB,OAAO,QAAkC;AACvD,KAAI,CAAC,OACH,QAAO,QAAQ,QAAQ;AAGzB,KAAI;AACF,SAAOC,SAAe,QAAQ;CAC/B,SAAQ,IAAI;AACX,SAAO,QAAQ,QAAQ;CACxB;AACF;;;;ACtBD,MAAM,EAAE,SAAS,GAAG;;;;AAWpB,MAAM,kBAAkB,SAAiB,KAAK,QAAQ,SAAS;;;;AAK/D,MAAM,mBAAmB,SAAiB,KAAK,QAAQ,wBAAwB;;;;;;AAO/E,SAAgB,MAAM,WAA2B,EAAE,EAAE,EAAE,SAAS,IAAI,WAAW,aAAa,aAAa,GAAG,WAAW,KAAmB,GAAG,EAAE,EAAU;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;EAChB;CAED,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;CACrF,MAEC,UAAS,QAAQ,UAAU;AAG7B,QAAO,gBAAgB,QAAQ,QAAQ,SAAS;AACjD"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/parser-ts",
-  "version": "3.17.1",
+  "version": "3.18.1",
   "description": "TypeScript parsing and manipulation utilities for Kubb, enabling code generation with proper TypeScript syntax and formatting.",
   "keywords": [
     "typescript",
@@ -55,7 +55,7 @@
   },
   "devDependencies": {
     "tsdown": "^0.14.1",
-    "@kubb/config-ts": "3.17.1"
+    "@kubb/config-ts": "3.18.1"
   },
   "engines": {
     "node": ">=20"

package/src/format.ts

@@ -1,8 +1,7 @@
+import type { Options } from 'prettier'
 import { format as prettierFormat } from 'prettier'
 import pluginTypescript from 'prettier/plugins/typescript'
 
-import type { Options } from 'prettier'
-
 const formatOptions: Options = {
   tabWidth: 2,
   printWidth: 160,
@@ -13,15 +12,14 @@ const formatOptions: Options = {
   endOfLine: 'auto',
   plugins: [pluginTypescript],
 }
-
-/**
- * Format the generated code based on Prettier
- */
-export async function format(source: string) {
-  // do some basic linting with the ts compiler
+export function format(source?: string): Promise<string> {
   if (!source) {
-    return ''
+    return Promise.resolve('')
   }
 
-  return prettierFormat(source, formatOptions)
+  try {
+    return prettierFormat(source, formatOptions)
+  } catch (_e) {
+    return Promise.resolve(source)
+  }
 }

package/src/index.ts

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

package/src/print.ts

@@ -1,49 +1,48 @@
 import ts from 'typescript'
 
-import type { PrinterOptions } from 'typescript'
-
 const { factory } = ts
 
 export type PrintOptions = {
   source?: string
   baseName?: string
   scriptKind?: ts.ScriptKind
-} & PrinterOptions
+}
 
 /**
  * Escaped new lines in code with block comments so they can be restored by {@link restoreNewLines}
- * @param code The code to escape new lines in
- * @returns The same code but with new lines escaped using block comments
  */
 const escapeNewLines = (code: string) => code.replace(/\n\n/g, '\n/* :newline: */')
 
 /**
  * Reverses {@link escapeNewLines} and restores new lines
- * @param code The code with escaped new lines
- * @returns The same code with new lines restored
  */
 const restoreNewLines = (code: string) => code.replace(/\/\* :newline: \*\//g, '\n')
 
 /**
- * Convert AST TypeScript nodes to a string based on the TypeScript printer.
+ * 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.ts', removeComments, noEmitHelpers, newLine = ts.NewLineKind.LineFeed, scriptKind = ts.ScriptKind.TS }: 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,
-    newLine,
-    removeComments,
-    noEmitHelpers,
+    newLine: ts.NewLineKind.LineFeed,
+    removeComments: false,
+    noEmitHelpers: true,
   })
-  // make sure that the nodes have the same order on every machine
-  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')
 }