@openwebf/webf 0.22.3 → 0.22.4

package/dist/commands.js

@@ -0,0 +1,704 @@
+"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.generateCommand = generateCommand;
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const generator_1 = require("./generator");
+const lodash_1 = __importDefault(require("lodash"));
+const inquirer_1 = __importDefault(require("inquirer"));
+const yaml_1 = __importDefault(require("yaml"));
+/**
+ * Sanitize a package name to comply with npm naming rules
+ * NPM package name rules:
+ * - Must be lowercase
+ * - Must be one word, no spaces
+ * - Can contain hyphens and underscores
+ * - Must start with a letter or number (or @ for scoped packages)
+ * - Cannot contain special characters except @ for scoped packages
+ * - Must be less than 214 characters
+ * - Cannot start with . or _
+ * - Cannot contain leading or trailing spaces
+ * - Cannot contain any non-URL-safe characters
+ */
+function sanitizePackageName(name) {
+    // Remove any leading/trailing whitespace
+    let sanitized = name.trim();
+    // Check if it's a scoped package
+    const isScoped = sanitized.startsWith('@');
+    let scope = '';
+    let packageName = sanitized;
+    if (isScoped) {
+        const parts = sanitized.split('/');
+        if (parts.length >= 2) {
+            scope = parts[0];
+            packageName = parts.slice(1).join('/');
+        }
+        else {
+            // Invalid scoped package, treat as regular
+            packageName = sanitized.substring(1);
+        }
+    }
+    // Sanitize scope if present
+    if (scope) {
+        scope = scope.toLowerCase();
+        // Remove invalid characters from scope (keep only @ and alphanumeric/hyphen)
+        scope = scope.replace(/[^@a-z0-9-]/g, '');
+        if (scope === '@') {
+            scope = '@pkg'; // Default scope if only @ remains
+        }
+    }
+    // Sanitize package name part
+    packageName = packageName.toLowerCase();
+    packageName = packageName.replace(/\s+/g, '-');
+    packageName = packageName.replace(/[^a-z0-9\-_.]/g, '');
+    packageName = packageName.replace(/^[._]+/, '');
+    packageName = packageName.replace(/[._]+$/, '');
+    packageName = packageName.replace(/[-_.]{2,}/g, '-');
+    packageName = packageName.replace(/^-+/, '').replace(/-+$/, '');
+    // Ensure package name is not empty
+    if (!packageName) {
+        packageName = 'package';
+    }
+    // Ensure it starts with a letter or number
+    if (!/^[a-z0-9]/.test(packageName)) {
+        packageName = 'pkg-' + packageName;
+    }
+    // Combine scope and package name
+    let result = scope ? `${scope}/${packageName}` : packageName;
+    // Truncate to 214 characters (npm limit)
+    if (result.length > 214) {
+        if (scope) {
+            // Try to preserve scope
+            const maxPackageLength = 214 - scope.length - 1; // -1 for the /
+            packageName = packageName.substring(0, maxPackageLength);
+            packageName = packageName.replace(/[._-]+$/, '');
+            result = `${scope}/${packageName}`;
+        }
+        else {
+            result = result.substring(0, 214);
+            result = result.replace(/[._-]+$/, '');
+        }
+    }
+    return result;
+}
+/**
+ * Validate if a package name follows npm naming rules
+ */
+function isValidNpmPackageName(name) {
+    // Check basic rules
+    if (!name || name.length === 0 || name.length > 214)
+        return false;
+    if (name.trim() !== name)
+        return false;
+    // Check if it's a scoped package
+    if (name.startsWith('@')) {
+        const parts = name.split('/');
+        if (parts.length !== 2)
+            return false; // Scoped packages must have exactly one /
+        const scope = parts[0];
+        const packageName = parts[1];
+        // Validate scope
+        if (!/^@[a-z0-9][a-z0-9-]*$/.test(scope))
+            return false;
+        // Validate package name part
+        return isValidNpmPackageName(packageName);
+    }
+    // For non-scoped packages
+    if (name !== name.toLowerCase())
+        return false;
+    if (name.startsWith('.') || name.startsWith('_'))
+        return false;
+    // Check for valid characters (letters, numbers, hyphens, underscores, dots)
+    if (!/^[a-z0-9][a-z0-9\-_.]*$/.test(name))
+        return false;
+    // Check for URL-safe characters
+    try {
+        if (encodeURIComponent(name) !== name)
+            return false;
+    }
+    catch (_a) {
+        return false;
+    }
+    return true;
+}
+const platform = process.platform;
+const NPM = platform == 'win32' ? 'npm.cmd' : 'npm';
+const gloabalDts = fs_1.default.readFileSync(path_1.default.resolve(__dirname, '../global.d.ts'), 'utf-8');
+const tsConfig = fs_1.default.readFileSync(path_1.default.resolve(__dirname, '../templates/tsconfig.json.tpl'), 'utf-8');
+const gitignore = fs_1.default.readFileSync(path_1.default.resolve(__dirname, '../templates/gitignore.tpl'), 'utf-8');
+const reactPackageJson = fs_1.default.readFileSync(path_1.default.resolve(__dirname, '../templates/react.package.json.tpl'), 'utf-8');
+const reactTsConfig = fs_1.default.readFileSync(path_1.default.resolve(__dirname, '../templates/react.tsconfig.json.tpl'), 'utf-8');
+const reactTsUpConfig = fs_1.default.readFileSync(path_1.default.resolve(__dirname, '../templates/react.tsup.config.ts.tpl'), 'utf-8');
+const reactIndexTpl = fs_1.default.readFileSync(path_1.default.resolve(__dirname, '../templates/react.index.ts.tpl'), 'utf-8');
+const vuePackageJson = fs_1.default.readFileSync(path_1.default.resolve(__dirname, '../templates/vue.package.json.tpl'), 'utf-8');
+const vueTsConfig = fs_1.default.readFileSync(path_1.default.resolve(__dirname, '../templates/vue.tsconfig.json.tpl'), 'utf-8');
+function readFlutterPackageMetadata(packagePath) {
+    try {
+        const pubspecPath = path_1.default.join(packagePath, 'pubspec.yaml');
+        if (!fs_1.default.existsSync(pubspecPath)) {
+            console.warn(`Warning: pubspec.yaml not found at ${pubspecPath}. Using default metadata.`);
+            return null;
+        }
+        const pubspecContent = fs_1.default.readFileSync(pubspecPath, 'utf-8');
+        const pubspec = yaml_1.default.parse(pubspecContent);
+        // Validate required fields
+        if (!pubspec.name) {
+            console.warn(`Warning: Flutter package name not found in ${pubspecPath}. Using default name.`);
+        }
+        return {
+            name: pubspec.name || '',
+            version: pubspec.version || '0.0.1',
+            description: pubspec.description || ''
+        };
+    }
+    catch (error) {
+        console.warn(`Warning: Could not read Flutter package metadata from ${packagePath}:`, error);
+        console.warn('Using default metadata. Ensure pubspec.yaml exists and is valid YAML.');
+        return null;
+    }
+}
+function validateTypeScriptEnvironment(projectPath) {
+    const errors = [];
+    // Check for TypeScript configuration
+    const tsConfigPath = path_1.default.join(projectPath, 'tsconfig.json');
+    if (!fs_1.default.existsSync(tsConfigPath)) {
+        errors.push('Missing tsconfig.json - TypeScript configuration is required for type definitions');
+    }
+    // Check for .d.ts files - this is critical
+    const libPath = path_1.default.join(projectPath, 'lib');
+    let hasDtsFiles = false;
+    if (fs_1.default.existsSync(libPath)) {
+        // Check in lib directory
+        hasDtsFiles = fs_1.default.readdirSync(libPath).some(file => file.endsWith('.d.ts') ||
+            (fs_1.default.statSync(path_1.default.join(libPath, file)).isDirectory() &&
+                fs_1.default.readdirSync(path_1.default.join(libPath, file)).some(f => f.endsWith('.d.ts'))));
+    }
+    // Also check in root directory
+    if (!hasDtsFiles) {
+        hasDtsFiles = fs_1.default.readdirSync(projectPath).some(file => file.endsWith('.d.ts') ||
+            (fs_1.default.statSync(path_1.default.join(projectPath, file)).isDirectory() &&
+                file !== 'node_modules' &&
+                fs_1.default.existsSync(path_1.default.join(projectPath, file, 'index.d.ts'))));
+    }
+    if (!hasDtsFiles) {
+        errors.push('No TypeScript definition files (.d.ts) found in the project - Please create .d.ts files for your components');
+    }
+    return {
+        isValid: errors.length === 0,
+        errors
+    };
+}
+function createCommand(target, options) {
+    const { framework, metadata } = options;
+    // Ensure package name is always valid
+    const packageName = isValidNpmPackageName(options.packageName)
+        ? options.packageName
+        : sanitizePackageName(options.packageName);
+    if (!fs_1.default.existsSync(target)) {
+        fs_1.default.mkdirSync(target, { recursive: true });
+    }
+    if (framework === 'react') {
+        const packageJsonPath = path_1.default.join(target, 'package.json');
+        const packageJsonContent = lodash_1.default.template(reactPackageJson)({
+            packageName,
+            version: (metadata === null || metadata === void 0 ? void 0 : metadata.version) || '0.0.1',
+            description: (metadata === null || metadata === void 0 ? void 0 : metadata.description) || ''
+        });
+        writeFileIfChanged(packageJsonPath, packageJsonContent);
+        const tsConfigPath = path_1.default.join(target, 'tsconfig.json');
+        const tsConfigContent = lodash_1.default.template(reactTsConfig)({});
+        writeFileIfChanged(tsConfigPath, tsConfigContent);
+        const tsupConfigPath = path_1.default.join(target, 'tsup.config.ts');
+        const tsupConfigContent = lodash_1.default.template(reactTsUpConfig)({});
+        writeFileIfChanged(tsupConfigPath, tsupConfigContent);
+        const gitignorePath = path_1.default.join(target, '.gitignore');
+        const gitignoreContent = lodash_1.default.template(gitignore)({});
+        writeFileIfChanged(gitignorePath, gitignoreContent);
+        const srcDir = path_1.default.join(target, 'src');
+        if (!fs_1.default.existsSync(srcDir)) {
+            fs_1.default.mkdirSync(srcDir, { recursive: true });
+        }
+        const indexFilePath = path_1.default.join(srcDir, 'index.ts');
+        const indexContent = lodash_1.default.template(reactIndexTpl)({
+            components: [],
+        });
+        writeFileIfChanged(indexFilePath, indexContent);
+        (0, child_process_1.spawnSync)(NPM, ['install', '--omit=peer'], {
+            cwd: target,
+            stdio: 'inherit'
+        });
+    }
+    else if (framework === 'vue') {
+        const packageJsonPath = path_1.default.join(target, 'package.json');
+        const packageJsonContent = lodash_1.default.template(vuePackageJson)({
+            packageName,
+            version: (metadata === null || metadata === void 0 ? void 0 : metadata.version) || '0.0.1',
+            description: (metadata === null || metadata === void 0 ? void 0 : metadata.description) || ''
+        });
+        writeFileIfChanged(packageJsonPath, packageJsonContent);
+        const tsConfigPath = path_1.default.join(target, 'tsconfig.json');
+        const tsConfigContent = lodash_1.default.template(vueTsConfig)({});
+        writeFileIfChanged(tsConfigPath, tsConfigContent);
+        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', '@types/vue', '-D'], {
+            cwd: target,
+            stdio: 'inherit'
+        });
+    }
+    console.log(`WebF ${framework} package created at: ${target}`);
+}
+function generateCommand(distPath, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c, _d;
+        // If distPath is not provided or is '.', create a temporary directory
+        let resolvedDistPath;
+        let isTempDir = false;
+        if (!distPath || distPath === '.') {
+            // Create a temporary directory for the generated package
+            const tempDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'webf-typings-'));
+            resolvedDistPath = tempDir;
+            isTempDir = true;
+            console.log(`\nUsing temporary directory: ${tempDir}`);
+        }
+        else {
+            resolvedDistPath = path_1.default.resolve(distPath);
+        }
+        // First, check if we're in a Flutter package directory when flutter-package-src is not provided
+        if (!options.flutterPackageSrc) {
+            // Check if current directory or parent directories contain pubspec.yaml
+            let currentDir = process.cwd();
+            let foundPubspec = false;
+            let pubspecDir = '';
+            // Search up to 3 levels up for pubspec.yaml
+            for (let i = 0; i < 3; i++) {
+                const pubspecPath = path_1.default.join(currentDir, 'pubspec.yaml');
+                if (fs_1.default.existsSync(pubspecPath)) {
+                    foundPubspec = true;
+                    pubspecDir = currentDir;
+                    break;
+                }
+                const parentDir = path_1.default.dirname(currentDir);
+                if (parentDir === currentDir)
+                    break; // Reached root
+                currentDir = parentDir;
+            }
+            if (foundPubspec) {
+                // Use the directory containing pubspec.yaml as the flutter package source
+                options.flutterPackageSrc = pubspecDir;
+                console.log(`\nDetected Flutter package at: ${pubspecDir}`);
+            }
+        }
+        // Check if the directory exists and has required files
+        const packageJsonPath = path_1.default.join(resolvedDistPath, 'package.json');
+        const globalDtsPath = path_1.default.join(resolvedDistPath, 'global.d.ts');
+        const tsConfigPath = path_1.default.join(resolvedDistPath, 'tsconfig.json');
+        const hasPackageJson = fs_1.default.existsSync(packageJsonPath);
+        const hasGlobalDts = fs_1.default.existsSync(globalDtsPath);
+        const hasTsConfig = fs_1.default.existsSync(tsConfigPath);
+        // Determine if we need to create a new project
+        const needsProjectCreation = !hasPackageJson || !hasGlobalDts || !hasTsConfig;
+        let framework = options.framework;
+        let packageName = options.packageName;
+        // Validate and sanitize package name if provided
+        if (packageName && !isValidNpmPackageName(packageName)) {
+            console.warn(`Warning: Package name "${packageName}" is not valid for npm.`);
+            const sanitized = sanitizePackageName(packageName);
+            console.log(`Using sanitized name: "${sanitized}"`);
+            packageName = sanitized;
+        }
+        if (needsProjectCreation) {
+            // If project needs creation but options are missing, prompt for them
+            if (!framework) {
+                const frameworkAnswer = yield inquirer_1.default.prompt([{
+                        type: 'list',
+                        name: 'framework',
+                        message: 'Which framework would you like to use?',
+                        choices: ['react', 'vue']
+                    }]);
+                framework = frameworkAnswer.framework;
+            }
+            // Try to read Flutter package metadata if flutterPackageSrc is provided
+            let metadata = null;
+            if (options.flutterPackageSrc) {
+                metadata = readFlutterPackageMetadata(options.flutterPackageSrc);
+            }
+            if (!packageName) {
+                // Use Flutter package name as default if available, sanitized for npm
+                const rawDefaultName = (metadata === null || metadata === void 0 ? void 0 : metadata.name) || path_1.default.basename(resolvedDistPath);
+                const defaultPackageName = sanitizePackageName(rawDefaultName);
+                const packageNameAnswer = yield inquirer_1.default.prompt([{
+                        type: 'input',
+                        name: 'packageName',
+                        message: 'What is your package name?',
+                        default: defaultPackageName,
+                        validate: (input) => {
+                            if (!input || input.trim() === '') {
+                                return 'Package name is required';
+                            }
+                            // Check if it's valid as-is
+                            if (isValidNpmPackageName(input)) {
+                                return true;
+                            }
+                            // If not valid, show what it would be sanitized to
+                            const sanitized = sanitizePackageName(input);
+                            return `Invalid npm package name. Would be sanitized to: "${sanitized}". Please enter a valid name.`;
+                        }
+                    }]);
+                packageName = packageNameAnswer.packageName;
+            }
+            console.log(`\nCreating new ${framework} project in ${resolvedDistPath}...`);
+            createCommand(resolvedDistPath, {
+                framework: framework,
+                packageName: packageName,
+                metadata: metadata || undefined
+            });
+        }
+        else {
+            // Validate existing project structure
+            if (hasPackageJson) {
+                try {
+                    const packageJson = JSON.parse(fs_1.default.readFileSync(packageJsonPath, 'utf-8'));
+                    // Detect framework from existing package.json
+                    if (!framework) {
+                        if (((_a = packageJson.dependencies) === null || _a === void 0 ? void 0 : _a.react) || ((_b = packageJson.devDependencies) === null || _b === void 0 ? void 0 : _b.react)) {
+                            framework = 'react';
+                        }
+                        else if (((_c = packageJson.dependencies) === null || _c === void 0 ? void 0 : _c.vue) || ((_d = packageJson.devDependencies) === null || _d === void 0 ? void 0 : _d.vue)) {
+                            framework = 'vue';
+                        }
+                        else {
+                            // If can't detect, prompt for it
+                            const frameworkAnswer = yield inquirer_1.default.prompt([{
+                                    type: 'list',
+                                    name: 'framework',
+                                    message: 'Which framework are you using?',
+                                    choices: ['react', 'vue']
+                                }]);
+                            framework = frameworkAnswer.framework;
+                        }
+                    }
+                    console.log(`\nDetected existing ${framework} project in ${resolvedDistPath}`);
+                }
+                catch (e) {
+                    console.error('Error reading package.json:', e);
+                    process.exit(1);
+                }
+            }
+        }
+        // Now proceed with code generation if flutter package source is provided
+        if (!options.flutterPackageSrc) {
+            console.log('\nProject is ready for code generation.');
+            console.log('To generate code, run:');
+            const displayPath = isTempDir ? '<output-dir>' : distPath;
+            console.log(`  webf codegen ${displayPath} --flutter-package-src=<path> --framework=${framework}`);
+            if (isTempDir) {
+                // Clean up temporary directory if we're not using it
+                fs_1.default.rmSync(resolvedDistPath, { recursive: true, force: true });
+            }
+            return;
+        }
+        // Validate TypeScript environment in the Flutter package
+        console.log(`\nValidating TypeScript environment in ${options.flutterPackageSrc}...`);
+        const validation = validateTypeScriptEnvironment(options.flutterPackageSrc);
+        if (!validation.isValid) {
+            // Check specifically for missing tsconfig.json
+            const tsConfigPath = path_1.default.join(options.flutterPackageSrc, 'tsconfig.json');
+            if (!fs_1.default.existsSync(tsConfigPath)) {
+                const createTsConfigAnswer = yield inquirer_1.default.prompt([{
+                        type: 'confirm',
+                        name: 'createTsConfig',
+                        message: 'No tsconfig.json found. Would you like me to create one for you?',
+                        default: true
+                    }]);
+                if (createTsConfigAnswer.createTsConfig) {
+                    // Create a default tsconfig.json
+                    const defaultTsConfig = {
+                        compilerOptions: {
+                            target: 'ES2020',
+                            module: 'commonjs',
+                            lib: ['ES2020'],
+                            declaration: true,
+                            strict: true,
+                            esModuleInterop: true,
+                            skipLibCheck: true,
+                            forceConsistentCasingInFileNames: true,
+                            resolveJsonModule: true,
+                            moduleResolution: 'node'
+                        },
+                        include: ['lib/**/*.d.ts', '**/*.d.ts'],
+                        exclude: ['node_modules', 'dist', 'build']
+                    };
+                    fs_1.default.writeFileSync(tsConfigPath, JSON.stringify(defaultTsConfig, null, 2), 'utf-8');
+                    console.log('✅ Created tsconfig.json');
+                    // Re-validate after creating tsconfig
+                    const newValidation = validateTypeScriptEnvironment(options.flutterPackageSrc);
+                    if (!newValidation.isValid) {
+                        console.error('\n⚠️  Additional setup required:');
+                        newValidation.errors.forEach(error => console.error(`   - ${error}`));
+                        console.error('\nPlease fix the above issues and run the command again.');
+                        process.exit(1);
+                    }
+                }
+                else {
+                    console.error('\n❌ TypeScript configuration is required for code generation.');
+                    console.error('Please create a tsconfig.json file manually and run the command again.');
+                    process.exit(1);
+                }
+            }
+            else {
+                // Show all validation errors
+                console.error('\n❌ TypeScript environment validation failed:');
+                validation.errors.forEach(error => console.error(`   - ${error}`));
+                console.error('\nPlease fix the above issues before generating code.');
+                process.exit(1);
+            }
+        }
+        const command = `webf codegen --flutter-package-src=${options.flutterPackageSrc} --framework=${framework} <distPath>`;
+        // Auto-initialize typings in the output directory if needed
+        ensureInitialized(resolvedDistPath);
+        console.log(`\nGenerating ${framework} code from ${options.flutterPackageSrc}...`);
+        yield (0, generator_1.dartGen)({
+            source: options.flutterPackageSrc,
+            target: options.flutterPackageSrc,
+            command,
+            exclude: options.exclude,
+        });
+        if (framework === 'react') {
+            // Get the package name from package.json if it exists
+            let reactPackageName;
+            try {
+                const packageJsonPath = path_1.default.join(resolvedDistPath, 'package.json');
+                if (fs_1.default.existsSync(packageJsonPath)) {
+                    const packageJson = JSON.parse(fs_1.default.readFileSync(packageJsonPath, 'utf-8'));
+                    reactPackageName = packageJson.name;
+                }
+            }
+            catch (e) {
+                // Ignore errors
+            }
+            yield (0, generator_1.reactGen)({
+                source: options.flutterPackageSrc,
+                target: resolvedDistPath,
+                command,
+                exclude: options.exclude,
+                packageName: reactPackageName,
+            });
+        }
+        else if (framework === 'vue') {
+            yield (0, generator_1.vueGen)({
+                source: options.flutterPackageSrc,
+                target: resolvedDistPath,
+                command,
+                exclude: options.exclude,
+            });
+        }
+        console.log('\nCode generation completed successfully!');
+        // Automatically build the generated package
+        if (framework) {
+            try {
+                yield buildPackage(resolvedDistPath);
+            }
+            catch (error) {
+                console.error('\nWarning: Build failed:', error);
+                // Don't exit here since generation was successful
+            }
+        }
+        // Handle npm publishing if requested via command line option
+        if (options.publishToNpm && framework) {
+            try {
+                yield buildAndPublishPackage(resolvedDistPath, options.npmRegistry);
+            }
+            catch (error) {
+                console.error('\nError during npm publish:', error);
+                process.exit(1);
+            }
+        }
+        else if (framework && !options.publishToNpm) {
+            // If not publishing via command line option, ask the user
+            const publishAnswer = yield inquirer_1.default.prompt([{
+                    type: 'confirm',
+                    name: 'publish',
+                    message: 'Would you like to publish this package to npm?',
+                    default: false
+                }]);
+            if (publishAnswer.publish) {
+                // Ask for registry
+                const registryAnswer = yield inquirer_1.default.prompt([{
+                        type: 'input',
+                        name: 'registry',
+                        message: 'NPM registry URL (leave empty for default npm registry):',
+                        default: '',
+                        validate: (input) => {
+                            if (!input)
+                                return true; // Empty is valid (use default)
+                            try {
+                                new URL(input); // Validate URL format
+                                return true;
+                            }
+                            catch (_a) {
+                                return 'Please enter a valid URL';
+                            }
+                        }
+                    }]);
+                try {
+                    yield buildAndPublishPackage(resolvedDistPath, registryAnswer.registry || undefined);
+                }
+                catch (error) {
+                    console.error('\nError during npm publish:', error);
+                    // Don't exit here since generation was successful
+                }
+            }
+        }
+        // If using a temporary directory, remind the user where the files are
+        if (isTempDir) {
+            console.log(`\n📁 Generated files are in: ${resolvedDistPath}`);
+            console.log('💡 To use these files, copy them to your desired location or publish to npm.');
+        }
+    });
+}
+function writeFileIfChanged(filePath, content) {
+    if (fs_1.default.existsSync(filePath)) {
+        const oldContent = fs_1.default.readFileSync(filePath, 'utf-8');
+        if (oldContent === content) {
+            return;
+        }
+    }
+    fs_1.default.writeFileSync(filePath, content, 'utf-8');
+}
+function ensureInitialized(targetPath) {
+    const globalDtsPath = path_1.default.join(targetPath, 'global.d.ts');
+    const tsConfigPath = path_1.default.join(targetPath, 'tsconfig.json');
+    // Check if initialization files already exist
+    const needsInit = !fs_1.default.existsSync(globalDtsPath) || !fs_1.default.existsSync(tsConfigPath);
+    if (needsInit) {
+        console.log('Initializing WebF typings...');
+        fs_1.default.mkdirSync(targetPath, { recursive: true });
+        if (!fs_1.default.existsSync(globalDtsPath)) {
+            fs_1.default.writeFileSync(globalDtsPath, gloabalDts, 'utf-8');
+            console.log('Created global.d.ts');
+        }
+        if (!fs_1.default.existsSync(tsConfigPath)) {
+            fs_1.default.writeFileSync(tsConfigPath, tsConfig, 'utf-8');
+            console.log('Created tsconfig.json');
+        }
+    }
+}
+function buildPackage(packagePath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        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
+            if (process.env.NODE_ENV === 'test' || process.env.JEST_WORKER_ID !== undefined) {
+                return;
+            }
+            throw new Error(`No package.json found in ${packagePath}`);
+        }
+        const packageJson = JSON.parse(fs_1.default.readFileSync(packageJsonPath, 'utf-8'));
+        const packageName = packageJson.name;
+        const packageVersion = packageJson.version;
+        // Check if node_modules exists
+        const nodeModulesPath = path_1.default.join(packagePath, 'node_modules');
+        if (!fs_1.default.existsSync(nodeModulesPath)) {
+            console.log(`\n📦 Installing dependencies for ${packageName}...`);
+            // Check if yarn.lock exists to determine package manager
+            const yarnLockPath = path_1.default.join(packagePath, 'yarn.lock');
+            const useYarn = fs_1.default.existsSync(yarnLockPath);
+            const installCommand = useYarn ? 'yarn' : NPM;
+            const installArgs = useYarn ? [] : ['install'];
+            const installResult = (0, child_process_1.spawnSync)(installCommand, installArgs, {
+                cwd: packagePath,
+                stdio: 'inherit'
+            });
+            if (installResult.status !== 0) {
+                throw new Error('Failed to install dependencies');
+            }
+            console.log('✅ Dependencies installed successfully!');
+        }
+        // Check if package has a build script
+        if ((_a = packageJson.scripts) === null || _a === void 0 ? void 0 : _a.build) {
+            console.log(`\nBuilding ${packageName}@${packageVersion}...`);
+            const buildResult = (0, child_process_1.spawnSync)(NPM, ['run', 'build'], {
+                cwd: packagePath,
+                stdio: 'inherit'
+            });
+            if (buildResult.status !== 0) {
+                throw new Error('Build failed');
+            }
+            console.log('✅ Build completed successfully!');
+        }
+        else {
+            console.log(`\nNo build script found for ${packageName}@${packageVersion}`);
+        }
+    });
+}
+function buildAndPublishPackage(packagePath, registry) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const packageJsonPath = path_1.default.join(packagePath, 'package.json');
+        if (!fs_1.default.existsSync(packageJsonPath)) {
+            throw new Error(`No package.json found in ${packagePath}`);
+        }
+        const packageJson = JSON.parse(fs_1.default.readFileSync(packageJsonPath, 'utf-8'));
+        const packageName = packageJson.name;
+        const packageVersion = packageJson.version;
+        // First, ensure dependencies are installed and build the package
+        yield buildPackage(packagePath);
+        // Set registry if provided
+        if (registry) {
+            console.log(`\nUsing npm registry: ${registry}`);
+            const setRegistryResult = (0, child_process_1.spawnSync)(NPM, ['config', 'set', 'registry', registry], {
+                cwd: packagePath,
+                stdio: 'inherit'
+            });
+            if (setRegistryResult.status !== 0) {
+                throw new Error('Failed to set npm registry');
+            }
+        }
+        // Check if user is logged in to npm
+        const whoamiResult = (0, child_process_1.spawnSync)(NPM, ['whoami'], {
+            cwd: packagePath,
+            encoding: 'utf-8'
+        });
+        if (whoamiResult.status !== 0) {
+            console.error('\nError: You must be logged in to npm to publish packages.');
+            console.error('Please run "npm login" first.');
+            throw new Error('Not logged in to npm');
+        }
+        console.log(`\nPublishing ${packageName}@${packageVersion} to npm...`);
+        // Publish the package
+        const publishResult = (0, child_process_1.spawnSync)(NPM, ['publish'], {
+            cwd: packagePath,
+            stdio: 'inherit'
+        });
+        if (publishResult.status !== 0) {
+            throw new Error('Publish failed');
+        }
+        console.log(`\n✅ Successfully published ${packageName}@${packageVersion}`);
+        // Reset registry to default if it was changed
+        if (registry) {
+            (0, child_process_1.spawnSync)(NPM, ['config', 'delete', 'registry'], {
+                cwd: packagePath
+            });
+        }
+    });
+}