kea-typegen 1.3.0 → 1.4.0

package/src/print/printSelectors.ts

@@ -1,39 +1,38 @@
-import * as ts from 'typescript'
+import { factory, SyntaxKind } from 'typescript'
 import { ParsedLogic } from '../types'
 import { cleanDuplicateAnyNodes } from '../utils'
 
 export function printSelectors(parsedLogic: ParsedLogic) {
-    return ts.createTypeLiteralNode(
+    return factory.createTypeLiteralNode(
         cleanDuplicateAnyNodes(parsedLogic.reducers.concat(parsedLogic.selectors)).map((reducer) => {
-            return ts.createPropertySignature(
+            return factory.createPropertySignature(
                 undefined,
-                ts.createIdentifier(reducer.name),
+                factory.createIdentifier(reducer.name),
                 undefined,
-                ts.createFunctionTypeNode(
+                factory.createFunctionTypeNode(
                     undefined,
                     [
-                        ts.createParameter(
+                        factory.createParameterDeclaration(
                             undefined,
                             undefined,
                             undefined,
-                            ts.createIdentifier('state'),
+                            factory.createIdentifier('state'),
                             undefined,
-                            ts.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
+                            factory.createKeywordTypeNode(SyntaxKind.AnyKeyword),
                             undefined,
                         ),
-                        ts.createParameter(
+                        factory.createParameterDeclaration(
                             undefined,
                             undefined,
                             undefined,
-                            ts.createIdentifier('props'),
-                            ts.createToken(ts.SyntaxKind.QuestionToken),
-                            ts.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
+                            factory.createIdentifier('props'),
+                            factory.createToken(SyntaxKind.QuestionToken),
+                            factory.createKeywordTypeNode(SyntaxKind.AnyKeyword),
                             undefined,
                         ),
                     ],
                     reducer.typeNode,
                 ),
-                undefined,
             )
         }),
     )

package/src/print/printSharedListeners.ts

@@ -1,61 +1,60 @@
-import * as ts from 'typescript'
+import { factory, SyntaxKind } from 'typescript'
 import { ParsedLogic } from '../types'
 
 export function printSharedListeners(parsedLogic: ParsedLogic) {
-    return ts.createTypeLiteralNode(
+    return factory.createTypeLiteralNode(
         parsedLogic.sharedListeners.map(({ name, payload, action }) =>
-            ts.createPropertySignature(
+            factory.createPropertySignature(
                 undefined,
-                ts.createStringLiteral(name),
+                factory.createStringLiteral(name),
                 undefined,
-                ts.createFunctionTypeNode(
+                factory.createFunctionTypeNode(
                     undefined,
                     [
-                        ts.createParameter(
+                        factory.createParameterDeclaration(
                             undefined,
                             undefined,
                             undefined,
-                            ts.createIdentifier('payload'),
+                            factory.createIdentifier('payload'),
                             undefined,
-                            payload || ts.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
+                            payload || factory.createKeywordTypeNode(SyntaxKind.AnyKeyword),
                             undefined,
                         ),
-                        ts.createParameter(
+                        factory.createParameterDeclaration(
                             undefined,
                             undefined,
                             undefined,
-                            ts.createIdentifier('breakpoint'),
+                            factory.createIdentifier('breakpoint'),
                             undefined,
-                            ts.createTypeReferenceNode(ts.createIdentifier('BreakPointFunction'), undefined),
+                            factory.createTypeReferenceNode(factory.createIdentifier('BreakPointFunction'), undefined),
                             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,
             ),
         ),
     )

package/src/print/printValues.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 printValues(parsedLogic: ParsedLogic) {
-    return ts.createTypeLiteralNode(
+    return factory.createTypeLiteralNode(
         cleanDuplicateAnyNodes(parsedLogic.reducers.concat(parsedLogic.selectors)).map((reducer) => {
-            return ts.createPropertySignature(
+            return factory.createPropertySignature(
                 undefined,
-                ts.createIdentifier(reducer.name),
+                factory.createIdentifier(reducer.name),
                 undefined,
                 reducer.typeNode,
-                undefined,
             )
         }),
     )

package/src/utils.ts

@@ -4,7 +4,7 @@ import { cloneNode } from '@wessberg/ts-clone-node'
 import { visitProgram } from './visit/visit'
 import { parsedLogicToTypeString } from './print/print'
 import { AppOptions, NameType, ParsedLogic } from './types'
-import { NodeBuilderFlags } from 'typescript'
+import { factory, NodeBuilderFlags, SyntaxKind } from 'typescript'
 
 export function logicSourceToLogicType(logicSource: string, appOptions?: AppOptions) {
     const program = programFromSource(logicSource)
@@ -54,19 +54,19 @@ export function getTypeNodeForNode(node: ts.Node, checker: ts.TypeChecker): ts.T
             if (ts.isParenthesizedTypeNode(typeNode)) {
                 typeNode = typeNode.type
             }
-        } else if (node?.kind === ts.SyntaxKind.TrueKeyword || node?.kind === ts.SyntaxKind.FalseKeyword) {
-            typeNode = ts.createKeywordTypeNode(ts.SyntaxKind.BooleanKeyword)
+        } else if (node?.kind === SyntaxKind.TrueKeyword || node?.kind === SyntaxKind.FalseKeyword) {
+            typeNode = factory.createKeywordTypeNode(SyntaxKind.BooleanKeyword)
         } else if (ts.isStringLiteralLike(node)) {
-            typeNode = ts.createKeywordTypeNode(ts.SyntaxKind.StringKeyword)
+            typeNode = factory.createKeywordTypeNode(SyntaxKind.StringKeyword)
         } else if (ts.isNumericLiteral(node)) {
-            typeNode = ts.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword)
+            typeNode = factory.createKeywordTypeNode(SyntaxKind.NumberKeyword)
         } else if (ts.isArrayLiteralExpression(node) && node.elements.length === 0) {
-            typeNode = ts.createArrayTypeNode(ts.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword))
+            typeNode = factory.createArrayTypeNode(factory.createKeywordTypeNode(SyntaxKind.AnyKeyword))
         } else {
             typeNode = checker.typeToTypeNode(checker.getTypeAtLocation(node), undefined, undefined)
         }
     } else {
-        typeNode = ts.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)
+        typeNode = factory.createKeywordTypeNode(SyntaxKind.AnyKeyword)
     }
     return typeNode
 }
@@ -82,13 +82,13 @@ export function getAndGatherTypeNodeForDefaultValue(
 }
 
 export function getParameterDeclaration(param: ts.ParameterDeclaration) {
-    return ts.createParameter(
+    return factory.createParameterDeclaration(
         undefined,
         undefined,
         undefined,
-        ts.createIdentifier(param.name.getText()),
-        param.initializer || param.questionToken ? ts.createToken(ts.SyntaxKind.QuestionToken) : undefined,
-        cloneNode(param.type || ts.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)),
+        factory.createIdentifier(param.name.getText()),
+        param.initializer || param.questionToken ? factory.createToken(SyntaxKind.QuestionToken) : undefined,
+        cloneNode(param.type || factory.createKeywordTypeNode(SyntaxKind.AnyKeyword)),
         undefined,
     )
 }
@@ -230,7 +230,7 @@ export function gatherImports(input: ts.Node, checker: ts.TypeChecker, parsedLog
         let node = requestedNode
         if (ts.isTypeReferenceNode(node)) {
             let typeRootName: string | undefined
-            if (node.typeName?.kind === ts.SyntaxKind.FirstNode) {
+            if (node.typeName?.kind === SyntaxKind.FirstNode) {
                 try {
                     typeRootName = node.typeName.getFirstToken().getText()
                 } catch (e) {
@@ -334,8 +334,8 @@ export function isAnyUnknown(node?: ts.Node): boolean {
     const unPromised = unPromisify(node)
     return (
         !unPromised ||
-        unPromised.kind === ts.SyntaxKind.AnyKeyword ||
-        unPromised.kind === ts.SyntaxKind.UnknownKeyword ||
+        unPromised.kind === SyntaxKind.AnyKeyword ||
+        unPromised.kind === SyntaxKind.UnknownKeyword ||
         (ts.isTypeLiteralNode(unPromised) && unPromised.members.length === 0)
     )
 }

package/src/visit/visit.ts

@@ -179,9 +179,9 @@ export function visitKeaCalls(
             // only if symbol resolves we mark the logic type as imported
             const symbol = checker.getSymbolAtLocation(keaTypeArgument.typeName)
             if (symbol) {
-                const declaration = symbol.getDeclarations()[0]
+                const declaration = symbol.getDeclarations()?.[0]
 
-                if (ts.isImportSpecifier(declaration)) {
+                if (declaration && ts.isImportSpecifier(declaration)) {
                     const filename = getFilenameForImportSpecifier(declaration, checker)
                     logicTypeImported = filename === typeFileName
                 }

package/src/visit/visitActions.ts

@@ -1,10 +1,10 @@
 import { ParsedLogic } from '../types'
-import * as ts from 'typescript'
+import { factory, isFunctionLike, isPropertyAssignment, PropertyAssignment, SyntaxKind, Type } from 'typescript'
 import { NodeBuilderFlags } from 'typescript'
 import { cloneNode } from '@wessberg/ts-clone-node'
 import { gatherImports } from '../utils'
 
-export function visitActions(type: ts.Type, inputProperty: ts.PropertyAssignment, parsedLogic: ParsedLogic) {
+export function visitActions(type: Type, inputProperty: PropertyAssignment, parsedLogic: ParsedLogic) {
     const { checker } = parsedLogic
     const properties = checker.getPropertiesOfType(type)
 
@@ -15,24 +15,26 @@ export function visitActions(type: ts.Type, inputProperty: ts.PropertyAssignment
         let returnTypeNode
         let parameters
 
-        if (!ts.isPropertyAssignment(property.valueDeclaration)) {
+        if (!isPropertyAssignment(property.valueDeclaration)) {
             continue
         }
         const { initializer } = property.valueDeclaration
 
-        if (ts.isFunctionLike(initializer)) {
+        if (isFunctionLike(initializer)) {
             // action is a function action: () => ({ ... })
             parameters = initializer.parameters.map((param) => {
                 if (param.type) {
                     gatherImports(param.type, checker, parsedLogic)
                 }
-                return ts.createParameter(
+                return factory.createParameterDeclaration(
                     undefined,
                     undefined,
                     undefined,
-                    ts.createIdentifier(param.name.getText()),
-                    param.initializer || param.questionToken ? ts.createToken(ts.SyntaxKind.QuestionToken) : undefined,
-                    param.type ? cloneNode(param.type) : ts.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
+                    factory.createIdentifier(param.name.getText()),
+                    param.initializer || param.questionToken
+                        ? factory.createToken(SyntaxKind.QuestionToken)
+                        : undefined,
+                    param.type ? cloneNode(param.type) : factory.createKeywordTypeNode(SyntaxKind.AnyKeyword),
                     undefined,
                 )
             })
@@ -58,8 +60,8 @@ export function visitActions(type: ts.Type, inputProperty: ts.PropertyAssignment
             // action is a value (action: true)
             const typeNode = checker.typeToTypeNode(type, undefined, undefined)
             gatherImports(typeNode, checker, parsedLogic)
-            returnTypeNode = ts.createTypeLiteralNode([
-                ts.createPropertySignature(undefined, ts.createIdentifier('value'), undefined, typeNode, undefined),
+            returnTypeNode = factory.createTypeLiteralNode([
+                factory.createPropertySignature(undefined, factory.createIdentifier('value'), undefined, typeNode),
             ])
         }
         parsedLogic.actions.push({ name, parameters, returnTypeNode })

package/src/visit/visitListeners.ts

@@ -47,20 +47,20 @@ export function visitListeners(type: ts.Type, inputProperty: ts.PropertyAssignme
                 parsedLogic.listeners.push({
                     name: action.name,
                     payload: action.returnTypeNode,
-                    action: ts.createTypeLiteralNode([
-                        ts.createPropertySignature(
+                    action: ts.factory.createTypeLiteralNode([
+                        ts.factory.createPropertySignature(
                             undefined,
-                            ts.createIdentifier('type'),
-                            undefined,
-                            ts.createLiteralTypeNode(ts.createStringLiteral(getActionType(action.name))),
+                            ts.factory.createIdentifier('type'),
                             undefined,
+                            ts.factory.createLiteralTypeNode(
+                                ts.factory.createStringLiteral(getActionType(action.name)),
+                            ),
                         ),
-                        ts.createPropertySignature(
+                        ts.factory.createPropertySignature(
                             undefined,
-                            ts.createIdentifier('payload'),
+                            ts.factory.createIdentifier('payload'),
                             undefined,
                             action.returnTypeNode,
-                            undefined,
                         ),
                     ]),
                 })

package/src/visit/visitLoaders.ts

@@ -1,5 +1,15 @@
 import { ParsedLogic } from '../types'
-import * as ts from 'typescript'
+import {
+    factory,
+    isArrayLiteralExpression,
+    isFunctionLike,
+    isObjectLiteralExpression,
+    isTypeReferenceNode,
+    PropertyAssignment,
+    SyntaxKind,
+    Type,
+    TypeNode,
+} from 'typescript'
 import {
     gatherImports,
     getParameterDeclaration,
@@ -9,22 +19,22 @@ import {
 } from '../utils'
 import { NodeBuilderFlags } from 'typescript'
 
-export function visitLoaders(type: ts.Type, inputProperty: ts.PropertyAssignment, parsedLogic: ParsedLogic) {
+export function visitLoaders(type: Type, inputProperty: PropertyAssignment, parsedLogic: ParsedLogic) {
     const { checker } = parsedLogic
 
     for (const property of type.getProperties()) {
         const loaderName = property.getName()
-        const value = (property.valueDeclaration as ts.PropertyAssignment).initializer
+        const value = (property.valueDeclaration as PropertyAssignment).initializer
 
         let defaultValue
         let objectLiteral
-        if (ts.isArrayLiteralExpression(value)) {
+        if (isArrayLiteralExpression(value)) {
             defaultValue = value.elements[0]
             objectLiteral = value.elements[1]
-        } else if (ts.isObjectLiteralExpression(value)) {
+        } else if (isObjectLiteralExpression(value)) {
             defaultValue = (value.properties.find(
                 (property) => checker.getSymbolAtLocation(property.name)?.getName() === '__default',
-            ) as ts.PropertyAssignment)?.initializer
+            ) as PropertyAssignment)?.initializer
             objectLiteral = value
         }
 
@@ -35,18 +45,18 @@ export function visitLoaders(type: ts.Type, inputProperty: ts.PropertyAssignment
         parsedLogic.reducers.push({ name: loaderName, typeNode: defaultValueTypeNode })
         parsedLogic.reducers.push({
             name: `${loaderName}Loading`,
-            typeNode: ts.createKeywordTypeNode(ts.SyntaxKind.BooleanKeyword),
+            typeNode: factory.createKeywordTypeNode(SyntaxKind.BooleanKeyword),
         })
 
         if (objectLiteral) {
-            ;(objectLiteral.properties || []).forEach((property: ts.PropertyAssignment) => {
+            ;(objectLiteral.properties || []).forEach((property: PropertyAssignment) => {
                 const loaderActionName = checker.getSymbolAtLocation(property.name)?.getName()
                 if (loaderActionName === '__default') {
                     return
                 }
 
                 const func = property.initializer
-                if (!ts.isFunctionLike(func)) {
+                if (!isFunctionLike(func)) {
                     return
                 }
 
@@ -54,14 +64,14 @@ export function visitLoaders(type: ts.Type, inputProperty: ts.PropertyAssignment
                 const parameters = param ? [getParameterDeclaration(param)] : []
 
                 if (!parsedLogic.actions.find(({ name }) => name === `${loaderActionName}`)) {
-                    const returnTypeNode = param?.type || ts.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)
+                    const returnTypeNode = param?.type || factory.createKeywordTypeNode(SyntaxKind.AnyKeyword)
                     gatherImports(param, checker, parsedLogic)
 
                     parsedLogic.actions.push({ name: `${loaderActionName}`, parameters, returnTypeNode })
                 }
 
                 if (!parsedLogic.actions.find(({ name }) => name === `${loaderActionName}Success`)) {
-                    let returnTypeNode: ts.TypeNode
+                    let returnTypeNode: TypeNode
                     if (func) {
                         const funcType = checker.getTypeAtLocation(func)
                         const signature = funcType?.getCallSignatures()[0]
@@ -82,11 +92,11 @@ export function visitLoaders(type: ts.Type, inputProperty: ts.PropertyAssignment
                     }
 
                     if (!returnTypeNode) {
-                        returnTypeNode = defaultValueTypeNode || ts.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)
+                        returnTypeNode = defaultValueTypeNode || factory.createKeywordTypeNode(SyntaxKind.AnyKeyword)
                     }
 
                     if (
-                        ts.isTypeReferenceNode(returnTypeNode) &&
+                        isTypeReferenceNode(returnTypeNode) &&
                         (returnTypeNode.typeName as any)?.escapedText === 'Promise'
                     ) {
                         returnTypeNode = returnTypeNode.typeArguments?.[0]
@@ -95,39 +105,37 @@ export function visitLoaders(type: ts.Type, inputProperty: ts.PropertyAssignment
                     gatherImports(returnTypeNode, checker, parsedLogic)
 
                     const successParameters = [
-                        ts.createParameter(
+                        factory.createParameterDeclaration(
                             undefined,
                             undefined,
                             undefined,
-                            ts.createIdentifier(loaderName),
+                            factory.createIdentifier(loaderName),
                             undefined,
                             returnTypeNode,
                             undefined,
                         ),
-                        ts.createParameter(
+                        factory.createParameterDeclaration(
                             undefined,
                             undefined,
                             undefined,
-                            ts.createIdentifier('payload'),
-                            ts.createToken(ts.SyntaxKind.QuestionToken),
+                            factory.createIdentifier('payload'),
+                            factory.createToken(SyntaxKind.QuestionToken),
                             parsedLogic.actions.find((a) => a.name === loaderActionName)?.returnTypeNode,
                             undefined,
                         ),
                     ]
-                    const successReturnTypeNode = ts.createTypeLiteralNode([
-                        ts.createPropertySignature(
+                    const successReturnTypeNode = factory.createTypeLiteralNode([
+                        factory.createPropertySignature(
                             undefined,
-                            ts.createIdentifier(loaderName),
+                            factory.createIdentifier(loaderName),
                             undefined,
                             returnTypeNode,
-                            undefined,
                         ),
-                        ts.createPropertySignature(
+                        factory.createPropertySignature(
                             undefined,
-                            ts.createIdentifier('payload'),
-                            ts.createToken(ts.SyntaxKind.QuestionToken),
+                            factory.createIdentifier('payload'),
+                            factory.createToken(SyntaxKind.QuestionToken),
                             parsedLogic.actions.find((a) => a.name === loaderActionName)?.returnTypeNode,
-                            undefined,
                         ),
                     ])
                     parsedLogic.actions.push({
@@ -139,39 +147,37 @@ export function visitLoaders(type: ts.Type, inputProperty: ts.PropertyAssignment
 
                 if (!parsedLogic.actions.find(({ name }) => name === `${loaderActionName}Failure`)) {
                     const failureParameters = [
-                        ts.createParameter(
+                        factory.createParameterDeclaration(
                             undefined,
                             undefined,
                             undefined,
-                            ts.createIdentifier('error'),
+                            factory.createIdentifier('error'),
                             undefined,
-                            ts.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),
+                            factory.createKeywordTypeNode(SyntaxKind.StringKeyword),
                             undefined,
                         ),
-                        ts.createParameter(
+                        factory.createParameterDeclaration(
                             undefined,
                             undefined,
                             undefined,
-                            ts.createIdentifier('errorObject'),
-                            ts.createToken(ts.SyntaxKind.QuestionToken),
-                            ts.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
+                            factory.createIdentifier('errorObject'),
+                            factory.createToken(SyntaxKind.QuestionToken),
+                            factory.createKeywordTypeNode(SyntaxKind.AnyKeyword),
                             undefined,
                         ),
                     ]
-                    const failureReturnTypeNode = ts.createTypeLiteralNode([
-                        ts.createPropertySignature(
+                    const failureReturnTypeNode = factory.createTypeLiteralNode([
+                        factory.createPropertySignature(
                             undefined,
-                            ts.createIdentifier('error'),
-                            undefined,
-                            ts.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),
+                            factory.createIdentifier('error'),
                             undefined,
+                            factory.createKeywordTypeNode(SyntaxKind.StringKeyword),
                         ),
-                        ts.createPropertySignature(
-                            undefined,
-                            ts.createIdentifier('errorObject'),
-                            ts.createToken(ts.SyntaxKind.QuestionToken),
-                            ts.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
+                        factory.createPropertySignature(
                             undefined,
+                            factory.createIdentifier('errorObject'),
+                            factory.createToken(SyntaxKind.QuestionToken),
+                            factory.createKeywordTypeNode(SyntaxKind.AnyKeyword),
                         ),
                     ])
 

package/src/visit/visitReducers.ts

@@ -34,7 +34,7 @@ export function visitReducers(type: ts.Type, inputProperty: ts.PropertyAssignmen
                     }
                 }
             } else if (ts.isObjectLiteralExpression(value)) {
-                typeNode = ts.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)
+                typeNode = ts.factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)
             }
 
             parsedLogic.reducers.push({ name, typeNode, reducerOptions })

package/src/visit/visitSelectors.ts

@@ -34,7 +34,7 @@ export function visitSelectors(type: ts.Type, inputProperty: ts.PropertyAssignme
 
             if (selectorInputTypeNode && ts.isTupleTypeNode(selectorInputTypeNode)) {
                 let takenNames: Record<string, number> = {}
-                functionTypes = (selectorInputTypeNode.elements || ts.createNodeArray([]))
+                functionTypes = (selectorInputTypeNode.elements || ts.factory.createNodeArray([]))
                     .filter((e) => ts.isTypeNode(e))
                     .map((selectorTypeNode, index) => {
                         let name = functionNames[index] || 'arg'
@@ -49,7 +49,7 @@ export function visitSelectors(type: ts.Type, inputProperty: ts.PropertyAssignme
                             name,
                             type: ts.isFunctionTypeNode(selectorTypeNode)
                                 ? cloneNode(selectorTypeNode.type)
-                                : ts.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
+                                : ts.factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
                         }
                     })
             }
@@ -67,7 +67,7 @@ export function visitSelectors(type: ts.Type, inputProperty: ts.PropertyAssignme
                     typeNode = checker.typeToTypeNode(type, undefined, NodeBuilderFlags.NoTruncation)
                     gatherImports(typeNode, checker, parsedLogic)
                 } else {
-                    typeNode = ts.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)
+                    typeNode = ts.factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)
                 }
 
                 parsedLogic.selectors.push({

package/src/visit/visitSharedListeners.ts

@@ -23,21 +23,19 @@ export function visitSharedListeners(type: ts.Type, inputProperty: ts.PropertyAs
             parsedLogic.sharedListeners.push({
                 name,
                 payload: typeNode,
-                action: ts.createTypeLiteralNode([
-                    ts.createPropertySignature(
+                action: ts.factory.createTypeLiteralNode([
+                    ts.factory.createPropertySignature(
                         undefined,
-                        ts.createIdentifier('type'),
-                        undefined,
-                        ts.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),
+                        ts.factory.createIdentifier('type'),
                         undefined,
+                        ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),
                     ),
-                    ts.createPropertySignature(
-                        undefined,
-                        ts.createIdentifier('payload'),
+                    ts.factory.createPropertySignature(
                         undefined,
-                        typeNode || ts.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
-                        // ts.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
+                        ts.factory.createIdentifier('payload'),
                         undefined,
+                        typeNode || ts.factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
+                        // ts.factory.createKeywordTypeNode(SyntaxKind.AnyKeyword),
                     ),
                 ]),
             })