kea-typegen 3.7.0 → 3.8.0

package/src/print/print.ts

@@ -36,6 +36,7 @@ import { printSharedListeners } from './printSharedListeners'
 import { printListeners } from './printListeners'
 import { writePaths } from '../write/writePaths'
 import { writeTypeImports } from '../write/writeTypeImports'
+import { writeInlineLogicTypes } from '../write/writeInlineLogicTypes'
 import { printInternalExtraInput } from './printInternalExtraInput'
 import { convertToBuilders } from '../write/convertToBuilders'
 import { cacheWrittenFile } from '../cache'
@@ -78,8 +79,10 @@ export async function printToFiles(
         }
         groupedByFile[parsedLogic.fileName].push(parsedLogic)
 
-        // create the Nodes and gather referenced types
-        printLogicType(parsedLogic, appOptions)
+        if (!appOptions.inline) {
+            // create the Nodes and gather referenced types
+            printLogicType(parsedLogic, appOptions)
+        }
     }
 
     // Automatically ignore imports from "node_modules/@types/node", if {types: ["node"]} in tsconfig.json
@@ -105,6 +108,11 @@ export async function printToFiles(
     const shouldIgnore = (absolutePath: string) =>
         !!doNotImportFromPaths.find((badPath) => absolutePath.startsWith(badPath))
 
+    const nodeModulesPath = path.join(
+        appOptions.packageJsonPath ? path.dirname(appOptions.packageJsonPath) : appOptions.rootPath,
+        'node_modules',
+    )
+
     let writtenFiles = 0
     let filesToWrite = 0
     let filesToModify = 0
@@ -112,6 +120,27 @@ export async function printToFiles(
     for (const [fileName, parsedLogics] of Object.entries(groupedByFile)) {
         const typeFileName = parsedLogics[0].typeFileName
 
+        if (appOptions.inline) {
+            // write/update MakeLogicType blocks above the logics instead of writing a logicType.ts file
+            const inlineResponse = await writeInlineLogicTypes(
+                program,
+                appOptions,
+                fileName,
+                parsedLogics,
+                nodeModulesPath,
+                shouldIgnore,
+            )
+            filesToWrite += inlineResponse.filesToWrite
+            writtenFiles += inlineResponse.writtenFiles
+
+            // the logicType.ts file is superseded by the inline block
+            if (appOptions.delete && fs.existsSync(typeFileName)) {
+                log(`🗑️ Deleting: ${path.relative(process.cwd(), typeFileName)}`)
+                fs.unlinkSync(typeFileName)
+            }
+            continue
+        }
+
         const logicStrings = []
         const requiredKeys = new Set(['Logic'])
         for (const parsedLogic of parsedLogics) {
@@ -131,62 +160,12 @@ export async function printToFiles(
 
         const output = logicStrings.join('\n\n')
 
-        const nodeModulesPath = path.join(
-            appOptions.packageJsonPath ? path.dirname(appOptions.packageJsonPath) : appOptions.rootPath,
-            'node_modules',
+        const otherimports = buildTypeImportEntries(
+            parsedLogics[0].typeReferencesToImportFromFiles,
+            parsedLogics[0].typeFileName,
+            nodeModulesPath,
+            shouldIgnore,
         )
-
-        const otherimports = Object.entries(parsedLogics[0].typeReferencesToImportFromFiles)
-            .filter(([_, list]) => list.size > 0)
-            .map(([file, list]) => {
-                let finalPath = file
-
-                // Relative path? Get the absolute.
-                if (finalPath.startsWith('.')) {
-                    finalPath = path.resolve(path.dirname(parsedLogics[0].typeFileName), finalPath)
-                }
-                if (finalPath.startsWith('node_modules/')) {
-                    finalPath = path.resolve(path.dirname(nodeModulesPath), finalPath)
-                }
-                // clean up '../../node_modules/...'
-                if (finalPath.startsWith(nodeModulesPath)) {
-                    finalPath = finalPath.substring(nodeModulesPath.length + 1)
-                    if (finalPath.startsWith('.pnpm/')) {
-                        // node_modules/.pnpm/pkg@version/node_modules/* --> *
-                        const regex = /\.pnpm\/[^/]+@[^\/]+\/node_modules\/(.*)/
-                        const result = finalPath.match(regex)
-                        if (result && result.length > 1) {
-                            finalPath = result[1]
-                        }
-                    }
-                    if (finalPath.startsWith('@types/')) {
-                        finalPath = finalPath.substring(7)
-                    }
-                }
-
-                // Resolve absolute urls
-                if (finalPath.startsWith('/')) {
-                    finalPath = path.relative(path.dirname(parsedLogics[0].typeFileName), finalPath)
-                    if (!finalPath.startsWith('.')) {
-                        finalPath = `./${finalPath}`
-                    }
-                }
-
-                // Remove extension
-                finalPath = finalPath.replace(/(\.d|)\.tsx?$/, '')
-
-                // Remove "/index"
-                if (finalPath.split('/').length === 2 && finalPath.endsWith('/index')) {
-                    finalPath = finalPath.substring(0, finalPath.length - 6)
-                }
-
-                return {
-                    list: [...list].sort(),
-                    fullPath: file,
-                    finalPath,
-                }
-            })
-            .filter((entry) => !shouldIgnore(entry.fullPath))
             .map(({ list, finalPath }) => `import type { ${list.join(', ')} } from '${finalPath}'`)
             .join('\n')
 
@@ -306,6 +285,72 @@ export async function printToFiles(
     return { filesToWrite, writtenFiles, filesToModify }
 }
 
+export interface TypeImportEntry {
+    list: string[]
+    fullPath: string
+    finalPath: string
+}
+
+/** Resolve gathered type references into import specifiers, relative to the file they'll be imported into */
+export function buildTypeImportEntries(
+    typeReferencesToImportFromFiles: Record<string, Set<string>>,
+    importIntoFile: string,
+    nodeModulesPath: string,
+    shouldIgnore: (absolutePath: string) => boolean,
+): TypeImportEntry[] {
+    return Object.entries(typeReferencesToImportFromFiles)
+        .filter(([_, list]) => list.size > 0)
+        .map(([file, list]) => {
+            let finalPath = file
+
+            // Relative path? Get the absolute.
+            if (finalPath.startsWith('.')) {
+                finalPath = path.resolve(path.dirname(importIntoFile), finalPath)
+            }
+            if (finalPath.startsWith('node_modules/')) {
+                finalPath = path.resolve(path.dirname(nodeModulesPath), finalPath)
+            }
+            // clean up '../../node_modules/...'
+            if (finalPath.startsWith(nodeModulesPath)) {
+                finalPath = finalPath.substring(nodeModulesPath.length + 1)
+                if (finalPath.startsWith('.pnpm/')) {
+                    // node_modules/.pnpm/pkg@version/node_modules/* --> *
+                    const regex = /\.pnpm\/[^/]+@[^\/]+\/node_modules\/(.*)/
+                    const result = finalPath.match(regex)
+                    if (result && result.length > 1) {
+                        finalPath = result[1]
+                    }
+                }
+                if (finalPath.startsWith('@types/')) {
+                    finalPath = finalPath.substring(7)
+                }
+            }
+
+            // Resolve absolute urls
+            if (finalPath.startsWith('/')) {
+                finalPath = path.relative(path.dirname(importIntoFile), finalPath)
+                if (!finalPath.startsWith('.')) {
+                    finalPath = `./${finalPath}`
+                }
+            }
+
+            // Remove extension
+            finalPath = finalPath.replace(/(\.d|)\.tsx?$/, '')
+
+            // Remove "/index"
+            if (finalPath.split('/').length === 2 && finalPath.endsWith('/index')) {
+                finalPath = finalPath.substring(0, finalPath.length - 6)
+            }
+
+            return {
+                list: [...list].sort(),
+                fullPath: file,
+                finalPath,
+            }
+        })
+        .filter((entry) => !shouldIgnore(entry.fullPath))
+}
+
 export function nodeToString(node: Node): string {
     const printer = createPrinter({ newLine: NewLineKind.LineFeed })
     const sourceFile = createSourceFile('logic.ts', '', ScriptTarget.Latest, false, ScriptKind.TS)

package/src/test-support/watch-mode-smoke.js

@@ -1,12 +1,15 @@
 const fs = require('fs')
+const os = require('os')
 const path = require('path')
 
 require('ts-node/register/transpile-only')
 
 const repoRoot = path.resolve(__dirname, '..', '..')
-const projectDir = fs.mkdtempSync(path.join(repoRoot, 'tmp-watch-smoke-'))
+const projectDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kea-typegen-watch-smoke-'))
 const tsconfigPath = path.join(projectDir, 'tsconfig.json')
+const keaDtsPath = path.join(projectDir, 'node_modules', 'kea', 'index.d.ts')
 const fileCount = 200
+const logicPaths = []
 
 const noop = () => {}
 console.info = noop
@@ -18,6 +21,10 @@ let completed = 0
 let settleTimer
 let timeoutTimer
 let finished = false
+let editTriggered = false
+let incrementalAfterEdit = false
+const parsedLogicCountsAfterEdit = []
+const sourceFilePathsAfterEdit = []
 
 function cleanup() {
     try {
@@ -41,16 +48,31 @@ function finish(code) {
             completed,
             active,
             maxActive,
+            incrementalAfterEdit,
+            parsedLogicCountsAfterEdit,
+            sourceFilePathsAfterEdit,
         }) + '\n',
     )
     process.exit(code)
 }
 
 function scheduleFinishIfSettled() {
-    if (started > 1 && active === 0) {
-        clearTimeout(settleTimer)
-        settleTimer = setTimeout(() => finish(0), 300)
+    if (active !== 0) {
+        return
     }
+
+    clearTimeout(settleTimer)
+    settleTimer = setTimeout(() => {
+        if (!editTriggered && started > 1) {
+            editTriggered = true
+            fs.appendFileSync(logicPaths[0], '\n// trigger incremental watch pass\n')
+            return
+        }
+
+        if (editTriggered && incrementalAfterEdit) {
+            finish(0)
+        }
+    }, 300)
 }
 
 process.on('uncaughtException', (error) => {
@@ -82,9 +104,13 @@ fs.writeFileSync(
     ),
 )
 
+fs.mkdirSync(path.dirname(keaDtsPath), { recursive: true })
+fs.writeFileSync(keaDtsPath, 'export function kea<T = any>(input: any): T\n')
+
 for (let i = 0; i < fileCount; i++) {
     const dir = path.join(projectDir, 'src', `group${String(i % 10).padStart(2, '0')}`)
     const filePath = path.join(dir, `logic${i}.ts`)
+    logicPaths.push(filePath)
 
     fs.mkdirSync(dir, { recursive: true })
     fs.writeFileSync(
@@ -109,11 +135,20 @@ const printModule = require(path.join(repoRoot, 'src/print/print'))
 const originalPrintToFiles = printModule.printToFiles
 
 printModule.printToFiles = async function (...args) {
+    const appOptions = args[1]
+    const parsedLogics = args[2]
+
     active += 1
     started += 1
     maxActive = Math.max(maxActive, active)
     clearTimeout(settleTimer)
 
+    if (editTriggered) {
+        parsedLogicCountsAfterEdit.push(parsedLogics.length)
+        sourceFilePathsAfterEdit.push(appOptions.sourceFilePath || null)
+        incrementalAfterEdit = incrementalAfterEdit || (parsedLogics.length === 1 && !!appOptions.sourceFilePath)
+    }
+
     await new Promise((resolve) => setTimeout(resolve, 25))
 
     try {

package/src/test-support/write-mode-smoke.js

@@ -1,13 +1,15 @@
 const fs = require('fs')
 const Module = require('module')
+const os = require('os')
 const path = require('path')
 
 require('ts-node/register/transpile-only')
 
 const repoRoot = path.resolve(__dirname, '..', '..')
-const projectDir = fs.mkdtempSync(path.join(repoRoot, 'tmp-write-smoke-'))
+const projectDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kea-typegen-write-smoke-'))
 const tsconfigPath = path.join(projectDir, 'tsconfig.json')
 const logicFilePath = path.join(projectDir, 'src', 'logic.ts')
+const keaDtsPath = path.join(projectDir, 'node_modules', 'kea', 'index.d.ts')
 
 const noop = () => {}
 
@@ -83,6 +85,7 @@ process.on('unhandledRejection', (error) => {
 })
 
 fs.mkdirSync(path.dirname(logicFilePath), { recursive: true })
+fs.mkdirSync(path.dirname(keaDtsPath), { recursive: true })
 fs.writeFileSync(
     tsconfigPath,
     JSON.stringify(
@@ -102,6 +105,8 @@ fs.writeFileSync(
     ),
 )
 
+fs.writeFileSync(keaDtsPath, 'export function kea<T = any>(input: any): T\n')
+
 fs.writeFileSync(
     logicFilePath,
     [

package/src/typegen.ts

@@ -6,6 +6,7 @@ import { AppOptions } from './types'
 import { Program } from 'typescript'
 import { version } from '../package.json'
 import { restoreCachedTypes } from './cache'
+import { createWatchChangeTracker, planWatchTypegenPass, WatchFileChange, WatchTypegenPlan } from './watch'
 
 // The undocumented defaultMaximumTruncationLength setting determines at what point printed types are truncated in versions less than 5.
 // In kea-typegen output, we NEVER want the types truncated, as that results in a syntax error –
@@ -50,12 +51,13 @@ export async function runTypeGen(appOptions: AppOptions) {
             // We don't emit JavaScript files in typegen watch mode, so the semantic-only
             // builder is enough and avoids extra emit-related work on every rebuild.
             const createProgram = ts.createSemanticDiagnosticsBuilderProgram
+            const watchChangeTracker = createWatchChangeTracker(ts.sys)
 
             const host = ts.createWatchCompilerHost(
                 appOptions.tsConfigPath,
                 compilerOptions.options,
                 {
-                    ...ts.sys,
+                    ...watchChangeTracker.system,
                     writeFile(_path: string, _data: string, _writeByteOrderMark?: boolean) {
                         // skip emit
                         // https://github.com/microsoft/TypeScript/issues/32385
@@ -92,6 +94,7 @@ export async function runTypeGen(appOptions: AppOptions) {
 
             const origPostProgramCreate = host.afterProgramCreate
             let scheduledProgram: Program | undefined
+            let scheduledChanges: WatchFileChange[] = []
             let runningTypegen = false
 
             const runScheduledTypegen = async () => {
@@ -104,10 +107,16 @@ export async function runTypeGen(appOptions: AppOptions) {
                 try {
                     while (scheduledProgram) {
                         const nextProgram = scheduledProgram
+                        const nextChanges = scheduledChanges
                         scheduledProgram = undefined
+                        scheduledChanges = []
 
                         try {
-                            await goThroughAllTheFiles(nextProgram, appOptions)
+                            await goThroughWatchTypegenPlan(
+                                nextProgram,
+                                appOptions,
+                                planWatchTypegenPass(nextProgram, nextChanges),
+                            )
                         } catch (error) {
                             console.error('⛔ Error running kea-typegen in watch mode')
                             console.error(error)
@@ -124,8 +133,10 @@ export async function runTypeGen(appOptions: AppOptions) {
 
             host.afterProgramCreate = (prog) => {
                 program = prog.getProgram()
+                const changes = watchChangeTracker.consume()
                 origPostProgramCreate?.(prog)
                 scheduledProgram = program
+                scheduledChanges.push(...changes)
                 void runScheduledTypegen()
             }
 
@@ -173,6 +184,46 @@ export async function runTypeGen(appOptions: AppOptions) {
         return response
     }
 
+    async function goThroughWatchTypegenPlan(
+        program,
+        appOptions,
+        plan: WatchTypegenPlan,
+    ): Promise<{ filesToWrite: number; writtenFiles: number; filesToModify: number }> {
+        if (plan.kind === 'skip') {
+            if (appOptions.verbose) {
+                appOptions.log(`⏭️ Skipping typegen watch pass: ${plan.reason}`)
+            }
+            return { filesToWrite: 0, writtenFiles: 0, filesToModify: 0 }
+        }
+
+        if (plan.kind === 'full') {
+            if (appOptions.verbose) {
+                appOptions.log(`🔎 Running full typegen watch pass: ${plan.reason}`)
+            }
+            return await goThroughAllTheFiles(program, appOptions)
+        }
+
+        if (appOptions.verbose) {
+            appOptions.log(`🎯 Running incremental typegen watch pass: ${plan.reason}`)
+        }
+
+        const response = { filesToWrite: 0, writtenFiles: 0, filesToModify: 0 }
+
+        for (const sourceFilePath of plan.sourceFilePaths) {
+            const fileResponse = await goThroughAllTheFiles(program, {
+                ...appOptions,
+                delete: false,
+                sourceFilePath,
+            })
+
+            response.filesToWrite += fileResponse.filesToWrite
+            response.writtenFiles += fileResponse.writtenFiles
+            response.filesToModify += fileResponse.filesToModify
+        }
+
+        return response
+    }
+
     if (program && !appOptions.watch && appOptions.sourceFilePath) {
         await goThroughAllTheFiles(program, appOptions)
         if (appOptions.write) {

package/src/types.ts

@@ -78,6 +78,8 @@ export interface AppOptions {
     addTsNocheck?: boolean
     /** Convert kea 2.0 logic input to kea 3.0 builders */
     convertToBuilders?: boolean
+    /** Write logic types as MakeLogicType blocks above each kea() call, instead of into logicType.ts files */
+    inline?: boolean
     /** Show TypeScript errors */
     showTsErrors?: boolean
     /** Cache generated logic files into .typegen, use them if generating a logic type for the first time */

package/src/utils.ts

@@ -53,6 +53,87 @@ export function isKeaCall(node: ts.Node, checker: ts.TypeChecker) {
     return ts.isObjectLiteralExpression(input) || ts.isArrayLiteralExpression(input)
 }
 
+/** True if the node has a leading "kea-typegen" comment, marking it as generated by us */
+export function hasKeaTypegenMarker(node: ts.Node): boolean {
+    const sourceFile = node.getSourceFile()
+    const ranges = ts.getLeadingCommentRanges(sourceFile.text, node.pos) ?? []
+    return ranges.some(({ pos, end }) => sourceFile.text.slice(pos, end).includes('kea-typegen'))
+}
+
+const INLINE_BLOCK_SUFFIXES = ['Values', 'Actions', 'Props']
+
+/**
+ * The statements making up an inline logic type block: the `logicType` alias itself, plus any
+ * `logicValues` / `logicActions` / `logicProps` interfaces directly above it.
+ */
+export function getInlineBlockStatements(
+    declaration: ts.TypeAliasDeclaration | ts.InterfaceDeclaration,
+    logicName: string,
+): ts.Statement[] {
+    const statements = declaration.getSourceFile().statements
+    const index = statements.indexOf(declaration)
+    if (index === -1) {
+        return [declaration]
+    }
+    const generatedNames = new Set(INLINE_BLOCK_SUFFIXES.map((suffix) => `${logicName}${suffix}`))
+    const block: ts.Statement[] = [declaration]
+    for (let i = index - 1; i >= 0; i--) {
+        const statement = statements[i]
+        if (
+            (ts.isInterfaceDeclaration(statement) || ts.isTypeAliasDeclaration(statement)) &&
+            generatedNames.has(statement.name.text)
+        ) {
+            block.unshift(statement)
+        } else {
+            break
+        }
+    }
+    return block
+}
+
+/** True if this local `logicType` declaration is part of a kea-typegen generated inline block */
+export function isGeneratedInlineBlock(
+    declaration: ts.TypeAliasDeclaration | ts.InterfaceDeclaration,
+    logicName: string,
+): boolean {
+    return getInlineBlockStatements(declaration, logicName).some(hasKeaTypegenMarker)
+}
+
+/**
+ * True if the type argument in `kea<...>()` is a manually written type (e.g. `MakeLogicType<...>`
+ * or a custom interface), as opposed to a type that kea-typegen generates and keeps updated.
+ * Manually typed logics are skipped entirely.
+ */
+export function isManuallyTypedLogic(
+    typeArgument: ts.TypeNode,
+    logicTypeName: string,
+    checker: ts.TypeChecker,
+): boolean {
+    if (!ts.isTypeReferenceNode(typeArgument)) {
+        // e.g. kea<{ actions: ... }>(...)
+        return true
+    }
+    if (!ts.isIdentifier(typeArgument.typeName) || typeArgument.typeName.escapedText !== logicTypeName) {
+        // e.g. kea<MakeLogicType<Values, Actions>>(...) or kea<MyCustomLogicType>(...)
+        return true
+    }
+    const symbol = checker.getSymbolAtLocation(typeArgument.typeName)
+    const declaration = symbol?.getDeclarations()?.[0]
+    if (!declaration) {
+        // "logicType" that doesn't resolve --> a generated type that doesn't exist yet
+        return false
+    }
+    if (ts.isImportSpecifier(declaration)) {
+        // imported logic types are managed by kea-typegen
+        return false
+    }
+    if (ts.isTypeAliasDeclaration(declaration) || ts.isInterfaceDeclaration(declaration)) {
+        // local declarations are ours only if their block carries the kea-typegen marker (written by --inline mode)
+        return !isGeneratedInlineBlock(declaration, logicTypeName.replace(/Type$/, ''))
+    }
+    return true
+}
+
 export function getTypeNodeForNode(node: ts.Node, checker: ts.TypeChecker): ts.TypeNode {
     let typeNode
     if (node) {

package/src/visit/visit.ts

@@ -10,6 +10,7 @@ import {
     getLogicPathString,
     getTypeNodeForNode,
     isKeaCall,
+    isManuallyTypedLogic,
 } from '../utils'
 import { visitActions } from './visitActions'
 import { visitReducers } from './visitReducers'
@@ -216,6 +217,19 @@ export function visitKeaCalls(
         const keaTypeArguments = ts.isCallExpression(node.parent) ? node.parent.typeArguments : []
         const keaTypeArgument = keaTypeArguments?.[0]
 
+        // if the logic is already manually typed (e.g. kea<MakeLogicType<...>>(...)), leave it alone
+        if (keaTypeArgument && isManuallyTypedLogic(keaTypeArgument, logicTypeName, checker)) {
+            if (appOptions?.verbose) {
+                appOptions.log(
+                    `🩶 Skipping manually typed logic "${logicName}" in ${path.relative(
+                        process.cwd(),
+                        sourceFile.fileName,
+                    )}`,
+                )
+            }
+            return
+        }
+
         const pathString = getLogicPathString(appOptions, sourceFile.fileName)
         let typeFileName = sourceFile.fileName.replace(/\.[tj]sx?$/, 'Type.ts')