kea-typegen 1.3.0 → 1.4.0

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,
             ),
         ),
     )

package/src/print/printProps.ts

@@ -1,12 +1,12 @@
-import * as ts from 'typescript'
+import { factory, SyntaxKind } from 'typescript'
 import { ParsedLogic } from '../types'
 
 export function printProps(parsedLogic: ParsedLogic) {
-    return parsedLogic.propsType || ts.createTypeReferenceNode(
-        ts.createIdentifier("Record"),
-        [
-            ts.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),
-            ts.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword)
-        ]
+    return (
+        parsedLogic.propsType ||
+        factory.createTypeReferenceNode(factory.createIdentifier('Record'), [
+            factory.createKeywordTypeNode(SyntaxKind.StringKeyword),
+            factory.createKeywordTypeNode(SyntaxKind.UnknownKeyword),
+        ])
     )
 }

package/src/print/printReducer.ts

@@ -1,47 +1,46 @@
-import * as ts from 'typescript'
+import { factory, SyntaxKind } from 'typescript'
 import { ParsedLogic } from '../types'
 import { cleanDuplicateAnyNodes } from '../utils'
 
 export function printReducer(parsedLogic: ParsedLogic) {
-    return ts.createFunctionTypeNode(
+    return 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('action'),
+                factory.createIdentifier('action'),
                 undefined,
-                ts.createFunctionTypeNode(undefined, [], ts.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)),
+                factory.createFunctionTypeNode(undefined, [], factory.createKeywordTypeNode(SyntaxKind.AnyKeyword)),
                 undefined,
             ),
-            ts.createParameter(
+            factory.createParameterDeclaration(
                 undefined,
                 undefined,
                 undefined,
-                ts.createIdentifier('fullState'),
+                factory.createIdentifier('fullState'),
                 undefined,
-                ts.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
+                factory.createKeywordTypeNode(SyntaxKind.AnyKeyword),
                 undefined,
             ),
         ],
-        ts.createTypeLiteralNode(
+        factory.createTypeLiteralNode(
             cleanDuplicateAnyNodes(parsedLogic.reducers).map((reducer) =>
-                ts.createPropertySignature(
+                factory.createPropertySignature(
                     undefined,
-                    ts.createIdentifier(reducer.name),
+                    factory.createIdentifier(reducer.name),
                     undefined,
                     reducer.typeNode,
-                    undefined,
                 ),
             ),
         ),

package/src/print/printReducerOptions.ts

@@ -1,19 +1,18 @@
-import * as ts from 'typescript'
+import { factory } from 'typescript'
 import { ParsedLogic, ReducerTransform } from '../types'
 import { cleanDuplicateAnyNodes } from '../utils'
 
 export function printReducerOptions(parsedLogic: ParsedLogic) {
-    return ts.createTypeLiteralNode(
+    return factory.createTypeLiteralNode(
         cleanDuplicateAnyNodes(parsedLogic.reducers)
             .filter((r: ReducerTransform) => r.reducerOptions)
             .map((reducer: ReducerTransform) => {
                 if (reducer.reducerOptions) {
-                    return ts.createPropertySignature(
+                    return factory.createPropertySignature(
                         undefined,
-                        ts.createIdentifier(reducer.name),
+                        factory.createIdentifier(reducer.name),
                         undefined,
                         reducer.reducerOptions,
-                        undefined,
                     )
                 }
             })

package/src/print/printReducers.ts

@@ -1,48 +1,47 @@
-import * as ts from 'typescript'
+import { factory, SyntaxKind } from 'typescript'
 import { ParsedLogic } from '../types'
 import { cleanDuplicateAnyNodes } from '../utils'
 
 export function printReducers(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,
-                ts.createFunctionTypeNode(
+                factory.createFunctionTypeNode(
                     undefined,
                     [
-                        ts.createParameter(
+                        factory.createParameterDeclaration(
                             undefined,
                             undefined,
                             undefined,
-                            ts.createIdentifier('state'),
+                            factory.createIdentifier('state'),
                             undefined,
                             reducer.typeNode,
                             undefined,
                         ),
-                        ts.createParameter(
+                        factory.createParameterDeclaration(
                             undefined,
                             undefined,
                             undefined,
-                            ts.createIdentifier('action'),
+                            factory.createIdentifier('action'),
                             undefined,
-                            ts.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
+                            factory.createKeywordTypeNode(SyntaxKind.AnyKeyword),
                             undefined,
                         ),
-                        ts.createParameter(
+                        factory.createParameterDeclaration(
                             undefined,
                             undefined,
                             undefined,
-                            ts.createIdentifier('fullState'),
+                            factory.createIdentifier('fullState'),
                             undefined,
-                            ts.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
+                            factory.createKeywordTypeNode(SyntaxKind.AnyKeyword),
                             undefined,
                         ),
                     ],
                     reducer.typeNode,
                 ),
-                undefined,
             )
         }),
     )

package/src/print/printSelector.ts

@@ -1,29 +1,28 @@
-import * as ts from 'typescript'
+import { factory, SyntaxKind } from 'typescript'
 import { ParsedLogic } from '../types'
 import { cleanDuplicateAnyNodes } from '../utils'
 
 export function printSelector(parsedLogic: ParsedLogic) {
-    return ts.createFunctionTypeNode(
+    return 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.createTypeLiteralNode(
+        factory.createTypeLiteralNode(
             cleanDuplicateAnyNodes(parsedLogic.reducers).map((reducer) =>
-                ts.createPropertySignature(
+                factory.createPropertySignature(
                     undefined,
-                    ts.createIdentifier(reducer.name),
+                    factory.createIdentifier(reducer.name),
                     undefined,
                     reducer.typeNode,
-                    undefined,
                 ),
             ),
         ),