kea-typegen 1.2.1 → 1.4.1

package/src/cli/typegen.ts

@@ -46,6 +46,15 @@ yargs
     })
     .option('quiet', { alias: 'q', describe: 'Write nothing to stdout', type: 'boolean' })
     .option('no-import', { describe: 'Do not automatically import generated types in logic files', type: 'boolean' })
+    .option('write-paths', { describe: 'Write paths into logic files that have none', type: 'boolean' })
+    .option('import-global-types', {
+        describe: 'Add import statements in logicType.ts files for global types (e.g. @types/node)',
+        type: 'boolean',
+    })
+    .option('ignore-import-paths', {
+        describe: 'List of paths we will never import from inside logicType.ts files',
+        type: 'array',
+    })
     .option('verbose', { describe: 'Slightly more verbose output log', type: 'boolean' })
     .demandCommand()
     .help()
@@ -60,18 +69,21 @@ function parsedToAppOptions(parsedOptions) {
         quiet: parsedOptions.quiet,
         verbose: parsedOptions.verbose,
         noImport: parsedOptions.noImport,
+        writePaths: parsedOptions.writePaths,
+        importGlobalTypes: parsedOptions.importGlobalTypes,
+        ignoreImportPaths: parsedOptions.ignoreImportPaths,
         log: parsedOptions.quiet ? () => null : console.log.bind(console),
     } as AppOptions
 
     return appOptions
 }
 
-function findKeaConfig(): string {
-    return ts.findConfigFile('./', ts.sys.fileExists, '.kearc')
+function findKeaConfig(searchPath): string {
+    return ts.findConfigFile(searchPath, ts.sys.fileExists, '.kearc')
 }
 
 function includeKeaConfig(appOptions: AppOptions): AppOptions {
-    const configFilePath = findKeaConfig()
+    const configFilePath = findKeaConfig(appOptions.rootPath)
     const newOptions = { ...appOptions } as AppOptions
 
     let rawData, keaConfig
@@ -105,16 +117,18 @@ function includeKeaConfig(appOptions: AppOptions): AppOptions {
                 // set all paths in .kearc to be relative from where the file is located
                 if (key.endsWith('Path')) {
                     newOptions[key] = path.resolve(process.cwd(), configDirPath, keaConfig[key])
+                } else if (key.endsWith('Paths')) {
+                    if (!Array.isArray(keaConfig[key])) {
+                        console.error(`Config "${key}" in ".kearc" is not an array`)
+                        process.exit(1)
+                    }
+                    newOptions[key] = keaConfig[key].map((value) => path.resolve(process.cwd(), configDirPath, value))
                 } else {
                     newOptions[key] = keaConfig[key]
                 }
             })
     }
 
-    if (!newOptions.tsConfigPath) {
-        newOptions.tsConfigPath = ts.findConfigFile('./', ts.sys.fileExists, 'tsconfig.json')
-    }
-
     if (!newOptions.rootPath) {
         newOptions.rootPath = newOptions.tsConfigPath ? path.dirname(newOptions.tsConfigPath) : process.cwd()
     }
@@ -123,5 +137,17 @@ function includeKeaConfig(appOptions: AppOptions): AppOptions {
         newOptions.typesPath = newOptions.rootPath
     }
 
+    if (!newOptions.tsConfigPath) {
+        newOptions.tsConfigPath =
+            ts.findConfigFile(newOptions.rootPath, ts.sys.fileExists, 'tsconfig.json') ||
+            ts.findConfigFile('./', ts.sys.fileExists, 'tsconfig.json')
+    }
+
+    if (!newOptions.packageJsonPath) {
+        newOptions.packageJsonPath =
+            ts.findConfigFile(newOptions.rootPath, ts.sys.fileExists, 'package.json') ||
+            ts.findConfigFile('./', ts.sys.fileExists, 'package.json')
+    }
+
     return newOptions
 }

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,38 @@ 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 +125,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 +172,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 +193,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 +237,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 +261,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 +274,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 +289,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)
 }