kea-typegen 3.7.1 → 3.8.1

package/src/__tests__/inline.ts

@@ -0,0 +1,747 @@
+import * as fs from 'fs'
+import * as os from 'os'
+import * as path from 'path'
+import * as ts from 'typescript'
+import { AppOptions } from '../types'
+import { programFromSource } from '../utils'
+import { visitProgram } from '../visit/visit'
+import { printToFiles } from '../print/print'
+
+describe('manually typed logics', () => {
+    test('skips logics typed with MakeLogicType', () => {
+        const logicSource = `
+            import { kea, MakeLogicType } from 'kea'
+
+            interface Values { name: string }
+            interface Actions { updateName: (name: string) => { name: string } }
+
+            const logic = kea<MakeLogicType<Values, Actions>>({
+                actions: () => ({
+                    updateName: (name: string) => ({ name }),
+                }),
+            })
+        `
+        expect(visitProgram(programFromSource(logicSource)).length).toBe(0)
+    })
+
+    test('skips logics typed with a custom local type, even when named like a generated one', () => {
+        const logicSource = `
+            import { kea, MakeLogicType } from 'kea'
+
+            export type logicType = MakeLogicType<{ name: string }, { updateName: (name: string) => { name: string } }>
+
+            const logic = kea<logicType>({
+                actions: () => ({
+                    updateName: (name: string) => ({ name }),
+                }),
+            })
+        `
+        expect(visitProgram(programFromSource(logicSource)).length).toBe(0)
+    })
+
+    test('does not skip local logic types carrying the kea-typegen marker', () => {
+        const logicSource = `
+            import { kea, MakeLogicType } from 'kea'
+
+            // Generated by kea-typegen. DO NOT EDIT THIS BLOCK MANUALLY.
+            export type logicType = MakeLogicType<{ name: string }, { updateName: (name: string) => { name: string } }>
+
+            const logic = kea<logicType>({
+                actions: () => ({
+                    updateName: (name: string) => ({ name }),
+                }),
+            })
+        `
+        const parsedLogics = visitProgram(programFromSource(logicSource))
+        expect(parsedLogics.length).toBe(1)
+        expect(parsedLogics[0].actions.map((a) => a.name)).toEqual(['updateName'])
+    })
+
+    test('does not skip generated blocks where the marker sits on the values interface', () => {
+        const logicSource = `
+            import { kea, MakeLogicType } from 'kea'
+
+            // Generated by kea-typegen. DO NOT EDIT THIS BLOCK MANUALLY.
+            export interface logicValues { name: string }
+
+            export interface logicActions { updateName: (name: string) => { name: string } }
+
+            export type logicType = MakeLogicType<logicValues, logicActions>
+
+            const logic = kea<logicType>({
+                actions: () => ({
+                    updateName: (name: string) => ({ name }),
+                }),
+            })
+        `
+        const parsedLogics = visitProgram(programFromSource(logicSource))
+        expect(parsedLogics.length).toBe(1)
+    })
+
+    test('does not skip logics with a generated type that does not resolve yet', () => {
+        const logicSource = `
+            import { kea } from 'kea'
+
+            const logic = kea<logicType>({
+                actions: () => ({
+                    updateName: (name: string) => ({ name }),
+                }),
+            })
+        `
+        expect(visitProgram(programFromSource(logicSource)).length).toBe(1)
+    })
+})
+
+describe('inline mode', () => {
+    const createProgram = (fileNames: string[]) =>
+        ts.createProgram(fileNames, {
+            module: ts.ModuleKind.CommonJS,
+            moduleResolution: ts.ModuleResolutionKind.NodeJs,
+            target: ts.ScriptTarget.ES2020,
+            skipLibCheck: true,
+        })
+
+    test('writes and updates MakeLogicType blocks above the logic', async () => {
+        const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kea-typegen-inline-'))
+
+        try {
+            const logicDir = path.join(tempDir, 'src')
+            const logicPath = path.join(logicDir, 'logic.ts')
+            const logicTypePath = path.join(logicDir, 'logicType.ts')
+            const keaDtsPath = path.join(tempDir, 'node_modules', 'kea', 'index.d.ts')
+
+            fs.mkdirSync(path.dirname(keaDtsPath), { recursive: true })
+            fs.mkdirSync(logicDir, { recursive: true })
+
+            fs.writeFileSync(
+                keaDtsPath,
+                [
+                    'export function kea<T = any>(input: any): T',
+                    'export interface MakeLogicType<V = any, A = any, P = any> {}',
+                    '',
+                ].join('\n'),
+            )
+            fs.writeFileSync(
+                logicPath,
+                [
+                    "import { kea } from 'kea'",
+                    '',
+                    'export const logic = kea({',
+                    '    props: {} as { id: number },',
+                    '    actions: () => ({',
+                    '        setValue: (value: string) => ({ value }),',
+                    '    }),',
+                    '    reducers: () => ({',
+                    "        value: ['' as string, { setValue: (_, { value }) => value }],",
+                    '    }),',
+                    '})',
+                    '',
+                ].join('\n'),
+            )
+
+            const appOptions: AppOptions = {
+                rootPath: logicDir,
+                typesPath: logicDir,
+                packageJsonPath: path.join(tempDir, 'package.json'),
+                inline: true,
+                write: true,
+                log: () => {},
+            }
+
+            const program = createProgram([logicPath])
+            const parsedLogics = visitProgram(program, appOptions)
+            expect(parsedLogics.length).toBe(1)
+
+            const response = await printToFiles(program, appOptions, parsedLogics)
+            expect(response.writtenFiles).toBe(1)
+
+            const writtenLogic = fs.readFileSync(logicPath, 'utf8')
+
+            expect(writtenLogic).toContain("import { MakeLogicType, kea } from 'kea'")
+            expect(writtenLogic).toContain('// Generated by kea-typegen. DO NOT EDIT THIS BLOCK MANUALLY.')
+            expect(writtenLogic).toContain('export interface logicValues {')
+            expect(writtenLogic).toContain('export interface logicActions {')
+            expect(writtenLogic).toContain('export interface logicProps {')
+            expect(writtenLogic).toContain('export type logicType = MakeLogicType<logicValues, logicActions, logicProps>')
+            expect(writtenLogic).toContain('export const logic = kea<logicType>({')
+            expect(writtenLogic).toContain('value: string')
+            expect(writtenLogic).toContain('setValue: (value: string) =>')
+            expect(fs.existsSync(logicTypePath)).toBe(false)
+
+            // a second pass over the written file changes nothing
+            const secondProgram = createProgram([logicPath])
+            const secondParsedLogics = visitProgram(secondProgram, appOptions)
+            expect(secondParsedLogics.length).toBe(1)
+
+            const secondResponse = await printToFiles(secondProgram, appOptions, secondParsedLogics)
+            expect(secondResponse).toEqual({ filesToWrite: 0, writtenFiles: 0, filesToModify: 0 })
+            expect(fs.readFileSync(logicPath, 'utf8')).toBe(writtenLogic)
+
+            // adding an action updates the existing block in place
+            fs.writeFileSync(
+                logicPath,
+                fs
+                    .readFileSync(logicPath, 'utf8')
+                    .replace('setValue: (value: string) => ({ value }),', 'setValue: (value: string) => ({ value }),\n        reset: true,'),
+            )
+
+            const thirdProgram = createProgram([logicPath])
+            const thirdResponse = await printToFiles(thirdProgram, appOptions, visitProgram(thirdProgram, appOptions))
+            expect(thirdResponse.writtenFiles).toBe(1)
+
+            const updatedLogic = fs.readFileSync(logicPath, 'utf8')
+            expect(updatedLogic).toContain('reset: ')
+            expect(updatedLogic.match(/export type logicType = MakeLogicType</g)?.length).toBe(1)
+            expect(updatedLogic.match(/export interface logicValues \{/g)?.length).toBe(1)
+            expect(updatedLogic.match(/export interface logicActions \{/g)?.length).toBe(1)
+            // one marker per generated interface (values, actions, props)
+            expect(updatedLogic.match(/DO NOT EDIT THIS BLOCK MANUALLY/g)?.length).toBe(3)
+        } finally {
+            fs.rmSync(tempDir, { recursive: true, force: true })
+        }
+    })
+
+    test('replaces the old logicType.ts import when switching to inline mode', async () => {
+        const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kea-typegen-inline-migrate-'))
+
+        try {
+            const logicDir = path.join(tempDir, 'src')
+            const logicPath = path.join(logicDir, 'logic.ts')
+            const logicTypePath = path.join(logicDir, 'logicType.ts')
+            const keaDtsPath = path.join(tempDir, 'node_modules', 'kea', 'index.d.ts')
+
+            fs.mkdirSync(path.dirname(keaDtsPath), { recursive: true })
+            fs.mkdirSync(logicDir, { recursive: true })
+
+            fs.writeFileSync(
+                keaDtsPath,
+                [
+                    'export function kea<T = any>(input: any): T',
+                    'export interface MakeLogicType<V = any, A = any, P = any> {}',
+                    '',
+                ].join('\n'),
+            )
+            fs.writeFileSync(logicTypePath, 'export interface logicType {}\n')
+            fs.writeFileSync(
+                logicPath,
+                [
+                    "import { kea } from 'kea'",
+                    "import type { logicType } from './logicType'",
+                    '',
+                    'export const logic = kea<logicType>({',
+                    '    actions: () => ({',
+                    '        setValue: (value: string) => ({ value }),',
+                    '    }),',
+                    '})',
+                    '',
+                ].join('\n'),
+            )
+
+            const appOptions: AppOptions = {
+                rootPath: logicDir,
+                typesPath: logicDir,
+                packageJsonPath: path.join(tempDir, 'package.json'),
+                inline: true,
+                write: true,
+                delete: true,
+                log: () => {},
+            }
+
+            const program = createProgram([logicPath])
+            const response = await printToFiles(program, appOptions, visitProgram(program, appOptions))
+            expect(response.writtenFiles).toBe(1)
+
+            const writtenLogic = fs.readFileSync(logicPath, 'utf8')
+
+            expect(writtenLogic).not.toContain("from './logicType'")
+            expect(writtenLogic).toContain("import { MakeLogicType, kea } from 'kea'")
+            expect(writtenLogic).toContain('export interface logicActions {')
+            // no values or props on this logic, so no interfaces are generated for them
+            expect(writtenLogic).toContain('export type logicType = MakeLogicType<{}, logicActions>')
+            expect(writtenLogic).toContain('export const logic = kea<logicType>({')
+            expect(fs.existsSync(logicTypePath)).toBe(false)
+        } finally {
+            fs.rmSync(tempDir, { recursive: true, force: true })
+        }
+    })
+
+    test('leaves a reformatted but semantically identical block alone', async () => {
+        const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kea-typegen-inline-reformat-'))
+
+        try {
+            const logicDir = path.join(tempDir, 'src')
+            const logicPath = path.join(logicDir, 'logic.ts')
+            const keaDtsPath = path.join(tempDir, 'node_modules', 'kea', 'index.d.ts')
+
+            fs.mkdirSync(path.dirname(keaDtsPath), { recursive: true })
+            fs.mkdirSync(logicDir, { recursive: true })
+
+            fs.writeFileSync(
+                keaDtsPath,
+                [
+                    'export function kea<T = any>(input: any): T',
+                    'export interface MakeLogicType<V = any, A = any, P = any> {}',
+                    '',
+                ].join('\n'),
+            )
+            fs.writeFileSync(
+                logicPath,
+                [
+                    "import { MakeLogicType, kea } from 'kea'",
+                    '',
+                    'export const logic = kea({',
+                    '    actions: () => ({',
+                    '        setValue: (value: string | number) => ({ value }),',
+                    '    }),',
+                    '})',
+                    '',
+                ].join('\n'),
+            )
+
+            const appOptions: AppOptions = {
+                rootPath: logicDir,
+                typesPath: logicDir,
+                packageJsonPath: path.join(tempDir, 'package.json'),
+                inline: true,
+                write: true,
+                log: () => {},
+            }
+
+            const program = createProgram([logicPath])
+            await printToFiles(program, appOptions, visitProgram(program, appOptions))
+
+            // simulate a formatter pass: strip semicolons and reflow unions with a leading pipe
+            const formatted = fs
+                .readFileSync(logicPath, 'utf8')
+                .replace(/;$/gm, '')
+                .replace(/value: string \| number\) =>/g, 'value:\n        | string\n        | number\n    ) =>')
+            fs.writeFileSync(logicPath, formatted)
+
+            const secondProgram = createProgram([logicPath])
+            const secondResponse = await printToFiles(secondProgram, appOptions, visitProgram(secondProgram, appOptions))
+            expect(secondResponse).toEqual({ filesToWrite: 0, writtenFiles: 0, filesToModify: 0 })
+            expect(fs.readFileSync(logicPath, 'utf8')).toBe(formatted)
+        } finally {
+            fs.rmSync(tempDir, { recursive: true, force: true })
+        }
+    })
+
+    test('keeps leading comments attached to the logic when inserting the block', async () => {
+        const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kea-typegen-inline-comments-'))
+
+        try {
+            const logicDir = path.join(tempDir, 'src')
+            const logicPath = path.join(logicDir, 'logic.ts')
+            const keaDtsPath = path.join(tempDir, 'node_modules', 'kea', 'index.d.ts')
+
+            fs.mkdirSync(path.dirname(keaDtsPath), { recursive: true })
+            fs.mkdirSync(logicDir, { recursive: true })
+
+            fs.writeFileSync(
+                keaDtsPath,
+                [
+                    'export function kea<T = any>(input: any): T',
+                    'export interface MakeLogicType<V = any, A = any, P = any> {}',
+                    '',
+                ].join('\n'),
+            )
+            fs.writeFileSync(
+                logicPath,
+                [
+                    "import { kea } from 'kea'",
+                    '',
+                    '// this comment describes the logic and must stay attached to it',
+                    'export const logic = kea({',
+                    '    actions: () => ({',
+                    '        setValue: (value: string) => ({ value }),',
+                    '    }),',
+                    '})',
+                    '',
+                ].join('\n'),
+            )
+
+            const appOptions: AppOptions = {
+                rootPath: logicDir,
+                typesPath: logicDir,
+                packageJsonPath: path.join(tempDir, 'package.json'),
+                inline: true,
+                write: true,
+                log: () => {},
+            }
+
+            const program = createProgram([logicPath])
+            const response = await printToFiles(program, appOptions, visitProgram(program, appOptions))
+            expect(response.writtenFiles).toBe(1)
+
+            const writtenLogic = fs.readFileSync(logicPath, 'utf8')
+            expect(writtenLogic).toContain(
+                [
+                    '// this comment describes the logic and must stay attached to it',
+                    'export const logic = kea<logicType>({',
+                ].join('\n'),
+            )
+            // the generated block sits above the comment
+            expect(writtenLogic.indexOf('DO NOT EDIT THIS BLOCK MANUALLY')).toBeLessThan(
+                writtenLogic.indexOf('// this comment describes the logic'),
+            )
+        } finally {
+            fs.rmSync(tempDir, { recursive: true, force: true })
+        }
+    })
+
+    test('annotates untyped selector combiner parameters', async () => {
+        const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kea-typegen-inline-selectors-'))
+
+        try {
+            const logicDir = path.join(tempDir, 'src')
+            const logicPath = path.join(logicDir, 'logic.ts')
+            const keaDtsPath = path.join(tempDir, 'node_modules', 'kea', 'index.d.ts')
+
+            fs.mkdirSync(path.dirname(keaDtsPath), { recursive: true })
+            fs.mkdirSync(logicDir, { recursive: true })
+
+            fs.writeFileSync(
+                keaDtsPath,
+                [
+                    'export function kea<T = any>(input: any): T',
+                    'export interface MakeLogicType<V = any, A = any, P = any> {}',
+                    '',
+                ].join('\n'),
+            )
+            fs.writeFileSync(
+                logicPath,
+                [
+                    "import { kea } from 'kea'",
+                    '',
+                    'export const logic = kea({',
+                    '    actions: () => ({',
+                    '        setCounter: (counter: number) => ({ counter }),',
+                    '    }),',
+                    '    reducers: () => ({',
+                    '        counter: [0 as number, { setCounter: (_, { counter }) => counter }],',
+                    '    }),',
+                    '    selectors: () => ({',
+                    '        doubleCounter: [(s): [() => number] => [s.counter], (counter) => counter * 2],',
+                    '        typedCounter: [(s): [() => number] => [s.counter], (counter: number) => counter * 3],',
+                    '    }),',
+                    '})',
+                    '',
+                ].join('\n'),
+            )
+
+            const appOptions: AppOptions = {
+                rootPath: logicDir,
+                typesPath: logicDir,
+                packageJsonPath: path.join(tempDir, 'package.json'),
+                inline: true,
+                write: true,
+                log: () => {},
+            }
+
+            const program = createProgram([logicPath])
+            const response = await printToFiles(program, appOptions, visitProgram(program, appOptions))
+            expect(response.writtenFiles).toBe(1)
+
+            const writtenLogic = fs.readFileSync(logicPath, 'utf8')
+            expect(writtenLogic).toContain('(counter: number) => counter * 2')
+            // already annotated params stay untouched
+            expect(writtenLogic).toContain('(counter: number) => counter * 3')
+
+            // a second pass changes nothing
+            const secondProgram = createProgram([logicPath])
+            const secondResponse = await printToFiles(secondProgram, appOptions, visitProgram(secondProgram, appOptions))
+            expect(secondResponse).toEqual({ filesToWrite: 0, writtenFiles: 0, filesToModify: 0 })
+        } finally {
+            fs.rmSync(tempDir, { recursive: true, force: true })
+        }
+    })
+})
+
+describe('mixed mode with inlinePaths', () => {
+    const createProgram = (fileNames: string[]) =>
+        ts.createProgram(fileNames, {
+            module: ts.ModuleKind.CommonJS,
+            moduleResolution: ts.ModuleResolutionKind.NodeJs,
+            target: ts.ScriptTarget.ES2020,
+            skipLibCheck: true,
+        })
+
+    const writeKeaDts = (tempDir: string) => {
+        const keaDtsPath = path.join(tempDir, 'node_modules', 'kea', 'index.d.ts')
+        fs.mkdirSync(path.dirname(keaDtsPath), { recursive: true })
+        fs.writeFileSync(
+            keaDtsPath,
+            [
+                'export function kea<T = any>(input: any): T',
+                'export interface MakeLogicType<V = any, A = any, P = any> {}',
+                '',
+            ].join('\n'),
+        )
+    }
+
+    const simpleLogicSource = [
+        "import { kea } from 'kea'",
+        '',
+        'export const logic = kea({',
+        '    actions: () => ({',
+        '        setValue: (value: string) => ({ value }),',
+        '    }),',
+        '})',
+        '',
+    ].join('\n')
+
+    test('files under inlinePaths go inline, everything else keeps logicType.ts', async () => {
+        const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kea-typegen-inline-paths-'))
+
+        try {
+            const rootDir = path.join(tempDir, 'src')
+            const inlineDir = path.join(rootDir, 'scenes', 'inlined')
+            const classicDir = path.join(rootDir, 'scenes', 'classic')
+            const inlineLogicPath = path.join(inlineDir, 'inlinedLogic.ts')
+            const classicLogicPath = path.join(classicDir, 'classicLogic.ts')
+
+            writeKeaDts(tempDir)
+            fs.mkdirSync(inlineDir, { recursive: true })
+            fs.mkdirSync(classicDir, { recursive: true })
+            fs.writeFileSync(inlineLogicPath, simpleLogicSource.replace('export const logic', 'export const inlinedLogic'))
+            fs.writeFileSync(classicLogicPath, simpleLogicSource.replace('export const logic', 'export const classicLogic'))
+
+            const appOptions: AppOptions = {
+                rootPath: rootDir,
+                typesPath: rootDir,
+                packageJsonPath: path.join(tempDir, 'package.json'),
+                inlinePaths: [path.join(rootDir, 'scenes', 'inlined')],
+                write: true,
+                delete: true,
+                log: () => {},
+            }
+
+            const program = createProgram([inlineLogicPath, classicLogicPath])
+            await printToFiles(program, appOptions, visitProgram(program, appOptions))
+
+            const writtenInlineLogic = fs.readFileSync(inlineLogicPath, 'utf8')
+            expect(writtenInlineLogic).toContain('// Generated by kea-typegen. DO NOT EDIT THIS BLOCK MANUALLY.')
+            expect(writtenInlineLogic).toContain('export type inlinedLogicType = MakeLogicType<{}, inlinedLogicActions>')
+            expect(fs.existsSync(path.join(inlineDir, 'inlinedLogicType.ts'))).toBe(false)
+
+            const writtenClassicLogic = fs.readFileSync(classicLogicPath, 'utf8')
+            expect(writtenClassicLogic).not.toContain('MakeLogicType')
+            expect(fs.existsSync(path.join(classicDir, 'classicLogicType.ts'))).toBe(true)
+        } finally {
+            fs.rmSync(tempDir, { recursive: true, force: true })
+        }
+    })
+
+    test('relative inlinePaths resolve against rootPath', async () => {
+        const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kea-typegen-inline-paths-relative-'))
+
+        try {
+            const rootDir = path.join(tempDir, 'src')
+            const inlineDir = path.join(rootDir, 'scenes', 'inlined')
+            const inlineLogicPath = path.join(inlineDir, 'inlinedLogic.ts')
+
+            writeKeaDts(tempDir)
+            fs.mkdirSync(inlineDir, { recursive: true })
+            fs.writeFileSync(inlineLogicPath, simpleLogicSource.replace('export const logic', 'export const inlinedLogic'))
+
+            const appOptions: AppOptions = {
+                rootPath: rootDir,
+                typesPath: rootDir,
+                packageJsonPath: path.join(tempDir, 'package.json'),
+                inlinePaths: ['./scenes/inlined'],
+                write: true,
+                log: () => {},
+            }
+
+            const program = createProgram([inlineLogicPath])
+            await printToFiles(program, appOptions, visitProgram(program, appOptions))
+
+            expect(fs.readFileSync(inlineLogicPath, 'utf8')).toContain(
+                '// Generated by kea-typegen. DO NOT EDIT THIS BLOCK MANUALLY.',
+            )
+            expect(fs.existsSync(path.join(inlineDir, 'inlinedLogicType.ts'))).toBe(false)
+        } finally {
+            fs.rmSync(tempDir, { recursive: true, force: true })
+        }
+    })
+
+    test('connected actions from an inline (MakeLogicType) logic land in the consuming logic type', async () => {
+        const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kea-typegen-inline-connect-'))
+
+        try {
+            const rootDir = path.join(tempDir, 'src')
+            const inlineLogicPath = path.join(rootDir, 'inlinedLogic.ts')
+            const consumerLogicPath = path.join(rootDir, 'consumerLogic.ts')
+            const keaDtsPath = path.join(tempDir, 'node_modules', 'kea', 'index.d.ts')
+
+            fs.mkdirSync(path.dirname(keaDtsPath), { recursive: true })
+            fs.mkdirSync(rootDir, { recursive: true })
+
+            // minimal kea with a mapped-type MakeLogicType, mirroring the real shape
+            fs.writeFileSync(
+                keaDtsPath,
+                [
+                    'export function kea<T = any>(input: any): T',
+                    'export type AnyFunction = (...args: any) => any',
+                    'export interface MakeLogicType<V = any, A = any, P = any> {',
+                    '    actionCreators: {',
+                    '        [K in keyof A]: A[K] extends AnyFunction',
+                    '            ? (...args: Parameters<A[K]>) => { type: string; payload: ReturnType<A[K]> }',
+                    '            : never',
+                    '    }',
+                    '    values: V',
+                    '}',
+                    '',
+                ].join('\n'),
+            )
+            fs.writeFileSync(
+                inlineLogicPath,
+                [
+                    "import { MakeLogicType, kea } from 'kea'",
+                    '',
+                    '// Generated by kea-typegen. DO NOT EDIT THIS BLOCK MANUALLY.',
+                    'export interface inlinedLogicValues {',
+                    '    value: string',
+                    '}',
+                    '',
+                    'export interface inlinedLogicActions {',
+                    '    setValue: (value: string) => {',
+                    '        value: string',
+                    '    }',
+                    '}',
+                    '',
+                    'export type inlinedLogicType = MakeLogicType<inlinedLogicValues, inlinedLogicActions>',
+                    '',
+                    'export const inlinedLogic = kea<inlinedLogicType>({',
+                    '    actions: () => ({',
+                    '        setValue: (value: string) => ({ value }),',
+                    '    }),',
+                    '    reducers: () => ({',
+                    "        value: ['' as string, { setValue: (_, { value }) => value }],",
+                    '    }),',
+                    '})',
+                    '',
+                ].join('\n'),
+            )
+            fs.writeFileSync(
+                consumerLogicPath,
+                [
+                    "import { kea } from 'kea'",
+                    '',
+                    "import { inlinedLogic } from './inlinedLogic'",
+                    '',
+                    'export const consumerLogic = kea({',
+                    '    connect: {',
+                    "        actions: [inlinedLogic, ['setValue']],",
+                    "        values: [inlinedLogic, ['value']],",
+                    '    },',
+                    '})',
+                    '',
+                ].join('\n'),
+            )
+            const inlineConsumerDir = path.join(rootDir, 'inlineConsumer')
+            const inlineConsumerLogicPath = path.join(inlineConsumerDir, 'inlineConsumerLogic.ts')
+            fs.mkdirSync(inlineConsumerDir, { recursive: true })
+            fs.writeFileSync(
+                inlineConsumerLogicPath,
+                [
+                    "import { kea } from 'kea'",
+                    '',
+                    "import { inlinedLogic } from '../inlinedLogic'",
+                    '',
+                    'export const inlineConsumerLogic = kea({',
+                    '    connect: {',
+                    "        actions: [inlinedLogic, ['setValue']],",
+                    "        values: [inlinedLogic, ['value']],",
+                    '    },',
+                    '})',
+                    '',
+                ].join('\n'),
+            )
+
+            const appOptions: AppOptions = {
+                rootPath: rootDir,
+                typesPath: rootDir,
+                packageJsonPath: path.join(tempDir, 'package.json'),
+                inlinePaths: [inlineConsumerDir],
+                write: true,
+                log: () => {},
+            }
+
+            const program = createProgram([inlineLogicPath, consumerLogicPath, inlineConsumerLogicPath])
+            await printToFiles(program, appOptions, visitProgram(program, appOptions))
+
+            // consumerLogic is classic-mode, so it gets a logicType.ts that must include the connected action
+            const consumerType = fs.readFileSync(path.join(rootDir, 'consumerLogicType.ts'), 'utf8')
+            expect(consumerType).toContain('setValue: (value: string) => void')
+            expect(consumerType).toContain('value: string')
+
+            // the inline consumer's block marks connected values/actions with their source logic
+            const inlineConsumer = fs.readFileSync(inlineConsumerLogicPath, 'utf8')
+            expect(inlineConsumer).toMatch(/value: string.* \/\/ inlinedLogic/)
+            expect(inlineConsumer).toMatch(/\};? \/\/ inlinedLogic/)
+
+            // a second pass over the annotated block changes nothing
+            const secondProgram = createProgram([inlineLogicPath, consumerLogicPath, inlineConsumerLogicPath])
+            const secondResponse = await printToFiles(secondProgram, appOptions, visitProgram(secondProgram, appOptions))
+            expect(secondResponse).toEqual({ filesToWrite: 0, writtenFiles: 0, filesToModify: 0 })
+        } finally {
+            fs.rmSync(tempDir, { recursive: true, force: true })
+        }
+    })
+
+    test('files that already carry an inline block stay inline without any inline options', async () => {
+        const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kea-typegen-inline-sticky-'))
+
+        try {
+            const rootDir = path.join(tempDir, 'src')
+            const logicPath = path.join(rootDir, 'stickyLogic.ts')
+
+            writeKeaDts(tempDir)
+            fs.mkdirSync(rootDir, { recursive: true })
+            fs.writeFileSync(
+                logicPath,
+                [
+                    "import { MakeLogicType, kea } from 'kea'",
+                    '',
+                    '// Generated by kea-typegen. DO NOT EDIT THIS BLOCK MANUALLY.',
+                    'export interface stickyLogicActions {',
+                    '    setValue: (value: string) => {',
+                    '        value: string',
+                    '    }',
+                    '}',
+                    '',
+                    'export type stickyLogicType = MakeLogicType<{}, stickyLogicActions>',
+                    '',
+                    'export const stickyLogic = kea<stickyLogicType>({',
+                    '    actions: () => ({',
+                    '        setValue: (value: string) => ({ value }),',
+                    '        setOther: (other: number) => ({ other }),',
+                    '    }),',
+                    '})',
+                    '',
+                ].join('\n'),
+            )
+
+            // no `inline`, no `inlinePaths` - the existing block alone keeps the file inline
+            const appOptions: AppOptions = {
+                rootPath: rootDir,
+                typesPath: rootDir,
+                packageJsonPath: path.join(tempDir, 'package.json'),
+                write: true,
+                log: () => {},
+            }
+
+            const program = createProgram([logicPath])
+            const response = await printToFiles(program, appOptions, visitProgram(program, appOptions))
+            expect(response.writtenFiles).toBe(1)
+
+            const writtenLogic = fs.readFileSync(logicPath, 'utf8')
+            expect(writtenLogic).toContain('setOther: (other: number) =>')
+            expect(writtenLogic.match(/DO NOT EDIT THIS BLOCK MANUALLY/g)?.length).toBe(1)
+            expect(fs.existsSync(path.join(rootDir, 'stickyLogicType.ts'))).toBe(false)
+        } finally {
+            fs.rmSync(tempDir, { recursive: true, force: true })
+        }
+    })
+})