@blocklet/component-studio-cli 0.4.134

package/dist/commands/migrate.js

@@ -0,0 +1,177 @@
+import chalk from 'chalk';
+import { Command } from 'commander';
+import fetch from 'node-fetch';
+import { createWriteStream, mkdirSync, readdirSync, readFileSync, rmSync } from 'node:fs';
+import { join, relative } from 'node:path';
+import { pipeline } from 'node:stream/promises';
+import ora from 'ora';
+import os from 'os';
+import { x } from 'tar';
+import { findClosestMetadataDir, getProjectPath, isPackageInstalled, checkPackageReference, installMissingPackage, } from '../utils/helper';
+export function createMigrateCommand() {
+    return new Command('migrate')
+        .description('Migrate components from pages-kit project')
+        .argument('<url>', 'URL to migrate components from')
+        .option('--output-dir <dir>', 'Custom output directory for components')
+        .action(async (url, options) => {
+        const spinner = ora('Preparing to migrate components...').start();
+        const projectPath = getProjectPath();
+        try {
+            // 创建临时目录
+            const tempDir = join(os.tmpdir(), `component-studio-migrate-${new Date().getTime()}`);
+            const zipPath = join(tempDir, 'components.zip');
+            mkdirSync(tempDir, { recursive: true });
+            // 下载文件
+            spinner.text = 'Downloading migration package...';
+            try {
+                const response = await fetch(url);
+                if (!response.ok) {
+                    throw new Error(`${response.statusText} (${response.status})`);
+                }
+                // 检查响应类型
+                const contentType = response.headers.get('content-type') || '';
+                const isZip = contentType.includes('application/zip') || contentType.includes('application/x-zip');
+                if (!isZip) {
+                    throw new Error('Response is not a ZIP file');
+                }
+                // 保存ZIP文件
+                await pipeline(response.body, createWriteStream(zipPath));
+                spinner.succeed('Downloaded migration package successfully!');
+            }
+            catch (error) {
+                spinner.fail(`Download failed: ${error.message}`);
+                rmSync(tempDir, { recursive: true, force: true });
+                process.exit(1);
+            }
+            // 解压ZIP文件
+            spinner.start('Extracting components...');
+            const extractDir = join(tempDir, 'extracted');
+            mkdirSync(extractDir, { recursive: true });
+            try {
+                await x({ file: zipPath, cwd: extractDir });
+                spinner.succeed('Extracted migration package successfully!');
+            }
+            catch (error) {
+                spinner.fail(`Extract failed: ${error.message}`);
+                rmSync(tempDir, { recursive: true, force: true });
+                process.exit(1);
+            }
+            // 查找组件目录
+            let componentsSourceDir = extractDir;
+            const extractedFiles = readdirSync(extractDir);
+            // 如果有'components'目录，使用它
+            if (extractedFiles.includes('components')) {
+                componentsSourceDir = join(extractDir, 'components');
+            }
+            // 检查组件目录
+            const componentNames = readdirSync(componentsSourceDir);
+            if (componentNames.length === 0) {
+                spinner.fail('No components found in the migration package');
+                rmSync(tempDir, { recursive: true, force: true });
+                process.exit(1);
+            }
+            spinner.info(`Found ${componentNames.length} components: ${componentNames.join(', ')}`);
+            // 确定目标目录
+            let targetComponentsDir;
+            if (options.outputDir) {
+                targetComponentsDir = join(projectPath, options.outputDir);
+                mkdirSync(targetComponentsDir, { recursive: true });
+            }
+            else {
+                // 查找最近的组件目录
+                spinner.start('Detecting components directory...');
+                const closestDir = await findClosestMetadataDir(projectPath);
+                if (closestDir) {
+                    targetComponentsDir = closestDir;
+                    spinner.succeed(`Found components directory: ${chalk.cyan(relative(projectPath, targetComponentsDir))}`);
+                }
+                else {
+                    // 默认使用 src
+                    targetComponentsDir = join(projectPath, 'src');
+                    mkdirSync(targetComponentsDir, { recursive: true });
+                    spinner.info(`Using default components directory: ${chalk.cyan('src')}`);
+                }
+            }
+            // 导入组件
+            spinner.start('Importing components...');
+            let importCount = 0;
+            let skipCount = 0;
+            let hasPagesKitDep = false;
+            for (const componentName of componentNames) {
+                const sourceDir = join(componentsSourceDir, componentName);
+                const targetDir = join(targetComponentsDir, componentName);
+                // 检查目标目录是否已存在
+                try {
+                    readdirSync(targetDir);
+                    spinner.info(`Skipping existing component: ${componentName}`);
+                    skipCount++;
+                    continue;
+                }
+                catch (err) {
+                    // 目录不存在，可以导入
+                }
+                // 复制组件
+                try {
+                    const copyFiles = (source, target) => {
+                        mkdirSync(target, { recursive: true });
+                        for (const file of readdirSync(source)) {
+                            const sourcePath = join(source, file);
+                            const targetPath = join(target, file);
+                            // 检查是否是目录
+                            try {
+                                readdirSync(sourcePath);
+                                copyFiles(sourcePath, targetPath);
+                            }
+                            catch (err) {
+                                // 是文件，直接复制
+                                const content = readFileSync(sourcePath);
+                                require('fs').writeFileSync(targetPath, content);
+                                // 检查index.tsx文件是否引用了@blocklet/pages-kit
+                                if (file === 'index.tsx') {
+                                    if (checkPackageReference(targetPath, '@blocklet/pages-kit')) {
+                                        hasPagesKitDep = true;
+                                    }
+                                }
+                            }
+                        }
+                    };
+                    copyFiles(sourceDir, targetDir);
+                    importCount++;
+                }
+                catch (error) {
+                    spinner.warn(`Failed to import component ${componentName}: ${error.message}`);
+                }
+            }
+            // 检查和安装依赖
+            if (hasPagesKitDep && !isPackageInstalled('@blocklet/pages-kit', projectPath)) {
+                spinner.info('Detected `@blocklet/pages-kit` dependency in migrated components');
+                spinner.stop();
+                installMissingPackage('@blocklet/pages-kit', projectPath);
+                spinner.start('Installing `@blocklet/pages-kit` dependencies...');
+            }
+            // 清理临时文件
+            rmSync(tempDir, { recursive: true, force: true });
+            if (importCount > 0) {
+                spinner.succeed(`Successfully imported ${importCount} components to ${chalk.cyan(relative(projectPath, targetComponentsDir))}`);
+                if (skipCount > 0) {
+                    spinner.info(chalk.yellow(`Skipped ${skipCount} components that already exist`));
+                }
+                console.log(chalk.green('\n🎉 Components migrated successfully!'));
+                console.log(`\n💡 Next steps: Check the migrated components in your component studio`);
+            }
+            else {
+                spinner.fail('No components were imported');
+                if (skipCount > 0) {
+                    console.log(chalk.yellow(`All ${skipCount} components already exist in your project`));
+                }
+            }
+        }
+        catch (error) {
+            spinner.fail(`Migration failed: ${error.message}`);
+            console.error(error);
+            process.exit(1);
+        }
+    })
+        .showHelpAfterError(true)
+        .showSuggestionAfterError(true);
+}

package/dist/commands/update.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function createUpdateCommand(): Command;

package/dist/commands/update.js

@@ -0,0 +1,22 @@
+import { Command } from 'commander';
+import { installDependencies, getProjectPath, getWorkspacePath, installGlobalPackage } from '../utils/helper';
+export function createUpdateCommand() {
+    return new Command('update').description('Update cli and project dependencies').action(async () => {
+        const projectPath = getProjectPath();
+        const workspacePath = getWorkspacePath();
+        try {
+            await installGlobalPackage('@blocklet/component-studio-cli@latest');
+            const dirsToInstall = {};
+            dirsToInstall['Workspace'] = workspacePath;
+            dirsToInstall['Project'] = projectPath;
+            const result = await installDependencies(dirsToInstall, 'update');
+            if (!result) {
+                process.exit(1);
+            }
+        }
+        catch (error) {
+            console.error(error);
+            process.exit(1);
+        }
+    });
+}

package/dist/utils/display-logo.d.ts

@@ -0,0 +1,2 @@
+export declare const asciiLogo: string;
+export declare function displayLogo(): void;

package/dist/utils/display-logo.js

@@ -0,0 +1,24 @@
+import chalk from 'chalk';
+import gradient from 'gradient-string';
+import pkg from '../../package.json' with { type: 'json' };
+const modernGradient = gradient(['#4facfe', '#7367f0', '#f86aad']);
+const logo = `
+   ______                                             __     _____ __            ___     
+  / ____/___  ____ ___  ____  ____  ____  ___  ____  / /_   / ___// /___  ______/ (_)___ 
+ / /   / __ \\/ __ \`__ \\/ __ \\/ __ \\/ __ \\/ _ \\/ __ \\/ __/   \\__ \\/ __/ / / / __  / / __ \\
+/ /___/ /_/ / / / / / / /_/ / /_/ / / / /  __/ / / / /_    ___/ / /_/ /_/ / /_/ / / /_/ /
+\\____/\\____/_/ /_/ /_/ .___/\\____/_/ /_/\\___/_/ /_/\\__/   /____/\\__/\\__,_/\\__,_/_/\\____/ 
+                    /_/                                                                  
+`;
+const frameworkInfo = `v${pkg.version}`;
+const logoLines = logo.split('\n');
+const maxLength = Math.max(...logoLines.filter((line) => line.trim()).map((line) => line.length));
+const versionText = frameworkInfo;
+const padding = Math.floor((maxLength - versionText.length) / 2);
+const centeredVersion = ' '.repeat(padding) + versionText;
+export const asciiLogo = `${modernGradient(logo)}\n${chalk.cyan(centeredVersion)}\n\n`;
+export function displayLogo() {
+    console.log(gradient(['#5383e8', '#22a5f7', '#00c2b8', '#56e39f']).multiline(logo));
+    console.log(chalk.cyan(centeredVersion));
+    console.log('');
+}

package/dist/utils/helper.d.ts

@@ -0,0 +1,97 @@
+export declare function getWorkspaceTemplatePath(): string;
+export declare function getWorkspacePath(): string;
+export declare function getProjectPath(): string;
+/**
+ * 复制模板文件，但排除某些特定文件
+ * @param sourcePath - 源模板路径
+ * @param targetPath - 目标项目路径
+ */
+export declare function copyTemplateFilesExcept(sourcePath: string, targetPath: string): Promise<void>;
+/**
+ * 合并基础 package.json 和模板的 package.json
+ * @param basePath - 基础包路径
+ * @param templatePath - 模板路径
+ */
+export declare function mergePackageJson(basePath: string, templatePath: string): Promise<void>;
+/**
+ * 在指定目录安装依赖
+ * @param dirs - 需要安装依赖的目录对象，key为目录描述，value为目录路径
+ * @returns 安装结果
+ */
+export declare function installDependencies(dirs: Record<string, string>, operation?: 'update' | 'install'): Promise<boolean>;
+/**
+ * 模板接口定义
+ */
+export interface Template {
+    key: string;
+    name: string;
+    description: string;
+}
+/**
+ * 从模板目录读取所有可用模板
+ * @param templatesDir - 模板目录路径，默认为 templates/init
+ * @returns 可用模板数组
+ */
+export declare function loadTemplates(templatesDir: string): Template[];
+/**
+ * 交互式选择模板，支持模板分组
+ * @param templates - 模板数组
+ * @param defaultTemplate - 可选的默认模板键名
+ * @returns Promise<string> 选择的模板键名
+ */
+export declare function selectTemplate(templates: Template[], defaultTemplate?: string, groupByDir?: boolean): Promise<string>;
+/**
+ * 验证所选模板是否存在
+ * @param templateKey - 模板键名
+ * @param templates - 模板数组
+ * @returns 选中的模板或null
+ */
+export declare function validateTemplate(templateKey: string, templates: Template[]): Template | null;
+/**
+ * 获取模板路径
+ * @param templateKey - 模板键名
+ * @param templatesBaseDir - 模板基础目录，默认为 templates/init
+ * @returns 模板完整路径
+ */
+export declare function getTemplatePath(templateKey: string, templatesBaseDir: string): string;
+/**
+ * 在文件中批量替换占位符
+ * @param filePath - 文件路径
+ * @param replacements - 替换对象，键为占位符，值为替换内容
+ */
+export declare function replaceInFile(filePath: string, replacements: Record<string, string>): Promise<void>;
+/**
+ * 在目录中递归替换所有文件中的占位符
+ * @param dirPath - 目录路径
+ * @param replacements - 替换对象，键为占位符，值为替换内容
+ */
+export declare function replaceInDirectory(dirPath: string, replacements: Record<string, string>): Promise<void>;
+/**
+ * 查找最接近指定目录的包含@metadata.json的目录
+ * @param startDir - 起始目录
+ * @returns 找到的最近目录或null
+ */
+export declare function findClosestMetadataDir(startDir: string): Promise<string | null>;
+/**
+ * 检查目标目录是否存在，如存在则询问是否覆盖
+ * @param targetDir - 目标目录路径
+ * @param itemType - 项目类型名称 (如 'component', 'tool')
+ * @param targetBaseDir - 基础目录路径（用于显示相对路径）
+ * @returns 是否可以继续操作（不存在或用户同意覆盖）
+ */
+export declare function checkTargetDirectoryExists(targetDir: string, targetBaseDir: string): Promise<boolean>;
+export declare function isPackageInstalled(packageName: string, projectPath: string): boolean;
+export declare function checkPackageReference(filePath: string, packageName: string): boolean;
+export declare function installMissingPackage(packageName: string, projectPath: string): boolean;
+/**
+ * 检查系统中是否存在指定命令
+ * @param command - 要检查的命令名称
+ * @returns 命令是否存在
+ */
+export declare function isCommandAvailable(command: string): boolean;
+/**
+ * 安装全局NPM包
+ * @param packageName - 要安装的包名
+ * @returns 安装是否成功
+ */
+export declare function installGlobalPackage(packageName: string): Promise<boolean>;