@openwebf/webf 0.23.7 → 0.24.0

package/dist/vue.js

@@ -8,7 +8,6 @@ const lodash_1 = __importDefault(require("lodash"));
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const declaration_1 = require("./declaration");
-const logger_1 = require("./logger");
 const utils_1 = require("./utils");
 function readTemplate(name) {
     return fs_1.default.readFileSync(path_1.default.join(__dirname, '../templates/' + name + '.tpl'), { encoding: 'utf-8' });
@@ -50,19 +49,18 @@ function generateReturnType(type) {
             return 'any';
         if (typeof pointerType === 'string' && pointerType.startsWith('typeof ')) {
             const ident = pointerType.substring('typeof '.length).trim();
-            return `typeof __webfTypes.${ident}`;
+            return `typeof ${ident}`;
         }
         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 = generateReturnType(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 (/^[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:
@@ -111,125 +109,111 @@ function generateMethodDeclaration(method) {
     var returnType = generateReturnType(method.returnType);
     return `${methodName}(${args}): ${returnType};`;
 }
-function generateVueComponent(blob) {
-    const classObjects = blob.objects;
-    // Skip if no class objects
-    if (!classObjects || classObjects.length === 0) {
-        return '';
-    }
-    const classObjectDictionary = Object.fromEntries(classObjects.map(object => {
-        return [object.name, object];
-    }));
-    const properties = classObjects.filter(object => {
-        return object.name.endsWith('Properties');
+function getVueComponentSpecs(blob) {
+    const classObjects = blob.objects.filter(obj => obj instanceof declaration_1.ClassObject);
+    if (classObjects.length === 0)
+        return [];
+    const properties = classObjects.filter(object => object.name.endsWith('Properties'));
+    const events = classObjects.filter(object => object.name.endsWith('Events'));
+    const methods = classObjects.filter(object => object.name.endsWith('Methods'));
+    const componentMap = new Map();
+    properties.forEach(prop => {
+        const className = prop.name.replace(/Properties$/, '');
+        if (!componentMap.has(className))
+            componentMap.set(className, { className });
+        componentMap.get(className).properties = prop;
     });
-    const events = classObjects.filter(object => {
-        return object.name.endsWith('Events');
+    events.forEach(ev => {
+        const className = ev.name.replace(/Events$/, '');
+        if (!componentMap.has(className))
+            componentMap.set(className, { className });
+        componentMap.get(className).events = ev;
     });
-    const others = classObjects.filter(object => {
-        return !object.name.endsWith('Properties')
-            && !object.name.endsWith('Events');
+    methods.forEach(m => {
+        const className = m.name.replace(/Methods$/, '');
+        if (!componentMap.has(className))
+            componentMap.set(className, { className });
+        componentMap.get(className).methods = m;
     });
-    const dependencies = others.map(object => {
-        if (!object || !object.props || object.props.length === 0) {
-            return '';
-        }
-        const interfaceLines = [];
-        if (object.documentation && object.documentation.trim().length > 0) {
-            interfaceLines.push('/**');
-            object.documentation.split('\n').forEach(line => {
-                interfaceLines.push(` * ${line}`);
+    return Array.from(componentMap.values())
+        .filter(spec => spec.className.trim().length > 0)
+        .sort((a, b) => a.className.localeCompare(b.className));
+}
+function renderSupportingInterface(object) {
+    const hasProps = !!object.props && object.props.length > 0;
+    const hasMethods = !!object.methods && object.methods.length > 0;
+    if (!hasProps && !hasMethods) {
+        return '';
+    }
+    const interfaceLines = [];
+    if (object.documentation && object.documentation.trim().length > 0) {
+        interfaceLines.push('/**');
+        object.documentation.split('\n').forEach(line => {
+            interfaceLines.push(` * ${line}`);
+        });
+        interfaceLines.push(' */');
+    }
+    interfaceLines.push(`export interface ${object.name} {`);
+    const propLines = (object.props || []).map(prop => {
+        const lines = [];
+        if (prop.documentation && prop.documentation.trim().length > 0) {
+            lines.push('  /**');
+            prop.documentation.split('\n').forEach(line => {
+                lines.push(`   * ${line}`);
             });
-            interfaceLines.push(' */');
+            lines.push('   */');
         }
-        interfaceLines.push(`interface ${object.name} {`);
-        const propLines = object.props.map(prop => {
-            const lines = [];
-            if (prop.documentation && prop.documentation.trim().length > 0) {
-                lines.push('  /**');
-                prop.documentation.split('\n').forEach(line => {
-                    lines.push(`   * ${line}`);
-                });
-                lines.push('   */');
-            }
-            const optionalToken = prop.optional ? '?' : '';
-            lines.push(`  ${prop.name}${optionalToken}: ${generateReturnType(prop.type)};`);
-            return lines.join('\n');
+        const optionalToken = prop.optional ? '?' : '';
+        lines.push(`  ${prop.name}${optionalToken}: ${generateReturnType(prop.type)};`);
+        return lines.join('\n');
+    });
+    interfaceLines.push(propLines.join('\n'));
+    if (object.methods && object.methods.length > 0) {
+        const methodLines = object.methods.map(method => {
+            return `  ${generateMethodDeclaration(method)}`;
         });
-        interfaceLines.push(propLines.join('\n'));
-        interfaceLines.push('}');
-        return interfaceLines.join('\n');
-    }).filter(dep => dep.trim() !== '').join('\n\n');
-    const componentProperties = properties.length > 0 ? properties[0] : undefined;
-    const componentEvents = events.length > 0 ? events[0] : undefined;
-    const className = (() => {
-        if (componentProperties) {
-            return componentProperties.name.replace(/Properties$/, '');
-        }
-        if (componentEvents) {
-            return componentEvents.name.replace(/Events$/, '');
-        }
-        return '';
-    })();
-    if (!className) {
-        return '';
+        interfaceLines.push(methodLines.join('\n'));
     }
-    const content = lodash_1.default.template(readTemplate('vue.component.partial'))({
-        className: className,
-        properties: componentProperties,
-        events: componentEvents,
-        classObjectDictionary,
-        dependencies,
-        blob,
-        generateReturnType,
-        generateMethodDeclaration,
-        generateEventHandlerType,
-    });
-    const result = content.split('\n').filter(str => {
-        return str.trim().length > 0;
-    }).join('\n');
-    return result;
+    interfaceLines.push('}');
+    return interfaceLines.join('\n');
 }
-function toVueTagName(className) {
+function toVueTagName(rawClassName) {
+    const className = rawClassName.trim();
     if (className.startsWith('WebF')) {
         const withoutPrefix = className.substring(4);
-        return 'web-f-' + lodash_1.default.kebabCase(withoutPrefix);
+        const suffix = lodash_1.default.kebabCase(withoutPrefix);
+        return suffix.length > 0 ? 'webf-' + suffix : 'webf';
     }
-    else if (className.startsWith('Flutter')) {
+    if (className.startsWith('Flutter')) {
         const withoutPrefix = className.substring(7);
-        return 'flutter-' + lodash_1.default.kebabCase(withoutPrefix);
+        const suffix = lodash_1.default.kebabCase(withoutPrefix);
+        return suffix.length > 0 ? 'flutter-' + suffix : 'flutter';
     }
-    return lodash_1.default.kebabCase(className);
+    const kebab = lodash_1.default.kebabCase(className);
+    return kebab.replace(/^web-f-/, 'webf-');
 }
 function generateVueTypings(blobs) {
-    const componentNames = blobs.map(blob => {
-        const classObjects = blob.objects;
-        const properties = classObjects.filter(object => {
-            return object.name.endsWith('Properties');
-        });
-        const events = classObjects.filter(object => {
-            return object.name.endsWith('Events');
-        });
-        const componentProperties = properties.length > 0 ? properties[0] : undefined;
-        const componentEvents = events.length > 0 ? events[0] : undefined;
-        const className = (() => {
-            if (componentProperties) {
-                return componentProperties.name.replace(/Properties$/, '');
-            }
-            if (componentEvents) {
-                return componentEvents.name.replace(/Events$/, '');
-            }
-            return '';
-        })();
-        return className;
-    }).filter(name => {
-        return name.length > 0;
+    const componentSpecMap = new Map();
+    blobs
+        .flatMap(blob => getVueComponentSpecs(blob))
+        .forEach(spec => {
+        if (!componentSpecMap.has(spec.className))
+            componentSpecMap.set(spec.className, spec);
     });
-    const components = blobs.map(blob => {
-        return generateVueComponent(blob);
-    }).filter(component => {
-        return component.length > 0;
-    }).join('\n\n');
+    const componentSpecs = Array.from(componentSpecMap.values()).sort((a, b) => a.className.localeCompare(b.className));
+    const componentNames = componentSpecs.map(spec => spec.className);
+    const components = componentSpecs.map(spec => {
+        const content = lodash_1.default.template(readTemplate('vue.component.partial'))({
+            className: spec.className,
+            properties: spec.properties,
+            events: spec.events,
+            methods: spec.methods,
+            generateReturnType,
+            generateMethodDeclaration,
+            generateEventHandlerType,
+        });
+        return content.split('\n').filter(str => str.trim().length > 0).join('\n');
+    }).filter(Boolean).join('\n\n');
     // Collect declare consts across blobs and render as exported ambient declarations
     const consts = blobs
         .flatMap(blob => blob.objects)
@@ -241,19 +225,55 @@ function generateVueTypings(blobs) {
             uniqueConsts.set(c.name, c);
     });
     const constDeclarations = Array.from(uniqueConsts.values())
+        .sort((a, b) => a.name.localeCompare(b.name))
         .map(c => `export declare const ${c.name}: ${c.type};`)
         .join('\n');
     // Collect declare enums across blobs
     const enums = blobs
         .flatMap(blob => blob.objects)
         .filter(obj => obj instanceof declaration_1.EnumObject);
-    const enumDeclarations = enums.map(e => {
+    const uniqueEnums = new Map();
+    enums.forEach(e => {
+        if (!uniqueEnums.has(e.name))
+            uniqueEnums.set(e.name, e);
+    });
+    const enumDeclarations = Array.from(uniqueEnums.values())
+        .sort((a, b) => a.name.localeCompare(b.name))
+        .map(e => {
         const members = e.members.map(m => m.initializer ? `${m.name} = ${m.initializer}` : `${m.name}`).join(', ');
         return `export declare enum ${e.name} { ${members} }`;
-    }).join('\n');
-    // 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`);
+    })
+        .join('\n');
+    // Collect type aliases across blobs and render as exported declarations.
+    const typeAliases = blobs
+        .flatMap(blob => blob.objects)
+        .filter(obj => obj instanceof declaration_1.TypeAliasObject);
+    const uniqueTypeAliases = new Map();
+    typeAliases.forEach(t => {
+        if (!uniqueTypeAliases.has(t.name))
+            uniqueTypeAliases.set(t.name, t);
+    });
+    const typeAliasDeclarations = Array.from(uniqueTypeAliases.values())
+        .sort((a, b) => a.name.localeCompare(b.name))
+        .map(t => `export type ${t.name} = ${t.type};`)
+        .join('\n');
+    // Collect supporting interfaces (non-component interfaces) so referenced types exist.
+    const supportingInterfaces = blobs
+        .flatMap(blob => blob.objects)
+        .filter(obj => obj instanceof declaration_1.ClassObject);
+    const supporting = supportingInterfaces.filter(obj => {
+        return !obj.name.endsWith('Properties') && !obj.name.endsWith('Events') && !obj.name.endsWith('Methods');
+    });
+    const uniqueSupporting = new Map();
+    supporting.forEach(obj => {
+        if (!uniqueSupporting.has(obj.name))
+            uniqueSupporting.set(obj.name, obj);
+    });
+    const supportingDeclarations = Array.from(uniqueSupporting.values())
+        .sort((a, b) => a.name.localeCompare(b.name))
+        .map(obj => renderSupportingInterface(obj))
+        .filter(Boolean)
+        .join('\n\n');
     // Build mapping of template tag names to class names for GlobalComponents
     const componentMetas = componentNames.map(className => ({
         className,
@@ -269,7 +289,8 @@ function generateVueTypings(blobs) {
         components,
         consts: constDeclarations,
         enums: enumDeclarations,
-        typesImport,
+        typeAliases: typeAliasDeclarations,
+        dependencies: supportingDeclarations,
     });
     return content.split('\n').filter(str => {
         return str.trim().length > 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openwebf/webf",
-  "version": "0.23.7",
+  "version": "0.24.0",
   "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",