kea-typegen 3.8.0 → 3.8.2

package/src/__tests__/inline.ts

@@ -158,7 +158,7 @@ describe('inline mode', () => {
             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("// Generated by kea-typegen. Update if you're an agent, ignore if you're human.")
             expect(writtenLogic).toContain('export interface logicValues {')
             expect(writtenLogic).toContain('export interface logicActions {')
             expect(writtenLogic).toContain('export interface logicProps {')
@@ -194,7 +194,8 @@ describe('inline mode', () => {
             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)
-            expect(updatedLogic.match(/DO NOT EDIT THIS BLOCK MANUALLY/g)?.length).toBe(1)
+            // one marker per generated interface (values, actions, props)
+            expect(updatedLogic.match(/Update if you're an agent, ignore if you're human/g)?.length).toBe(3)
         } finally {
             fs.rmSync(tempDir, { recursive: true, force: true })
         }
@@ -263,4 +264,608 @@ describe('inline mode', () => {
             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("Update if you're an agent, ignore if you're human")).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. Update if you're an agent, ignore if you're human.")
+            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. Update if you're an agent, ignore if you're human.",
+            )
+            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('sorts values and actions: connected first grouped by source logic, then own, all alphabetical', async () => {
+        const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kea-typegen-inline-sort-'))
+
+        try {
+            const rootDir = path.join(tempDir, 'src')
+            const keaDtsPath = path.join(tempDir, 'node_modules', 'kea', 'index.d.ts')
+            fs.mkdirSync(path.dirname(keaDtsPath), { recursive: true })
+            fs.mkdirSync(rootDir, { recursive: true })
+            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'),
+            )
+
+            const makeProvider = (name: string, entries: [string, string][]): string =>
+                [
+                    "import { MakeLogicType, kea } from 'kea'",
+                    '',
+                    '// Generated by kea-typegen. DO NOT EDIT THIS BLOCK MANUALLY.',
+                    `export interface ${name}Values {`,
+                    ...entries.map(([value]) => `    ${value}: string`),
+                    '}',
+                    '',
+                    `export interface ${name}Actions {`,
+                    ...entries.map(([value, action]) => `    ${action}: (${value}: string) => { ${value}: string }`),
+                    '}',
+                    '',
+                    `export type ${name}Type = MakeLogicType<${name}Values, ${name}Actions>`,
+                    '',
+                    `export const ${name} = kea<${name}Type>({`,
+                    '    actions: () => ({',
+                    ...entries.map(([value, action]) => `        ${action}: (${value}: string) => ({ ${value} }),`),
+                    '    }),',
+                    '    reducers: () => ({',
+                    ...entries.map(([value, action]) => `        ${value}: ['', { ${action}: (_, p) => p.${value} }],`),
+                    '    }),',
+                    '})',
+                    '',
+                ].join('\n')
+
+            fs.writeFileSync(
+                path.join(rootDir, 'alphaLogic.ts'),
+                makeProvider('alphaLogic', [
+                    ['bravo', 'setBravo'],
+                    ['alpha', 'setAlpha'],
+                ]),
+            )
+            fs.writeFileSync(path.join(rootDir, 'betaLogic.ts'), makeProvider('betaLogic', [['charlie', 'setCharlie']]))
+
+            const consumerDir = path.join(rootDir, 'consumer')
+            const consumerLogicPath = path.join(consumerDir, 'sortedLogic.ts')
+            fs.mkdirSync(consumerDir, { recursive: true })
+            fs.writeFileSync(
+                consumerLogicPath,
+                [
+                    "import { kea } from 'kea'",
+                    '',
+                    "import { alphaLogic } from '../alphaLogic'",
+                    "import { betaLogic } from '../betaLogic'",
+                    '',
+                    'export const sortedLogic = kea({',
+                    '    connect: {',
+                    "        actions: [betaLogic, ['setCharlie'], alphaLogic, ['setBravo', 'setAlpha']],",
+                    "        values: [betaLogic, ['charlie'], alphaLogic, ['bravo', 'alpha']],",
+                    '    },',
+                    '    actions: () => ({',
+                    '        zulu: (z: number) => ({ z }),',
+                    '        aardvark: (a: number) => ({ a }),',
+                    '    }),',
+                    '    reducers: () => ({',
+                    '        zebra: [0, { zulu: (_, { z }) => z }],',
+                    '        anteater: [0, { aardvark: (_, { a }) => a }],',
+                    '    }),',
+                    '})',
+                    '',
+                ].join('\n'),
+            )
+
+            const appOptions: AppOptions = {
+                rootPath: rootDir,
+                typesPath: rootDir,
+                packageJsonPath: path.join(tempDir, 'package.json'),
+                inlinePaths: [consumerDir],
+                write: true,
+                log: () => {},
+            }
+
+            const program = createProgram([
+                path.join(rootDir, 'alphaLogic.ts'),
+                path.join(rootDir, 'betaLogic.ts'),
+                consumerLogicPath,
+            ])
+            await printToFiles(program, appOptions, visitProgram(program, appOptions))
+
+            const written = fs.readFileSync(consumerLogicPath, 'utf8')
+            const orderOf = (names: string[]): void => {
+                const positions = names.map((name) => written.indexOf(name))
+                positions.forEach((position, index) => {
+                    expect(position).toBeGreaterThan(-1)
+                    if (index > 0) {
+                        expect(position).toBeGreaterThan(positions[index - 1])
+                    }
+                })
+            }
+            // values: alphaLogic group (alphabetical), betaLogic group, then own values alphabetically
+            orderOf(['alpha: string', 'bravo: string', 'charlie: string', 'anteater: number', 'zebra: number'])
+            // actions: same grouping
+            orderOf(['setAlpha:', 'setBravo:', 'setCharlie:', 'aardvark:', 'zulu:'])
+        } 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(/Update if you're an agent, ignore if you're human/g)?.length).toBe(1)
+            expect(fs.existsSync(path.join(rootDir, 'stickyLogicType.ts'))).toBe(false)
+        } finally {
+            fs.rmSync(tempDir, { recursive: true, force: true })
+        }
+    })
 })

package/src/cache.ts

@@ -3,6 +3,7 @@ import * as path from 'path'
 import { AppOptions, ParsedLogic } from './types'
 import { Program } from 'typescript'
 import { visitProgram } from './visit/visit'
+import { isInlineFile } from './utils'
 
 export function cachePath(appOptions: AppOptions, fileName: string): string {
     return path.join(process.cwd(), '.typegen', path.relative(process.cwd(), fileName))
@@ -13,8 +14,16 @@ export function restoreCachedTypes(program: Program, appOptions: AppOptions, log
         return false
     }
     const parsedLogics = visitProgram(program, appOptions)
+    const parsedLogicsByFile: Record<string, ParsedLogic[]> = {}
+    for (const pl of parsedLogics) {
+        parsedLogicsByFile[pl.fileName] = [...(parsedLogicsByFile[pl.fileName] ?? []), pl]
+    }
     let restored = false
     for (const pl of parsedLogics) {
+        if (isInlineFile(appOptions, program.getSourceFile(pl.fileName), parsedLogicsByFile[pl.fileName])) {
+            // inline files have their types in the logic file itself, there is no logicType.ts to restore
+            continue
+        }
         if (!fs.existsSync(pl.typeFileName)) {
             const from = cachePath(appOptions, pl.typeFileName)
             if (fs.existsSync(from)) {
@@ -36,3 +45,13 @@ export function cacheWrittenFile(fileName: string, appOptions: AppOptions) {
     fs.mkdirSync(path.dirname(dest), { recursive: true })
     fs.copyFileSync(fileName, dest)
 }
+
+export function deleteCachedFile(fileName: string, appOptions: AppOptions) {
+    if (!appOptions.useCache) {
+        return
+    }
+    const dest = cachePath(appOptions, fileName)
+    if (fs.existsSync(dest)) {
+        fs.unlinkSync(dest)
+    }
+}

package/src/cli/typegen.ts

@@ -43,6 +43,12 @@ yargs
         describe: 'Write logic types as MakeLogicType blocks above each kea() call, instead of logicType.ts files',
         type: 'boolean',
     })
+    .option('inline-paths', {
+        describe:
+            'Like --inline, but only for logic files under these paths (relative to --root). ' +
+            'Everything else keeps its logicType.ts file.',
+        type: 'array',
+    })
     .option('import-global-types', {
         describe: 'Add import statements in logicType.ts files for global types (e.g. @types/node)',
         type: 'boolean',