@openwebf/webf 0.23.10 → 0.24.0

package/dist/commands.js

@@ -20,6 +20,7 @@ const path_1 = __importDefault(require("path"));
 const os_1 = __importDefault(require("os"));
 const generator_1 = require("./generator");
 const module_1 = require("./module");
+const peerDeps_1 = require("./peerDeps");
 const glob_1 = require("glob");
 const lodash_1 = __importDefault(require("lodash"));
 const inquirer_1 = __importDefault(require("inquirer"));
@@ -177,6 +178,33 @@ function readFlutterPackageMetadata(packagePath) {
         return null;
     }
 }
+function copyReadmeToPackageRoot(params) {
+    const { sourceRoot, targetRoot } = params;
+    const targetPath = path_1.default.join(targetRoot, 'README.md');
+    if (fs_1.default.existsSync(targetPath)) {
+        return { copied: false, targetPath };
+    }
+    const candidateNames = ['README.md', 'Readme.md', 'readme.md'];
+    let sourcePath = null;
+    for (const candidate of candidateNames) {
+        const abs = path_1.default.join(sourceRoot, candidate);
+        if (fs_1.default.existsSync(abs)) {
+            sourcePath = abs;
+            break;
+        }
+    }
+    if (!sourcePath) {
+        return { copied: false, targetPath };
+    }
+    try {
+        const content = fs_1.default.readFileSync(sourcePath, 'utf-8');
+        writeFileIfChanged(targetPath, content);
+        return { copied: true, sourcePath, targetPath };
+    }
+    catch (_a) {
+        return { copied: false, targetPath };
+    }
+}
 // 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) {
@@ -350,7 +378,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'], {
+        // Ensure devDependencies are installed even if the user's shell has NODE_ENV=production.
+        (0, child_process_1.spawnSync)(NPM, ['install', '--production=false'], {
             cwd: target,
             stdio: 'inherit'
         });
@@ -369,11 +398,8 @@ function createCommand(target, options) {
         const gitignorePath = path_1.default.join(target, '.gitignore');
         const gitignoreContent = lodash_1.default.template(gitignore)({});
         writeFileIfChanged(gitignorePath, gitignoreContent);
-        (0, child_process_1.spawnSync)(NPM, ['install', '@openwebf/webf-enterprise-typings'], {
-            cwd: target,
-            stdio: 'inherit'
-        });
-        (0, child_process_1.spawnSync)(NPM, ['install', 'vue', '-D'], {
+        // Ensure devDependencies are installed even if the user's shell has NODE_ENV=production.
+        (0, child_process_1.spawnSync)(NPM, ['install', '--production=false'], {
             cwd: target,
             stdio: 'inherit'
         });
@@ -658,6 +684,16 @@ function generateCommand(distPath, options) {
         }
         // Auto-initialize typings in the output directory if needed
         ensureInitialized(resolvedDistPath);
+        // Copy README.md from the source Flutter package into the npm package root (so `npm publish` includes it).
+        if (options.flutterPackageSrc) {
+            const { copied } = copyReadmeToPackageRoot({
+                sourceRoot: options.flutterPackageSrc,
+                targetRoot: resolvedDistPath,
+            });
+            if (copied) {
+                console.log('📄 Copied README.md to package root');
+            }
+        }
         console.log(`\nGenerating ${framework} code from ${options.flutterPackageSrc}...`);
         yield (0, generator_1.dartGen)({
             source: options.flutterPackageSrc,
@@ -1003,7 +1039,7 @@ function ensureInitialized(targetPath) {
 }
 function buildPackage(packagePath) {
     return __awaiter(this, void 0, void 0, function* () {
-        var _a;
+        var _a, _b, _c;
         const packageJsonPath = path_1.default.join(packagePath, 'package.json');
         if (!fs_1.default.existsSync(packageJsonPath)) {
             // Skip the error in test environment to avoid console warnings
@@ -1015,6 +1051,91 @@ function buildPackage(packagePath) {
         const packageJson = JSON.parse(fs_1.default.readFileSync(packageJsonPath, 'utf-8'));
         const packageName = packageJson.name;
         const packageVersion = packageJson.version;
+        function getInstalledPackageJsonPath(pkgName) {
+            const parts = pkgName.split('/');
+            return path_1.default.join(packagePath, 'node_modules', ...parts, 'package.json');
+        }
+        function getInstalledPackageDir(pkgName) {
+            const parts = pkgName.split('/');
+            return path_1.default.join(packagePath, 'node_modules', ...parts);
+        }
+        function findUp(startDir, relativePathToFind) {
+            let dir = path_1.default.resolve(startDir);
+            while (true) {
+                const candidate = path_1.default.join(dir, relativePathToFind);
+                if (fs_1.default.existsSync(candidate))
+                    return candidate;
+                const parent = path_1.default.dirname(dir);
+                if (parent === dir)
+                    return null;
+                dir = parent;
+            }
+        }
+        function ensurePeerDependencyAvailableForBuild(peerName) {
+            var _a, _b;
+            const installedPkgJson = getInstalledPackageJsonPath(peerName);
+            if (fs_1.default.existsSync(installedPkgJson))
+                return;
+            const peerRange = (_a = packageJson.peerDependencies) === null || _a === void 0 ? void 0 : _a[peerName];
+            const localMap = {
+                '@openwebf/react-core-ui': path_1.default.join('packages', 'react-core-ui'),
+                '@openwebf/vue-core-ui': path_1.default.join('packages', 'vue-core-ui'),
+            };
+            let installSpec = null;
+            const localRel = localMap[peerName];
+            if (localRel) {
+                const localPath = findUp(process.cwd(), localRel);
+                if (localPath) {
+                    if (!(0, peerDeps_1.isPackageTypesReady)(localPath)) {
+                        const localPkgJsonPath = path_1.default.join(localPath, 'package.json');
+                        if (fs_1.default.existsSync(localPkgJsonPath)) {
+                            const localPkgJson = (0, peerDeps_1.readJsonFile)(localPkgJsonPath);
+                            if ((_b = localPkgJson.scripts) === null || _b === void 0 ? void 0 : _b.build) {
+                                if (process.env.WEBF_CODEGEN_BUILD_LOCAL_PEERS !== '1') {
+                                    console.warn(`\n⚠️  Local ${peerName} found at ${localPath} but type declarations are missing; falling back to registry install.`);
+                                }
+                                else {
+                                    console.log(`\n🔧 Local ${peerName} found at ${localPath} but build artifacts are missing; building it for DTS...`);
+                                    const buildLocalResult = (0, child_process_1.spawnSync)(NPM, ['run', 'build'], {
+                                        cwd: localPath,
+                                        stdio: 'inherit'
+                                    });
+                                    if (buildLocalResult.status === 0) {
+                                        if ((0, peerDeps_1.isPackageTypesReady)(localPath)) {
+                                            installSpec = localPath;
+                                        }
+                                        else {
+                                            console.warn(`\n⚠️  Built local ${peerName} but type declarations are still missing; falling back to registry install.`);
+                                        }
+                                    }
+                                    else {
+                                        console.warn(`\n⚠️  Failed to build local ${peerName}; falling back to registry install.`);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    else {
+                        installSpec = localPath;
+                    }
+                }
+            }
+            if (!installSpec) {
+                installSpec = peerRange ? `${peerName}@${peerRange}` : peerName;
+            }
+            console.log(`\n📦 Installing peer dependency for build: ${peerName}...`);
+            const installResult = (0, child_process_1.spawnSync)(NPM, ['install', '--no-save', installSpec], {
+                cwd: packagePath,
+                stdio: 'inherit'
+            });
+            if (installResult.status !== 0) {
+                throw new Error(`Failed to install peer dependency for build: ${peerName}`);
+            }
+            const installedTypesFile = (0, peerDeps_1.getPackageTypesFileFromDir)(getInstalledPackageDir(peerName));
+            if (installedTypesFile && !fs_1.default.existsSync(installedTypesFile)) {
+                throw new Error(`Peer dependency ${peerName} was installed but type declarations were not found at ${installedTypesFile}`);
+            }
+        }
         // Check if node_modules exists
         const nodeModulesPath = path_1.default.join(packagePath, 'node_modules');
         if (!fs_1.default.existsSync(nodeModulesPath)) {
@@ -1035,6 +1156,13 @@ function buildPackage(packagePath) {
         }
         // Check if package has a build script
         if ((_a = packageJson.scripts) === null || _a === void 0 ? void 0 : _a.build) {
+            // DTS build needs peer deps present locally to resolve types (even though they are not bundled).
+            if ((_b = packageJson.peerDependencies) === null || _b === void 0 ? void 0 : _b['@openwebf/react-core-ui']) {
+                ensurePeerDependencyAvailableForBuild('@openwebf/react-core-ui');
+            }
+            if ((_c = packageJson.peerDependencies) === null || _c === void 0 ? void 0 : _c['@openwebf/vue-core-ui']) {
+                ensurePeerDependencyAvailableForBuild('@openwebf/vue-core-ui');
+            }
             console.log(`\nBuilding ${packageName}@${packageVersion}...`);
             const buildResult = (0, child_process_1.spawnSync)(NPM, ['run', 'build'], {
                 cwd: packagePath,

package/dist/generator.js

@@ -378,11 +378,8 @@ function reactGen(_a) {
                 (0, logger_1.warn)(`Failed to merge into existing index.ts. Skipping modifications: ${indexFilePath}`);
             }
         }
-        (0, logger_1.timeEnd)('reactGen');
-        (0, logger_1.success)(`React code generation completed. ${filesChanged} files changed.`);
-        (0, logger_1.info)(`Output directory: ${normalizedTarget}`);
-        (0, logger_1.info)('You can now import these components in your React project.');
-        // Aggregate standalone type declarations (consts/enums/type aliases) into a single types.ts
+        // Always generate src/types.ts so generated components can safely import it.
+        // When there are no standalone declarations, emit an empty module (`export {};`).
         try {
             const consts = blobs.flatMap(b => b.objects.filter(o => o instanceof declaration_1.ConstObject));
             const enums = blobs.flatMap(b => b.objects.filter(o => o instanceof declaration_1.EnumObject));
@@ -395,38 +392,38 @@ function reactGen(_a) {
             typeAliases.forEach(t => { if (!typeAliasMap.has(t.name))
                 typeAliasMap.set(t.name, t); });
             const hasAny = constMap.size > 0 || enums.length > 0 || typeAliasMap.size > 0;
-            if (hasAny) {
-                const constDecl = Array.from(constMap.values())
-                    .map(c => `export declare const ${c.name}: ${c.type};`)
-                    .join('\n');
-                const enumDecl = enums
-                    .map(e => `export enum ${e.name} { ${e.members.map(m => m.initializer ? `${m.name} = ${m.initializer}` : `${m.name}`).join(', ')} }`)
-                    .join('\n');
-                const typeAliasDecl = Array.from(typeAliasMap.values())
-                    .map(t => `export type ${t.name} = ${t.type};`)
-                    .join('\n');
-                const typesContent = [
-                    '/* Generated by WebF CLI - aggregated type declarations */',
-                    typeAliasDecl,
-                    constDecl,
-                    enumDecl,
-                    ''
-                ].filter(Boolean).join('\n');
-                const typesPath = path_1.default.join(normalizedTarget, 'src', 'types.ts');
-                if (writeFileIfChanged(typesPath, typesContent)) {
-                    filesChanged++;
-                    (0, logger_1.debug)(`Generated: src/types.ts`);
-                    try {
-                        const constNames = Array.from(constMap.keys());
-                        const aliasNames = Array.from(typeAliasMap.keys());
-                        const enumNames = enums.map(e => e.name);
-                        (0, logger_1.debug)(`[react] Aggregated types - consts: ${constNames.join(', ') || '(none)'}; typeAliases: ${aliasNames.join(', ') || '(none)'}; enums: ${enumNames.join(', ') || '(none)'}\n`);
-                        (0, logger_1.debug)(`[react] src/types.ts preview:\n` + typesContent.split('\n').slice(0, 20).join('\n'));
-                    }
-                    catch (_b) { }
+            const constDecl = Array.from(constMap.values())
+                .map(c => `export declare const ${c.name}: ${c.type};`)
+                .join('\n');
+            const enumDecl = enums
+                .map(e => `export enum ${e.name} { ${e.members.map(m => m.initializer ? `${m.name} = ${m.initializer}` : `${m.name}`).join(', ')} }`)
+                .join('\n');
+            const typeAliasDecl = Array.from(typeAliasMap.values())
+                .map(t => `export type ${t.name} = ${t.type};`)
+                .join('\n');
+            const typesContent = [
+                '/* Generated by WebF CLI - aggregated type declarations */',
+                hasAny ? typeAliasDecl : '',
+                hasAny ? constDecl : '',
+                hasAny ? enumDecl : '',
+                hasAny ? '' : 'export {};',
+                ''
+            ].filter(Boolean).join('\n');
+            const typesPath = path_1.default.join(normalizedTarget, 'src', 'types.ts');
+            if (writeFileIfChanged(typesPath, typesContent)) {
+                filesChanged++;
+                (0, logger_1.debug)(`Generated: src/types.ts`);
+                try {
+                    const constNames = Array.from(constMap.keys());
+                    const aliasNames = Array.from(typeAliasMap.keys());
+                    const enumNames = enums.map(e => e.name);
+                    (0, logger_1.debug)(`[react] Aggregated types - consts: ${constNames.join(', ') || '(none)'}; typeAliases: ${aliasNames.join(', ') || '(none)'}; enums: ${enumNames.join(', ') || '(none)'}\n`);
+                    (0, logger_1.debug)(`[react] src/types.ts preview:\n` + typesContent.split('\n').slice(0, 20).join('\n'));
                 }
-                // Ensure index.ts re-exports these types so consumers get them on import.
-                const indexFilePath = path_1.default.join(normalizedTarget, 'src', 'index.ts');
+                catch (_b) { }
+            }
+            // Only re-export from index.ts when there are actual declarations to surface.
+            if (hasAny) {
                 try {
                     let current = '';
                     if (fs_1.default.existsSync(indexFilePath)) {
@@ -447,6 +444,10 @@ function reactGen(_a) {
         catch (e) {
             (0, logger_1.warn)('Failed to generate aggregated React types');
         }
+        (0, logger_1.timeEnd)('reactGen');
+        (0, logger_1.success)(`React code generation completed. ${filesChanged} files changed.`);
+        (0, logger_1.info)(`Output directory: ${normalizedTarget}`);
+        (0, logger_1.info)('You can now import these components in your React project.');
     });
 }
 function vueGen(_a) {

package/dist/module.js

@@ -247,14 +247,14 @@ function mapTsParamTypeToDart(typeText, optionNames) {
     }
     return { dartType: 'dynamic', isByteData: false };
 }
-function mapTsPropertyTypeToDart(type) {
+function mapTsPropertyTypeToDart(type, optional) {
     switch (type.kind) {
         case typescript_1.default.SyntaxKind.StringKeyword:
-            return 'String?';
+            return optional ? 'String?' : 'String';
         case typescript_1.default.SyntaxKind.NumberKeyword:
-            return 'num?';
+            return optional ? 'num?' : 'num';
         case typescript_1.default.SyntaxKind.BooleanKeyword:
-            return 'bool?';
+            return optional ? 'bool?' : 'bool';
         default:
             return 'dynamic';
     }
@@ -288,28 +288,52 @@ function buildDartBindings(def, command) {
                 continue;
             const key = member.name.getText(def.sourceFile).replace(/['"]/g, '');
             const fieldName = key;
-            const dartType = member.type ? mapTsPropertyTypeToDart(member.type) : 'dynamic';
-            propInfos.push({ fieldName, key, dartType });
+            const optional = !!member.questionToken;
+            const dartType = member.type ? mapTsPropertyTypeToDart(member.type, optional) : 'dynamic';
+            propInfos.push({ fieldName, key, dartType, optional });
         }
         lines.push(`class ${name} {`);
         for (const prop of propInfos) {
             lines.push(`  final ${prop.dartType} ${prop.fieldName};`);
         }
         lines.push('');
-        const ctorParams = propInfos.map(p => `this.${p.fieldName}`).join(', ');
+        const ctorParams = propInfos.map(p => {
+            if (p.optional || p.dartType === 'dynamic') {
+                return `this.${p.fieldName}`;
+            }
+            return `required this.${p.fieldName}`;
+        }).join(', ');
         lines.push(`  const ${name}({${ctorParams}});`);
         lines.push('');
         lines.push(`  factory ${name}.fromMap(Map<String, dynamic> map) {`);
         lines.push(`    return ${name}(`);
         for (const prop of propInfos) {
-            if (prop.dartType.startsWith('String')) {
-                lines.push(`      ${prop.fieldName}: map['${prop.key}']?.toString(),`);
+            const isString = prop.dartType.startsWith('String');
+            const isBool = prop.dartType.startsWith('bool');
+            const isNum = prop.dartType.startsWith('num');
+            if (isString) {
+                if (prop.optional) {
+                    lines.push(`      ${prop.fieldName}: map['${prop.key}']?.toString(),`);
+                }
+                else {
+                    lines.push(`      ${prop.fieldName}: map['${prop.key}']?.toString() ?? '',`);
+                }
             }
-            else if (prop.dartType.startsWith('bool')) {
-                lines.push(`      ${prop.fieldName}: map['${prop.key}'] is bool ? map['${prop.key}'] as bool : null,`);
+            else if (isBool) {
+                if (prop.optional) {
+                    lines.push(`      ${prop.fieldName}: map['${prop.key}'] is bool ? map['${prop.key}'] as bool : null,`);
+                }
+                else {
+                    lines.push(`      ${prop.fieldName}: map['${prop.key}'] is bool ? map['${prop.key}'] as bool : false,`);
+                }
             }
-            else if (prop.dartType.startsWith('num')) {
-                lines.push(`      ${prop.fieldName}: map['${prop.key}'] is num ? map['${prop.key}'] as num : null,`);
+            else if (isNum) {
+                if (prop.optional) {
+                    lines.push(`      ${prop.fieldName}: map['${prop.key}'] is num ? map['${prop.key}'] as num : null,`);
+                }
+                else {
+                    lines.push(`      ${prop.fieldName}: map['${prop.key}'] is num ? map['${prop.key}'] as num : 0,`);
+                }
             }
             else {
                 lines.push(`      ${prop.fieldName}: map['${prop.key}'],`);
@@ -321,7 +345,12 @@ function buildDartBindings(def, command) {
         lines.push('  Map<String, dynamic> toMap() {');
         lines.push('    final map = <String, dynamic>{};');
         for (const prop of propInfos) {
-            lines.push(`    if (${prop.fieldName} != null) { map['${prop.key}'] = ${prop.fieldName}; }`);
+            if (!prop.optional && (prop.dartType === 'String' || prop.dartType === 'bool' || prop.dartType === 'num')) {
+                lines.push(`    map['${prop.key}'] = ${prop.fieldName};`);
+            }
+            else {
+                lines.push(`    if (${prop.fieldName} != null) { map['${prop.key}'] = ${prop.fieldName}; }`);
+            }
         }
         lines.push('    return map;');
         lines.push('  }');

package/dist/peerDeps.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readJsonFile = readJsonFile;
+exports.getPackageTypesFileFromDir = getPackageTypesFileFromDir;
+exports.isPackageTypesReady = isPackageTypesReady;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function readJsonFile(jsonPath) {
+    return JSON.parse(fs_1.default.readFileSync(jsonPath, 'utf-8'));
+}
+function getPackageTypesFileFromDir(pkgDir) {
+    const pkgJsonPath = path_1.default.join(pkgDir, 'package.json');
+    if (!fs_1.default.existsSync(pkgJsonPath))
+        return null;
+    const pkgJson = readJsonFile(pkgJsonPath);
+    const typesRel = pkgJson.types;
+    if (!typesRel)
+        return null;
+    return path_1.default.join(pkgDir, typesRel);
+}
+function isPackageTypesReady(pkgDir) {
+    const typesFile = getPackageTypesFileFromDir(pkgDir);
+    return typesFile ? fs_1.default.existsSync(typesFile) : true;
+}

package/dist/react.js

@@ -55,14 +55,13 @@ function generateReturnType(type) {
         return pointerType;
     }
     if (type.isArray && typeof type.value === 'object' && !Array.isArray(type.value)) {
-        const elemType = (0, utils_1.getPointerType)(type.value);
-        // Map arrays of Dart `Type` to `any[]` in TS; parenthesize typeof
-        if (elemType === 'Type')
+        const elemType = generateReturnType(type.value);
+        if (!elemType)
             return 'any[]';
-        if (typeof elemType === 'string' && elemType.startsWith('typeof ')) {
-            return `(${elemType})[]`;
+        if (/^[A-Za-z_][A-Za-z0-9_]*(?:\\.[A-Za-z_][A-Za-z0-9_]*)*$/.test(elemType)) {
+            return `${elemType}[]`;
         }
-        return `${elemType}[]`;
+        return `(${elemType})[]`;
     }
     switch (type.value) {
         case declaration_1.FunctionArgumentType.int:
@@ -348,20 +347,13 @@ function generateReactComponent(blob, packageName, relativeDir) {
                 return pointerType;
             }
             if (type.isArray && typeof type.value === 'object' && !Array.isArray(type.value)) {
-                const elemType = (0, utils_1.getPointerType)(type.value);
-                if (elemType === 'Type')
+                const elemType = genRT(type.value);
+                if (!elemType)
                     return 'any[]';
-                if (typeof elemType === 'string' && elemType.startsWith('typeof ')) {
-                    const ident = elemType.substring('typeof '.length).trim();
-                    return `(typeof __webfTypes.${ident})[]`;
-                }
-                if (typeof elemType === 'string' && /^(?:[A-Za-z_][A-Za-z0-9_]*)(?:\.[A-Za-z_][A-Za-z0-9_]*)*$/.test(elemType)) {
-                    const base = elemType.split('.')[0];
-                    if (!localTypeNames.has(base)) {
-                        return `__webfTypes.${elemType}[]`;
-                    }
+                if (/^[A-Za-z_][A-Za-z0-9_]*(?:\\.[A-Za-z_][A-Za-z0-9_]*)*$/.test(elemType)) {
+                    return `${elemType}[]`;
                 }
-                return `${elemType}[]`;
+                return `(${elemType})[]`;
             }
             switch (type.value) {
                 case declaration_1.FunctionArgumentType.int: