@openwebf/webf 0.22.3 → 0.22.5

package/dist/generator.js

@@ -0,0 +1,466 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dartGen = dartGen;
+exports.reactGen = reactGen;
+exports.vueGen = vueGen;
+exports.clearAllCaches = clearAllCaches;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const process_1 = __importDefault(require("process"));
+const lodash_1 = __importDefault(require("lodash"));
+const glob_1 = require("glob");
+const yaml_1 = __importDefault(require("yaml"));
+const IDLBlob_1 = require("./IDLBlob");
+const declaration_1 = require("./declaration");
+const analyzer_1 = require("./analyzer");
+const dart_1 = require("./dart");
+const react_1 = require("./react");
+const vue_1 = require("./vue");
+const logger_1 = require("./logger");
+// Cache for file content to avoid redundant reads
+const fileContentCache = new Map();
+// Cache for generated content to detect changes
+const generatedContentCache = new Map();
+function writeFileIfChanged(filePath, content) {
+    // Check if content has changed by comparing with cache
+    const cachedContent = generatedContentCache.get(filePath);
+    if (cachedContent === content) {
+        return false; // No change
+    }
+    // Check if file exists and has same content
+    if (fs_1.default.existsSync(filePath)) {
+        const existingContent = fileContentCache.get(filePath) || fs_1.default.readFileSync(filePath, 'utf-8');
+        fileContentCache.set(filePath, existingContent);
+        if (existingContent === content) {
+            generatedContentCache.set(filePath, content);
+            return false; // No change
+        }
+    }
+    // Create directory if it doesn't exist
+    const dir = path_1.default.dirname(filePath);
+    if (!fs_1.default.existsSync(dir)) {
+        fs_1.default.mkdirSync(dir, { recursive: true });
+    }
+    // Write file and update caches
+    fs_1.default.writeFileSync(filePath, content, 'utf-8');
+    fileContentCache.set(filePath, content);
+    generatedContentCache.set(filePath, content);
+    return true; // File was changed
+}
+class DefinedPropertyCollector {
+    constructor() {
+        this.properties = new Set();
+        this.files = new Set();
+        this.interfaces = new Set();
+    }
+}
+class UnionTypeCollector {
+    constructor() {
+        this.types = new Set();
+    }
+}
+// Batch processing for file operations
+function processFilesInBatch(items, batchSize, processor) {
+    return __awaiter(this, void 0, void 0, function* () {
+        for (let i = 0; i < items.length; i += batchSize) {
+            const batch = items.slice(i, i + batchSize);
+            yield Promise.all(batch.map(item => processor(item)));
+        }
+    });
+}
+function validatePaths(source, target) {
+    if (!source) {
+        throw new Error('Source path is required');
+    }
+    if (!target) {
+        throw new Error('Target path is required');
+    }
+    // Normalize paths
+    const normalizedSource = path_1.default.isAbsolute(source) ? source : path_1.default.join(process_1.default.cwd(), source);
+    const normalizedTarget = path_1.default.isAbsolute(target) ? target : path_1.default.join(process_1.default.cwd(), target);
+    // Validate source exists
+    if (!fs_1.default.existsSync(normalizedSource)) {
+        throw new Error(`Source path does not exist: ${normalizedSource}`);
+    }
+    return { source: normalizedSource, target: normalizedTarget };
+}
+function getTypeFiles(source, excludePatterns) {
+    try {
+        const defaultIgnore = ['**/node_modules/**', '**/dist/**', '**/build/**', '**/example/**'];
+        const ignore = excludePatterns ? [...defaultIgnore, ...excludePatterns] : defaultIgnore;
+        const files = glob_1.glob.globSync("**/*.d.ts", {
+            cwd: source,
+            ignore: ignore
+        });
+        return files.filter(file => !file.includes('global.d.ts'));
+    }
+    catch (err) {
+        (0, logger_1.error)(`Error scanning for type files in ${source}`, err);
+        throw new Error(`Failed to scan type files: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+function createBlobs(typeFiles, source, target) {
+    return typeFiles.map(file => {
+        const filename = path_1.default.basename(file, '.d.ts');
+        const implement = file.replace(path_1.default.join(__dirname, '../../'), '').replace('.d.ts', '');
+        // Store the relative directory path for maintaining structure
+        const relativeDir = path_1.default.dirname(file);
+        const blob = new IDLBlob_1.IDLBlob(path_1.default.join(source, file), target, filename, implement, relativeDir);
+        // Pre-cache file content
+        if (!fileContentCache.has(blob.source)) {
+            try {
+                const content = fs_1.default.readFileSync(blob.source, 'utf-8');
+                fileContentCache.set(blob.source, content);
+                blob.raw = content;
+            }
+            catch (err) {
+                (0, logger_1.error)(`Error reading file ${blob.source}`, err);
+                throw err;
+            }
+        }
+        else {
+            blob.raw = fileContentCache.get(blob.source);
+        }
+        return blob;
+    });
+}
+function dartGen(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ source, target, command, exclude }) {
+        (0, logger_1.group)('Dart Code Generation');
+        (0, logger_1.time)('dartGen');
+        const { source: normalizedSource, target: normalizedTarget } = validatePaths(source, target);
+        const definedPropertyCollector = new DefinedPropertyCollector();
+        const unionTypeCollector = new UnionTypeCollector();
+        // Clear analyzer caches for fresh run
+        if (typeof analyzer_1.clearCaches === 'function') {
+            (0, analyzer_1.clearCaches)();
+        }
+        // Get type files
+        const typeFiles = getTypeFiles(normalizedSource, exclude);
+        (0, logger_1.info)(`Found ${typeFiles.length} type definition files`);
+        if (typeFiles.length === 0) {
+            (0, logger_1.warn)('No type definition files found');
+            (0, logger_1.timeEnd)('dartGen');
+            return;
+        }
+        // Create blobs
+        const blobs = createBlobs(typeFiles, normalizedSource, normalizedTarget);
+        // Reset global class map
+        declaration_1.ClassObject.globalClassMap = Object.create(null);
+        // Analyze all files first
+        (0, logger_1.info)('Analyzing type definitions...');
+        let analyzed = 0;
+        for (const blob of blobs) {
+            try {
+                (0, analyzer_1.analyzer)(blob, definedPropertyCollector, unionTypeCollector);
+                analyzed++;
+                (0, logger_1.progress)(analyzed, blobs.length, `Analyzing ${blob.filename}`);
+            }
+            catch (err) {
+                (0, logger_1.error)(`Error analyzing ${blob.filename}`, err);
+                // Continue with other files
+            }
+        }
+        // Generate Dart code and copy .d.ts files
+        (0, logger_1.info)('\nGenerating Dart classes...');
+        let filesChanged = 0;
+        yield processFilesInBatch(blobs, 5, (blob) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const result = (0, dart_1.generateDartClass)(blob, command);
+                blob.dist = normalizedTarget;
+                // Maintain the same directory structure as the .d.ts file
+                const outputDir = path_1.default.join(blob.dist, blob.relativeDir);
+                // Ensure the directory exists
+                if (!fs_1.default.existsSync(outputDir)) {
+                    fs_1.default.mkdirSync(outputDir, { recursive: true });
+                }
+                // Generate Dart file
+                const genFilePath = path_1.default.join(outputDir, lodash_1.default.snakeCase(blob.filename));
+                const fullPath = genFilePath + '_bindings_generated.dart';
+                if (writeFileIfChanged(fullPath, result)) {
+                    filesChanged++;
+                    (0, logger_1.debug)(`Generated: ${path_1.default.basename(fullPath)}`);
+                }
+                // Copy the original .d.ts file to the output directory
+                const dtsOutputPath = path_1.default.join(outputDir, blob.filename + '.d.ts');
+                if (writeFileIfChanged(dtsOutputPath, blob.raw)) {
+                    filesChanged++;
+                    (0, logger_1.debug)(`Copied: ${path_1.default.basename(dtsOutputPath)}`);
+                }
+            }
+            catch (err) {
+                (0, logger_1.error)(`Error generating Dart code for ${blob.filename}`, err);
+            }
+        }));
+        // Generate index.d.ts file with references to all .d.ts files
+        const indexDtsContent = generateTypeScriptIndex(blobs, normalizedTarget);
+        const indexDtsPath = path_1.default.join(normalizedTarget, 'index.d.ts');
+        if (writeFileIfChanged(indexDtsPath, indexDtsContent)) {
+            filesChanged++;
+            (0, logger_1.debug)('Generated: index.d.ts');
+        }
+        (0, logger_1.timeEnd)('dartGen');
+        (0, logger_1.success)(`Dart code generation completed. ${filesChanged} files changed.`);
+        (0, logger_1.info)(`Output directory: ${normalizedTarget}`);
+    });
+}
+function reactGen(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ source, target, exclude, packageName }) {
+        (0, logger_1.group)('React Code Generation');
+        (0, logger_1.time)('reactGen');
+        const { source: normalizedSource, target: normalizedTarget } = validatePaths(source, target);
+        const definedPropertyCollector = new DefinedPropertyCollector();
+        const unionTypeCollector = new UnionTypeCollector();
+        // Clear analyzer caches for fresh run
+        if (typeof analyzer_1.clearCaches === 'function') {
+            (0, analyzer_1.clearCaches)();
+        }
+        // Get type files
+        const typeFiles = getTypeFiles(normalizedSource, exclude);
+        (0, logger_1.info)(`Found ${typeFiles.length} type definition files`);
+        if (typeFiles.length === 0) {
+            (0, logger_1.warn)('No type definition files found');
+            (0, logger_1.timeEnd)('reactGen');
+            return;
+        }
+        // Create blobs
+        const blobs = createBlobs(typeFiles, normalizedSource, normalizedTarget);
+        // Reset global class map
+        declaration_1.ClassObject.globalClassMap = Object.create(null);
+        // Analyze all files first
+        (0, logger_1.info)('Analyzing type definitions...');
+        let analyzed = 0;
+        for (const blob of blobs) {
+            try {
+                (0, analyzer_1.analyzer)(blob, definedPropertyCollector, unionTypeCollector);
+                analyzed++;
+                (0, logger_1.progress)(analyzed, blobs.length, `Analyzing ${blob.filename}`);
+            }
+            catch (err) {
+                (0, logger_1.error)(`Error analyzing ${blob.filename}`, err);
+                // Continue with other files
+            }
+        }
+        // Ensure src directory exists
+        const srcDir = path_1.default.join(normalizedTarget, 'src');
+        if (!fs_1.default.existsSync(srcDir)) {
+            fs_1.default.mkdirSync(srcDir, { recursive: true });
+        }
+        // Generate React components
+        (0, logger_1.info)('\nGenerating React components...');
+        let filesChanged = 0;
+        yield processFilesInBatch(blobs, 5, (blob) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const result = (0, react_1.generateReactComponent)(blob, packageName, blob.relativeDir);
+                // Skip if no content was generated
+                if (!result || result.trim().length === 0) {
+                    (0, logger_1.debug)(`Skipped ${blob.filename} - no components found`);
+                    return;
+                }
+                // Maintain the same directory structure as the .d.ts file
+                // Always put files under src/ directory
+                const outputDir = path_1.default.join(normalizedTarget, 'src', blob.relativeDir);
+                // Ensure the directory exists
+                if (!fs_1.default.existsSync(outputDir)) {
+                    fs_1.default.mkdirSync(outputDir, { recursive: true });
+                }
+                const genFilePath = path_1.default.join(outputDir, blob.filename);
+                const fullPath = genFilePath + '.tsx';
+                if (writeFileIfChanged(fullPath, result)) {
+                    filesChanged++;
+                    (0, logger_1.debug)(`Generated: ${path_1.default.basename(fullPath)}`);
+                }
+            }
+            catch (err) {
+                (0, logger_1.error)(`Error generating React component for ${blob.filename}`, err);
+            }
+        }));
+        // Generate or update index file
+        const indexFilePath = path_1.default.join(normalizedTarget, 'src', 'index.ts');
+        const newExports = (0, react_1.generateReactIndex)(blobs);
+        if (fs_1.default.existsSync(indexFilePath)) {
+            // Read existing index file
+            const existingContent = fs_1.default.readFileSync(indexFilePath, 'utf-8');
+            const existingLines = existingContent.split('\n');
+            // Parse new exports
+            const newExportLines = newExports.split('\n').filter(line => line.startsWith('export '));
+            // Find which exports are missing
+            const missingExports = [];
+            for (const newExport of newExportLines) {
+                // Extract the export statement to check if it exists
+                const exportMatch = newExport.match(/export\s*{\s*([^}]+)\s*}\s*from\s*["']([^"']+)["']/);
+                if (exportMatch) {
+                    const [, exportNames, modulePath] = exportMatch;
+                    const exportedItems = exportNames.split(',').map(s => s.trim());
+                    // Check if this exact export exists
+                    const exists = existingLines.some(line => {
+                        if (!line.startsWith('export '))
+                            return false;
+                        const lineMatch = line.match(/export\s*{\s*([^}]+)\s*}\s*from\s*["']([^"']+)["']/);
+                        if (!lineMatch)
+                            return false;
+                        const [, lineExportNames, lineModulePath] = lineMatch;
+                        const lineExportedItems = lineExportNames.split(',').map(s => s.trim());
+                        // Check if same module and same exports
+                        return lineModulePath === modulePath &&
+                            exportedItems.every(item => lineExportedItems.includes(item)) &&
+                            lineExportedItems.every(item => exportedItems.includes(item));
+                    });
+                    if (!exists) {
+                        missingExports.push(newExport);
+                    }
+                }
+            }
+            // If there are missing exports, append them
+            if (missingExports.length > 0) {
+                let updatedContent = existingContent.trimRight();
+                if (!updatedContent.endsWith('\n')) {
+                    updatedContent += '\n';
+                }
+                updatedContent += missingExports.join('\n') + '\n';
+                if (writeFileIfChanged(indexFilePath, updatedContent)) {
+                    filesChanged++;
+                    (0, logger_1.debug)(`Updated: index.ts (added ${missingExports.length} exports)`);
+                }
+            }
+            else {
+                (0, logger_1.debug)(`Skipped: index.ts (all exports already exist)`);
+            }
+        }
+        else {
+            // File doesn't exist, create it
+            if (writeFileIfChanged(indexFilePath, newExports)) {
+                filesChanged++;
+                (0, logger_1.debug)(`Generated: index.ts`);
+            }
+        }
+        (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) {
+    return __awaiter(this, arguments, void 0, function* ({ source, target, exclude }) {
+        (0, logger_1.group)('Vue Typings Generation');
+        (0, logger_1.time)('vueGen');
+        const { source: normalizedSource, target: normalizedTarget } = validatePaths(source, target);
+        const definedPropertyCollector = new DefinedPropertyCollector();
+        const unionTypeCollector = new UnionTypeCollector();
+        // Clear analyzer caches for fresh run
+        if (typeof analyzer_1.clearCaches === 'function') {
+            (0, analyzer_1.clearCaches)();
+        }
+        // Get type files
+        const typeFiles = getTypeFiles(normalizedSource, exclude);
+        (0, logger_1.info)(`Found ${typeFiles.length} type definition files`);
+        if (typeFiles.length === 0) {
+            (0, logger_1.warn)('No type definition files found');
+            (0, logger_1.timeEnd)('vueGen');
+            return;
+        }
+        // Create blobs
+        const blobs = createBlobs(typeFiles, normalizedSource, normalizedTarget);
+        // Reset global class map
+        declaration_1.ClassObject.globalClassMap = Object.create(null);
+        // Analyze all files first
+        (0, logger_1.info)('Analyzing type definitions...');
+        let analyzed = 0;
+        for (const blob of blobs) {
+            try {
+                (0, analyzer_1.analyzer)(blob, definedPropertyCollector, unionTypeCollector);
+                analyzed++;
+                (0, logger_1.progress)(analyzed, blobs.length, `Analyzing ${blob.filename}`);
+            }
+            catch (err) {
+                (0, logger_1.error)(`Error analyzing ${blob.filename}`, err);
+                // Continue with other files
+            }
+        }
+        // Generate Vue typings
+        (0, logger_1.info)('\nGenerating Vue typings...');
+        const typingsContent = (0, vue_1.generateVueTypings)(blobs);
+        const typingsFilePath = path_1.default.join(normalizedTarget, 'index.d.ts');
+        let filesChanged = 0;
+        if (writeFileIfChanged(typingsFilePath, typingsContent)) {
+            filesChanged++;
+            (0, logger_1.debug)(`Generated: index.d.ts`);
+        }
+        (0, logger_1.timeEnd)('vueGen');
+        (0, logger_1.success)(`Vue typings generation completed. ${filesChanged} files changed.`);
+        (0, logger_1.info)(`Output directory: ${normalizedTarget}`);
+        (0, logger_1.info)('You can now import these types in your Vue project.');
+    });
+}
+function generateTypeScriptIndex(blobs, targetPath) {
+    const references = ['/// <reference path="./global.d.ts" />'];
+    const exports = [];
+    // Group blobs by directory to maintain structure
+    const filesByDir = new Map();
+    blobs.forEach(blob => {
+        const dir = blob.relativeDir || '.';
+        if (!filesByDir.has(dir)) {
+            filesByDir.set(dir, []);
+        }
+        filesByDir.get(dir).push(blob);
+    });
+    // Sort directories and files for consistent output
+    const sortedDirs = Array.from(filesByDir.keys()).sort();
+    sortedDirs.forEach(dir => {
+        const dirBlobs = filesByDir.get(dir).sort((a, b) => a.filename.localeCompare(b.filename));
+        dirBlobs.forEach(blob => {
+            const relativePath = dir === '.' ? blob.filename : path_1.default.join(dir, blob.filename);
+            references.push(`/// <reference path="./${relativePath}.d.ts" />`);
+            exports.push(`export * from './${relativePath}';`);
+        });
+    });
+    // Get package name from pubspec.yaml if available
+    let packageName = 'WebF Package';
+    let packageDescription = 'TypeScript Definitions';
+    try {
+        const pubspecPath = path_1.default.join(targetPath, 'pubspec.yaml');
+        if (fs_1.default.existsSync(pubspecPath)) {
+            const pubspecContent = fs_1.default.readFileSync(pubspecPath, 'utf-8');
+            const pubspec = yaml_1.default.parse(pubspecContent);
+            if (pubspec.name) {
+                packageName = pubspec.name.replace(/_/g, ' ').replace(/\b\w/g, (l) => l.toUpperCase());
+            }
+            if (pubspec.description) {
+                packageDescription = pubspec.description;
+            }
+        }
+    }
+    catch (err) {
+        // Ignore errors, use defaults
+    }
+    return `${references.join('\n')}
+
+/**
+ * ${packageName} - TypeScript Definitions
+ * 
+ * ${packageDescription}
+ */
+
+${exports.join('\n')}
+`;
+}
+// Clear all caches (useful for watch mode or between runs)
+function clearAllCaches() {
+    fileContentCache.clear();
+    generatedContentCache.clear();
+    if (typeof analyzer_1.clearCaches === 'function') {
+        (0, analyzer_1.clearCaches)(); // Clear analyzer caches
+    }
+}

package/dist/logger.js

@@ -0,0 +1,103 @@
+"use strict";
+// Simplified logger without chalk dependency for now
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.timeEnd = exports.time = exports.progress = exports.group = exports.error = exports.warn = exports.success = exports.info = exports.debug = exports.logger = exports.LogLevel = void 0;
+var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["DEBUG"] = 0] = "DEBUG";
+    LogLevel[LogLevel["INFO"] = 1] = "INFO";
+    LogLevel[LogLevel["WARN"] = 2] = "WARN";
+    LogLevel[LogLevel["ERROR"] = 3] = "ERROR";
+    LogLevel[LogLevel["SILENT"] = 4] = "SILENT";
+})(LogLevel || (exports.LogLevel = LogLevel = {}));
+class Logger {
+    constructor() {
+        this.logLevel = LogLevel.INFO;
+        this.debugMode = false;
+        // Check for debug environment variable
+        this.debugMode = process.env.WEBF_DEBUG === 'true' || process.env.DEBUG === 'true';
+        if (this.debugMode) {
+            this.logLevel = LogLevel.DEBUG;
+        }
+    }
+    setLogLevel(level) {
+        this.logLevel = level;
+    }
+    debug(message, ...args) {
+        if (this.logLevel <= LogLevel.DEBUG) {
+            console.log(`[DEBUG] ${message}`, ...args);
+        }
+    }
+    info(message, ...args) {
+        if (this.logLevel <= LogLevel.INFO) {
+            console.log(`ℹ ${message}`, ...args);
+        }
+    }
+    success(message, ...args) {
+        if (this.logLevel <= LogLevel.INFO) {
+            console.log(`✓ ${message}`, ...args);
+        }
+    }
+    warn(message, ...args) {
+        if (this.logLevel <= LogLevel.WARN) {
+            console.warn(`⚠ ${message}`, ...args);
+        }
+    }
+    error(message, error) {
+        if (this.logLevel <= LogLevel.ERROR) {
+            console.error(`✗ ${message}`);
+            if (error) {
+                if (error instanceof Error) {
+                    console.error(error.stack || error.message);
+                }
+                else {
+                    console.error(String(error));
+                }
+            }
+        }
+    }
+    group(title) {
+        if (this.logLevel <= LogLevel.INFO) {
+            console.log(`\n${title}`);
+            console.log('─'.repeat(title.length));
+        }
+    }
+    progress(current, total, message) {
+        if (this.logLevel <= LogLevel.INFO) {
+            const percentage = Math.round((current / total) * 100);
+            const progressBar = this.createProgressBar(percentage);
+            process.stdout.write(`\r${progressBar} ${percentage}% - ${message}`);
+            if (current === total) {
+                process.stdout.write('\n');
+            }
+        }
+    }
+    createProgressBar(percentage) {
+        const width = 20;
+        const filled = Math.round((percentage / 100) * width);
+        const empty = width - filled;
+        return `[${'█'.repeat(filled)}${'░'.repeat(empty)}]`;
+    }
+    time(label) {
+        if (this.logLevel <= LogLevel.DEBUG) {
+            console.time(`[TIMER] ${label}`);
+        }
+    }
+    timeEnd(label) {
+        if (this.logLevel <= LogLevel.DEBUG) {
+            console.timeEnd(`[TIMER] ${label}`);
+        }
+    }
+}
+// Export singleton instance
+exports.logger = new Logger();
+// Export convenience functions
+exports.debug = exports.logger.debug.bind(exports.logger);
+exports.info = exports.logger.info.bind(exports.logger);
+exports.success = exports.logger.success.bind(exports.logger);
+exports.warn = exports.logger.warn.bind(exports.logger);
+exports.error = exports.logger.error.bind(exports.logger);
+exports.group = exports.logger.group.bind(exports.logger);
+exports.progress = exports.logger.progress.bind(exports.logger);
+exports.time = exports.logger.time.bind(exports.logger);
+exports.timeEnd = exports.logger.timeEnd.bind(exports.logger);