@metamask-previews/messenger-cli 0.0.0-preview-e024252b6 → 0.1.0-preview-8f51c7a3a

package/dist/docs/discovery.mjs

@@ -0,0 +1,41 @@
+import { glob } from "glob";
+/**
+ * Find all non-test TypeScript source files in a directory.
+ * Skips node_modules, dist, test directories, and declaration files.
+ *
+ * @param dir - The directory to search.
+ * @returns A promise that resolves to an array of absolute file paths.
+ */
+export async function findTsFiles(dir) {
+    return await glob('**/*.ts', {
+        cwd: dir,
+        absolute: true,
+        ignore: [
+            '**/node_modules/**',
+            '**/dist/**',
+            '**/__tests__/**',
+            '**/tests/**',
+            '**/test/**',
+            '**/__mocks__/**',
+            '**/*.test.ts',
+            '**/*.test-d.ts',
+            '**/*.spec.ts',
+            '**/*.d.ts',
+        ],
+    });
+}
+/**
+ * Find all `.d.cts` declaration files in a directory.
+ * Skips nested node_modules subdirectories.
+ *
+ * @param dir - The directory to search.
+ * @returns A promise that resolves to an array of absolute file paths.
+ */
+export async function findDtsFiles(dir) {
+    return await glob('**/*.d.cts', {
+        cwd: dir,
+        absolute: true,
+        ignore: ['**/node_modules/**'],
+    });
+}
+//# sourceMappingURL=discovery.mjs.map

package/dist/docs/discovery.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"discovery.mjs","sourceRoot":"","sources":["../../src/docs/discovery.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,aAAa;AAE5B;;;;;;GAMG;AACH,MAAM,CAAC,KAAK,UAAU,WAAW,CAAC,GAAW;IAC3C,OAAO,MAAM,IAAI,CAAC,SAAS,EAAE;QAC3B,GAAG,EAAE,GAAG;QACR,QAAQ,EAAE,IAAI;QACd,MAAM,EAAE;YACN,oBAAoB;YACpB,YAAY;YACZ,iBAAiB;YACjB,aAAa;YACb,YAAY;YACZ,iBAAiB;YACjB,cAAc;YACd,gBAAgB;YAChB,cAAc;YACd,WAAW;SACZ;KACF,CAAC,CAAC;AACL,CAAC;AAED;;;;;;GAMG;AACH,MAAM,CAAC,KAAK,UAAU,YAAY,CAAC,GAAW;IAC5C,OAAO,MAAM,IAAI,CAAC,YAAY,EAAE;QAC9B,GAAG,EAAE,GAAG;QACR,QAAQ,EAAE,IAAI;QACd,MAAM,EAAE,CAAC,oBAAoB,CAAC;KAC/B,CAAC,CAAC;AACL,CAAC","sourcesContent":["import { glob } from 'glob';\n\n/**\n * Find all non-test TypeScript source files in a directory.\n * Skips node_modules, dist, test directories, and declaration files.\n *\n * @param dir - The directory to search.\n * @returns A promise that resolves to an array of absolute file paths.\n */\nexport async function findTsFiles(dir: string): Promise<string[]> {\n  return await glob('**/*.ts', {\n    cwd: dir,\n    absolute: true,\n    ignore: [\n      '**/node_modules/**',\n      '**/dist/**',\n      '**/__tests__/**',\n      '**/tests/**',\n      '**/test/**',\n      '**/__mocks__/**',\n      '**/*.test.ts',\n      '**/*.test-d.ts',\n      '**/*.spec.ts',\n      '**/*.d.ts',\n    ],\n  });\n}\n\n/**\n * Find all `.d.cts` declaration files in a directory.\n * Skips nested node_modules subdirectories.\n *\n * @param dir - The directory to search.\n * @returns A promise that resolves to an array of absolute file paths.\n */\nexport async function findDtsFiles(dir: string): Promise<string[]> {\n  return await glob('**/*.d.cts', {\n    cwd: dir,\n    absolute: true,\n    ignore: ['**/node_modules/**'],\n  });\n}\n"]}

package/dist/docs/extraction.cjs

@@ -0,0 +1,577 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractFromFile = void 0;
+const fs = __importStar(require("node:fs/promises"));
+const path = __importStar(require("node:path"));
+const typescript_1 = require("typescript");
+/**
+ * Check whether a file exists.
+ *
+ * @param filePath - The path to check.
+ * @returns A promise that resolves to true if the file exists.
+ */
+async function fileExists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Extract string constants from top-level variable declarations in a source file.
+ * Only looks at top-level `const x = 'string'` or `const x = 'string' as const`.
+ *
+ * @param sourceFile - The TypeScript source file to extract constants from.
+ * @returns A map of constant name to string value.
+ */
+function extractStringConstants(sourceFile) {
+    const names = new Map();
+    for (const statement of sourceFile.statements) {
+        if (!(0, typescript_1.isVariableStatement)(statement)) {
+            continue;
+        }
+        for (const decl of statement.declarationList.declarations) {
+            if (!(0, typescript_1.isIdentifier)(decl.name)) {
+                continue;
+            }
+            if (decl.initializer) {
+                const init = decl.initializer;
+                if ((0, typescript_1.isStringLiteral)(init)) {
+                    names.set(decl.name.text, init.text);
+                }
+                else if ((0, typescript_1.isAsExpression)(init) && (0, typescript_1.isStringLiteral)(init.expression)) {
+                    names.set(decl.name.text, init.expression.text);
+                }
+            }
+            // Handle `declare const x: "value"` (common in .d.cts files)
+            if (!decl.initializer &&
+                decl.type &&
+                (0, typescript_1.isLiteralTypeNode)(decl.type) &&
+                (0, typescript_1.isStringLiteral)(decl.type.literal)) {
+                names.set(decl.name.text, decl.type.literal.text);
+            }
+        }
+    }
+    return names;
+}
+/**
+ * Resolve the value of `controllerName` (or similar constant) defined in the
+ * same file or imported from a local `./constants*` module (single-hop only).
+ *
+ * @param sourceFile - The TypeScript source file to search.
+ * @param filePath - The absolute path of the source file on disk.
+ * @returns A promise that resolves to a map of constant name to resolved string value.
+ */
+async function resolveControllerName(sourceFile, filePath) {
+    const names = extractStringConstants(sourceFile);
+    // Chase single-hop local imports (no further recursion):
+    //   import { BRIDGE_CONTROLLER_NAME } from './constants/bridge';
+    for (const statement of sourceFile.statements) {
+        if (!(0, typescript_1.isImportDeclaration)(statement) ||
+            !statement.moduleSpecifier ||
+            !(0, typescript_1.isStringLiteral)(statement.moduleSpecifier)) {
+            continue;
+        }
+        const spec = statement.moduleSpecifier.text;
+        if (!spec.startsWith('.')) {
+            continue;
+        }
+        const dir = path.dirname(filePath);
+        const isDts = filePath.endsWith('.d.cts') || filePath.endsWith('.d.ts');
+        // Strip .cjs/.js extension from specifier for .d.cts resolution
+        const bareSpec = spec.replace(/\.(c|m)?js$/u, '');
+        const candidates = isDts
+            ? [
+                path.join(dir, `${bareSpec}.d.cts`),
+                path.join(dir, bareSpec, 'index.d.cts'),
+                path.join(dir, `${bareSpec}.d.ts`),
+                path.join(dir, bareSpec, 'index.d.ts'),
+            ]
+            : [path.join(dir, `${spec}.ts`), path.join(dir, spec, 'index.ts')];
+        for (const candidate of candidates) {
+            if (!(await fileExists(candidate))) {
+                continue;
+            }
+            const content = await fs.readFile(candidate, 'utf8');
+            const sf = (0, typescript_1.createSourceFile)(candidate, content, typescript_1.ScriptTarget.Latest, true);
+            // Only extract constants — do NOT follow further imports
+            const imported = extractStringConstants(sf);
+            if (statement.importClause?.namedBindings &&
+                (0, typescript_1.isNamedImports)(statement.importClause.namedBindings)) {
+                for (const element of statement.importClause.namedBindings.elements) {
+                    const importedName = (element.propertyName ?? element.name).text;
+                    const localName = element.name.text;
+                    const value = imported.get(importedName);
+                    if (value !== undefined) {
+                        names.set(localName, value);
+                    }
+                }
+            }
+            break;
+        }
+    }
+    return names;
+}
+/**
+ * Resolve a template-literal or string-literal `type` property to its string
+ * value. Returns null if unresolvable.
+ *
+ * @param node - The expression node to resolve.
+ * @param constants - A map of known constant names to their string values.
+ * @returns The resolved string value, or null if unresolvable.
+ */
+function resolveTypeString(node, constants) {
+    if ((0, typescript_1.isStringLiteral)(node) || (0, typescript_1.isNoSubstitutionTemplateLiteral)(node)) {
+        return node.text;
+    }
+    if ((0, typescript_1.isTemplateExpression)(node)) {
+        let result = node.head.text;
+        for (const span of node.templateSpans) {
+            // typeof X  →  resolve X
+            if ((0, typescript_1.isTypeOfExpression)(span.expression)) {
+                if ((0, typescript_1.isIdentifier)(span.expression.expression)) {
+                    const val = constants.get(span.expression.expression.text);
+                    if (val === undefined) {
+                        return null;
+                    }
+                    result += val;
+                }
+                else {
+                    return null;
+                }
+            }
+            else if ((0, typescript_1.isIdentifier)(span.expression)) {
+                const val = constants.get(span.expression.text);
+                if (val === undefined) {
+                    return null;
+                }
+                result += val;
+            }
+            else {
+                return null;
+            }
+            result += span.literal.text;
+        }
+        return result;
+    }
+    return null;
+}
+/**
+ * Resolve a TemplateLiteralTypeNode (used in type positions like
+ * `type: \`${typeof controllerName}:name\``) to its string value.
+ *
+ * @param node - The template literal type node to resolve.
+ * @param constants - A map of known constant names to their string values.
+ * @returns The resolved string value, or null if unresolvable.
+ */
+function resolveTemplateLiteralType(node, constants) {
+    let result = node.head.text;
+    for (const span of node.templateSpans) {
+        // In type position, `typeof X` is a TypeQueryNode
+        if ((0, typescript_1.isTypeQueryNode)(span.type) && (0, typescript_1.isIdentifier)(span.type.exprName)) {
+            const val = constants.get(span.type.exprName.text);
+            if (val === undefined) {
+                return null;
+            }
+            result += val;
+        }
+        else if ((0, typescript_1.isLiteralTypeNode)(span.type) &&
+            (0, typescript_1.isStringLiteral)(span.type.literal)) {
+            result += span.type.literal.text;
+        }
+        else {
+            return null;
+        }
+        result += span.literal.text;
+    }
+    return result;
+}
+/**
+ * Extract cleaned JSDoc body text from a node.
+ *
+ * @param node - The AST node to extract JSDoc from.
+ * @param sourceFile - The source file containing the node.
+ * @returns The cleaned JSDoc text, or empty string if none.
+ */
+function extractJsDocText(node, sourceFile) {
+    const jsDocs = (0, typescript_1.getJSDocCommentsAndTags)(node);
+    if (jsDocs.length === 0) {
+        return '';
+    }
+    const jsDoc = jsDocs[0];
+    if (!(0, typescript_1.isJSDoc)(jsDoc)) {
+        return '';
+    }
+    const fullText = sourceFile.getFullText();
+    const raw = fullText.substring(jsDoc.getFullStart(), jsDoc.getEnd()).trim();
+    // Strip comment delimiters, leading asterisks, and @param/@returns/@see tags
+    const lines = raw.split('\n');
+    const cleaned = [];
+    const skippedTags = [
+        '@param',
+        '@returns',
+        '@see',
+        '@throws',
+        '@template',
+        '@example',
+    ];
+    let currentTag = null;
+    let deprecatedParts = [];
+    for (const rawLine of lines) {
+        let trimmed = rawLine.trim();
+        if (trimmed === '/**' || trimmed === '*/') {
+            continue;
+        }
+        if (trimmed.startsWith('* ')) {
+            trimmed = trimmed.slice(2);
+        }
+        else if (trimmed === '*') {
+            trimmed = '';
+        }
+        else if (trimmed.startsWith('*')) {
+            trimmed = trimmed.slice(1);
+        }
+        // Check if this line starts a new tag
+        if (trimmed.startsWith('@')) {
+            // Flush any accumulated deprecated text
+            if (currentTag === 'deprecated' && deprecatedParts.length > 0) {
+                cleaned.push(`**Deprecated:** ${deprecatedParts.join(' ')}`);
+                deprecatedParts = [];
+            }
+            if (trimmed.startsWith('@deprecated')) {
+                currentTag = 'deprecated';
+                const depText = trimmed.slice('@deprecated'.length).trim();
+                if (depText) {
+                    deprecatedParts.push(depText);
+                }
+                continue;
+            }
+            currentTag = skippedTags.some((tag) => trimmed.startsWith(tag))
+                ? 'skip'
+                : null;
+            if (currentTag === 'skip') {
+                continue;
+            }
+        }
+        else if (currentTag === 'skip') {
+            if (trimmed === '') {
+                currentTag = null;
+            }
+            else {
+                continue;
+            }
+        }
+        else if (currentTag === 'deprecated') {
+            if (trimmed === '') {
+                // End of deprecated tag
+                if (deprecatedParts.length > 0) {
+                    cleaned.push(`**Deprecated:** ${deprecatedParts.join(' ')}`);
+                    deprecatedParts = [];
+                }
+                currentTag = null;
+            }
+            else {
+                deprecatedParts.push(trimmed);
+                continue;
+            }
+        }
+        cleaned.push(trimmed);
+    }
+    // Flush any remaining deprecated text
+    if (deprecatedParts.length > 0) {
+        cleaned.push(`**Deprecated:** ${deprecatedParts.join(' ')}`);
+    }
+    let result = cleaned.join('\n').trim();
+    // Convert JSDoc {@link X} references to markdown backtick code
+    result = result.replace(/\{@link\s+([^}]+)\}/gu, '`$1`');
+    // Escape remaining curly braces for MDX safety (but not inside backtick code spans)
+    result = result.replace(/`[^`]*`|(\{)|(\})/gu, (match, open, close) => {
+        if (open) {
+            return '\\{';
+        }
+        if (close) {
+            return '\\}';
+        }
+        return match; // preserve content inside backticks
+    });
+    return result;
+}
+/**
+ * Check whether a node has an `@deprecated` JSDoc tag.
+ *
+ * @param node - The AST node to check.
+ * @returns True if the node has an `@deprecated` tag.
+ */
+function isDeprecated(node) {
+    const tags = (0, typescript_1.getJSDocTags)(node);
+    return tags.some((tag) => tag.tagName.text === 'deprecated');
+}
+/**
+ * Collect method info from all class declarations in a source file.
+ * Returns a map keyed by "ClassName.methodName".
+ *
+ * @param sourceFile - The TypeScript source file to scan.
+ * @returns A map of "ClassName.methodName" to method info.
+ */
+function collectClassMethods(sourceFile) {
+    const methods = new Map();
+    for (const statement of sourceFile.statements) {
+        if (!(0, typescript_1.isClassDeclaration)(statement) || !statement.name) {
+            continue;
+        }
+        const className = statement.name.text;
+        for (const member of statement.members) {
+            if (!(0, typescript_1.isMethodDeclaration)(member) ||
+                !member.name ||
+                !(0, typescript_1.isIdentifier)(member.name)) {
+                continue;
+            }
+            const methodName = member.name.text;
+            // Build parameter list
+            const params = member.parameters
+                .map((param) => {
+                const paramName = param.name.getText(sourceFile);
+                const optional = param.questionToken ? '?' : '';
+                const paramType = param.type
+                    ? param.type.getText(sourceFile)
+                    : 'unknown';
+                return `${paramName}${optional}: ${paramType}`;
+            })
+                .join(', ');
+            // Get return type
+            const returnType = member.type ? member.type.getText(sourceFile) : 'void';
+            // For async methods, the declared return type already includes Promise<>,
+            // so we don't need to wrap again.
+            const methodSignature = `(${params}) => ${returnType}`;
+            const jsDoc = extractJsDocText(member, sourceFile);
+            methods.set(`${className}.${methodName}`, {
+                jsDoc,
+                signature: methodSignature,
+            });
+        }
+    }
+    return methods;
+}
+/**
+ * If `handlerText` matches `ClassName['methodName']`, look it up in classMethodInfo
+ * and return the resolved signature. Otherwise return the original text.
+ *
+ * @param handlerText - The raw handler text to resolve.
+ * @param classMethods - A map of class methods collected from the source file.
+ * @returns An object with the resolved signature and any associated JSDoc.
+ */
+function resolveHandler(handlerText, classMethods) {
+    const match = handlerText.match(/^(\w+)\['(\w+)'\]$/u);
+    if (match) {
+        const key = `${match[1]}.${match[2]}`;
+        const info = classMethods.get(key);
+        if (info) {
+            return { signature: info.signature, methodJsDoc: info.jsDoc };
+        }
+    }
+    return { signature: handlerText, methodJsDoc: '' };
+}
+/**
+ * Get the raw source text for a property value inside a type literal.
+ *
+ * @param members - The type literal members to search.
+ * @param propName - The property name to find.
+ * @param sourceFile - The source file for getText calls.
+ * @returns The raw text of the property type, or empty string if not found.
+ */
+function getPropertyText(members, propName, sourceFile) {
+    for (const member of members) {
+        if ((0, typescript_1.isPropertySignature)(member) &&
+            member.name &&
+            (0, typescript_1.isIdentifier)(member.name) &&
+            member.name.text === propName &&
+            member.type) {
+            return member.type.getText(sourceFile).trim();
+        }
+    }
+    return '';
+}
+// ---------------------------------------------------------------------------
+// Main extraction
+// ---------------------------------------------------------------------------
+/**
+ * Extract messenger action/event type definitions from a single TypeScript file.
+ *
+ * @param filePath - The absolute path to the TypeScript file.
+ * @param relBase - Base path for computing relative source paths.
+ * @returns A promise that resolves to an array of extracted messenger item docs.
+ */
+async function extractFromFile(filePath, relBase) {
+    const content = await fs.readFile(filePath, 'utf8');
+    const sourceFile = (0, typescript_1.createSourceFile)(filePath, content, typescript_1.ScriptTarget.Latest, true);
+    const constants = await resolveControllerName(sourceFile, filePath);
+    const classMethods = collectClassMethods(sourceFile);
+    const items = [];
+    const relPath = path.relative(relBase, filePath);
+    // Type aliases and interfaces are always top-level statements
+    for (const statement of sourceFile.statements) {
+        // ---------------------------------------------------------------
+        // Pattern 1: { type: '...'; handler/payload: ... }
+        // Matches both:
+        //   type X = { type: '...'; handler: ... }   (type alias with literal body)
+        //   interface X { type: '...'; handler: ... } (interface declaration)
+        // ---------------------------------------------------------------
+        let inlineNode;
+        let inlineMembers;
+        if ((0, typescript_1.isTypeAliasDeclaration)(statement) &&
+            (0, typescript_1.isTypeLiteralNode)(statement.type)) {
+            inlineNode = statement;
+            inlineMembers = statement.type.members;
+        }
+        else if ((0, typescript_1.isInterfaceDeclaration)(statement)) {
+            inlineNode = statement;
+            inlineMembers = statement.members;
+        }
+        if (inlineNode && inlineMembers) {
+            const typeName = inlineNode.name.text;
+            const line = sourceFile.getLineAndCharacterOfPosition(inlineNode.getStart()).line +
+                1;
+            // Find `type` property
+            let typeString = null;
+            for (const member of inlineMembers) {
+                if ((0, typescript_1.isPropertySignature)(member) &&
+                    member.name &&
+                    (0, typescript_1.isIdentifier)(member.name) &&
+                    member.name.text === 'type' &&
+                    member.type) {
+                    if ((0, typescript_1.isLiteralTypeNode)(member.type)) {
+                        typeString = resolveTypeString(member.type.literal, constants);
+                    }
+                    else if ((0, typescript_1.isTemplateLiteralTypeNode)(member.type)) {
+                        typeString = resolveTemplateLiteralType(member.type, constants);
+                    }
+                }
+            }
+            if (typeString?.includes(':')) {
+                const handlerText = getPropertyText(inlineMembers, 'handler', sourceFile);
+                const payloadText = getPropertyText(inlineMembers, 'payload', sourceFile);
+                if (handlerText || payloadText) {
+                    const kind = handlerText ? 'action' : 'event';
+                    // For actions, resolve ClassName['methodName'] to actual signature + JSDoc
+                    let resolvedHandler = handlerText || payloadText;
+                    let typeAliasJsDoc = extractJsDocText(inlineNode, sourceFile);
+                    if (handlerText) {
+                        const resolved = resolveHandler(handlerText, classMethods);
+                        resolvedHandler = resolved.signature;
+                        // If the type alias has no JSDoc, use the method's JSDoc
+                        if (!typeAliasJsDoc && resolved.methodJsDoc) {
+                            typeAliasJsDoc = resolved.methodJsDoc;
+                        }
+                    }
+                    items.push({
+                        typeName,
+                        typeString,
+                        kind,
+                        jsDoc: typeAliasJsDoc,
+                        handlerOrPayload: resolvedHandler,
+                        sourceFile: relPath,
+                        line,
+                        deprecated: isDeprecated(inlineNode),
+                    });
+                }
+            }
+        }
+        // -------------------------------------------------------------------
+        // Patterns 2 & 3 only apply to type aliases (generic type references)
+        // -------------------------------------------------------------------
+        if (!(0, typescript_1.isTypeAliasDeclaration)(statement)) {
+            continue;
+        }
+        const node = statement;
+        const typeName = node.name.text;
+        const line = sourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1;
+        // -------------------------------------------------------------------
+        // Pattern 2: ControllerGetStateAction<typeof cn, State>
+        // -------------------------------------------------------------------
+        if ((0, typescript_1.isTypeReferenceNode)(node.type) &&
+            (0, typescript_1.isIdentifier)(node.type.typeName) &&
+            node.type.typeName.text === 'ControllerGetStateAction' &&
+            node.type.typeArguments &&
+            node.type.typeArguments.length >= 2) {
+            const firstArg = node.type.typeArguments[0];
+            const stateArg = node.type.typeArguments[1];
+            let namespace = null;
+            if ((0, typescript_1.isTypeQueryNode)(firstArg) && (0, typescript_1.isIdentifier)(firstArg.exprName)) {
+                namespace = constants.get(firstArg.exprName.text) ?? null;
+            }
+            if ((0, typescript_1.isLiteralTypeNode)(firstArg) && (0, typescript_1.isStringLiteral)(firstArg.literal)) {
+                namespace = firstArg.literal.text;
+            }
+            if (namespace) {
+                items.push({
+                    typeName,
+                    typeString: `${namespace}:getState`,
+                    kind: 'action',
+                    jsDoc: extractJsDocText(node, sourceFile),
+                    handlerOrPayload: `() => ${stateArg.getText(sourceFile)}`,
+                    sourceFile: relPath,
+                    line,
+                    deprecated: isDeprecated(node),
+                });
+            }
+        }
+        // -------------------------------------------------------------------
+        // Pattern 3: ControllerStateChangeEvent<typeof cn, State>
+        // -------------------------------------------------------------------
+        if ((0, typescript_1.isTypeReferenceNode)(node.type) &&
+            (0, typescript_1.isIdentifier)(node.type.typeName) &&
+            node.type.typeName.text === 'ControllerStateChangeEvent' &&
+            node.type.typeArguments &&
+            node.type.typeArguments.length >= 2) {
+            const firstArg = node.type.typeArguments[0];
+            const stateArg = node.type.typeArguments[1];
+            let namespace = null;
+            if ((0, typescript_1.isTypeQueryNode)(firstArg) && (0, typescript_1.isIdentifier)(firstArg.exprName)) {
+                namespace = constants.get(firstArg.exprName.text) ?? null;
+            }
+            if ((0, typescript_1.isLiteralTypeNode)(firstArg) && (0, typescript_1.isStringLiteral)(firstArg.literal)) {
+                namespace = firstArg.literal.text;
+            }
+            if (namespace) {
+                items.push({
+                    typeName,
+                    typeString: `${namespace}:stateChange`,
+                    kind: 'event',
+                    jsDoc: extractJsDocText(node, sourceFile),
+                    handlerOrPayload: `[${stateArg.getText(sourceFile)}, Patch[]]`,
+                    sourceFile: relPath,
+                    line,
+                    deprecated: isDeprecated(node),
+                });
+            }
+        }
+    }
+    return items;
+}
+exports.extractFromFile = extractFromFile;
+//# sourceMappingURL=extraction.cjs.map