neo-cmp-cli 1.8.6-beta.6 → 1.8.7

package/src/utils/projectUtils/createCmpProjectZip.js

@@ -0,0 +1,120 @@
+const fs = require('fs-extra');
+const path = require('path');
+const AdmZip = require('adm-zip');
+const _ = require('lodash');
+const { consoleTag } = require('../neoParams'); // 输出标记
+const hasNeoProject = require('./hasNeoProject');
+
+/**
+ * 创建自定义组件源码 zip 包
+ * @param {*} cmpType 自定义组件名称
+ * @returns {string} zip 文件路径
+ */
+module.exports = function (cmpType, _projectPath, assetsRoot) {
+  const projectRoot = _projectPath || process.cwd();
+  const finalAssetsRoot = assetsRoot || path.join(projectRoot, 'dist');
+
+  if (!hasNeoProject(_projectPath)) {
+    console.error(`${consoleTag}当前目录不是自定义组件项目，请在自定义组件项目目录下执行。`);
+    process.exit(1);
+  }
+
+  if (!cmpType) {
+    console.error(`${consoleTag}自定义组件名称不能为空`);
+    process.exit(1);
+  }
+
+  const zip = new AdmZip();
+
+  // 需要排除的目录和文件
+  const excludeDirs = ['node_modules', '.neo-cli', 'dist'];
+  const excludeFiles = ['.eslintcache', 'auth.config.js'];
+
+  /**
+   * 判断文件/目录是否应该被排除
+   * @param {string} filePath 文件路径
+   * @param {string} relativePath 相对路径
+   * @returns {boolean} 是否应该排除
+   */
+  const shouldExclude = (filePath, relativePath) => {
+    const name = path.basename(filePath);
+    const stat = fs.statSync(filePath);
+
+    // 排除指定的目录
+    if (stat.isDirectory() && excludeDirs.includes(name)) {
+      return true;
+    }
+
+    // 排除指定的文件
+    if (stat.isFile() && excludeFiles.includes(name)) {
+      return true;
+    }
+
+    // 对于 src/components 目录，只包含 cmpType 子目录
+    // 处理逻辑：如果路径是 src/components/xxx，且 xxx 不是 cmpType，则排除
+    if (relativePath.startsWith('src/components')) {
+      const relativeToComponents = path.relative('src/components', relativePath);
+      // 如果相对路径不为空，说明已经在 components 的子目录中
+      if (relativeToComponents && relativeToComponents !== '.') {
+        const firstPart = relativeToComponents.split(path.sep)[0];
+        // 如果第一个部分不是 cmpType，则排除
+        if (firstPart !== cmpType) {
+          return true;
+        }
+      }
+    }
+
+    return false;
+  };
+
+  /**
+   * 递归遍历目录并添加到 zip
+   * @param {string} dirPath 目录路径
+   * @param {string} relativePath 相对路径（用于 zip 中的路径）
+   */
+  const addDirectoryToZip = (dirPath, relativePath = '') => {
+    try {
+      const items = fs.readdirSync(dirPath);
+
+      items.forEach((item) => {
+        const itemPath = path.join(dirPath, item);
+        const itemRelativePath = relativePath ? path.join(relativePath, item) : item;
+
+        // 检查是否应该排除
+        if (shouldExclude(itemPath, itemRelativePath)) {
+          return;
+        }
+
+        const stat = fs.statSync(itemPath);
+
+        if (stat.isDirectory()) {
+          // 递归处理子目录
+          addDirectoryToZip(itemPath, itemRelativePath);
+        } else if (stat.isFile()) {
+          // 添加文件到 zip，保持相对路径结构
+          const fileContent = fs.readFileSync(itemPath);
+          zip.addFile(itemRelativePath, fileContent);
+        }
+      });
+    } catch (error) {
+      console.error(`${consoleTag}遍历目录失败 (${dirPath}):`, error.message);
+    }
+  };
+
+  // 开始遍历项目根目录
+  addDirectoryToZip(projectRoot);
+
+  // 生成 zip 文件名
+  const zipFileName = `${_.camelCase(cmpType)}Source.zip`;
+  const zipPath = path.join(finalAssetsRoot, zipFileName);
+
+  // 如果已存在同名 zip 文件，先删除
+  if (fs.existsSync(zipPath)) {
+    fs.removeSync(zipPath);
+  }
+
+  // 写入 zip 文件
+  zip.writeZip(zipPath);
+
+  return zipPath;
+};

package/src/utils/projectUtils/getEntries.js

@@ -0,0 +1,80 @@
+const fs = require('fs');
+const path = require('path');
+const _ = require('lodash');
+const { resolveToCurrentRoot } = require('../pathUtils');
+
+/**
+ * 从指定目录获取组件入口文件
+ * @param {*} defaultComponentsDir 默认组件目录
+ * @returns 组件入口文件
+ */
+module.exports = (defaultComponentsDir = './src/components', cmpType) => {
+  const widgetEntries = {};
+  const linkDebugEntries = {
+    index: []
+  };
+  const cmpTypes = []; // 用于记录组件名称
+  const defaultExports = {}; // 用于记录默认导出
+  const componentsBaseDir = resolveToCurrentRoot(defaultComponentsDir);
+  if (!fs.existsSync(componentsBaseDir)) {
+    console.error(`未找到组件目录，请检查 ${defaultComponentsDir} 目录是否存在`);
+
+    // 退出进程
+    process.exit(1);
+  }
+
+  try {
+    // 读取指定目录下的所有文件
+    let widgetDirs = [];
+    if (cmpType) {
+      // 如果传入了 cmpType，则只读取指定组件目录
+      widgetDirs = [cmpType];
+    } else {
+      widgetDirs = fs.readdirSync(componentsBaseDir);
+    }
+
+    // 遍历所有目录
+    widgetDirs.forEach((dir) => {
+      const filePath = path.join(componentsBaseDir, dir);
+      // 获取文件状态
+      const stat = fs.statSync(filePath);
+      // 如果文件是目录，则递归处理子目录
+      if (stat.isDirectory() && !dir.startsWith('.') && dir !== 'node_modules') {
+        const curCmpPath = path.join(componentsBaseDir, dir);
+        const curCmpName = dir; // _.camelCase(dir);
+        const cmpNameKey = _.camelCase(curCmpName);
+
+        // 记录组件类型
+        cmpTypes.push(curCmpName);
+
+        fs.readdirSync(curCmpPath)
+          .filter((file) => file.match(/[index|register|model]\.(tsx?|jsx?|vue)$/))
+          .map((file) => path.join(defaultComponentsDir, curCmpName, file))
+          .forEach((filePath) => {
+            const curPath = `./${filePath}`;
+            if (filePath.match(/register\.[tj]sx?$/)) {
+              widgetEntries[cmpNameKey] = curPath;
+            } else if (filePath.match(/model\.[tj]sx?$/)) {
+              widgetEntries[`${cmpNameKey}Model`] = curPath;
+            } else if (filePath.match(/index\.(tsx?|jsx?|vue)$/)) {
+              // 组件内容文件
+              defaultExports[cmpNameKey] = path.resolve(filePath); // 记录默认导出
+            }
+            linkDebugEntries.index.push(curPath);
+          });
+      }
+    });
+  } catch (error) {
+    console.error('获取自定义组件入口文件失败（getEntries）:', error);
+
+    // 退出进程
+    process.exit(1);
+  }
+
+  return {
+    widgetEntries,
+    linkDebugEntries,
+    cmpTypes,
+    defaultExports
+  };
+};

package/src/utils/projectUtils/getEntriesWithAutoRegister.js

@@ -0,0 +1,108 @@
+const fs = require('fs');
+const path = require('path');
+const _ = require('lodash');
+const { resolveToCurrentRoot } = require('../pathUtils');
+const getCmpRegisterCode = require('../cmpUtils/getCmpRegisterCode');
+const getCmpModelRegisterCode = require('../cmpUtils/getCmpModelRegisterCode');
+/**
+ * 从指定目录获取组件入口文件，并自动创建对应的注册文件
+ * @param {*} defaultComponentsDir 默认组件目录
+ * @returns 组件入口文件
+ */
+module.exports = (defaultComponentsDir = './src/components', cmpType) => {
+  const widgetEntries = {};
+  const linkDebugEntries = {
+    index: []
+  };
+  const cmpTypes = []; // 用于记录组件名称
+  const defaultExports = {}; // 用于记录默认导出
+  const componentsBaseDir = resolveToCurrentRoot(defaultComponentsDir);
+  if (!fs.existsSync(componentsBaseDir)) {
+    console.error(`未找到组件目录，请检查 ${defaultComponentsDir} 目录是否存在`);
+
+    // 退出进程
+    process.exit(1);
+  }
+
+  // 创建存放 cli 的临时目录
+  const cliTempDir = resolveToCurrentRoot('./.neo-cli');
+  if (!fs.existsSync(cliTempDir)) {
+    fs.mkdirSync(cliTempDir);
+  }
+
+  try {
+    // 读取指定目录下的所有文件
+    let widgetDirs = [];
+    if (cmpType) {
+      // 如果传入了 cmpType，则只读取指定组件目录
+      widgetDirs = [cmpType];
+    } else {
+      widgetDirs = fs.readdirSync(componentsBaseDir);
+    }
+
+    // 遍历所有目录
+    widgetDirs.forEach((dir) => {
+      // 当前自定义组件目录
+      const widgetPath = path.join(componentsBaseDir, dir);
+      // 获取文件状态
+      const stat = fs.statSync(widgetPath);
+      // 如果文件是目录，则递归处理子目录
+      if (stat.isDirectory() && !dir.startsWith('.') && dir !== 'node_modules') {
+        // 当前自定义组件名称
+        const curCmpName = dir; // _.camelCase(dir);
+        const cmpNameKey = _.camelCase(curCmpName);
+
+        // 记录组件类型
+        cmpTypes.push(curCmpName);
+
+        // 当前自定义组件临时目录
+        const cmpTempDir = `${cliTempDir}/${curCmpName}`;
+        if (!fs.existsSync(cmpTempDir)) {
+          fs.mkdirSync(cmpTempDir);
+        }
+
+        fs.readdirSync(widgetPath)
+          .filter((file) => file.match(/(index|model)\.(tsx?|jsx?|vue)$/))
+          .map((file) => path.join(defaultComponentsDir, curCmpName, file))
+          .forEach((filePath) => {
+            if (filePath.match(/index\.(tsx?|jsx?|vue)$/)) {
+              // 记录默认导出
+              defaultExports[cmpNameKey] = path.resolve(filePath);
+
+              // 自动创建对应的注册文件
+              const registerContent = getCmpRegisterCode(componentsBaseDir, curCmpName);
+              const registerDir = `${cmpTempDir}/register.js`;
+
+              // 写入注册文件
+              fs.writeFileSync(registerDir, registerContent);
+
+              widgetEntries[cmpNameKey] = registerDir;
+              linkDebugEntries.index.push(registerDir);
+            } else if (filePath.match(/model\.[tj]sx?$/)) {
+              // 自动创建对应的模型注册文件
+              const modelRegisterContent = getCmpModelRegisterCode(componentsBaseDir, curCmpName);
+              const modelRegisterDir = `${cmpTempDir}/model.js`;
+
+              // 写入模型注册文件
+              fs.writeFileSync(modelRegisterDir, modelRegisterContent);
+
+              widgetEntries[`${cmpNameKey}Model`] = modelRegisterDir;
+              linkDebugEntries.index.push(modelRegisterDir);
+            }
+          });
+      }
+    });
+  } catch (error) {
+    console.error('获取自定义组件入口文件失败（getEntriesWithAutoRegister）:', error);
+
+    // 退出进程
+    process.exit(1);
+  }
+
+  return {
+    widgetEntries,
+    linkDebugEntries,
+    cmpTypes,
+    defaultExports
+  };
+};

package/src/utils/projectUtils/hasNeoProject.js

@@ -0,0 +1,17 @@
+const fs = require('fs-extra');
+const path = require('path');
+
+/**
+ * 判断当前是否存在 自定义组件项目
+ * 备注：neo.config.js 和 package.json 必须同时存在才算作 自定义组件项目
+ */
+module.exports = function (_projectPath) {
+  const projectPath = _projectPath || process.cwd();
+  const neoConfigPath = path.resolve(projectPath, 'neo.config.js');
+  const packagePath = path.resolve(projectPath, 'package.json');
+
+  if (fs.existsSync(neoConfigPath) && fs.existsSync(packagePath)) {
+    return true;
+  }
+  return false;
+};

package/src/utils/projectUtils/openProject.js

@@ -0,0 +1,96 @@
+const path = require('path');
+const fs = require('fs');
+const open = require('open');
+const ora = require('ora');
+const { consoleTag } = require('../neoParams');
+const { errorLog } = require('../common');
+
+/**
+ * 打开自定义组件项目
+ */
+const openProject = async function (editorType, targetPath) {
+  const targetDir = targetPath ? path.resolve(targetPath) : process.cwd();
+
+  // 检查目录是否存在
+  if (!fs.existsSync(targetDir)) {
+    errorLog(`目录不存在: ${targetDir}`);
+    process.exit(1);
+  }
+
+  // 检查是否为目录
+  const stats = fs.statSync(targetDir);
+  if (!stats.isDirectory()) {
+    errorLog(`路径不是目录: ${targetDir}`);
+    process.exit(1);
+  }
+
+  const isMac = process.platform === 'darwin';
+  const isWindows = process.platform === 'win32';
+  const isLinux = process.platform === 'linux';
+
+  // 构建编辑器配置列表（按优先级排序）
+  let editorConfigs = [];
+  let editorName = '编辑器';
+
+  // 根据编辑器类型和平台构建配置列表
+  if (editorType === 'cursor') {
+    editorName = 'Cursor';
+    // macOS 可以使用应用名称或命令名称
+    if (isMac) {
+      editorConfigs = [{ app: { name: 'cursor' } }, { app: { name: 'Cursor' } }];
+    } else if (isWindows || isLinux) {
+      editorConfigs = [{ app: { name: 'cursor' } }];
+    }
+  } else if (editorType === 'vscode' || editorType === 'code') {
+    editorName = 'Visual Studio Code';
+    if (isMac) {
+      editorConfigs = [{ app: { name: 'code' } }, { app: { name: 'Visual Studio Code' } }];
+    } else if (isWindows || isLinux) {
+      editorConfigs = [{ app: { name: 'code' } }];
+    }
+  } else {
+    // 自动检测：优先尝试 Cursor，如果失败则尝试 VSCode
+    if (isMac) {
+      editorConfigs = [
+        { app: { name: 'cursor' } },
+        { app: { name: 'Cursor' } },
+        { app: { name: 'code' } },
+        { app: { name: 'Visual Studio Code' } }
+      ];
+    } else if (isWindows || isLinux) {
+      editorConfigs = [{ app: { name: 'cursor' } }, { app: { name: 'code' } }];
+    }
+  }
+
+  if (editorConfigs.length === 0) {
+    errorLog(`不支持的操作系统: ${process.platform}`);
+    process.exit(1);
+  }
+
+  const spinner = ora(`${consoleTag}正在尝试使用 ${editorName} 打开项目: ${targetDir}`).start();
+
+  // 尝试打开编辑器
+  const tryOpenEditor = async (index) => {
+    if (index >= editorConfigs.length) {
+      errorLog(
+        `无法打开编辑器，已尝试所有可用方式。\n 请确保已安装 Cursor 或 Visual Studio Code 并将其添加到系统 PATH 中。`,
+        spinner
+      );
+      process.exit(1);
+    }
+
+    const config = editorConfigs[index];
+    try {
+      await open(targetDir, config);
+      spinner.stop();
+      // 成功打开，不需要继续尝试
+    } catch (error) {
+      // 如果当前配置失败，尝试下一个
+      await tryOpenEditor(index + 1);
+    }
+  };
+
+  await tryOpenEditor(0);
+};
+
+module.exports = openProject;

package/src/utils/projectUtils/updatePublishLog.js

@@ -0,0 +1,30 @@
+const fs = require('fs');
+const _ = require('lodash');
+const { resolveToCurrentRoot } = require('../pathUtils');
+/**
+ * 更新发布日志
+ */
+module.exports = function (curHistoryData) {
+  // 创建存放 cli 的临时目录
+  const cliTempDir = resolveToCurrentRoot('./.neo-cli');
+  if (!fs.existsSync(cliTempDir)) {
+    fs.mkdirSync(cliTempDir);
+  }
+
+  const historyFile = `${cliTempDir}/history.json`;
+  let historyData = {};
+  if (fs.existsSync(historyFile)) {
+    // 读取历史文件
+    try {
+      historyData = JSON.parse(fs.readFileSync(historyFile, 'utf8'));
+    } catch (error) {
+      console.error('读取历史文件失败:', error);
+      historyData = {};
+    }
+  }
+  const historyKey = new Date().toString();
+  historyData[historyKey] = curHistoryData;
+
+  // 更新历史文件
+  fs.writeFileSync(historyFile, JSON.stringify(historyData, null, 2));
+};

package/src/utils/replaceInFiles.js

@@ -0,0 +1,47 @@
+const fs = require('fs-extra');
+const path = require('path');
+
+/**
+ * 全局替换项目中的指定字符串
+ * @param dir 项目目录
+ * @param oldStr 旧字符串
+ * @param newStr 新字符串
+ * @param fileExtensions 文件扩展名
+ */
+function replaceInFiles(
+  dir,
+  oldStr,
+  newStr,
+  fileExtensions = ['.js', '.jsx', '.ts', '.tsx', '.vue', '.html', '.css', '.scss', '.json']
+) {
+  try {
+    // 读取指定目录下的所有文件
+    const files = fs.readdirSync(dir);
+
+    // 遍历所有文件
+    files.forEach((file) => {
+      const filePath = path.join(dir, file);
+      // 获取文件状态
+      const stat = fs.statSync(filePath);
+      // 如果文件是目录，则递归处理子目录
+      if (stat.isDirectory() && !file.startsWith('.') && file !== 'node_modules') {
+        // 递归处理子目录
+        replaceInFiles(filePath, oldStr, newStr, fileExtensions);
+      } else if (stat.isFile()) {
+        // 检查文件扩展名
+        const ext = path.extname(file);
+        if (fileExtensions.includes(ext)) {
+          let content = fs.readFileSync(filePath, 'utf8');
+          if (content.includes(oldStr)) {
+            content = content.replace(new RegExp(oldStr, 'g'), newStr); // 全局替换
+            fs.writeFileSync(filePath, content, 'utf8');
+          }
+        }
+      }
+    });
+  } catch (error) {
+    console.error('replaceInFiles 运行失败:', error);
+  }
+}
+
+module.exports = replaceInFiles;

package/src/utils/replaceInFilesByMap.js

@@ -0,0 +1,54 @@
+const fs = require('fs-extra');
+const path = require('path');
+
+/**
+ * 全局替换项目中的指定字符串
+ * @param dir 项目目录
+ * @param needReplaceStrMap {
+ *  [oldStr]: newStr
+ * }
+ * @param fileExtensions 文件扩展名
+ */
+function replaceInFilesByMap(
+  dir,
+  needReplaceStrMap = {},
+  fileExtensions = ['.js', '.jsx', '.ts', '.tsx', '.vue', '.html', '.css', '.scss', '.json']
+) {
+  try {
+    // 读取指定目录下的所有文件
+    const files = fs.readdirSync(dir);
+
+    // 遍历所有文件
+    files.forEach((file) => {
+      const filePath = path.join(dir, file);
+      // 获取文件状态
+      const stat = fs.statSync(filePath);
+      // 如果文件是目录，则递归处理子目录
+      if (stat.isDirectory() && !file.startsWith('.') && file !== 'node_modules') {
+        // 递归处理子目录
+        replaceInFilesByMap(filePath, needReplaceStrMap, fileExtensions);
+      } else if (stat.isFile()) {
+        // 检查文件扩展名
+        const ext = path.extname(file);
+        if (fileExtensions.includes(ext)) {
+          if (needReplaceStrMap &&Object.keys(needReplaceStrMap).length > 0) {
+            let content = fs.readFileSync(filePath, 'utf8');
+            Object.keys(needReplaceStrMap).forEach((key) => {
+              const oldStr = key;
+              const newStr = needReplaceStrMap[key];
+              if (content.includes(oldStr)) {
+                content = content.replace(new RegExp(oldStr, 'g'), newStr); // 全局替换
+              }
+            });
+            // 写入文件（更新文件内容）
+            fs.writeFileSync(filePath, content, 'utf8');
+          }
+        }
+      }
+    });
+  } catch (error) {
+    console.error('replaceInFiles 运行失败:', error);
+  }
+}
+
+module.exports = replaceInFilesByMap;

package/src/utils/replaceInPackage.js

@@ -0,0 +1,134 @@
+const fs = require('fs-extra');
+const path = require('path');
+
+/**
+ * package.json文件中替换指定字符串
+ * @param dir 项目目录
+ * @param oldStr 旧字符串
+ * @param newStr 新字符串
+ * @returns 替换结果对象: { success: boolean, message: string, filePath?: string, replaced?: boolean }
+ */
+function replaceInPackage(dir, oldStr, newStr) {
+  try {
+    // 检查目录是否存在
+    if (!fs.existsSync(dir)) {
+      return {
+        success: false,
+        message: `目录不存在: ${dir}`
+      };
+    }
+
+    // 检查是否为目录
+    const stat = fs.statSync(dir);
+    if (!stat.isDirectory()) {
+      return {
+        success: false,
+        message: `指定路径不是目录: ${dir}`
+      };
+    }
+
+    // 构建package.json的完整路径
+    const packageJsonPath = path.join(dir, 'package.json');
+
+    // 检查package.json文件是否存在
+    if (!fs.existsSync(packageJsonPath)) {
+      return {
+        success: false,
+        message: `package.json文件不存在: ${packageJsonPath}`
+      };
+    }
+
+    // 读取package.json文件内容
+    let content = fs.readFileSync(packageJsonPath, 'utf8');
+
+    // 检查是否包含要替换的字符串
+    if (!content.includes(oldStr)) {
+      return {
+        success: true,
+        message: `package.json中未找到要替换的字符串: ${oldStr}`,
+        filePath: packageJsonPath,
+        replaced: false
+      };
+    }
+
+    // 执行全局替换
+    const newContent = content.replace(new RegExp(oldStr, 'g'), newStr);
+
+    // 检查是否有实际变化
+    if (content === newContent) {
+      return {
+        success: true,
+        message: '替换后内容无变化',
+        filePath: packageJsonPath,
+        replaced: false
+      };
+    }
+
+    // 写入替换后的内容
+    fs.writeFileSync(packageJsonPath, newContent, 'utf8');
+
+    // 统计替换次数
+    const matches = content.match(new RegExp(oldStr, 'g'));
+    const replaceCount = matches ? matches.length : 0;
+
+    return {
+      success: true,
+      message: `成功替换 ${replaceCount} 处字符串`,
+      filePath: packageJsonPath,
+      replaced: true
+    };
+  } catch (error) {
+    return {
+      success: false,
+      message: `replaceInPackage 运行失败: ${error.message}`
+    };
+  }
+}
+
+/**
+ * 批量替换多个目录中的package.json文件
+ * @param dirs 目录数组
+ * @param oldStr 旧字符串
+ * @param newStr 新字符串
+ * @returns 批量替换结果
+ */
+function replaceInMultiplePackages(dirs, oldStr, newStr) {
+  const results = dirs.map((dir) => ({
+    dir,
+    result: replaceInPackage(dir, oldStr, newStr)
+  }));
+
+  const success = results.filter((r) => r.result.success).length;
+  const failed = results.length - success;
+
+  return {
+    total: dirs.length,
+    success,
+    failed,
+    results
+  };
+}
+
+/**
+ * 验证package.json文件格式是否正确
+ * @param filePath package.json文件路径
+ * @returns 验证结果: { valid: boolean, error?: string }
+ */
+function validatePackageJson(filePath) {
+  try {
+    const content = fs.readFileSync(filePath, 'utf8');
+    JSON.parse(content);
+    return { valid: true };
+  } catch (error) {
+    return {
+      valid: false,
+      error: `JSON格式错误: ${error.message}`
+    };
+  }
+}
+
+module.exports = {
+  replaceInPackage,
+  replaceInMultiplePackages,
+  validatePackageJson
+};