@openwebf/webf 0.23.10 → 0.24.1

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:

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,34 +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');
-    // 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 '${typesImportPath}';`;
-    (0, logger_1.debug)(`[vue] Generating typings; importing types from ${typesImportPath}`);
+    })
+        .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,
@@ -284,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.10",
+  "version": "0.24.1",
   "description": "Command line tools for WebF",
   "main": "index.js",
   "bin": {
@@ -39,6 +39,7 @@
   "dependencies": {
     "@microsoft/tsdoc": "^0.15.1",
     "@microsoft/tsdoc-config": "^0.17.1",
+    "@openwebf/claude-code-skills": "^1.0.1",
     "commander": "^14.0.0",
     "glob": "^10.4.5",
     "inquirer": "^8.2.6",