kea-typegen 3.8.1 → 3.8.3

package/src/__tests__/inline.ts

@@ -5,7 +5,37 @@ import * as ts from 'typescript'
 import { AppOptions } from '../types'
 import { programFromSource } from '../utils'
 import { visitProgram } from '../visit/visit'
-import { printToFiles } from '../print/print'
+import { buildTypeImportEntries, printToFiles } from '../print/print'
+
+describe('inline type imports', () => {
+    test('collapses physical pnpm paths outside the configured node_modules root', () => {
+        const workspace = path.join(os.tmpdir(), 'kea-typegen-workspace')
+        const physicalType = path.join(
+            workspace,
+            'node_modules',
+            '.pnpm',
+            'kea-router@3.4.1_kea@4.0.0_patch_hash=abc',
+            'node_modules',
+            'kea-router',
+            'lib',
+            'types.d.ts',
+        )
+        const entries = buildTypeImportEntries(
+            { [physicalType]: new Set(['LocationChangedPayload']) },
+            path.join(workspace, 'frontend', 'src', 'logic.ts'),
+            path.join(workspace, 'frontend', 'node_modules'),
+            () => false,
+        )
+
+        expect(entries).toEqual([
+            {
+                list: ['LocationChangedPayload'],
+                fullPath: physicalType,
+                finalPath: 'kea-router/lib/types',
+            },
+        ])
+    })
+})
 
 describe('manually typed logics', () => {
     test('skips logics typed with MakeLogicType', () => {
@@ -117,7 +147,8 @@ describe('inline mode', () => {
                 keaDtsPath,
                 [
                     'export function kea<T = any>(input: any): T',
-                    'export interface MakeLogicType<V = any, A = any, P = any> {}',
+                    'export interface MakeLogicType<V = any, A = any, P = any, M = any> {}',
+                    'export type BreakPointFunction = (() => void) & ((ms: number) => Promise<void>)',
                     '',
                 ].join('\n'),
             )
@@ -128,12 +159,16 @@ describe('inline mode', () => {
                     '',
                     'export const logic = kea({',
                     '    props: {} as { id: number },',
+                    '    key: (props: { id: number }) => props.id,',
                     '    actions: () => ({',
                     '        setValue: (value: string) => ({ value }),',
                     '    }),',
                     '    reducers: () => ({',
                     "        value: ['' as string, { setValue: (_, { value }) => value }],",
                     '    }),',
+                    '    sharedListeners: () => ({',
+                    '        syncValue: () => {},',
+                    '    }),',
                     '})',
                     '',
                 ].join('\n'),
@@ -158,31 +193,44 @@ 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 {')
-            expect(writtenLogic).toContain('export type logicType = MakeLogicType<logicValues, logicActions, logicProps>')
+            expect(writtenLogic).toContain('export interface logicMeta {')
+            expect(writtenLogic).toContain('key: number')
+            expect(writtenLogic).toContain('sharedListeners: {')
+            expect(writtenLogic).toContain(
+                'export type logicType = MakeLogicType<logicValues, logicActions, logicProps, logicMeta>',
+            )
+            expect(writtenLogic).toContain("import type { BreakPointFunction } from 'kea'")
             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
+            // a second pass leaves formatter-unquoted property names alone
+            const formattedLogic = writtenLogic.replace('"syncValue":', 'syncValue:')
+            fs.writeFileSync(logicPath, formattedLogic)
             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)
+            expect(fs.readFileSync(logicPath, 'utf8')).toBe(formattedLogic)
 
             // 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,'),
+                    .replace(
+                        'setValue: (value: string) => ({ value }),',
+                        'setValue: (value: string) => ({ value }),\n        reset: true,',
+                    ),
             )
 
             const thirdProgram = createProgram([logicPath])
@@ -194,8 +242,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)
-            // one marker per generated interface (values, actions, props)
-            expect(updatedLogic.match(/DO NOT EDIT THIS BLOCK MANUALLY/g)?.length).toBe(3)
+            // one marker per generated interface (values, actions, props, meta)
+            expect(updatedLogic.match(/Update if you're an agent, ignore if you're human/g)?.length).toBe(4)
         } finally {
             fs.rmSync(tempDir, { recursive: true, force: true })
         }
@@ -310,15 +358,31 @@ describe('inline mode', () => {
             const program = createProgram([logicPath])
             await printToFiles(program, appOptions, visitProgram(program, appOptions))
 
-            // simulate a formatter pass: strip semicolons and reflow unions with a leading pipe
+            // simulate an oxfmt pass: strip semicolons and reflow nested unions and objects
             const formatted = fs
                 .readFileSync(logicPath, 'utf8')
                 .replace(/;$/gm, '')
-                .replace(/value: string \| number\) =>/g, 'value:\n        | string\n        | number\n    ) =>')
+                .replace(
+                    /setValue: \(value: string \| number\) => \{\n        value: string \| number\n    \}/g,
+                    [
+                        'setValue: (',
+                        '        value:',
+                        '            | string',
+                        '            | number,',
+                        '    ) => {',
+                        '        value: string | number',
+                        '    }',
+                    ].join('\n'),
+                )
+                .replace('        value: string | number\n    }', '        value: (string | number)\n    }')
             fs.writeFileSync(logicPath, formatted)
 
             const secondProgram = createProgram([logicPath])
-            const secondResponse = await printToFiles(secondProgram, appOptions, visitProgram(secondProgram, appOptions))
+            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 {
@@ -381,7 +445,7 @@ describe('inline mode', () => {
                 ].join('\n'),
             )
             // the generated block sits above the comment
-            expect(writtenLogic.indexOf('DO NOT EDIT THIS BLOCK MANUALLY')).toBeLessThan(
+            expect(writtenLogic.indexOf("Update if you're an agent, ignore if you're human")).toBeLessThan(
                 writtenLogic.indexOf('// this comment describes the logic'),
             )
         } finally {
@@ -449,7 +513,11 @@ describe('inline mode', () => {
 
             // a second pass changes nothing
             const secondProgram = createProgram([logicPath])
-            const secondResponse = await printToFiles(secondProgram, appOptions, visitProgram(secondProgram, appOptions))
+            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 })
@@ -503,8 +571,14 @@ describe('mixed mode with inlinePaths', () => {
             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'))
+            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,
@@ -520,8 +594,12 @@ describe('mixed mode with inlinePaths', () => {
             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(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')
@@ -542,7 +620,10 @@ describe('mixed mode with inlinePaths', () => {
 
             writeKeaDts(tempDir)
             fs.mkdirSync(inlineDir, { recursive: true })
-            fs.writeFileSync(inlineLogicPath, simpleLogicSource.replace('export const logic', 'export const inlinedLogic'))
+            fs.writeFileSync(
+                inlineLogicPath,
+                simpleLogicSource.replace('export const logic', 'export const inlinedLogic'),
+            )
 
             const appOptions: AppOptions = {
                 rootPath: rootDir,
@@ -557,7 +638,7 @@ describe('mixed mode with inlinePaths', () => {
             await printToFiles(program, appOptions, visitProgram(program, appOptions))
 
             expect(fs.readFileSync(inlineLogicPath, 'utf8')).toContain(
-                '// Generated by kea-typegen. DO NOT EDIT THIS BLOCK MANUALLY.',
+                "// 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 {
@@ -683,13 +764,141 @@ describe('mixed mode with inlinePaths', () => {
 
             // a second pass over the annotated block changes nothing
             const secondProgram = createProgram([inlineLogicPath, consumerLogicPath, inlineConsumerLogicPath])
-            const secondResponse = await printToFiles(secondProgram, appOptions, visitProgram(secondProgram, appOptions))
+            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-'))
 
@@ -738,7 +947,7 @@ describe('mixed mode with inlinePaths', () => {
 
             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(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/print/print.ts

@@ -323,9 +323,17 @@ export function buildTypeImportEntries(
                         finalPath = result[1]
                     }
                 }
-                if (finalPath.startsWith('@types/')) {
-                    finalPath = finalPath.substring(7)
-                }
+            }
+
+            // A workspace package.json can point at a different node_modules root than the physical
+            // dependency path. Collapse the innermost package path instead of writing pnpm internals.
+            const nestedNodeModules = `${path.sep}node_modules${path.sep}`
+            const nestedNodeModulesIndex = finalPath.lastIndexOf(nestedNodeModules)
+            if (nestedNodeModulesIndex >= 0) {
+                finalPath = finalPath.substring(nestedNodeModulesIndex + nestedNodeModules.length)
+            }
+            if (finalPath.startsWith('@types/')) {
+                finalPath = finalPath.substring(7)
             }
 
             // Resolve absolute urls

package/src/utils.ts

@@ -60,11 +60,11 @@ export function hasKeaTypegenMarker(node: ts.Node): boolean {
     return ranges.some(({ pos, end }) => sourceFile.text.slice(pos, end).includes('kea-typegen'))
 }
 
-const INLINE_BLOCK_SUFFIXES = ['Values', 'Actions', 'Props']
+const INLINE_BLOCK_SUFFIXES = ['Values', 'Actions', 'Props', 'Meta']
 
 /**
  * The statements making up an inline logic type block: the `logicType` alias itself, plus any
- * `logicValues` / `logicActions` / `logicProps` interfaces directly above it.
+ * `logicValues` / `logicActions` / `logicProps` / `logicMeta` interfaces directly above it.
  */
 export function getInlineBlockStatements(
     declaration: ts.TypeAliasDeclaration | ts.InterfaceDeclaration,

package/src/write/writeInlineLogicTypes.ts

@@ -4,11 +4,15 @@ import * as osPath from 'path'
 import { factory, SyntaxKind } from 'typescript'
 import { AppOptions, ParsedLogic } from '../types'
 import { buildTypeImportEntries, nodeToString, runThroughPrettier } from '../print/print'
-import { printValues } from '../print/printValues'
-import { getInlineBlockStatements, isGeneratedInlineBlock } from '../utils'
+import { printInternalExtraInput } from '../print/printInternalExtraInput'
+import { printInternalReducerActions } from '../print/printInternalReducerActions'
+import { printInternalSelectorTypes } from '../print/printInternalSelectorTypes'
+import { printKey } from '../print/printKey'
+import { printSharedListeners } from '../print/printSharedListeners'
+import { cleanDuplicateAnyNodes, getInlineBlockStatements, isGeneratedInlineBlock } from '../utils'
 import { applyTextEdits, getImportInsertPosition, getTypeArgumentInsertEnd, TextEdit } from './writeTypeImports'
 
-export const INLINE_TYPE_MARKER = ' Generated by kea-typegen. DO NOT EDIT THIS BLOCK MANUALLY.'
+export const INLINE_TYPE_MARKER = " Generated by kea-typegen. Update if you're an agent, ignore if you're human."
 
 /**
  * Print a block of interfaces (Values, Actions, and Props when it's a literal), plus an
@@ -40,35 +44,51 @@ export function printInlineLogicType(parsedLogic: ParsedLogic): string {
 
     // mark connected values/actions with the logic they come from, e.g. `user: UserType | null // userLogic`
     const withSourceLogicComment = <T extends ts.TypeElement>(member: T, sourceLogic: string | undefined): T =>
-        sourceLogic ? ts.addSyntheticTrailingComment(member, SyntaxKind.SingleLineCommentTrivia, ` ${sourceLogic}`, false) : member
+        sourceLogic
+            ? ts.addSyntheticTrailingComment(member, SyntaxKind.SingleLineCommentTrivia, ` ${sourceLogic}`, false)
+            : member
 
-    const valueSources = new Map<string, string | undefined>()
-    for (const value of [...parsedLogic.reducers, ...parsedLogic.selectors]) {
-        valueSources.set(value.name, value.sourceLogic)
+    // connected entries first, grouped by source logic (groups alphabetical, entries alphabetical
+    // within each group), then the logic's own entries alphabetically
+    const bySourceLogicThenName = (
+        a: { name: string; sourceLogic?: string },
+        b: { name: string; sourceLogic?: string },
+    ): number => {
+        if (!!a.sourceLogic !== !!b.sourceLogic) {
+            return a.sourceLogic ? -1 : 1
+        }
+        if (a.sourceLogic && b.sourceLogic && a.sourceLogic !== b.sourceLogic) {
+            return a.sourceLogic < b.sourceLogic ? -1 : 1
+        }
+        return a.name === b.name ? 0 : a.name < b.name ? -1 : 1
     }
 
     addSection(
         'Values',
-        printValues(parsedLogic).members.map((member) =>
-            withSourceLogicComment(
-                member,
-                member.name && ts.isIdentifier(member.name) ? valueSources.get(member.name.text) : undefined,
+        [...cleanDuplicateAnyNodes(parsedLogic.reducers.concat(parsedLogic.selectors))]
+            .sort(bySourceLogicThenName)
+            .map(({ name, typeNode, sourceLogic }) =>
+                withSourceLogicComment(
+                    factory.createPropertySignature(undefined, factory.createIdentifier(name), undefined, typeNode),
+                    sourceLogic,
+                ),
             ),
-        ),
     )
     addSection(
         'Actions',
-        parsedLogic.actions.map(({ name, parameters, returnTypeNode, sourceLogic }) =>
-            withSourceLogicComment(
-                factory.createPropertySignature(
-                    undefined,
-                    factory.createIdentifier(name),
-                    undefined,
-                    factory.createFunctionTypeNode(undefined, parameters, returnTypeNode),
+        [...parsedLogic.actions]
+            .sort(bySourceLogicThenName)
+            .map(({ name, parameters, returnTypeNode, sourceLogic }) =>
+                withSourceLogicComment(
+                    factory.createPropertySignature(
+                        undefined,
+                        factory.createIdentifier(name),
+                        undefined,
+                        factory.createFunctionTypeNode(undefined, parameters, returnTypeNode),
+                    ),
+                    sourceLogic,
                 ),
-                sourceLogic,
             ),
-        ),
     )
     if (parsedLogic.propsType) {
         if (ts.isTypeLiteralNode(parsedLogic.propsType)) {
@@ -79,6 +99,39 @@ export function printInlineLogicType(parsedLogic: ParsedLogic): string {
         }
     }
 
+    const metaMembers: ts.TypeElement[] = []
+    const addMetaProperty = (name: string, typeNode: ts.TypeNode): void => {
+        metaMembers.push(
+            factory.createPropertySignature(undefined, factory.createIdentifier(name), undefined, typeNode),
+        )
+    }
+    if (parsedLogic.keyType) {
+        addMetaProperty('key', printKey(parsedLogic))
+    }
+    if (parsedLogic.sharedListeners.length > 0) {
+        addMetaProperty('sharedListeners', printSharedListeners(parsedLogic))
+    }
+    if (parsedLogic.selectors.some((selector) => (selector.functionTypes?.length ?? 0) > 0)) {
+        addMetaProperty('__keaTypeGenInternalSelectorTypes', printInternalSelectorTypes(parsedLogic))
+    }
+    if (Object.keys(parsedLogic.extraActions).length > 0) {
+        addMetaProperty('__keaTypeGenInternalReducerActions', printInternalReducerActions(parsedLogic))
+    }
+    if (Object.keys(parsedLogic.extraInput).length > 0) {
+        addMetaProperty('__keaTypeGenInternalExtraInput', printInternalExtraInput(parsedLogic))
+    }
+    if (metaMembers.length > 0) {
+        if (!parsedLogic.propsType) {
+            typeArguments.push(
+                factory.createTypeReferenceNode(factory.createIdentifier('Record'), [
+                    factory.createKeywordTypeNode(SyntaxKind.StringKeyword),
+                    factory.createKeywordTypeNode(SyntaxKind.AnyKeyword),
+                ]),
+            )
+        }
+        addSection('Meta', metaMembers)
+    }
+
     const typeAlias = factory.createTypeAliasDeclaration(
         [factory.createModifier(SyntaxKind.ExportKeyword)],
         factory.createIdentifier(parsedLogic.logicTypeName),
@@ -193,6 +246,12 @@ export async function writeInlineLogicTypes(
                 newImportLines.push(`import type { MakeLogicType } from 'kea'`)
             }
         }
+        if (
+            managedLogics.some((parsedLogic) => parsedLogic.sharedListeners.length > 0) &&
+            !importsNamedKeaType(importDeclarations, 'BreakPointFunction')
+        ) {
+            newImportLines.push(`import type { BreakPointFunction } from 'kea'`)
+        }
 
         // remove the now obsolete `import type { logicType } from './logicType'`, if any
         const typeFileNameBase = parsedLogics[0].typeFileName.replace(/\.[tj]sx?$/, '')
@@ -279,13 +338,32 @@ export async function writeInlineLogicTypes(
  * block - semicolons, trailing commas, quotes, line breaks - does not make us rewrite it forever.
  */
 function sameGeneratedCode(existingCode: string, generatedCode: string): boolean {
-    const normalize = (code: string): string =>
-        code
+    const normalize = (code: string): string => {
+        const sourceFile = ts.createSourceFile(
+            'inlineLogicType.ts',
+            code,
+            ts.ScriptTarget.Latest,
+            true,
+            ts.ScriptKind.TS,
+        )
+        const transformer: ts.TransformerFactory<ts.SourceFile> = (context) => {
+            const visit: ts.Visitor = (node) =>
+                ts.isParenthesizedTypeNode(node)
+                    ? ts.visitNode(node.type, visit)
+                    : ts.visitEachChild(node, visit, context)
+            return (root) => ts.visitNode(root, visit) as ts.SourceFile
+        }
+        const transformed = ts.transform(sourceFile, [transformer])
+        const normalized = ts
+            .createPrinter({ removeComments: true })
+            .printFile(transformed.transformed[0])
             .replace(/"/g, "'")
-            .replace(/[;,]/g, '')
             .replace(/\s+/g, '')
-            // leading pipe of a formatter-reflowed union type, e.g. `selection: | number | EditorRange`
-            .replace(/([:(<=[])\|/g, '$1')
+            .replace(/,(?=[}\])])/g, '')
+            .replace(/'([A-Za-z_$][\w$]*)':/g, '$1:')
+        transformed.dispose()
+        return normalized
+    }
     return normalize(existingCode) === normalize(generatedCode)
 }
 
@@ -305,6 +383,10 @@ function getTopLevelStatement(node: ts.Node): ts.Node {
 }
 
 function importsMakeLogicType(importDeclarations: ts.ImportDeclaration[]): boolean {
+    return importsNamedKeaType(importDeclarations, 'MakeLogicType')
+}
+
+function importsNamedKeaType(importDeclarations: ts.ImportDeclaration[], name: string): boolean {
     return importDeclarations.some(
         (declaration) =>
             ts.isStringLiteralLike(declaration.moduleSpecifier) &&
@@ -312,7 +394,7 @@ function importsMakeLogicType(importDeclarations: ts.ImportDeclaration[]): boole
             declaration.importClause?.namedBindings &&
             ts.isNamedImports(declaration.importClause.namedBindings) &&
             declaration.importClause.namedBindings.elements.some(
-                (element) => element.name.text === 'MakeLogicType' && !element.propertyName,
+                (element) => element.name.text === name && !element.propertyName,
             ),
     )
 }