kea-typegen 3.0.0 → 3.1.3

package/src/print/print.ts

@@ -9,7 +9,7 @@ import {
     ScriptKind,
     ScriptTarget,
     SyntaxKind,
-    TypeParameterDeclaration,
+    TypeNode,
 } from 'typescript'
 import * as fs from 'fs'
 import * as path from 'path'
@@ -132,7 +132,7 @@ export function printToFiles(
                 }
             })
             .filter(({ fullPath }) => !shouldIgnore(fullPath))
-            .map(({ list, relativePath }) => `import { ${list.join(', ')} } from '${relativePath}'`)
+            .map(({ list, relativePath }) => `import type { ${list.join(', ')} } from '${relativePath}'`)
             .join('\n')
 
         const finalOutput = [
@@ -142,7 +142,7 @@ export function printToFiles(
             ]
                 .filter((a) => !!a)
                 .join('\n'),
-            `import { ${[...requiredKeys.values()].join(', ')} } from 'kea'`,
+            `import type { ${[...requiredKeys.values()].join(', ')} } from 'kea'`,
             otherimports,
             output,
         ]
@@ -181,7 +181,7 @@ export function printToFiles(
             // 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.logicTypeArguments.length > 0) &&
             pl.fileName.match(/\.tsx?$/)
 
         // write the type into the logic itself
@@ -261,70 +261,70 @@ export function parsedLogicToTypeString(parsedLogic: ParsedLogic, appOptions?: A
     return nodeToString(parsedLogic.interfaceDeclaration)
 }
 
-export function getLogicTypeArguments(parsedLogic: ParsedLogic): TypeParameterDeclaration[] {
-    return [...parsedLogic.typeReferencesInLogicInput]
-        .sort()
-        .map((text) => factory.createTypeParameterDeclaration(factory.createIdentifier(text), undefined))
-}
-
 export function printLogicType(parsedLogic: ParsedLogic, appOptions?: AppOptions): void {
-    const printProperty = (name, typeNode) =>
-        factory.createPropertySignature(undefined, factory.createIdentifier(name), undefined, typeNode)
-
     const addSelectorTypeHelp = parsedLogic.selectors.filter((s) => s.functionTypes.length > 0).length > 0
 
-    const logicProperties = [
-        printProperty('actionCreators', printActionCreators(parsedLogic, appOptions)),
-        printProperty('actionKeys', printActionKeys(parsedLogic, appOptions)),
-        printProperty('actionTypes', printActionTypes(parsedLogic, appOptions)),
-        printProperty('actions', printActions(parsedLogic, appOptions)),
-        printProperty('defaults', printDefaults(parsedLogic)),
-        printProperty('events', printEvents(parsedLogic)),
-        printProperty('key', printKey(parsedLogic)),
-        printProperty('listeners', printListeners(parsedLogic)),
-        printProperty(
-            'path',
-            factory.createTupleTypeNode(
-                parsedLogic.path.map((p) => factory.createLiteralTypeNode(factory.createStringLiteral(p))),
-            ),
+    const logicProperties: Record<string, TypeNode | null> = {
+        actionCreators: printActionCreators(parsedLogic, appOptions),
+        actionKeys: printActionKeys(parsedLogic, appOptions),
+        actionTypes: printActionTypes(parsedLogic, appOptions),
+        actions: printActions(parsedLogic, appOptions),
+        defaults: printDefaults(parsedLogic),
+        events: printEvents(parsedLogic),
+        key: printKey(parsedLogic),
+        listeners: printListeners(parsedLogic),
+        path: factory.createTupleTypeNode(
+            parsedLogic.path.map((p) => factory.createLiteralTypeNode(factory.createStringLiteral(p))),
         ),
-        printProperty('pathString', factory.createStringLiteral(parsedLogic.pathString)),
-        printProperty('props', printProps(parsedLogic)),
-        printProperty('reducer', printReducer(parsedLogic)),
-        printProperty('reducers', printReducers(parsedLogic)),
-        printProperty('selector', printSelector(parsedLogic)),
-        printProperty('selectors', printSelectors(parsedLogic)),
-        printProperty('sharedListeners', printSharedListeners(parsedLogic)),
-        printProperty('values', printValues(parsedLogic)),
-        printProperty('_isKea', factory.createTrue()),
-        printProperty('_isKeaWithKey', parsedLogic.keyType ? factory.createTrue() : factory.createFalse()),
-        addSelectorTypeHelp
-            ? printProperty('__keaTypeGenInternalSelectorTypes', printInternalSelectorTypes(parsedLogic))
-            : null,
-        Object.keys(parsedLogic.extraActions).length > 0
-            ? printProperty('__keaTypeGenInternalReducerActions', printInternalReducerActions(parsedLogic))
-            : null,
-        Object.keys(parsedLogic.extraInput).length > 0
-            ? printProperty('__keaTypeGenInternalExtraInput', printInternalExtraInput(parsedLogic))
-            : null,
-    ].filter((a) => !!a)
+        pathString: factory.createLiteralTypeNode(factory.createStringLiteral(parsedLogic.pathString)),
+        props: printProps(parsedLogic),
+        reducer: printReducer(parsedLogic),
+        reducers: printReducers(parsedLogic),
+        selector: printSelector(parsedLogic),
+        selectors: printSelectors(parsedLogic),
+        sharedListeners: printSharedListeners(parsedLogic),
+        values: printValues(parsedLogic),
+    }
+    for (const [name, typeNode] of Object.entries(parsedLogic.extraLogicFields)) {
+        if (name in logicProperties) {
+            console.error(`❗ Can not add extra logic field ${name} because this field is already in the logic.`)
+        } else {
+            logicProperties[name] = typeNode
+        }
+    }
+    const logicMetaProperties: Record<string, TypeNode | null> = {
+        _isKea: factory.createLiteralTypeNode(factory.createTrue()),
+        _isKeaWithKey: factory.createLiteralTypeNode(
+            parsedLogic.keyType ? factory.createTrue() : factory.createFalse(),
+        ),
+        __keaTypeGenInternalSelectorTypes: addSelectorTypeHelp ? printInternalSelectorTypes(parsedLogic) : null,
+        __keaTypeGenInternalReducerActions:
+            Object.keys(parsedLogic.extraActions).length > 0 ? printInternalReducerActions(parsedLogic) : null,
+        __keaTypeGenInternalExtraInput:
+            Object.keys(parsedLogic.extraInput).length > 0 ? printInternalExtraInput(parsedLogic) : null,
+    }
 
-    const logicTypeArguments = getLogicTypeArguments(parsedLogic)
+    const sortedLogicProperties = {
+        ...Object.fromEntries(
+            Object.entries(logicProperties).sort((a, b) => (a[0] === b[0] ? 0 : a[0] < b[0] ? -1 : 1)),
+        ),
+        ...logicMetaProperties,
+    }
 
     parsedLogic.interfaceDeclaration = factory.createInterfaceDeclaration(
         undefined,
         [factory.createModifier(SyntaxKind.ExportKeyword)],
         factory.createIdentifier(`${parsedLogic.logicName}Type`),
-        logicTypeArguments,
+        undefined,
         [
             factory.createHeritageClause(SyntaxKind.ExtendsKeyword, [
                 factory.createExpressionWithTypeArguments(factory.createIdentifier('Logic'), undefined),
             ]),
         ],
-        logicProperties,
+        Object.entries(sortedLogicProperties)
+            .filter(([_, value]) => !!value)
+            .map(([name, typeNode]) =>
+                factory.createPropertySignature(undefined, factory.createIdentifier(name), undefined, typeNode),
+            ),
     )
 }
-
-// haha
-let i = 0
-const smiles = ['/', ']', '[', ')', '(', '\\', 'D', '|', 'O']

package/src/print/printInternalExtraInput.ts

@@ -5,10 +5,6 @@ export function printInternalExtraInput(parsedLogic: ParsedLogic) {
     return factory.createTypeLiteralNode(
         Object.entries(parsedLogic.extraInput).map(([type, { typeNode, withLogicFunction }]) => {
             if (withLogicFunction) {
-                const logicTypeArguments = [...parsedLogic.typeReferencesInLogicInput]
-                    .sort()
-                    .map((text) => factory.createTypeReferenceNode(factory.createIdentifier(text), undefined))
-
                 return factory.createPropertySignature(
                     undefined,
                     factory.createStringLiteral(type),
@@ -27,7 +23,7 @@ export function printInternalExtraInput(parsedLogic: ParsedLogic) {
                                     undefined,
                                     factory.createTypeReferenceNode(
                                         factory.createIdentifier(parsedLogic.logicTypeName),
-                                        logicTypeArguments.length > 0 ? logicTypeArguments : undefined,
+                                        undefined,
                                     ),
                                     undefined,
                                 ),

package/src/types.ts

@@ -43,13 +43,13 @@ export interface ParsedLogic {
     selectors: SelectorTransform[]
     listeners: ListenerTransform[]
     sharedListeners: ListenerTransform[]
-    extraActions: Record<string, ts.TypeNode>
     propsType?: ts.TypeNode
     keyType?: ts.TypeNode
     typeReferencesToImportFromFiles: Record<string, Set<string>>
-    typeReferencesInLogicInput: Set<string>
     interfaceDeclaration?: ts.InterfaceDeclaration
+    extraActions: Record<string, ts.TypeNode>
     extraInput: Record<string, { typeNode: ts.TypeNode; withLogicFunction: boolean }>
+    extraLogicFields: Record<string, ts.TypeNode>
     importFromKeaInLogicType: Set<string>
     inputBuilderArray: boolean
 }

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 { factory, NodeBuilderFlags, SyntaxKind } from 'typescript'
+import { factory, isSourceFile, NodeBuilderFlags, SyntaxKind } from 'typescript'
 
 export function logicSourceToLogicType(logicSource: string, appOptions?: AppOptions) {
     const program = programFromSource(logicSource)
@@ -23,6 +23,13 @@ export function programFromSource(sourceCode: string) {
     return ts.createProgram(['logic.ts'], options, compilerHost)
 }
 
+function rejectImportPath(path: string): boolean {
+    if (path.includes('/node_modules/typescript/')) {
+        return true
+    }
+    return false
+}
+
 export function isKeaCall(node: ts.Node, checker: ts.TypeChecker) {
     if (!ts.isIdentifier(node)) {
         return false
@@ -216,9 +223,7 @@ export function getLogicPathString(appOptions: AppOptions, fileName: string) {
 }
 
 export function getFilenamesForSymbol(symbol: ts.Symbol): string[] | undefined {
-    return (symbol?.declarations || [])
-        .map((d) => d.getSourceFile().fileName)
-        .filter((str) => !str.includes('/node_modules/typescript/lib/lib'))
+    return (symbol?.declarations || []).map((d) => d.getSourceFile().fileName).filter((f) => !rejectImportPath(f))
 }
 
 /** gathers onto parsedLogic the TypeReference nodes that are declared in a different sourceFile */
@@ -237,7 +242,6 @@ export function gatherImports(input: ts.Node, checker: ts.TypeChecker, parsedLog
                     typeRootName = (node.typeName.left as any)?.escapedText
                 }
             }
-
             const symbol = checker.getSymbolAtLocation(node.typeName) || (node.typeName as any).symbol
             if (symbol) {
                 storeExtractedSymbol(symbol, checker, parsedLogic, typeRootName)
@@ -255,32 +259,23 @@ export function storeExtractedSymbol(
     typeRootName?: string,
 ) {
     const declaration = symbol.getDeclarations()?.[0]
+    let typeName = typeRootName
 
-    if (declaration && ts.isImportSpecifier(declaration)) {
-        const importFilename = getFilenameForImportSpecifier(declaration, checker)
-        if (importFilename) {
-            addTypeImport(parsedLogic, importFilename, typeRootName || declaration.getText())
-        } else {
-            parsedLogic.typeReferencesInLogicInput.add(typeRootName || declaration.getText())
-        }
-        return
-    }
-
-    const files = getFilenamesForSymbol(symbol)
-    if (files[0]) {
-        // same file, add to logicType<...>
-        if (
+    if (
+        declaration &&
+        (ts.isImportSpecifier(declaration) ||
             ts.isTypeAliasDeclaration(declaration) ||
             ts.isInterfaceDeclaration(declaration) ||
             ts.isEnumDeclaration(declaration) ||
-            ts.isClassDeclaration(declaration)
-        ) {
-            if (files[0] === parsedLogic.fileName) {
-                parsedLogic.typeReferencesInLogicInput.add(typeRootName || declaration.name.getText())
-            } else {
-                // but is it exported?
-                addTypeImport(parsedLogic, files[0], typeRootName || declaration.name.getText())
-            }
+            ts.isClassDeclaration(declaration))
+    ) {
+        typeName = typeName || declaration.name.getText()
+    }
+
+    if (typeName) {
+        const importFilename = getFilenameForNode(declaration, checker)
+        if (importFilename && !rejectImportPath(importFilename)) {
+            addTypeImport(parsedLogic, importFilename, typeName)
         }
     }
 }
@@ -293,14 +288,17 @@ export function getFilenameForImportDeclaration(checker: ts.TypeChecker, importN
     }
 }
 
-export function getFilenameForImportSpecifier(declaration: ts.ImportSpecifier, checker: ts.TypeChecker): string | void {
-    let importNode: ts.Node = declaration
-    while (importNode && !ts.isImportDeclaration(importNode)) {
+export function getFilenameForNode(node: ts.Node, checker: ts.TypeChecker): string | void {
+    let importNode: ts.Node = node
+    while (importNode) {
+        if (ts.isImportDeclaration(importNode)) {
+            return getFilenameForImportDeclaration(checker, importNode)
+        }
+        if (isSourceFile(importNode)) {
+            return importNode.fileName
+        }
         importNode = importNode.parent
     }
-    if (ts.isImportDeclaration(importNode)) {
-        return getFilenameForImportDeclaration(checker, importNode)
-    }
 }
 
 function addTypeImport(parsedLogic: ParsedLogic, file: string, typeName: string) {
@@ -310,16 +308,6 @@ function addTypeImport(parsedLogic: ParsedLogic, file: string, typeName: string)
     parsedLogic.typeReferencesToImportFromFiles[file].add(typeName.split('.')[0])
 }
 
-export function arrayContainsSet(array: string[], setToContain: Set<string>): boolean {
-    const arraySet = new Set(array)
-    for (const str of setToContain) {
-        if (!arraySet.has(str)) {
-            return false
-        }
-    }
-    return true
-}
-
 export function unPromisify(node: ts.Node): ts.Node {
     if (ts.isTypeReferenceNode(node) && (node.typeName as any)?.escapedText === 'Promise') {
         return node.typeArguments?.[0]

package/src/visit/visit.ts

@@ -4,7 +4,7 @@ import { AppOptions, ParsedLogic, PluginModule, TypeBuilderModule, VisitKeaPrope
 import {
     gatherImports,
     getFilenameForImportDeclaration,
-    getFilenameForImportSpecifier,
+    getFilenameForNode,
     getLogicPathString,
     getTypeNodeForNode,
     isKeaCall,
@@ -185,7 +185,7 @@ export function visitKeaCalls(
                 const declaration = symbol.getDeclarations()?.[0]
 
                 if (declaration && ts.isImportSpecifier(declaration)) {
-                    const filename = getFilenameForImportSpecifier(declaration, checker)
+                    const filename = getFilenameForNode(declaration, checker)
                     logicTypeImported = filename === typeFileName
                 }
             }
@@ -213,7 +213,6 @@ export function visitKeaCalls(
             listeners: [],
             sharedListeners: [],
             events: {},
-            extraActions: {},
             keyType: undefined,
             propsType: undefined,
             path: pathString.split('.'),
@@ -221,8 +220,9 @@ export function visitKeaCalls(
             hasKeyInLogic: false,
             hasPathInLogic: false,
             typeReferencesToImportFromFiles: {},
-            typeReferencesInLogicInput: new Set(),
+            extraActions: {},
             extraInput: {},
+            extraLogicFields: {},
             importFromKeaInLogicType: new Set([]),
             inputBuilderArray: ts.isArrayLiteralExpression(input),
         }
@@ -286,7 +286,10 @@ export function visitKeaCalls(
                                 }
 
                                 const folder = path.dirname(filename)
-                                const fileNoExt = path.basename(filename, path.extname(filename))
+                                let fileNoExt = path.basename(filename, path.extname(filename))
+                                if (fileNoExt.endsWith('.d')) {
+                                    fileNoExt = fileNoExt.slice(0, -2)
+                                }
                                 const pathsToTry = [
                                     'typegen.js',
                                     'typegen.ts',

package/src/write/writeTypeImports.ts

@@ -1,10 +1,10 @@
-import { AppOptions, ParsedLogic } from "../types";
-import * as ts from "typescript";
-import { print, visit } from "recast";
-import * as osPath from "path";
-import { runThroughPrettier } from "../print/print";
-import * as fs from "fs";
-import { t, b, visitAllKeaCalls, getAst } from "./utils";
+import { AppOptions, ParsedLogic } from '../types'
+import * as ts from 'typescript'
+import { print, visit } from 'recast'
+import * as osPath from 'path'
+import { runThroughPrettier } from '../print/print'
+import * as fs from 'fs'
+import { t, b, visitAllKeaCalls, getAst } from './utils'
 
 export function writeTypeImports(
     appOptions: AppOptions,
@@ -68,19 +68,10 @@ export function writeTypeImports(
         })
     }
 
-    // find all kea calls, add `<logicType<a,b>>` type parameters if needed
+    // find all kea calls, add `<logicType>` type parameters if needed
     visitAllKeaCalls(ast, logicsNeedingImports, filename, ({ path, parsedLogic }) => {
-        const { logicTypeName, typeReferencesInLogicInput } = parsedLogic
-
         path.node.typeParameters = b.tsTypeParameterInstantiation([
-            b.tsTypeReference(
-                b.identifier(logicTypeName),
-                typeReferencesInLogicInput.size > 0 ? b.tsTypeParameterInstantiation(
-                    [...typeReferencesInLogicInput.values()]
-                        .sort()
-                        .map((type) => b.tsTypeReference(b.identifier(type))),
-                ) : null,
-            ),
+            b.tsTypeReference(b.identifier(parsedLogic.logicTypeName)),
         ])
     })