kea-typegen 1.2.2 → 1.4.2

package/src/print/print.ts

@@ -1,4 +1,16 @@
-import * as ts from 'typescript'
+import {
+    createPrinter,
+    createSourceFile,
+    EmitHint,
+    factory,
+    Node,
+    NewLineKind,
+    Program,
+    ScriptKind,
+    ScriptTarget,
+    SyntaxKind,
+    TypeParameterDeclaration,
+} from 'typescript'
 import * as fs from 'fs'
 import * as path from 'path'
 import * as prettier from 'prettier'
@@ -23,7 +35,7 @@ import { printReducerOptions } from './printReducerOptions'
 import { printEvents } from './printEvents'
 import { printSharedListeners } from './printSharedListeners'
 import { printListeners } from './printListeners'
-import { writeLogicTypeImports } from '../import/writeLogicTypeImports'
+import { writePaths, writeTypeImports } from '../write/write'
 import { printInternalExtraInput } from './printInternalExtraInput'
 
 export function runThroughPrettier(sourceText: string, filePath: string): string {
@@ -43,10 +55,10 @@ export function runThroughPrettier(sourceText: string, filePath: string): string
 
 // returns files to write
 export function printToFiles(
-    program: ts.Program,
+    program: Program,
     appOptions: AppOptions,
     parsedLogics: ParsedLogic[],
-): { filesToWrite: number; writtenFiles: number; importsToModify: number } {
+): { filesToWrite: number; writtenFiles: number; filesToModify: number } {
     const { log } = appOptions
 
     const groupedByFile: Record<string, ParsedLogic[]> = {}
@@ -56,13 +68,36 @@ export function printToFiles(
         }
         groupedByFile[parsedLogic.fileName].push(parsedLogic)
 
-        // create the ts.Nodes and gather referenced types
+        // create the Nodes and gather referenced types
         printLogicType(parsedLogic, appOptions)
     }
 
+    // Automatically ignore imports from "node_modules/@types/node", if {types: ["node"]} in tsconfig.json
+    const defaultGlobalTypePaths = appOptions.importGlobalTypes
+        ? []
+        : (program.getCompilerOptions().types || []).map(
+              (type) =>
+                  path.join(
+                      appOptions.packageJsonPath ? path.dirname(appOptions.packageJsonPath) : appOptions.rootPath,
+                      'node_modules',
+                      '@types',
+                      type,
+                  ) + path.sep,
+          )
+
+    // Manually ignored
+    const ignoredImportPaths = (appOptions.ignoreImportPaths || []).map((importPath) =>
+        path.resolve(appOptions.rootPath, importPath),
+    )
+
+    const doNotImportFromPaths = [...defaultGlobalTypePaths, ...ignoredImportPaths]
+
+    const shouldIgnore = (absolutePath: string) =>
+        !!doNotImportFromPaths.find((badPath) => absolutePath.startsWith(badPath))
+
     let writtenFiles = 0
     let filesToWrite = 0
-    let importsToModify = 0
+    let filesToModify = 0
 
     Object.entries(groupedByFile).forEach(([fileName, parsedLogics]) => {
         const typeFileName = parsedLogics[0].typeFileName
@@ -88,8 +123,14 @@ export function printToFiles(
                 if (!relativePath.startsWith('.')) {
                     relativePath = `./${relativePath}`
                 }
-                return `import { ${[...list].sort().join(', ')} } from '${relativePath}'`
+                return {
+                    list: [...list].sort(),
+                    fullPath: file,
+                    relativePath,
+                }
             })
+            .filter(({ fullPath }) => !shouldIgnore(fullPath))
+            .map(({ list, relativePath }) => `import { ${list.join(', ')} } from '${relativePath}'`)
             .join('\n')
 
         const finalOutput = [
@@ -129,19 +170,19 @@ export function printToFiles(
             }
         }
 
+        const parsedLogicNeedsTypeImport = (pl: ParsedLogic) =>
+            // reload if logic type not imported
+            (pl.logicTypeImported === false ||
+                // reload if don't have the right types in arguments
+                pl.logicTypeArguments.join(', ') !== [...pl.typeReferencesInLogicInput].sort().join(', ')) &&
+            pl.fileName.match(/\.tsx?$/)
+
         // write the type into the logic itself
-        const logicsNeedingImports = parsedLogics.filter(
-            (pl) =>
-                // reload if logic type not imported
-                (pl.logicTypeImported === false ||
-                    // reload if don't have the right types in arguments
-                    pl.logicTypeArguments.join(', ') !== [...pl.typeReferencesInLogicInput].sort().join(', ')) &&
-                pl.fileName.match(/\.tsx?$/),
-        )
+        const logicsNeedingImports = parsedLogics.filter(parsedLogicNeedsTypeImport)
         if (logicsNeedingImports.length > 0) {
             if (appOptions.write && !appOptions.noImport) {
-                writeLogicTypeImports(appOptions, program, fileName, logicsNeedingImports, parsedLogics)
-                importsToModify = logicsNeedingImports.length
+                writeTypeImports(appOptions, program, fileName, logicsNeedingImports, parsedLogics)
+                filesToModify += logicsNeedingImports.length
             } else {
                 log(
                     `❌ Will not write ${logicsNeedingImports.length} logic type import${
@@ -150,28 +191,43 @@ export function printToFiles(
                 )
             }
         }
+
+        const parsedLogicNeedsPath = appOptions.writePaths ? (pl: ParsedLogic) => !pl.hasPathInLogic : () => false
+        const logicsNeedingPaths = parsedLogics.filter(parsedLogicNeedsPath)
+        if (logicsNeedingPaths.length > 0) {
+            if (appOptions.write && !appOptions.noImport) {
+                writePaths(appOptions, program, fileName, logicsNeedingPaths)
+                filesToModify += logicsNeedingPaths.length
+            } else {
+                log(
+                    `❌ Will not write ${logicsNeedingPaths.length} logic path${
+                        logicsNeedingPaths.length === 1 ? '' : 's'
+                    }`,
+                )
+            }
+        }
     })
 
-    if (writtenFiles === 0 && importsToModify === 0) {
+    if (writtenFiles === 0 && filesToModify === 0) {
         if (appOptions.write) {
             log(`💚 ${parsedLogics.length} logic type${parsedLogics.length === 1 ? '' : 's'} up to date!`)
             log('')
-        } else if (filesToWrite > 0 || importsToModify > 0) {
+        } else if (filesToWrite > 0 || filesToModify > 0) {
             log(
-                `🚨 Run "kea-typegen write" to save ${filesToWrite + importsToModify} file${
+                `🚨 Run "kea-typegen write" to save ${filesToWrite + filesToModify} file${
                     filesToWrite === 1 ? '' : 's'
                 } to disk`,
             )
         }
     }
 
-    return { filesToWrite, writtenFiles, importsToModify }
+    return { filesToWrite, writtenFiles, filesToModify }
 }
 
-export function nodeToString(node: ts.Node): string {
-    const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed })
-    const sourceFile = ts.createSourceFile('logic.ts', '', ts.ScriptTarget.Latest, false, ts.ScriptKind.TS)
-    return printer.printNode(ts.EmitHint.Unspecified, node, sourceFile)
+export function nodeToString(node: Node): string {
+    const printer = createPrinter({ newLine: NewLineKind.LineFeed })
+    const sourceFile = createSourceFile('logic.ts', '', ScriptTarget.Latest, false, ScriptKind.TS)
+    return printer.printNode(EmitHint.Unspecified, node, sourceFile)
 }
 
 export function parsedLogicToTypeString(parsedLogic: ParsedLogic, appOptions?: AppOptions): string {
@@ -179,15 +235,15 @@ export function parsedLogicToTypeString(parsedLogic: ParsedLogic, appOptions?: A
     return nodeToString(parsedLogic.interfaceDeclaration)
 }
 
-export function getLogicTypeArguments(parsedLogic: ParsedLogic): ts.TypeParameterDeclaration[] {
+export function getLogicTypeArguments(parsedLogic: ParsedLogic): TypeParameterDeclaration[] {
     return [...parsedLogic.typeReferencesInLogicInput]
         .sort()
-        .map((text) => ts.createTypeParameterDeclaration(ts.createIdentifier(text), undefined))
+        .map((text) => factory.createTypeParameterDeclaration(factory.createIdentifier(text), undefined))
 }
 
 export function printLogicType(parsedLogic: ParsedLogic, appOptions?: AppOptions): void {
     const printProperty = (name, typeNode) =>
-        ts.createPropertySignature(undefined, ts.createIdentifier(name), undefined, typeNode, undefined)
+        factory.createPropertySignature(undefined, factory.createIdentifier(name), undefined, typeNode)
 
     const addSelectorTypeHelp = parsedLogic.selectors.filter((s) => s.functionTypes.length > 0).length > 0
 
@@ -203,9 +259,11 @@ export function printLogicType(parsedLogic: ParsedLogic, appOptions?: AppOptions
         printProperty('listeners', printListeners(parsedLogic)),
         printProperty(
             'path',
-            ts.createTupleTypeNode(parsedLogic.path.map((p) => ts.createLiteralTypeNode(ts.createStringLiteral(p)))),
+            factory.createTupleTypeNode(
+                parsedLogic.path.map((p) => factory.createLiteralTypeNode(factory.createStringLiteral(p))),
+            ),
         ),
-        printProperty('pathString', ts.createStringLiteral(parsedLogic.pathString)),
+        printProperty('pathString', factory.createStringLiteral(parsedLogic.pathString)),
         printProperty('props', printProps(parsedLogic)),
         printProperty('reducer', printReducer(parsedLogic)),
         printProperty('reducerOptions', printReducerOptions(parsedLogic)),
@@ -214,8 +272,8 @@ export function printLogicType(parsedLogic: ParsedLogic, appOptions?: AppOptions
         printProperty('selectors', printSelectors(parsedLogic)),
         printProperty('sharedListeners', printSharedListeners(parsedLogic)),
         printProperty('values', printValues(parsedLogic)),
-        printProperty('_isKea', ts.createTrue()),
-        printProperty('_isKeaWithKey', parsedLogic.keyType ? ts.createTrue() : ts.createFalse()),
+        printProperty('_isKea', factory.createTrue()),
+        printProperty('_isKeaWithKey', parsedLogic.keyType ? factory.createTrue() : factory.createFalse()),
         addSelectorTypeHelp
             ? printProperty('__keaTypeGenInternalSelectorTypes', printInternalSelectorTypes(parsedLogic))
             : null,
@@ -229,14 +287,14 @@ export function printLogicType(parsedLogic: ParsedLogic, appOptions?: AppOptions
 
     const logicTypeArguments = getLogicTypeArguments(parsedLogic)
 
-    parsedLogic.interfaceDeclaration = ts.createInterfaceDeclaration(
+    parsedLogic.interfaceDeclaration = factory.createInterfaceDeclaration(
         undefined,
-        [ts.createModifier(ts.SyntaxKind.ExportKeyword)],
-        ts.createIdentifier(`${parsedLogic.logicName}Type`),
+        [factory.createModifier(SyntaxKind.ExportKeyword)],
+        factory.createIdentifier(`${parsedLogic.logicName}Type`),
         logicTypeArguments,
         [
-            ts.createHeritageClause(ts.SyntaxKind.ExtendsKeyword, [
-                ts.createExpressionWithTypeArguments(undefined, ts.createIdentifier('Logic')),
+            factory.createHeritageClause(SyntaxKind.ExtendsKeyword, [
+                factory.createExpressionWithTypeArguments(factory.createIdentifier('Logic'), undefined),
             ]),
         ],
         logicProperties,

package/src/print/printActionCreators.ts

@@ -1,39 +1,36 @@
-import * as ts from 'typescript'
+import { factory } from 'typescript'
 import { AppOptions, ParsedLogic } from '../types'
 import { getActionTypeCreator } from '../utils'
 
 export function printActionCreators(parsedLogic: ParsedLogic, appOptions?: AppOptions) {
     const getActionType = getActionTypeCreator(parsedLogic)
 
-    return ts.createTypeLiteralNode(
+    return factory.createTypeLiteralNode(
         parsedLogic.actions.map(({ name, parameters, returnTypeNode }) => {
-            return ts.createPropertySignature(
+            return factory.createPropertySignature(
                 undefined,
-                ts.createIdentifier(name),
+                factory.createIdentifier(name),
                 undefined,
-                ts.createFunctionTypeNode(
+                factory.createFunctionTypeNode(
                     undefined,
                     parameters,
-                    ts.createParenthesizedType(
-                        ts.createTypeLiteralNode([
-                            ts.createPropertySignature(
+                    factory.createParenthesizedType(
+                        factory.createTypeLiteralNode([
+                            factory.createPropertySignature(
                                 undefined,
-                                ts.createIdentifier('type'),
-                                undefined,
-                                ts.createLiteralTypeNode(ts.createStringLiteral(getActionType(name))),
+                                factory.createIdentifier('type'),
                                 undefined,
+                                factory.createLiteralTypeNode(factory.createStringLiteral(getActionType(name))),
                             ),
-                            ts.createPropertySignature(
+                            factory.createPropertySignature(
                                 undefined,
-                                ts.createIdentifier('payload'),
+                                factory.createIdentifier('payload'),
                                 undefined,
                                 returnTypeNode,
-                                undefined,
                             ),
                         ]),
                     ),
                 ),
-                undefined,
             )
         }),
     )

package/src/print/printActionKeys.ts

@@ -1,18 +1,17 @@
-import * as ts from 'typescript'
+import { factory } from 'typescript'
 import { AppOptions, ParsedLogic } from '../types'
 import { getActionTypeCreator } from '../utils'
 
 export function printActionKeys(parsedLogic: ParsedLogic, appOptions?: AppOptions) {
     const getActionType = getActionTypeCreator(parsedLogic)
 
-    return ts.createTypeLiteralNode(
+    return factory.createTypeLiteralNode(
         parsedLogic.actions.map(({ name, parameters, returnTypeNode }) => {
-            return ts.createPropertySignature(
+            return factory.createPropertySignature(
                 undefined,
-                ts.createStringLiteral(getActionType(name)),
-                undefined,
-                ts.createLiteralTypeNode(ts.createStringLiteral(name)),
+                factory.createStringLiteral(getActionType(name)),
                 undefined,
+                factory.createLiteralTypeNode(factory.createStringLiteral(name)),
             )
         }),
     )

package/src/print/printActionTypes.ts

@@ -1,18 +1,17 @@
-import * as ts from 'typescript'
+import { factory } from 'typescript'
 import { AppOptions, ParsedLogic } from '../types'
 import { getActionTypeCreator } from '../utils'
 
 export function printActionTypes(parsedLogic: ParsedLogic, appOptions?: AppOptions) {
     const getActionType = getActionTypeCreator(parsedLogic)
 
-    return ts.createTypeLiteralNode(
-        parsedLogic.actions.map(({ name, parameters, returnTypeNode }) => {
-            return ts.createPropertySignature(
+    return factory.createTypeLiteralNode(
+        parsedLogic.actions.map(({ name }) => {
+            return factory.createPropertySignature(
                 undefined,
-                ts.createIdentifier(name),
-                undefined,
-                ts.createLiteralTypeNode(ts.createStringLiteral(getActionType(name))),
+                factory.createIdentifier(name),
                 undefined,
+                factory.createLiteralTypeNode(factory.createStringLiteral(getActionType(name))),
             )
         }),
     )

package/src/print/printActions.ts

@@ -1,24 +1,17 @@
-import * as ts from 'typescript'
+import { factory, SyntaxKind } from 'typescript'
 import { AppOptions, ParsedLogic } from '../types'
 import { getActionTypeCreator } from '../utils'
 
 export function printActions(parsedLogic: ParsedLogic, appOptions?: AppOptions) {
     const getActionType = getActionTypeCreator(parsedLogic)
 
-    return ts.createTypeLiteralNode(
-        parsedLogic.actions.map(({ name, parameters, returnTypeNode }) => {
-            return ts.createPropertySignature(
+    return factory.createTypeLiteralNode(
+        parsedLogic.actions.map(({ name, parameters }) => {
+            return factory.createPropertySignature(
                 undefined,
-                ts.createIdentifier(name),
-                undefined,
-                ts.createFunctionTypeNode(
-                    undefined,
-                    parameters,
-                    // Please someone tell me what must I do here?
-                    // Just ts.createToken(void), as suggested by ts-ast-viewer.com doesn't work
-                    { ...ts.createToken(ts.SyntaxKind.VoidKeyword), _typeNodeBrand: true }
-                ),
+                factory.createIdentifier(name),
                 undefined,
+                factory.createFunctionTypeNode(undefined, parameters, factory.createToken(SyntaxKind.VoidKeyword)),
             )
         }),
     )

package/src/print/printConstants.ts

@@ -1,15 +1,14 @@
-import * as ts from 'typescript'
+import { factory } from 'typescript'
 import { ParsedLogic } from '../types'
 
 export function printConstants(parsedLogic: ParsedLogic) {
-    return ts.createTypeLiteralNode(
+    return factory.createTypeLiteralNode(
         parsedLogic.constants.map((constant) =>
-            ts.createPropertySignature(
+            factory.createPropertySignature(
                 undefined,
-                ts.createStringLiteral(constant),
-                undefined,
-                ts.createLiteralTypeNode(ts.createStringLiteral(constant)),
+                factory.createStringLiteral(constant),
                 undefined,
+                factory.createLiteralTypeNode(factory.createStringLiteral(constant)),
             ),
         ),
     )

package/src/print/printDefaults.ts

@@ -1,16 +1,15 @@
-import * as ts from 'typescript'
+import { factory } from 'typescript'
 import { ParsedLogic } from '../types'
-import {cleanDuplicateAnyNodes} from "../utils";
+import { cleanDuplicateAnyNodes } from '../utils'
 
 export function printDefaults(parsedLogic: ParsedLogic) {
-    return ts.createTypeLiteralNode(
+    return factory.createTypeLiteralNode(
         cleanDuplicateAnyNodes(parsedLogic.reducers).map((reducer) => {
-            return ts.createPropertySignature(
+            return factory.createPropertySignature(
                 undefined,
-                ts.createIdentifier(reducer.name),
+                factory.createIdentifier(reducer.name),
                 undefined,
                 reducer.typeNode,
-                undefined,
             )
         }),
     )

package/src/print/printEvents.ts

@@ -1,15 +1,17 @@
-import * as ts from 'typescript'
+import { factory, SyntaxKind } from 'typescript'
 import { ParsedLogic } from '../types'
 
 export function printEvents(parsedLogic: ParsedLogic) {
-    return ts.createTypeLiteralNode(
+    return factory.createTypeLiteralNode(
         Object.keys(parsedLogic.events).map((name) => {
-            return ts.createPropertySignature(
+            return factory.createPropertySignature(
                 undefined,
-                ts.createIdentifier(name),
-                undefined,
-                ts.createFunctionTypeNode(undefined, [], { ...ts.createToken(ts.SyntaxKind.VoidKeyword), _typeNodeBrand: true }),
+                factory.createIdentifier(name),
                 undefined,
+                factory.createFunctionTypeNode(undefined, [], {
+                    ...factory.createToken(SyntaxKind.VoidKeyword),
+                    _typeNodeBrand: true,
+                }),
             )
         }),
     )

package/src/print/printInternalExtraInput.ts

@@ -1,32 +1,32 @@
 import { ParsedLogic } from '../types'
-import * as ts from 'typescript'
+import { factory } from 'typescript'
 
 export function printInternalExtraInput(parsedLogic: ParsedLogic) {
-    return ts.createTypeLiteralNode(
+    return factory.createTypeLiteralNode(
         Object.entries(parsedLogic.extraInput).map(([type, { typeNode, withLogicFunction }]) => {
             if (withLogicFunction) {
                 const logicTypeArguments = [...parsedLogic.typeReferencesInLogicInput]
                     .sort()
-                    .map((text) => ts.createTypeReferenceNode(ts.createIdentifier(text), undefined))
+                    .map((text) => factory.createTypeReferenceNode(factory.createIdentifier(text), undefined))
 
-                return ts.createPropertySignature(
+                return factory.createPropertySignature(
                     undefined,
-                    ts.createStringLiteral(type),
+                    factory.createStringLiteral(type),
                     undefined,
 
-                    ts.createUnionTypeNode([
+                    factory.createUnionTypeNode([
                         typeNode,
-                        ts.createFunctionTypeNode(
+                        factory.createFunctionTypeNode(
                             undefined,
                             [
-                                ts.createParameter(
+                                factory.createParameterDeclaration(
                                     undefined,
                                     undefined,
                                     undefined,
-                                    ts.createIdentifier('logic'),
+                                    factory.createIdentifier('logic'),
                                     undefined,
-                                    ts.createTypeReferenceNode(
-                                        ts.createIdentifier(parsedLogic.logicTypeName),
+                                    factory.createTypeReferenceNode(
+                                        factory.createIdentifier(parsedLogic.logicTypeName),
                                         logicTypeArguments.length > 0 ? logicTypeArguments : undefined,
                                     ),
                                     undefined,
@@ -35,11 +35,10 @@ export function printInternalExtraInput(parsedLogic: ParsedLogic) {
                             typeNode,
                         ),
                     ]),
-                    undefined,
                 )
             }
 
-            return ts.createPropertySignature(undefined, ts.createStringLiteral(type), undefined, typeNode, undefined)
+            return factory.createPropertySignature(undefined, factory.createStringLiteral(type), undefined, typeNode)
         }),
     )
 }

package/src/print/printInternalReducerActions.ts

@@ -1,17 +1,10 @@
 import { ParsedLogic } from '../types'
-import * as ts from 'typescript'
+import { factory } from 'typescript'
 
 export function printInternalReducerActions(parsedLogic: ParsedLogic) {
-    return ts.createTypeLiteralNode(
-        Object.entries(parsedLogic.extraActions)
-            .map(([type, typeNode]) => {
-                return ts.createPropertySignature(
-                    undefined,
-                    ts.createStringLiteral(type),
-                    undefined,
-                    typeNode,
-                    undefined,
-                )
-            }),
+    return factory.createTypeLiteralNode(
+        Object.entries(parsedLogic.extraActions).map(([type, typeNode]) => {
+            return factory.createPropertySignature(undefined, factory.createStringLiteral(type), undefined, typeNode)
+        }),
     )
 }

package/src/print/printInternalSelectorTypes.ts

@@ -1,24 +1,24 @@
 import { ParsedLogic } from '../types'
-import * as ts from 'typescript'
+import { factory } from 'typescript'
 
 export function printInternalSelectorTypes(parsedLogic: ParsedLogic) {
-    return ts.createTypeLiteralNode(
+    return factory.createTypeLiteralNode(
         parsedLogic.selectors
             .filter((s) => s.functionTypes.length > 0)
             .map((selector) => {
-                return ts.createPropertySignature(
+                return factory.createPropertySignature(
                     undefined,
-                    ts.createIdentifier(selector.name),
+                    factory.createIdentifier(selector.name),
                     undefined,
 
-                    ts.createFunctionTypeNode(
+                    factory.createFunctionTypeNode(
                         undefined,
                         selector.functionTypes.map((functionType, index) =>
-                            ts.createParameter(
+                            factory.createParameterDeclaration(
                                 undefined,
                                 undefined,
                                 undefined,
-                                ts.createIdentifier(functionType.name),
+                                factory.createIdentifier(functionType.name),
                                 undefined,
                                 functionType.type,
                                 undefined,
@@ -26,7 +26,6 @@ export function printInternalSelectorTypes(parsedLogic: ParsedLogic) {
                         ),
                         selector.typeNode,
                     ),
-                    undefined,
                 )
             }),
     )

package/src/print/printKey.ts

@@ -1,6 +1,6 @@
-import * as ts from 'typescript'
+import { factory, SyntaxKind } from 'typescript'
 import { ParsedLogic } from '../types'
 
 export function printKey(parsedLogic: ParsedLogic) {
-    return parsedLogic.keyType || ts.createKeywordTypeNode(ts.SyntaxKind.UndefinedKeyword)
+    return parsedLogic.keyType || factory.createKeywordTypeNode(SyntaxKind.UndefinedKeyword)
 }

package/src/print/printListeners.ts

@@ -1,47 +1,46 @@
-import * as ts from 'typescript'
+import { factory, SyntaxKind } from 'typescript'
 import { ParsedLogic } from '../types'
 
 export function printListeners(parsedLogic: ParsedLogic) {
-    return ts.createTypeLiteralNode(
+    return factory.createTypeLiteralNode(
         parsedLogic.listeners.map(({ name, payload, action }) =>
-            ts.createPropertySignature(
+            factory.createPropertySignature(
                 undefined,
-                ts.createStringLiteral(name),
+                factory.createStringLiteral(name),
                 undefined,
-                ts.createArrayTypeNode(
-                    ts.createParenthesizedType(
-                        ts.createFunctionTypeNode(
+                factory.createArrayTypeNode(
+                    factory.createParenthesizedType(
+                        factory.createFunctionTypeNode(
                             undefined,
                             [
-                                ts.createParameter(
+                                factory.createParameterDeclaration(
                                     undefined,
                                     undefined,
                                     undefined,
-                                    ts.createIdentifier('action'),
+                                    factory.createIdentifier('action'),
                                     undefined,
                                     action,
                                     undefined,
                                 ),
-                                ts.createParameter(
+                                factory.createParameterDeclaration(
                                     undefined,
                                     undefined,
                                     undefined,
-                                    ts.createIdentifier('previousState'),
+                                    factory.createIdentifier('previousState'),
                                     undefined,
-                                    ts.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
+                                    factory.createKeywordTypeNode(SyntaxKind.AnyKeyword),
                                     undefined,
                                 ),
                             ],
-                            ts.createUnionTypeNode([
-                                { ...ts.createToken(ts.SyntaxKind.VoidKeyword), _typeNodeBrand: true },
-                                ts.createTypeReferenceNode(ts.createIdentifier('Promise'), [
-                                    { ...ts.createToken(ts.SyntaxKind.VoidKeyword), _typeNodeBrand: true },
+                            factory.createUnionTypeNode([
+                                { ...factory.createToken(SyntaxKind.VoidKeyword), _typeNodeBrand: true },
+                                factory.createTypeReferenceNode(factory.createIdentifier('Promise'), [
+                                    { ...factory.createToken(SyntaxKind.VoidKeyword), _typeNodeBrand: true },
                                 ]),
                             ]),
                         ),
                     ),
                 ),
-                undefined,
             ),
         ),
     )