@openwebf/webf 0.23.0 → 0.23.7

package/dist/commands.js

@@ -18,6 +18,7 @@ const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const os_1 = __importDefault(require("os"));
 const generator_1 = require("./generator");
+const glob_1 = require("glob");
 const lodash_1 = __importDefault(require("lodash"));
 const inquirer_1 = __importDefault(require("inquirer"));
 const yaml_1 = __importDefault(require("yaml"));
@@ -171,6 +172,107 @@ function readFlutterPackageMetadata(packagePath) {
         return null;
     }
 }
+// Copy markdown docs that match .d.ts basenames from source to the built dist folder,
+// and generate an aggregated README.md in the dist directory.
+function copyMarkdownDocsToDist(params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { sourceRoot, distRoot, exclude } = params;
+        // Ensure dist exists
+        if (!fs_1.default.existsSync(distRoot)) {
+            return { copied: 0, skipped: 0 };
+        }
+        // Default ignore patterns similar to generator
+        const defaultIgnore = ['**/node_modules/**', '**/dist/**', '**/build/**', '**/example/**'];
+        const ignore = exclude && exclude.length ? [...defaultIgnore, ...exclude] : defaultIgnore;
+        // Find all .d.ts files and check for sibling .md files
+        const dtsFiles = glob_1.glob.globSync('**/*.d.ts', { cwd: sourceRoot, ignore });
+        let copied = 0;
+        let skipped = 0;
+        const readmeSections = [];
+        for (const relDts of dtsFiles) {
+            if (path_1.default.basename(relDts) === 'global.d.ts') {
+                continue;
+            }
+            const relMd = relDts.replace(/\.d\.ts$/i, '.md');
+            const absMd = path_1.default.join(sourceRoot, relMd);
+            if (!fs_1.default.existsSync(absMd)) {
+                skipped++;
+                continue;
+            }
+            let content = '';
+            try {
+                content = fs_1.default.readFileSync(absMd, 'utf-8');
+            }
+            catch (_a) {
+                // If we cannot read the file, still attempt to copy it and skip README aggregation for this entry.
+            }
+            // Copy into dist preserving relative path
+            const destPath = path_1.default.join(distRoot, relMd);
+            const destDir = path_1.default.dirname(destPath);
+            if (!fs_1.default.existsSync(destDir)) {
+                fs_1.default.mkdirSync(destDir, { recursive: true });
+            }
+            fs_1.default.copyFileSync(absMd, destPath);
+            copied++;
+            if (content) {
+                const base = path_1.default.basename(relMd, '.md');
+                const title = base
+                    .split(/[-_]+/)
+                    .filter(Boolean)
+                    .map(part => part.charAt(0).toUpperCase() + part.slice(1))
+                    .join(' ');
+                readmeSections.push({
+                    title: title || base,
+                    relPath: relMd,
+                    content
+                });
+            }
+        }
+        // Generate an aggregated README.md inside distRoot so consumers can see component docs easily.
+        if (readmeSections.length > 0) {
+            const readmePath = path_1.default.join(distRoot, 'README.md');
+            let existing = '';
+            if (fs_1.default.existsSync(readmePath)) {
+                try {
+                    existing = fs_1.default.readFileSync(readmePath, 'utf-8');
+                }
+                catch (_b) {
+                    existing = '';
+                }
+            }
+            const headerLines = [
+                '# WebF Component Documentation',
+                '',
+                '> This README is generated from markdown docs co-located with TypeScript definitions in the Flutter package.',
+                ''
+            ];
+            const sectionBlocks = readmeSections.map(section => {
+                const lines = [];
+                lines.push(`## ${section.title}`);
+                lines.push('');
+                lines.push(`_Source: \`./${section.relPath}\`_`);
+                lines.push('');
+                lines.push(section.content.trim());
+                lines.push('');
+                return lines.join('\n');
+            }).join('\n');
+            let finalContent;
+            if (existing && existing.trim().length > 0) {
+                finalContent = `${existing.trim()}\n\n---\n\n${headerLines.join('\n')}${sectionBlocks}\n`;
+            }
+            else {
+                finalContent = `${headerLines.join('\n')}${sectionBlocks}\n`;
+            }
+            try {
+                fs_1.default.writeFileSync(readmePath, finalContent, 'utf-8');
+            }
+            catch (_c) {
+                // If README generation fails, do not affect overall codegen.
+            }
+        }
+        return { copied, skipped };
+    });
+}
 function validateTypeScriptEnvironment(projectPath) {
     const errors = [];
     // Check for TypeScript configuration
@@ -243,7 +345,8 @@ function createCommand(target, options) {
             // Do not overwrite existing index.ts created by the user
             // Leave merge to the codegen step which appends exports safely
         }
-        (0, child_process_1.spawnSync)(NPM, ['install', '--omit=peer'], {
+        // !no '--omit=peer' here.
+        (0, child_process_1.spawnSync)(NPM, ['install'], {
             cwd: target,
             stdio: 'inherit'
         });
@@ -279,12 +382,19 @@ function generateCommand(distPath, options) {
         // If distPath is not provided or is '.', create a temporary directory
         let resolvedDistPath;
         let isTempDir = false;
+        const isDartOnly = options.dartOnly;
         if (!distPath || distPath === '.') {
-            // Create a temporary directory for the generated package
-            const tempDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'webf-typings-'));
-            resolvedDistPath = tempDir;
-            isTempDir = true;
-            console.log(`\nUsing temporary directory: ${tempDir}`);
+            if (isDartOnly) {
+                // In Dart-only mode we don't need a temporary Node project directory
+                resolvedDistPath = path_1.default.resolve(distPath || '.');
+            }
+            else {
+                // Create a temporary directory for the generated package
+                const tempDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'webf-typings-'));
+                resolvedDistPath = tempDir;
+                isTempDir = true;
+                console.log(`\nUsing temporary directory: ${tempDir}`);
+            }
         }
         else {
             resolvedDistPath = path_1.default.resolve(distPath);
@@ -314,111 +424,123 @@ function generateCommand(distPath, options) {
                 console.log(`\nDetected Flutter package at: ${pubspecDir}`);
             }
         }
-        // Check if the directory exists and has required files
-        const packageJsonPath = path_1.default.join(resolvedDistPath, 'package.json');
-        const globalDtsPath = path_1.default.join(resolvedDistPath, 'global.d.ts');
-        const tsConfigPath = path_1.default.join(resolvedDistPath, 'tsconfig.json');
-        const hasPackageJson = fs_1.default.existsSync(packageJsonPath);
-        const hasGlobalDts = fs_1.default.existsSync(globalDtsPath);
-        const hasTsConfig = fs_1.default.existsSync(tsConfigPath);
-        // Determine if we need to create a new project
-        const needsProjectCreation = !hasPackageJson || !hasGlobalDts || !hasTsConfig;
-        // Track if this is an existing project (has all required files)
-        const isExistingProject = hasPackageJson && hasGlobalDts && hasTsConfig;
         let framework = options.framework;
         let packageName = options.packageName;
-        // Validate and sanitize package name if provided
-        if (packageName && !isValidNpmPackageName(packageName)) {
-            console.warn(`Warning: Package name "${packageName}" is not valid for npm.`);
-            const sanitized = sanitizePackageName(packageName);
-            console.log(`Using sanitized name: "${sanitized}"`);
-            packageName = sanitized;
-        }
-        if (needsProjectCreation) {
-            // If project needs creation but options are missing, prompt for them
-            if (!framework) {
-                const frameworkAnswer = yield inquirer_1.default.prompt([{
-                        type: 'list',
-                        name: 'framework',
-                        message: 'Which framework would you like to use?',
-                        choices: ['react', 'vue']
-                    }]);
-                framework = frameworkAnswer.framework;
-            }
-            // Try to read Flutter package metadata if flutterPackageSrc is provided
-            let metadata = null;
-            if (options.flutterPackageSrc) {
-                metadata = readFlutterPackageMetadata(options.flutterPackageSrc);
-            }
-            if (!packageName) {
-                // Use Flutter package name as default if available, sanitized for npm
-                const rawDefaultName = (metadata === null || metadata === void 0 ? void 0 : metadata.name) || path_1.default.basename(resolvedDistPath);
-                const defaultPackageName = sanitizePackageName(rawDefaultName);
-                const packageNameAnswer = yield inquirer_1.default.prompt([{
-                        type: 'input',
-                        name: 'packageName',
-                        message: 'What is your package name?',
-                        default: defaultPackageName,
-                        validate: (input) => {
-                            if (!input || input.trim() === '') {
-                                return 'Package name is required';
-                            }
-                            // Check if it's valid as-is
-                            if (isValidNpmPackageName(input)) {
-                                return true;
+        let isExistingProject = false;
+        if (!isDartOnly) {
+            // Check if the directory exists and has required files
+            const packageJsonPath = path_1.default.join(resolvedDistPath, 'package.json');
+            const globalDtsPath = path_1.default.join(resolvedDistPath, 'global.d.ts');
+            const tsConfigPath = path_1.default.join(resolvedDistPath, 'tsconfig.json');
+            const hasPackageJson = fs_1.default.existsSync(packageJsonPath);
+            const hasGlobalDts = fs_1.default.existsSync(globalDtsPath);
+            const hasTsConfig = fs_1.default.existsSync(tsConfigPath);
+            // Determine if we need to create a new project
+            const needsProjectCreation = !hasPackageJson || !hasGlobalDts || !hasTsConfig;
+            // Track if this is an existing project (has all required files)
+            isExistingProject = hasPackageJson && hasGlobalDts && hasTsConfig;
+            // Validate and sanitize package name if provided
+            if (packageName && !isValidNpmPackageName(packageName)) {
+                console.warn(`Warning: Package name "${packageName}" is not valid for npm.`);
+                const sanitized = sanitizePackageName(packageName);
+                console.log(`Using sanitized name: "${sanitized}"`);
+                packageName = sanitized;
+            }
+            if (needsProjectCreation) {
+                // If project needs creation but options are missing, prompt for them
+                if (!framework) {
+                    const frameworkAnswer = yield inquirer_1.default.prompt([{
+                            type: 'list',
+                            name: 'framework',
+                            message: 'Which framework would you like to use?',
+                            choices: ['react', 'vue']
+                        }]);
+                    framework = frameworkAnswer.framework;
+                }
+                // Try to read Flutter package metadata if flutterPackageSrc is provided
+                let metadata = null;
+                if (options.flutterPackageSrc) {
+                    metadata = readFlutterPackageMetadata(options.flutterPackageSrc);
+                }
+                if (!packageName) {
+                    // Use Flutter package name as default if available, sanitized for npm
+                    const rawDefaultName = (metadata === null || metadata === void 0 ? void 0 : metadata.name) || path_1.default.basename(resolvedDistPath);
+                    const defaultPackageName = sanitizePackageName(rawDefaultName);
+                    const packageNameAnswer = yield inquirer_1.default.prompt([{
+                            type: 'input',
+                            name: 'packageName',
+                            message: 'What is your package name?',
+                            default: defaultPackageName,
+                            validate: (input) => {
+                                if (!input || input.trim() === '') {
+                                    return 'Package name is required';
+                                }
+                                // Check if it's valid as-is
+                                if (isValidNpmPackageName(input)) {
+                                    return true;
+                                }
+                                // If not valid, show what it would be sanitized to
+                                const sanitized = sanitizePackageName(input);
+                                return `Invalid npm package name. Would be sanitized to: "${sanitized}". Please enter a valid name.`;
                             }
-                            // If not valid, show what it would be sanitized to
-                            const sanitized = sanitizePackageName(input);
-                            return `Invalid npm package name. Would be sanitized to: "${sanitized}". Please enter a valid name.`;
-                        }
-                    }]);
-                packageName = packageNameAnswer.packageName;
+                        }]);
+                    packageName = packageNameAnswer.packageName;
+                }
+                console.log(`\nCreating new ${framework} project in ${resolvedDistPath}...`);
+                createCommand(resolvedDistPath, {
+                    framework: framework,
+                    packageName: packageName,
+                    metadata: metadata || undefined
+                });
             }
-            console.log(`\nCreating new ${framework} project in ${resolvedDistPath}...`);
-            createCommand(resolvedDistPath, {
-                framework: framework,
-                packageName: packageName,
-                metadata: metadata || undefined
-            });
-        }
-        else {
-            // Validate existing project structure
-            if (hasPackageJson) {
-                try {
-                    const packageJson = JSON.parse(fs_1.default.readFileSync(packageJsonPath, 'utf-8'));
-                    // Detect framework from existing package.json
-                    if (!framework) {
-                        if (((_a = packageJson.dependencies) === null || _a === void 0 ? void 0 : _a.react) || ((_b = packageJson.devDependencies) === null || _b === void 0 ? void 0 : _b.react)) {
-                            framework = 'react';
-                        }
-                        else if (((_c = packageJson.dependencies) === null || _c === void 0 ? void 0 : _c.vue) || ((_d = packageJson.devDependencies) === null || _d === void 0 ? void 0 : _d.vue)) {
-                            framework = 'vue';
-                        }
-                        else {
-                            // If can't detect, prompt for it
-                            const frameworkAnswer = yield inquirer_1.default.prompt([{
-                                    type: 'list',
-                                    name: 'framework',
-                                    message: 'Which framework are you using?',
-                                    choices: ['react', 'vue']
-                                }]);
-                            framework = frameworkAnswer.framework;
+            else {
+                // Validate existing project structure
+                if (hasPackageJson) {
+                    try {
+                        const packageJson = JSON.parse(fs_1.default.readFileSync(packageJsonPath, 'utf-8'));
+                        // Detect framework from existing package.json
+                        if (!framework) {
+                            if (((_a = packageJson.dependencies) === null || _a === void 0 ? void 0 : _a.react) || ((_b = packageJson.devDependencies) === null || _b === void 0 ? void 0 : _b.react)) {
+                                framework = 'react';
+                            }
+                            else if (((_c = packageJson.dependencies) === null || _c === void 0 ? void 0 : _c.vue) || ((_d = packageJson.devDependencies) === null || _d === void 0 ? void 0 : _d.vue)) {
+                                framework = 'vue';
+                            }
+                            else {
+                                // If can't detect, prompt for it
+                                const frameworkAnswer = yield inquirer_1.default.prompt([{
+                                        type: 'list',
+                                        name: 'framework',
+                                        message: 'Which framework are you using?',
+                                        choices: ['react', 'vue']
+                                    }]);
+                                framework = frameworkAnswer.framework;
+                            }
                         }
+                        console.log(`\nDetected existing ${framework} project in ${resolvedDistPath}`);
+                    }
+                    catch (e) {
+                        console.error('Error reading package.json:', e);
+                        process.exit(1);
                     }
-                    console.log(`\nDetected existing ${framework} project in ${resolvedDistPath}`);
-                }
-                catch (e) {
-                    console.error('Error reading package.json:', e);
-                    process.exit(1);
                 }
             }
         }
+        else {
+            // In Dart-only mode, framework/packageName are unused; ensure framework is not accidentally required later.
+            framework = options.framework;
+        }
         // Now proceed with code generation if flutter package source is provided
         if (!options.flutterPackageSrc) {
             console.log('\nProject is ready for code generation.');
             console.log('To generate code, run:');
             const displayPath = isTempDir ? '<output-dir>' : distPath;
-            console.log(`  webf codegen ${displayPath} --flutter-package-src=<path> --framework=${framework}`);
+            if (isDartOnly) {
+                console.log(`  webf codegen ${displayPath} --flutter-package-src=<path> --dart-only`);
+            }
+            else {
+                console.log(`  webf codegen ${displayPath} --flutter-package-src=<path> --framework=${framework}`);
+            }
             if (isTempDir) {
                 // Clean up temporary directory if we're not using it
                 fs_1.default.rmSync(resolvedDistPath, { recursive: true, force: true });
@@ -481,7 +603,23 @@ function generateCommand(distPath, options) {
                 process.exit(1);
             }
         }
-        const command = `webf codegen --flutter-package-src=${options.flutterPackageSrc} --framework=${framework} <distPath>`;
+        const baseCommand = 'webf codegen';
+        const flutterPart = options.flutterPackageSrc ? ` --flutter-package-src=${options.flutterPackageSrc}` : '';
+        const modePart = isDartOnly
+            ? ' --dart-only'
+            : (framework ? ` --framework=${framework}` : '');
+        const command = `${baseCommand}${flutterPart}${modePart} <distPath>`;
+        if (isDartOnly) {
+            console.log(`\nGenerating Dart bindings from ${options.flutterPackageSrc}...`);
+            yield (0, generator_1.dartGen)({
+                source: options.flutterPackageSrc,
+                target: options.flutterPackageSrc,
+                command,
+                exclude: options.exclude,
+            });
+            console.log('\nDart code generation completed successfully!');
+            return;
+        }
         // Auto-initialize typings in the output directory if needed
         ensureInitialized(resolvedDistPath);
         console.log(`\nGenerating ${framework} code from ${options.flutterPackageSrc}...`);
@@ -509,7 +647,9 @@ function generateCommand(distPath, options) {
                 target: resolvedDistPath,
                 command,
                 exclude: options.exclude,
-                packageName: reactPackageName,
+                // Prefer CLI-provided packageName (validated/sanitized above),
+                // fallback to detected name from package.json
+                packageName: packageName || reactPackageName,
             });
         }
         else if (framework === 'vue') {
@@ -525,6 +665,18 @@ function generateCommand(distPath, options) {
         if (framework) {
             try {
                 yield buildPackage(resolvedDistPath);
+                // After building React package, copy any matching .md docs next to built JS files
+                if (framework === 'react' && options.flutterPackageSrc) {
+                    const distOut = path_1.default.join(resolvedDistPath, 'dist');
+                    const { copied } = yield copyMarkdownDocsToDist({
+                        sourceRoot: options.flutterPackageSrc,
+                        distRoot: distOut,
+                        exclude: options.exclude,
+                    });
+                    if (copied > 0) {
+                        console.log(`📄 Copied ${copied} markdown docs to dist`);
+                    }
+                }
             }
             catch (error) {
                 console.error('\nWarning: Build failed:', error);

package/dist/constants.js

@@ -0,0 +1,242 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateUnionConstantsValuesTs = generateUnionConstantsValuesTs;
+exports.generateUnionConstantsDts = generateUnionConstantsDts;
+exports.generateDeclaredConstantsValuesTs = generateDeclaredConstantsValuesTs;
+exports.generateDeclaredConstantsDts = generateDeclaredConstantsDts;
+const lodash_1 = __importDefault(require("lodash"));
+const typescript_1 = __importDefault(require("typescript"));
+const dart_1 = require("./dart");
+// Generate constant name from component (Properties/Bindings trimmed) and prop name
+function getConstName(className, propName) {
+    const baseName = className.replace(/Properties$|Bindings$/, '');
+    return baseName + lodash_1.default.upperFirst(lodash_1.default.camelCase(propName));
+}
+function collectUnionStringProps(blobs) {
+    const results = [];
+    for (const blob of blobs) {
+        const classObjects = (blob.objects || []);
+        const properties = classObjects.filter(obj => obj.name && obj.name.endsWith('Properties'));
+        if (!properties.length)
+            continue;
+        const componentProps = properties[0];
+        const componentName = componentProps.name.replace(/Properties$/, '');
+        for (const prop of componentProps.props || []) {
+            if (!(0, dart_1.isStringUnionType)(prop.type))
+                continue;
+            const values = (0, dart_1.getUnionStringValues)(prop, blob);
+            if (!values || values.length === 0)
+                continue;
+            const constName = getConstName(componentProps.name, prop.name);
+            results.push({ constName, values, className: componentName, propName: prop.name });
+        }
+    }
+    return results;
+}
+function generateUnionConstantsValuesTs(blobs) {
+    const items = collectUnionStringProps(blobs);
+    if (!items.length)
+        return '';
+    const header = `// Auto-generated by WebF CLI\n// Constants for string-union properties extracted from .d.ts definitions\n`;
+    const blocks = items.map(item => {
+        const entries = item.values.map(v => `  '${v}': '${v}',`).join('\n');
+        return `// ${item.className}.${item.propName}\nexport const ${item.constName} = {\n${entries}\n} as const;`;
+    });
+    return [header, ...blocks].join('\n\n') + '\n';
+}
+function generateUnionConstantsDts(blobs) {
+    const items = collectUnionStringProps(blobs);
+    if (!items.length)
+        return '';
+    const header = `// Auto-generated by WebF CLI\n// Type declarations for constants representing string-union property values\n`;
+    const blocks = items.map(item => {
+        const entries = item.values.map(v => `  readonly '${v}': '${v}';`).join('\n');
+        return `// ${item.className}.${item.propName}\nexport declare const ${item.constName}: {\n${entries}\n};`;
+    });
+    return [header, ...blocks].join('\n\n') + '\n';
+}
+function parseLiteralFromType(node) {
+    if (typescript_1.default.isLiteralTypeNode(node)) {
+        const lit = node.literal;
+        if (typescript_1.default.isStringLiteral(lit))
+            return lit.text;
+        if (typescript_1.default.isNumericLiteral(lit))
+            return Number(lit.text);
+        if (lit.kind === typescript_1.default.SyntaxKind.TrueKeyword)
+            return true;
+        if (lit.kind === typescript_1.default.SyntaxKind.FalseKeyword)
+            return false;
+        return null;
+    }
+    if (typescript_1.default.isTypeQueryNode(node)) {
+        // typeof Identifier
+        if (typescript_1.default.isIdentifier(node.exprName)) {
+            return { typeofRef: node.exprName.text };
+        }
+    }
+    return null;
+}
+function collectDeclaredConstsFromSource(content, fileName = 'index.d.ts') {
+    const source = typescript_1.default.createSourceFile(fileName, content, typescript_1.default.ScriptTarget.ES2020, true, typescript_1.default.ScriptKind.TS);
+    const results = [];
+    const handleVariableStatement = (stmt) => {
+        // Only consider const declarations
+        if ((stmt.declarationList.flags & typescript_1.default.NodeFlags.Const) === 0)
+            return;
+        for (const decl of stmt.declarationList.declarations) {
+            if (!typescript_1.default.isIdentifier(decl.name) || !decl.type)
+                continue;
+            const name = decl.name.text;
+            const val = parseLiteralFromType(decl.type);
+            if (val == null)
+                continue;
+            results.push({ kind: 'const', name, value: val });
+        }
+    };
+    const handleClass = (cls) => {
+        var _a, _b, _c;
+        const container = (_a = cls.name) === null || _a === void 0 ? void 0 : _a.text;
+        if (!container)
+            return;
+        for (const m of cls.members) {
+            if (!typescript_1.default.isPropertyDeclaration(m))
+                continue;
+            const isStatic = (_b = m.modifiers) === null || _b === void 0 ? void 0 : _b.some(mod => mod.kind === typescript_1.default.SyntaxKind.StaticKeyword);
+            const isReadonly = (_c = m.modifiers) === null || _c === void 0 ? void 0 : _c.some(mod => mod.kind === typescript_1.default.SyntaxKind.ReadonlyKeyword);
+            if (!isStatic || !isReadonly || !m.type)
+                continue;
+            if (!typescript_1.default.isIdentifier(m.name))
+                continue;
+            const name = m.name.text;
+            const val = parseLiteralFromType(m.type);
+            if (val == null)
+                continue;
+            results.push({ kind: 'container', container, name, value: val });
+        }
+    };
+    const handleModule = (mod) => {
+        const container = mod.name.getText(source).replace(/['"]/g, '');
+        if (!mod.body || !typescript_1.default.isModuleBlock(mod.body))
+            return;
+        for (const stmt of mod.body.statements) {
+            if (typescript_1.default.isVariableStatement(stmt)) {
+                if ((stmt.declarationList.flags & typescript_1.default.NodeFlags.Const) === 0)
+                    continue;
+                for (const decl of stmt.declarationList.declarations) {
+                    if (!typescript_1.default.isIdentifier(decl.name) || !decl.type)
+                        continue;
+                    const name = decl.name.text;
+                    const val = parseLiteralFromType(decl.type);
+                    if (val == null)
+                        continue;
+                    results.push({ kind: 'container', container, name, value: val });
+                }
+            }
+        }
+    };
+    for (const stmt of source.statements) {
+        if (typescript_1.default.isVariableStatement(stmt))
+            handleVariableStatement(stmt);
+        else if (typescript_1.default.isClassDeclaration(stmt))
+            handleClass(stmt);
+        else if (typescript_1.default.isModuleDeclaration(stmt))
+            handleModule(stmt);
+    }
+    return results;
+}
+function collectDeclaredConsts(blobs) {
+    const all = [];
+    for (const blob of blobs) {
+        const raw = blob.raw || '';
+        if (!raw)
+            continue;
+        try {
+            const items = collectDeclaredConstsFromSource(raw, blob.filename + '.d.ts');
+            all.push(...items);
+        }
+        catch (_) {
+            // ignore parse errors per file
+        }
+    }
+    return all;
+}
+function literalToTsValue(val) {
+    if (typeof val === 'string')
+        return `'${val.replace(/'/g, "\\'")}'`;
+    if (typeof val === 'number')
+        return String(val);
+    if (typeof val === 'boolean')
+        return val ? 'true' : 'false';
+    if (typeof val.typeofRef === 'string')
+        return val.typeofRef;
+    return 'undefined';
+}
+function generateDeclaredConstantsValuesTs(blobs) {
+    const items = collectDeclaredConsts(blobs);
+    if (!items.length)
+        return '';
+    const header = `// Auto-generated by WebF CLI\n// Runtime constants mirrored from .d.ts 'declare const' definitions\n`;
+    const topLevel = [];
+    const containers = new Map();
+    for (const it of items) {
+        if (it.kind === 'const') {
+            topLevel.push(`export const ${it.name} = ${literalToTsValue(it.value)} as const;`);
+        }
+        else {
+            if (!containers.has(it.container))
+                containers.set(it.container, []);
+            containers.get(it.container).push(it);
+        }
+    }
+    const containerBlocks = [];
+    for (const [container, arr] of containers) {
+        const lines = arr
+            .sort((a, b) => a.name.localeCompare(b.name))
+            .map(a => `  ${a.name}: ${literalToTsValue(a.value)},`) // keep plain object
+            .join('\n');
+        containerBlocks.push(`export const ${container} = {\n${lines}\n} as const;`);
+    }
+    return [header, ...topLevel, ...containerBlocks].filter(Boolean).join('\n\n') + '\n';
+}
+function generateDeclaredConstantsDts(blobs) {
+    const items = collectDeclaredConsts(blobs);
+    if (!items.length)
+        return '';
+    const header = `// Auto-generated by WebF CLI\n// Type declarations for 'declare const' values mirrored into JS runtime\n`;
+    const topLevel = [];
+    const containers = new Map();
+    for (const it of items) {
+        if (it.kind === 'const') {
+            const val = typeof it.value === 'object' && it.value.typeofRef
+                ? `typeof ${it.value.typeofRef}`
+                : typeof it.value === 'string'
+                    ? `'${it.value.replace(/'/g, "\\'")}'`
+                    : String(it.value);
+            topLevel.push(`export declare const ${it.name}: ${val};`);
+        }
+        else {
+            if (!containers.has(it.container))
+                containers.set(it.container, []);
+            containers.get(it.container).push(it);
+        }
+    }
+    const containerBlocks = [];
+    for (const [container, arr] of containers) {
+        const lines = arr
+            .sort((a, b) => a.name.localeCompare(b.name))
+            .map(a => {
+            const v = typeof a.value === 'object' && a.value.typeofRef
+                ? `typeof ${a.value.typeofRef}`
+                : typeof a.value === 'string'
+                    ? `'${a.value.replace(/'/g, "\\'")}'`
+                    : String(a.value);
+            return `  readonly ${a.name}: ${v};`;
+        })
+            .join('\n');
+        containerBlocks.push(`export declare const ${container}: {\n${lines}\n};`);
+    }
+    return [header, ...topLevel, ...containerBlocks].filter(Boolean).join('\n\n') + '\n';
+}