@openwebf/webf 0.23.7 → 0.23.10

package/dist/module.js

@@ -0,0 +1,458 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateModuleArtifacts = generateModuleArtifacts;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const typescript_1 = __importDefault(require("typescript"));
+const lodash_1 = __importDefault(require("lodash"));
+const generator_1 = require("./generator");
+function parseModuleDefinition(modulePath) {
+    const sourceText = fs_1.default.readFileSync(modulePath, 'utf-8');
+    const sourceFile = typescript_1.default.createSourceFile(modulePath, sourceText, typescript_1.default.ScriptTarget.ES2020, true, typescript_1.default.ScriptKind.TS);
+    let interfaceDecl;
+    const supporting = [];
+    for (const stmt of sourceFile.statements) {
+        if (typescript_1.default.isInterfaceDeclaration(stmt)) {
+            const name = stmt.name.text;
+            if (!interfaceDecl && name.startsWith('WebF')) {
+                interfaceDecl = stmt;
+            }
+            supporting.push(stmt);
+        }
+        else if (typescript_1.default.isTypeAliasDeclaration(stmt) ||
+            typescript_1.default.isEnumDeclaration(stmt) ||
+            typescript_1.default.isVariableStatement(stmt)) {
+            supporting.push(stmt);
+        }
+    }
+    if (!interfaceDecl) {
+        throw new Error(`No interface starting with "WebF" found in module interface file: ${modulePath}`);
+    }
+    const interfaceName = interfaceDecl.name.text;
+    const moduleName = interfaceName.startsWith('WebF')
+        ? interfaceName.substring('WebF'.length)
+        : interfaceName;
+    const printer = typescript_1.default.createPrinter();
+    const methods = [];
+    for (const member of interfaceDecl.members) {
+        if (!typescript_1.default.isMethodSignature(member))
+            continue;
+        const nameNode = member.name;
+        const methodName = nameNode.getText(sourceFile);
+        if (!methodName || methodName === 'constructor')
+            continue;
+        const params = member.parameters.map(param => ({
+            name: param.name.getText(sourceFile),
+            text: printer.printNode(typescript_1.default.EmitHint.Unspecified, param, sourceFile),
+            typeText: param.type
+                ? printer.printNode(typescript_1.default.EmitHint.Unspecified, param.type, sourceFile)
+                : 'any',
+        }));
+        const returnTypeText = member.type
+            ? printer.printNode(typescript_1.default.EmitHint.Unspecified, member.type, sourceFile)
+            : 'Promise<any>';
+        let documentation;
+        const jsDocs = member.jsDoc;
+        if (jsDocs && jsDocs.length > 0) {
+            documentation = jsDocs
+                .map(doc => doc.comment)
+                .filter(Boolean)
+                .join('\n');
+        }
+        methods.push({
+            name: methodName,
+            jsName: methodName,
+            params,
+            returnTypeText,
+            documentation,
+        });
+    }
+    if (methods.length === 0) {
+        throw new Error(`Interface ${interfaceName} in ${modulePath} does not declare any methods`);
+    }
+    return { interfaceName, moduleName, methods, supportingStatements: supporting, sourceFile };
+}
+function buildTypesFile(def) {
+    const printer = typescript_1.default.createPrinter();
+    const lines = [];
+    lines.push('// AUTO GENERATED FILE, DO NOT EDIT.');
+    lines.push('//');
+    lines.push('// Generated by `webf module-codegen`');
+    lines.push('');
+    for (const stmt of def.supportingStatements) {
+        // Skip the main module interface (e.g. WebFShare); we only want supporting types.
+        if (typescript_1.default.isInterfaceDeclaration(stmt) && stmt.name.text === def.interfaceName) {
+            continue;
+        }
+        let printed = printer.printNode(typescript_1.default.EmitHint.Unspecified, stmt, def.sourceFile);
+        // Ensure declarations are exported so types.ts is a proper module.
+        if (typescript_1.default.isInterfaceDeclaration(stmt) ||
+            typescript_1.default.isTypeAliasDeclaration(stmt) ||
+            typescript_1.default.isEnumDeclaration(stmt)) {
+            const trimmed = printed.trimStart();
+            if (!trimmed.startsWith('export ')) {
+                const leadingLength = printed.length - trimmed.length;
+                const leading = printed.slice(0, leadingLength);
+                printed = `${leading}export ${trimmed}`;
+            }
+        }
+        lines.push(printed);
+    }
+    lines.push('');
+    // Ensure file is treated as a module even if no declarations were emitted.
+    lines.push('export {};');
+    return lines.join('\n');
+}
+function buildIndexFile(def) {
+    const lines = [];
+    lines.push('/**');
+    lines.push(` * Auto-generated WebF module wrapper for "${def.moduleName}".`);
+    lines.push(' *');
+    lines.push(' * This file is generated from a TypeScript interface that describes');
+    lines.push(' * the module API. It forwards calls to `webf.invokeModuleAsync` at runtime.');
+    lines.push(' */');
+    lines.push('');
+    lines.push(`import { webf } from '@openwebf/webf-enterprise-typings';`);
+    // Import option/result types purely as types so this stays tree-shake friendly.
+    const typeImportNames = new Set();
+    for (const stmt of def.supportingStatements) {
+        if (typescript_1.default.isInterfaceDeclaration(stmt) ||
+            typescript_1.default.isTypeAliasDeclaration(stmt) ||
+            typescript_1.default.isEnumDeclaration(stmt)) {
+            const name = stmt.name.text;
+            if (name === def.interfaceName)
+                continue;
+            typeImportNames.add(name);
+        }
+    }
+    const typeImportsSorted = Array.from(typeImportNames).sort();
+    if (typeImportsSorted.length > 0) {
+        lines.push(`import type { ${typeImportsSorted.join(', ')} } from './types';`);
+    }
+    lines.push('');
+    lines.push(`export class ${def.interfaceName} {`);
+    lines.push('  static isAvailable(): boolean {');
+    lines.push("    return typeof webf !== 'undefined' && typeof (webf as any).invokeModuleAsync === 'function';");
+    lines.push('  }');
+    lines.push('');
+    for (const method of def.methods) {
+        if (method.documentation) {
+            lines.push('  /**');
+            for (const line of method.documentation.split('\n')) {
+                lines.push('   * ' + line);
+            }
+            lines.push('   */');
+        }
+        const paramsText = method.params.map(p => p.text).join(', ');
+        const argNames = method.params.map(p => p.name).join(', ');
+        lines.push(`  static async ${method.name}(${paramsText}): ${method.returnTypeText} {`);
+        lines.push('    if (!this.isAvailable()) {');
+        lines.push(`      throw new Error('WebF module "${def.moduleName}" is not available. Make sure it is registered via WebF.defineModule().');`);
+        lines.push('    }');
+        const argsPart = argNames ? `, ${argNames}` : '';
+        lines.push(`    return webf.invokeModuleAsync('${def.moduleName}', '${method.jsName}'${argsPart});`);
+        lines.push('  }');
+        lines.push('');
+    }
+    lines.push('}');
+    lines.push('');
+    lines.push(`export type {`);
+    const typeExportNames = new Set();
+    for (const stmt of def.supportingStatements) {
+        if (typescript_1.default.isInterfaceDeclaration(stmt) ||
+            typescript_1.default.isTypeAliasDeclaration(stmt) ||
+            typescript_1.default.isEnumDeclaration(stmt)) {
+            const name = stmt.name.text;
+            // Do not re-export the main module interface (e.g. WebFShare) to avoid clashes
+            // with the generated class of the same name.
+            if (name === def.interfaceName)
+                continue;
+            typeExportNames.add(stmt.name.text);
+        }
+    }
+    const sorted = Array.from(typeExportNames).sort();
+    if (sorted.length) {
+        lines.push('  ' + sorted.join(','));
+    }
+    lines.push(`} from './types';`);
+    lines.push('');
+    return lines.join('\n');
+}
+function mapTsReturnTypeToDart(typeText) {
+    const raw = typeText.trim();
+    // Expect Promise<...> for async module methods
+    const promiseMatch = raw.match(/^Promise<(.+)>$/);
+    if (!promiseMatch) {
+        return 'Future<dynamic>';
+    }
+    const inner = promiseMatch[1].trim();
+    const innerLower = inner.toLowerCase();
+    if (innerLower === 'boolean' || innerLower === 'bool') {
+        return 'Future<bool>';
+    }
+    return 'Future<dynamic>';
+}
+function isTsByteArrayUnion(typeText) {
+    if (!typeText)
+        return false;
+    // Remove parentheses and whitespace
+    const cleaned = typeText.replace(/[()]/g, '').trim();
+    if (!cleaned)
+        return false;
+    const parts = cleaned.split('|').map(p => p.trim()).filter(Boolean);
+    if (parts.length === 0)
+        return false;
+    const byteTypes = new Set(['ArrayBuffer', 'Uint8Array']);
+    const nullable = new Set(['null', 'undefined']);
+    let hasByte = false;
+    for (const part of parts) {
+        if (byteTypes.has(part)) {
+            hasByte = true;
+            continue;
+        }
+        if (nullable.has(part))
+            continue;
+        return false;
+    }
+    return hasByte;
+}
+function getBaseTypeName(typeText) {
+    if (!typeText)
+        return null;
+    const cleaned = typeText.replace(/[()]/g, '').trim();
+    if (!cleaned)
+        return null;
+    const parts = cleaned.split('|').map(p => p.trim()).filter(Boolean);
+    const nullable = new Set(['null', 'undefined', 'void', 'never']);
+    const nonNullable = parts.filter(p => !nullable.has(p));
+    if (nonNullable.length !== 1)
+        return null;
+    const candidate = nonNullable[0];
+    if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(candidate)) {
+        return candidate;
+    }
+    return null;
+}
+function mapTsParamTypeToDart(typeText, optionNames) {
+    const raw = typeText.trim();
+    if (isTsByteArrayUnion(raw)) {
+        return { dartType: 'NativeByteData', isByteData: true };
+    }
+    const base = getBaseTypeName(raw);
+    if (base && optionNames.has(base)) {
+        return { dartType: `${base}?`, isByteData: false, optionClassName: base };
+    }
+    return { dartType: 'dynamic', isByteData: false };
+}
+function mapTsPropertyTypeToDart(type) {
+    switch (type.kind) {
+        case typescript_1.default.SyntaxKind.StringKeyword:
+            return 'String?';
+        case typescript_1.default.SyntaxKind.NumberKeyword:
+            return 'num?';
+        case typescript_1.default.SyntaxKind.BooleanKeyword:
+            return 'bool?';
+        default:
+            return 'dynamic';
+    }
+}
+function buildDartBindings(def, command) {
+    const dartClassBase = `${def.moduleName}Module`;
+    const dartBindingsClass = `${dartClassBase}Bindings`;
+    const lines = [];
+    lines.push('// AUTO GENERATED FILE, DO NOT EDIT.');
+    lines.push('//');
+    lines.push('// Generated by `webf module-codegen`');
+    lines.push('');
+    lines.push("import 'package:webf/module.dart';");
+    if (def.methods.some(m => m.params.some(p => isTsByteArrayUnion(p.typeText)))) {
+        lines.push("import 'package:webf/bridge.dart';");
+    }
+    lines.push('');
+    // Generate Dart classes for supporting TS interfaces (compound option types).
+    const optionInterfaces = [];
+    for (const stmt of def.supportingStatements) {
+        if (typescript_1.default.isInterfaceDeclaration(stmt) && stmt.name.text !== def.interfaceName) {
+            optionInterfaces.push(stmt);
+        }
+    }
+    const optionTypeNames = new Set(optionInterfaces.map(i => i.name.text));
+    for (const iface of optionInterfaces) {
+        const name = iface.name.text;
+        const propInfos = [];
+        for (const member of iface.members) {
+            if (!typescript_1.default.isPropertySignature(member) || !member.name)
+                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 });
+        }
+        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(', ');
+        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(),`);
+            }
+            else if (prop.dartType.startsWith('bool')) {
+                lines.push(`      ${prop.fieldName}: map['${prop.key}'] is bool ? map['${prop.key}'] as bool : null,`);
+            }
+            else if (prop.dartType.startsWith('num')) {
+                lines.push(`      ${prop.fieldName}: map['${prop.key}'] is num ? map['${prop.key}'] as num : null,`);
+            }
+            else {
+                lines.push(`      ${prop.fieldName}: map['${prop.key}'],`);
+            }
+        }
+        lines.push('    );');
+        lines.push('  }');
+        lines.push('');
+        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}; }`);
+        }
+        lines.push('    return map;');
+        lines.push('  }');
+        lines.push('');
+        lines.push('  Map<String, dynamic> toJson() => toMap();');
+        lines.push('}');
+        lines.push('');
+    }
+    lines.push(`abstract class ${dartBindingsClass} extends WebFBaseModule {`);
+    lines.push(`  ${dartBindingsClass}(super.moduleManager);`);
+    lines.push('');
+    lines.push(`  @override`);
+    lines.push(`  String get name => '${def.moduleName}';`);
+    lines.push('');
+    for (const method of def.methods) {
+        const dartMethodName = lodash_1.default.camelCase(method.name);
+        let dartReturnType = mapTsReturnTypeToDart(method.returnTypeText);
+        // If the Promise inner type is one of the option interfaces, map return type to that Dart class.
+        const promiseMatch = method.returnTypeText.trim().match(/^Promise<(.+)>$/);
+        if (promiseMatch) {
+            const inner = promiseMatch[1].trim();
+            const baseInner = getBaseTypeName(inner);
+            if (baseInner && optionTypeNames.has(baseInner)) {
+                dartReturnType = `Future<${baseInner}>`;
+            }
+        }
+        const paramInfos = [];
+        method.params.forEach((p, index) => {
+            const mapped = mapTsParamTypeToDart(p.typeText, optionTypeNames);
+            paramInfos.push({
+                name: p.name,
+                index,
+                dartType: mapped.dartType,
+                optionClass: mapped.optionClassName,
+            });
+        });
+        const dartParams = paramInfos
+            .map(info => `${info.dartType} ${info.name}`)
+            .join(', ');
+        lines.push(`  ${dartReturnType} ${dartMethodName}(${dartParams});`);
+    }
+    lines.push('');
+    lines.push('  @override');
+    lines.push('  Future<dynamic> invoke(String method, List<dynamic> params) async {');
+    lines.push('    switch (method) {');
+    for (const method of def.methods) {
+        const dartMethodName = lodash_1.default.camelCase(method.name);
+        const paramInfos = [];
+        method.params.forEach((p, index) => {
+            const mapped = mapTsParamTypeToDart(p.typeText, optionTypeNames);
+            paramInfos.push({
+                name: p.name,
+                index,
+                dartType: mapped.dartType,
+                optionClass: mapped.optionClassName,
+            });
+        });
+        // Detect if this method returns a structured Dart class (from TS interface),
+        // in which case we should convert the result back to a Map for JS.
+        let structuredReturnClass = null;
+        const retMatch = method.returnTypeText.trim().match(/^Promise<(.+)>$/);
+        if (retMatch) {
+            const inner = retMatch[1].trim();
+            const baseInner = getBaseTypeName(inner);
+            if (baseInner && optionTypeNames.has(baseInner)) {
+                structuredReturnClass = baseInner;
+            }
+        }
+        lines.push(`      case '${method.jsName}': {`);
+        // Preprocess option-type parameters (Map -> Dart class instance)
+        for (const info of paramInfos) {
+            if (!info.optionClass)
+                continue;
+            const rawVar = `_raw${info.index}`;
+            lines.push(`        final ${rawVar} = params.length > ${info.index} ? params[${info.index}] : null;`);
+            lines.push(`        final ${info.name} = ${rawVar} is Map`
+                + ` ? ${info.optionClass}.fromMap(Map<String, dynamic>.from(${rawVar} as Map))`
+                + ` : (${rawVar} as ${info.optionClass}?);`);
+        }
+        if (paramInfos.length === 0) {
+            if (structuredReturnClass) {
+                lines.push(`        final result = await ${dartMethodName}();`);
+                lines.push('        return result.toMap();');
+            }
+            else {
+                lines.push(`        return ${dartMethodName}();`);
+            }
+        }
+        else {
+            const callArgs = paramInfos
+                .map(info => info.optionClass
+                ? info.name
+                : `params.length > ${info.index} ? params[${info.index}] : null`)
+                .join(', ');
+            if (structuredReturnClass) {
+                lines.push(`        final result = await ${dartMethodName}(${callArgs});`);
+                lines.push('        return result.toMap();');
+            }
+            else {
+                lines.push(`        return ${dartMethodName}(${callArgs});`);
+            }
+        }
+        lines.push('      }');
+    }
+    lines.push('      default:');
+    lines.push("        throw Exception('Unknown method for module ${name}: $method');");
+    lines.push('    }');
+    lines.push('  }');
+    lines.push('}');
+    lines.push('');
+    return lines.join('\n');
+}
+function generateModuleArtifacts(params) {
+    const def = parseModuleDefinition(params.moduleInterfacePath);
+    const srcDir = path_1.default.join(params.npmTargetDir, 'src');
+    if (!fs_1.default.existsSync(srcDir)) {
+        fs_1.default.mkdirSync(srcDir, { recursive: true });
+    }
+    const typesContent = buildTypesFile(def);
+    const typesPath = path_1.default.join(srcDir, 'types.ts');
+    (0, generator_1.writeFileIfChanged)(typesPath, typesContent);
+    const indexContent = buildIndexFile(def);
+    const indexPath = path_1.default.join(srcDir, 'index.ts');
+    (0, generator_1.writeFileIfChanged)(indexPath, indexContent);
+    const dartBindingsContent = buildDartBindings(def, params.command);
+    const dartDir = path_1.default.join(params.flutterPackageDir, 'lib', 'src');
+    if (!fs_1.default.existsSync(dartDir)) {
+        fs_1.default.mkdirSync(dartDir, { recursive: true });
+    }
+    const dartFileName = `${lodash_1.default.snakeCase(def.moduleName)}_module_bindings_generated.dart`;
+    const dartBindingsPath = path_1.default.join(dartDir, dartFileName);
+    (0, generator_1.writeFileIfChanged)(dartBindingsPath, dartBindingsContent);
+    return { indexPath, typesPath, dartBindingsPath };
+}

package/dist/vue.js

@@ -251,9 +251,24 @@ function generateVueTypings(blobs) {
         const members = e.members.map(m => m.initializer ? `${m.name} = ${m.initializer}` : `${m.name}`).join(', ');
         return `export declare enum ${e.name} { ${members} }`;
     }).join('\n');
+    // Compute relative import path from the generated typings file (index.d.ts at dist root)
+    // to the aggregated React types module (src/types.ts) when present.
+    let typesImportPath = './src/types';
+    try {
+        if (blobs.length > 0) {
+            const distRoot = blobs[0].dist;
+            const typingsDir = distRoot; // index.d.ts is written directly under distRoot
+            const typesFilePath = path_1.default.join(distRoot, 'src', 'types');
+            const rel = path_1.default.relative(typingsDir, typesFilePath).replace(/\\/g, '/');
+            typesImportPath = rel.startsWith('.') ? rel : `./${rel}`;
+        }
+    }
+    catch (_a) {
+        typesImportPath = './src/types';
+    }
     // Always import the types namespace to support typeof references
-    const typesImport = `import * as __webfTypes from './src/types';`;
-    (0, logger_1.debug)(`[vue] Generating typings; importing types from ./src/types`);
+    const typesImport = `import * as __webfTypes from '${typesImportPath}';`;
+    (0, logger_1.debug)(`[vue] Generating typings; importing types from ${typesImportPath}`);
     // Build mapping of template tag names to class names for GlobalComponents
     const componentMetas = componentNames.map(className => ({
         className,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openwebf/webf",
-  "version": "0.23.7",
+  "version": "0.23.10",
   "description": "Command line tools for WebF",
   "main": "index.js",
   "bin": {
@@ -24,7 +24,7 @@
   },
   "keywords": [],
   "author": "",
-  "license": "MIT",
+  "license": "Apache-2.0",
   "type": "commonjs",
   "devDependencies": {
     "@types/inquirer": "^8.2.11",