@openwebf/webf 0.24.0 → 0.24.2

package/README.md

@@ -10,6 +10,14 @@ npm install -g @openwebf/webf
 
 ## Usage
 
+### Initialize Claude Code Skills
+
+The `webf agents init` command injects WebF Claude Code skills (from `@openwebf/claude-code-skills`) into your project and updates `CLAUDE.md` to reference them.
+
+```bash
+webf agents init [project-dir]
+```
+
 ### Generate Code
 
 The `webf codegen` command generates Dart abstract classes and React/Vue components from TypeScript definitions. It automatically creates a project if needed.
@@ -142,7 +150,7 @@ my-webf-app/
 │   └── index.ts
 ├── package.json
 ├── tsconfig.json
-├── tsup.config.ts
+├── tsdown.config.ts
 ├── global.d.ts
 └── .gitignore
 ```

package/bin/webf.js

@@ -2,7 +2,7 @@
 
 const { Command } = require('commander');
 const version = require('../package.json').version;
-const { generateCommand, generateModuleCommand } = require('../dist/commands');
+const { generateCommand, generateModuleCommand, agentsInitCommand } = require('../dist/commands');
 
 const program = new Command();
 
@@ -35,4 +35,12 @@ program
   .description('Generate NPM package and Dart bindings for a WebF module from TypeScript interfaces (*.module.d.ts)')
   .action(generateModuleCommand);
 
+const agents = program.command('agents').description('Manage Claude Code agent configs');
+
+agents
+  .command('init')
+  .argument('[projectDir]', 'Target project directory', '.')
+  .description('Initialize Claude Code skills config for a project')
+  .action(agentsInitCommand);
+
 program.parse();

package/dist/agents.js

@@ -0,0 +1,245 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.agentsInitCommand = agentsInitCommand;
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const yaml_1 = __importDefault(require("yaml"));
+const WEBF_AGENTS_BLOCK_START = '<!-- webf-agents:init start -->';
+const WEBF_AGENTS_BLOCK_END = '<!-- webf-agents:init end -->';
+function ensureDirSync(dirPath) {
+    fs_1.default.mkdirSync(dirPath, { recursive: true });
+}
+function readFileIfExists(filePath) {
+    try {
+        return fs_1.default.readFileSync(filePath);
+    }
+    catch (error) {
+        if ((error === null || error === void 0 ? void 0 : error.code) === 'ENOENT')
+            return null;
+        throw error;
+    }
+}
+function backupFileSync(filePath) {
+    const timestamp = new Date()
+        .toISOString()
+        .replace(/[:.]/g, '')
+        .replace('T', '')
+        .replace('Z', 'Z');
+    const backupPath = `${filePath}.bak.${timestamp}`;
+    fs_1.default.copyFileSync(filePath, backupPath);
+    return backupPath;
+}
+function copyFileWithBackupSync(srcPath, destPath) {
+    const src = fs_1.default.readFileSync(srcPath);
+    const dest = readFileIfExists(destPath);
+    if (dest && Buffer.compare(src, dest) === 0)
+        return { changed: false, backupPath: null };
+    ensureDirSync(path_1.default.dirname(destPath));
+    let backupPath = null;
+    if (dest) {
+        backupPath = backupFileSync(destPath);
+    }
+    fs_1.default.writeFileSync(destPath, src);
+    return { changed: true, backupPath };
+}
+function copyDirRecursiveSync(srcDir, destDir, stats) {
+    ensureDirSync(destDir);
+    const entries = fs_1.default.readdirSync(srcDir, { withFileTypes: true });
+    for (const entry of entries) {
+        const srcPath = path_1.default.join(srcDir, entry.name);
+        const destPath = path_1.default.join(destDir, entry.name);
+        if (entry.isDirectory()) {
+            copyDirRecursiveSync(srcPath, destPath, stats);
+            continue;
+        }
+        if (entry.isFile()) {
+            const { changed, backupPath } = copyFileWithBackupSync(srcPath, destPath);
+            if (changed)
+                stats.filesWritten += 1;
+            else
+                stats.filesUnchanged += 1;
+            if (backupPath)
+                stats.backupsCreated += 1;
+        }
+    }
+}
+function listFilesRecursiveSync(dirPath) {
+    const out = [];
+    const entries = fs_1.default.readdirSync(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+        const entryPath = path_1.default.join(dirPath, entry.name);
+        if (entry.isDirectory()) {
+            out.push(...listFilesRecursiveSync(entryPath));
+            continue;
+        }
+        if (entry.isFile())
+            out.push(entryPath);
+    }
+    return out;
+}
+function toPosixRelativePath(fromDir, absolutePath) {
+    const rel = path_1.default.relative(fromDir, absolutePath);
+    return rel.split(path_1.default.sep).join('/');
+}
+function parseSkillFrontmatter(skillMd) {
+    var _a;
+    const trimmed = skillMd.trimStart();
+    if (!trimmed.startsWith('---'))
+        return {};
+    const endIndex = trimmed.indexOf('\n---', 3);
+    if (endIndex === -1)
+        return {};
+    const fm = trimmed.slice(3, endIndex).trim();
+    try {
+        const parsed = (_a = yaml_1.default.parse(fm)) !== null && _a !== void 0 ? _a : {};
+        return { name: parsed === null || parsed === void 0 ? void 0 : parsed.name, description: parsed === null || parsed === void 0 ? void 0 : parsed.description };
+    }
+    catch (_b) {
+        return {};
+    }
+}
+function updateOrAppendMarkedBlock(existing, newBlock) {
+    const startIndex = existing.indexOf(WEBF_AGENTS_BLOCK_START);
+    const endIndex = existing.indexOf(WEBF_AGENTS_BLOCK_END);
+    if (startIndex !== -1 && endIndex !== -1 && endIndex > startIndex) {
+        const before = existing.slice(0, startIndex).trimEnd();
+        const after = existing.slice(endIndex + WEBF_AGENTS_BLOCK_END.length).trimStart();
+        const next = [before, newBlock.trim(), after].filter(Boolean).join('\n\n');
+        return { content: next + '\n', action: 'replaced' };
+    }
+    const content = existing.trimEnd();
+    return { content: (content ? content + '\n\n' : '') + newBlock.trim() + '\n', action: 'appended' };
+}
+function buildClaudeBlock(sourcePackageName, sourcePackageVersion, skills) {
+    const lines = [];
+    lines.push(WEBF_AGENTS_BLOCK_START);
+    lines.push('## WebF Claude Code Skills');
+    lines.push('');
+    lines.push(`Source: \`${sourcePackageName}@${sourcePackageVersion}\``);
+    lines.push('');
+    lines.push('### Skills');
+    for (const skill of skills) {
+        const desc = skill.description ? ` — ${skill.description}` : '';
+        lines.push(`- \`${skill.name}\`${desc} (\`${skill.skillFileRelativePath}\`)`);
+    }
+    const anyReferences = skills.some(s => s.referenceRelativePaths.length > 0);
+    if (anyReferences) {
+        lines.push('');
+        lines.push('### References');
+        for (const skill of skills) {
+            if (skill.referenceRelativePaths.length === 0)
+                continue;
+            const refs = skill.referenceRelativePaths.map(r => `\`${r}\``).join(', ');
+            lines.push(`- \`${skill.name}\`: ${refs}`);
+        }
+    }
+    lines.push(WEBF_AGENTS_BLOCK_END);
+    return lines.join('\n');
+}
+function resolveSkillsPackageRoot() {
+    var _a, _b;
+    const packageJsonPath = require.resolve('@openwebf/claude-code-skills/package.json');
+    const packageRoot = path_1.default.dirname(packageJsonPath);
+    const packageJson = JSON.parse(fs_1.default.readFileSync(packageJsonPath, 'utf-8'));
+    return {
+        packageRoot,
+        packageName: (_a = packageJson === null || packageJson === void 0 ? void 0 : packageJson.name) !== null && _a !== void 0 ? _a : '@openwebf/claude-code-skills',
+        packageVersion: (_b = packageJson === null || packageJson === void 0 ? void 0 : packageJson.version) !== null && _b !== void 0 ? _b : 'unknown',
+    };
+}
+function listSkillDirectories(skillsPackageRoot) {
+    const entries = fs_1.default.readdirSync(skillsPackageRoot, { withFileTypes: true });
+    const dirs = entries
+        .filter(e => e.isDirectory())
+        .map(e => e.name)
+        .filter(name => fs_1.default.existsSync(path_1.default.join(skillsPackageRoot, name, 'SKILL.md')))
+        .sort();
+    return dirs;
+}
+function collectSkillInfo(projectRoot, skillsDir, skillDirectoryName) {
+    var _a;
+    const skillDirAbs = path_1.default.join(skillsDir, skillDirectoryName);
+    const skillMdAbs = path_1.default.join(skillDirAbs, 'SKILL.md');
+    const skillMd = fs_1.default.readFileSync(skillMdAbs, 'utf-8');
+    const fm = parseSkillFrontmatter(skillMd);
+    const referenceRelativePaths = [];
+    const files = listFilesRecursiveSync(skillDirAbs);
+    for (const fileAbs of files) {
+        if (path_1.default.basename(fileAbs) === 'SKILL.md')
+            continue;
+        referenceRelativePaths.push(toPosixRelativePath(projectRoot, fileAbs));
+    }
+    referenceRelativePaths.sort();
+    return {
+        directoryName: skillDirectoryName,
+        name: (_a = fm.name) !== null && _a !== void 0 ? _a : skillDirectoryName,
+        description: fm.description,
+        skillFileRelativePath: toPosixRelativePath(projectRoot, skillMdAbs),
+        referenceRelativePaths,
+    };
+}
+function agentsInitCommand(projectDir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        const startedAt = Date.now();
+        const resolvedProjectDir = path_1.default.resolve(process.cwd(), projectDir || '.');
+        const claudeMdPath = path_1.default.join(resolvedProjectDir, 'CLAUDE.md');
+        const claudeDir = path_1.default.join(resolvedProjectDir, '.claude');
+        const projectSkillsDir = path_1.default.join(claudeDir, 'skills');
+        const hasClaudeMd = fs_1.default.existsSync(claudeMdPath);
+        const hasClaudeDir = fs_1.default.existsSync(claudeDir);
+        const isNewProject = !hasClaudeMd && !hasClaudeDir;
+        console.log('webf agents init');
+        console.log(`Project: ${resolvedProjectDir}`);
+        if (isNewProject) {
+            console.log('Detected: no CLAUDE.md and no .claude/ (new project)');
+        }
+        else {
+            console.log(`Detected: CLAUDE.md=${hasClaudeMd ? 'yes' : 'no'}, .claude/=${hasClaudeDir ? 'yes' : 'no'} (existing project)`);
+        }
+        const { packageRoot, packageName, packageVersion } = resolveSkillsPackageRoot();
+        const skillDirectories = listSkillDirectories(packageRoot);
+        if (skillDirectories.length === 0) {
+            throw new Error(`No skills found in ${packageName} (resolved at ${packageRoot}).`);
+        }
+        console.log(`Skills source: ${packageName}@${packageVersion}`);
+        console.log(`Skills destination: ${toPosixRelativePath(resolvedProjectDir, projectSkillsDir)}`);
+        ensureDirSync(projectSkillsDir);
+        const copyStats = { filesWritten: 0, filesUnchanged: 0, backupsCreated: 0 };
+        for (const skillDirName of skillDirectories) {
+            const srcSkillDir = path_1.default.join(packageRoot, skillDirName);
+            const destSkillDir = path_1.default.join(projectSkillsDir, skillDirName);
+            copyDirRecursiveSync(srcSkillDir, destSkillDir, copyStats);
+        }
+        const installedSkills = skillDirectories.map(skillDirName => collectSkillInfo(resolvedProjectDir, projectSkillsDir, skillDirName));
+        const block = buildClaudeBlock(packageName, packageVersion, installedSkills);
+        if (isNewProject) {
+            const initial = ['# Claude Code', '', block, ''].join('\n');
+            fs_1.default.writeFileSync(claudeMdPath, initial, 'utf-8');
+            console.log(`Created ${toPosixRelativePath(resolvedProjectDir, claudeMdPath)}`);
+        }
+        else {
+            const existing = (_b = (_a = readFileIfExists(claudeMdPath)) === null || _a === void 0 ? void 0 : _a.toString('utf-8')) !== null && _b !== void 0 ? _b : '';
+            const { content, action } = updateOrAppendMarkedBlock(existing, block);
+            fs_1.default.writeFileSync(claudeMdPath, content, 'utf-8');
+            console.log(`${action === 'replaced' ? 'Updated' : 'Appended'} WebF skills block in ${toPosixRelativePath(resolvedProjectDir, claudeMdPath)}`);
+        }
+        const versionFilePath = path_1.default.join(claudeDir, 'webf-claude-code-skills.version');
+        fs_1.default.writeFileSync(versionFilePath, `${packageName}@${packageVersion}${os_1.default.EOL}`, 'utf-8');
+        console.log(`Wrote ${toPosixRelativePath(resolvedProjectDir, versionFilePath)}`);
+        console.log(`Installed ${installedSkills.length} skills (${copyStats.filesWritten} files written, ${copyStats.filesUnchanged} unchanged, ${copyStats.backupsCreated} backups) in ${Date.now() - startedAt}ms`);
+    });
+}

package/dist/analyzer.js

@@ -365,134 +365,196 @@ function handleGenericWrapper(typeReference, mode) {
     const argument = typeReference.typeArguments[0];
     return getParameterBaseType(argument, mode);
 }
-function handleCustomEventType(typeReference) {
-    var _a;
-    // Handle CustomEvent<T> by returning the full type with generic parameter
-    if (!typeReference.typeArguments || !typeReference.typeArguments[0]) {
-        return 'CustomEvent';
+const customEventTypePrinter = typescript_1.default.createPrinter({ removeComments: true });
+function mapTypeReferenceIdentifierToTsType(identifier) {
+    const mappedType = TYPE_REFERENCE_MAP[identifier];
+    if (mappedType === undefined)
+        return null;
+    switch (mappedType) {
+        case declaration_1.FunctionArgumentType.boolean:
+            return 'boolean';
+        case declaration_1.FunctionArgumentType.dom_string:
+            return 'string';
+        case declaration_1.FunctionArgumentType.double:
+        case declaration_1.FunctionArgumentType.int:
+            return 'number';
+        case declaration_1.FunctionArgumentType.any:
+            return 'any';
+        case declaration_1.FunctionArgumentType.void:
+            return 'void';
+        case declaration_1.FunctionArgumentType.function:
+            return 'Function';
+        case declaration_1.FunctionArgumentType.promise:
+            return 'Promise<any>';
+        default:
+            return null;
     }
-    const argument = typeReference.typeArguments[0];
-    let genericType;
-    // Preserve simple union/compound generic types (e.g., boolean | null)
-    if (typescript_1.default.isUnionTypeNode(argument) || typescript_1.default.isIntersectionTypeNode(argument)) {
-        const unionTypes = (_a = argument.types) !== null && _a !== void 0 ? _a : [];
-        const parts = unionTypes.map(t => {
-            // Literal union members: handle null/undefined explicitly
-            if (typescript_1.default.isLiteralTypeNode(t)) {
-                const lit = t.literal;
-                if (lit.kind === typescript_1.default.SyntaxKind.NullKeyword)
-                    return 'null';
-                if (lit.kind === typescript_1.default.SyntaxKind.UndefinedKeyword)
-                    return 'undefined';
-                if (typescript_1.default.isStringLiteral(lit))
-                    return JSON.stringify(lit.text);
-                return 'any';
-            }
-            // Basic keywords: boolean, string, number, null, undefined
-            const basic = BASIC_TYPE_MAP[t.kind];
-            if (basic !== undefined) {
-                switch (basic) {
-                    case declaration_1.FunctionArgumentType.boolean:
-                        return 'boolean';
-                    case declaration_1.FunctionArgumentType.dom_string:
-                        return 'string';
-                    case declaration_1.FunctionArgumentType.double:
-                    case declaration_1.FunctionArgumentType.int:
-                        return 'number';
-                    case declaration_1.FunctionArgumentType.null:
-                        return 'null';
-                    case declaration_1.FunctionArgumentType.undefined:
-                        return 'undefined';
-                    default:
-                        return 'any';
-                }
-            }
-            // Literal null/undefined keywords that BASIC_TYPE_MAP may not cover
-            if (t.kind === typescript_1.default.SyntaxKind.NullKeyword)
-                return 'null';
-            if (t.kind === typescript_1.default.SyntaxKind.UndefinedKeyword)
-                return 'undefined';
-            // Fallback: rely on toString of node kind
+}
+function getBasicTypeKindAsTsType(kind) {
+    const basicType = BASIC_TYPE_MAP[kind];
+    if (basicType === undefined)
+        return null;
+    switch (basicType) {
+        case declaration_1.FunctionArgumentType.boolean:
+            return 'boolean';
+        case declaration_1.FunctionArgumentType.dom_string:
+            return 'string';
+        case declaration_1.FunctionArgumentType.double:
+        case declaration_1.FunctionArgumentType.int:
+            return 'number';
+        case declaration_1.FunctionArgumentType.any:
             return 'any';
-        });
-        genericType = parts.join(' | ');
+        case declaration_1.FunctionArgumentType.void:
+            return 'void';
+        case declaration_1.FunctionArgumentType.null:
+            return 'null';
+        case declaration_1.FunctionArgumentType.undefined:
+            return 'undefined';
+        default:
+            return null;
     }
-    else if (typescript_1.default.isTypeReferenceNode(argument) && typescript_1.default.isIdentifier(argument.typeName)) {
-        const typeName = argument.typeName.text;
-        // Check if it's a mapped type reference like 'int' or 'double'
-        const mappedType = TYPE_REFERENCE_MAP[typeName];
-        if (mappedType !== undefined) {
-            switch (mappedType) {
-                case declaration_1.FunctionArgumentType.boolean:
-                    genericType = 'boolean';
-                    break;
-                case declaration_1.FunctionArgumentType.dom_string:
-                    genericType = 'string';
-                    break;
-                case declaration_1.FunctionArgumentType.double:
-                case declaration_1.FunctionArgumentType.int:
-                    genericType = 'number';
-                    break;
-                case declaration_1.FunctionArgumentType.any:
-                    genericType = 'any';
-                    break;
-                case declaration_1.FunctionArgumentType.void:
-                    genericType = 'void';
-                    break;
-                case declaration_1.FunctionArgumentType.function:
-                    genericType = 'Function';
-                    break;
-                case declaration_1.FunctionArgumentType.promise:
-                    genericType = 'Promise<any>';
-                    break;
-                default:
-                    genericType = typeName;
+}
+function stringifyEntityName(name) {
+    if (typescript_1.default.isIdentifier(name))
+        return name.text;
+    return `${stringifyEntityName(name.left)}.${name.right.text}`;
+}
+function safePrintCustomEventNode(node) {
+    const sourceFile = node.getSourceFile();
+    const printed = customEventTypePrinter.printNode(typescript_1.default.EmitHint.Unspecified, node, sourceFile);
+    // Ensure WebF IDL-like aliases used in type definitions do not leak into generated TypeScript packages.
+    return printed.replace(/\bint\b/g, 'number').replace(/\bdouble\b/g, 'number');
+}
+function stringifyCustomEventGenericTypeNode(typeNode) {
+    if (typescript_1.default.isParenthesizedTypeNode(typeNode)) {
+        const inner = stringifyCustomEventGenericTypeNode(typeNode.type);
+        return inner ? `(${inner})` : null;
+    }
+    if (typescript_1.default.isUnionTypeNode(typeNode)) {
+        const parts = typeNode.types.map(t => stringifyCustomEventGenericTypeNode(t)).filter((t) => Boolean(t));
+        return parts.length === typeNode.types.length ? parts.join(' | ') : null;
+    }
+    if (typescript_1.default.isIntersectionTypeNode(typeNode)) {
+        const parts = typeNode.types.map(t => stringifyCustomEventGenericTypeNode(t)).filter((t) => Boolean(t));
+        return parts.length === typeNode.types.length ? parts.join(' & ') : null;
+    }
+    if (typescript_1.default.isArrayTypeNode(typeNode)) {
+        const element = stringifyCustomEventGenericTypeNode(typeNode.elementType);
+        return element ? `${element}[]` : null;
+    }
+    if (typescript_1.default.isTupleTypeNode(typeNode)) {
+        const elements = typeNode.elements.map(e => stringifyCustomEventGenericTypeNode(e)).filter((t) => Boolean(t));
+        return elements.length === typeNode.elements.length ? `[${elements.join(', ')}]` : null;
+    }
+    if (typescript_1.default.isLiteralTypeNode(typeNode)) {
+        const literal = typeNode.literal;
+        if (literal.kind === typescript_1.default.SyntaxKind.NullKeyword)
+            return 'null';
+        if (literal.kind === typescript_1.default.SyntaxKind.UndefinedKeyword)
+            return 'undefined';
+        if (literal.kind === typescript_1.default.SyntaxKind.TrueKeyword)
+            return 'true';
+        if (literal.kind === typescript_1.default.SyntaxKind.FalseKeyword)
+            return 'false';
+        if (typescript_1.default.isStringLiteral(literal))
+            return JSON.stringify(literal.text);
+        if (typescript_1.default.isNumericLiteral(literal))
+            return literal.text;
+        return null;
+    }
+    const basic = getBasicTypeKindAsTsType(typeNode.kind);
+    if (basic)
+        return basic;
+    if (typescript_1.default.isTypeReferenceNode(typeNode)) {
+        const typeName = stringifyEntityName(typeNode.typeName);
+        // Unwrap internal helpers used by WebF typings.
+        if (typeName === 'DartImpl' && typeNode.typeArguments && typeNode.typeArguments[0]) {
+            return stringifyCustomEventGenericTypeNode(typeNode.typeArguments[0]);
+        }
+        if (typeName === 'Promise') {
+            if (!typeNode.typeArguments || !typeNode.typeArguments[0])
+                return 'Promise<any>';
+            const inner = stringifyCustomEventGenericTypeNode(typeNode.typeArguments[0]);
+            return inner ? `Promise<${inner}>` : null;
+        }
+        const mapped = mapTypeReferenceIdentifierToTsType(typeName);
+        if (mapped)
+            return mapped;
+        if (!typeNode.typeArguments || typeNode.typeArguments.length === 0) {
+            return typeName;
+        }
+        const args = typeNode.typeArguments
+            .map(arg => stringifyCustomEventGenericTypeNode(arg))
+            .filter((t) => Boolean(t));
+        if (args.length !== typeNode.typeArguments.length)
+            return null;
+        return `${typeName}<${args.join(', ')}>`;
+    }
+    if (typescript_1.default.isTypeLiteralNode(typeNode)) {
+        const members = [];
+        for (const member of typeNode.members) {
+            if (typescript_1.default.isPropertySignature(member) && member.type) {
+                const typeString = stringifyCustomEventGenericTypeNode(member.type);
+                if (!typeString)
+                    return null;
+                let nameText;
+                if (typescript_1.default.isIdentifier(member.name))
+                    nameText = member.name.text;
+                else if (typescript_1.default.isStringLiteral(member.name))
+                    nameText = JSON.stringify(member.name.text);
+                else if (typescript_1.default.isNumericLiteral(member.name))
+                    nameText = member.name.text;
+                else
+                    nameText = member.name.getText();
+                const optional = member.questionToken ? '?' : '';
+                members.push(`${nameText}${optional}: ${typeString}`);
+                continue;
             }
+            if (typescript_1.default.isIndexSignatureDeclaration(member) && member.type && member.parameters.length === 1) {
+                const param = member.parameters[0];
+                const paramName = typescript_1.default.isIdentifier(param.name) ? param.name.text : param.name.getText();
+                const paramType = param.type ? stringifyCustomEventGenericTypeNode(param.type) : 'string';
+                const valueType = stringifyCustomEventGenericTypeNode(member.type);
+                if (!paramType || !valueType)
+                    return null;
+                members.push(`[${paramName}: ${paramType}]: ${valueType}`);
+                continue;
+            }
+            // Fallback for uncommon members (call signatures, method signatures, etc.).
+            members.push(safePrintCustomEventNode(member));
         }
-        else {
-            // For other type references, use the type name directly
-            genericType = typeName;
-        }
+        return `{ ${members.join('; ')} }`;
     }
-    else if (typescript_1.default.isLiteralTypeNode(argument) && typescript_1.default.isStringLiteral(argument.literal)) {
-        genericType = argument.literal.text;
+    if (typescript_1.default.isTypeOperatorNode(typeNode)) {
+        const inner = stringifyCustomEventGenericTypeNode(typeNode.type);
+        if (!inner)
+            return null;
+        const operator = typeNode.operator === typescript_1.default.SyntaxKind.KeyOfKeyword ? 'keyof' :
+            typeNode.operator === typescript_1.default.SyntaxKind.ReadonlyKeyword ? 'readonly' :
+                typeNode.operator === typescript_1.default.SyntaxKind.UniqueKeyword ? 'unique' :
+                    null;
+        return operator ? `${operator} ${inner}` : null;
+    }
+    if (typescript_1.default.isIndexedAccessTypeNode(typeNode)) {
+        const objectType = stringifyCustomEventGenericTypeNode(typeNode.objectType);
+        const indexType = stringifyCustomEventGenericTypeNode(typeNode.indexType);
+        if (!objectType || !indexType)
+            return null;
+        return `${objectType}[${indexType}]`;
     }
-    else {
-        // Handle basic types (boolean, string, number, etc.)
-        const basicType = BASIC_TYPE_MAP[argument.kind];
-        if (basicType !== undefined) {
-            switch (basicType) {
-                case declaration_1.FunctionArgumentType.boolean:
-                    genericType = 'boolean';
-                    break;
-                case declaration_1.FunctionArgumentType.dom_string:
-                    genericType = 'string';
-                    break;
-                case declaration_1.FunctionArgumentType.double:
-                case declaration_1.FunctionArgumentType.int:
-                    genericType = 'number';
-                    break;
-                case declaration_1.FunctionArgumentType.any:
-                    genericType = 'any';
-                    break;
-                case declaration_1.FunctionArgumentType.void:
-                    genericType = 'void';
-                    break;
-                case declaration_1.FunctionArgumentType.null:
-                    genericType = 'null';
-                    break;
-                case declaration_1.FunctionArgumentType.undefined:
-                    genericType = 'undefined';
-                    break;
-                default:
-                    genericType = 'any';
-            }
-        }
-        else {
-            // For truly complex types, fallback to 'any' to avoid errors
-            console.warn('Complex generic type in CustomEvent, using any');
-            genericType = 'any';
-        }
+    // As a last resort, keep the original syntax but normalize known WebF aliases.
+    return safePrintCustomEventNode(typeNode);
+}
+function handleCustomEventType(typeReference) {
+    // Handle CustomEvent<T> by returning the full type with generic parameter
+    if (!typeReference.typeArguments || !typeReference.typeArguments[0]) {
+        return 'CustomEvent';
+    }
+    const argument = typeReference.typeArguments[0];
+    const genericType = stringifyCustomEventGenericTypeNode(argument);
+    if (!genericType) {
+        console.warn('Complex generic type in CustomEvent, using any');
+        return 'CustomEvent<any>';
     }
     return `CustomEvent<${genericType}>`;
 }