neo-cmp-cli 1.8.7 → 1.8.8

package/dist/utils/projectUtils/createCmpProjectZip.js

@@ -0,0 +1,141 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const require$$0 = require('fs-extra');
+const require$$1 = require('node:path');
+const require$$2 = require('adm-zip');
+const require$$2$1 = require('lodash');
+const neoParams = require('../neoParams.js');
+const hasNeoProject = require('./hasNeoProject.js');
+
+var createCmpProjectZip;
+var hasRequiredCreateCmpProjectZip;
+
+function requireCreateCmpProjectZip () {
+	if (hasRequiredCreateCmpProjectZip) return createCmpProjectZip;
+	hasRequiredCreateCmpProjectZip = 1;
+	const fs = require$$0;
+	const path = require$$1;
+	const AdmZip = require$$2;
+	const _ = require$$2$1;
+	const { consoleTag } = neoParams.__require(); // 输出标记
+	const hasNeoProject$1 = hasNeoProject.__require();
+
+	/**
+	 * 创建自定义组件源码 zip 包
+	 * @param {*} cmpType 自定义组件名称
+	 * @returns {string} zip 文件路径
+	 */
+	createCmpProjectZip = function (cmpType, _projectPath, assetsRoot) {
+	  const projectRoot = _projectPath || process.cwd();
+	  const finalAssetsRoot = assetsRoot || path.join(projectRoot, 'dist');
+
+	  if (!hasNeoProject$1(_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;
+	};
+	return createCmpProjectZip;
+}
+
+exports.__require = requireCreateCmpProjectZip;

package/dist/utils/projectUtils/getEntries.js

@@ -0,0 +1,99 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const require$$0 = require('node:fs');
+const require$$1 = require('node:path');
+const require$$2 = require('lodash');
+const pathUtils = require('../pathUtils.js');
+
+var getEntries;
+var hasRequiredGetEntries;
+
+function requireGetEntries () {
+	if (hasRequiredGetEntries) return getEntries;
+	hasRequiredGetEntries = 1;
+	const fs = require$$0;
+	const path = require$$1;
+	const _ = require$$2;
+	const { resolveToCurrentRoot } = pathUtils.__require();
+
+	/**
+	 * 从指定目录获取组件入口文件
+	 * @param {*} defaultComponentsDir 默认组件目录
+	 * @returns 组件入口文件
+	 */
+	getEntries = (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
+	  };
+	};
+	return getEntries;
+}
+
+exports.__require = requireGetEntries;

package/dist/utils/projectUtils/getEntriesWithAutoRegister.js

@@ -0,0 +1,129 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const require$$0 = require('node:fs');
+const require$$1 = require('node:path');
+const require$$2 = require('lodash');
+const pathUtils = require('../pathUtils.js');
+const getCmpRegisterCode = require('../cmpUtils/getCmpRegisterCode.js');
+const getCmpModelRegisterCode = require('../cmpUtils/getCmpModelRegisterCode.js');
+
+var getEntriesWithAutoRegister;
+var hasRequiredGetEntriesWithAutoRegister;
+
+function requireGetEntriesWithAutoRegister () {
+	if (hasRequiredGetEntriesWithAutoRegister) return getEntriesWithAutoRegister;
+	hasRequiredGetEntriesWithAutoRegister = 1;
+	const fs = require$$0;
+	const path = require$$1;
+	const _ = require$$2;
+	const { resolveToCurrentRoot } = pathUtils.__require();
+	const getCmpRegisterCode$1 = getCmpRegisterCode.__require();
+	const getCmpModelRegisterCode$1 = getCmpModelRegisterCode.__require();
+	/**
+	 * 从指定目录获取组件入口文件，并自动创建对应的注册文件
+	 * @param {*} defaultComponentsDir 默认组件目录
+	 * @returns 组件入口文件
+	 */
+	getEntriesWithAutoRegister = (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$1(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$1(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
+	  };
+	};
+	return getEntriesWithAutoRegister;
+}
+
+exports.__require = requireGetEntriesWithAutoRegister;

package/dist/utils/projectUtils/hasNeoProject.js

@@ -0,0 +1,34 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const require$$0 = require('fs-extra');
+const require$$1 = require('node:path');
+
+var hasNeoProject;
+var hasRequiredHasNeoProject;
+
+function requireHasNeoProject () {
+	if (hasRequiredHasNeoProject) return hasNeoProject;
+	hasRequiredHasNeoProject = 1;
+	const fs = require$$0;
+	const path = require$$1;
+
+	/**
+	 * 判断当前是否存在 自定义组件项目
+	 * 备注：neo.config.js 和 package.json 必须同时存在才算作 自定义组件项目
+	 */
+	hasNeoProject = 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;
+	};
+	return hasNeoProject;
+}
+
+exports.__require = requireHasNeoProject;

package/dist/utils/projectUtils/openProject.js

@@ -0,0 +1,117 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const require$$1 = require('node:path');
+const require$$0 = require('node:fs');
+const require$$2 = require('open');
+const require$$3 = require('ora');
+const neoParams = require('../neoParams.js');
+const common = require('../common.js');
+
+var openProject_1;
+var hasRequiredOpenProject;
+
+function requireOpenProject () {
+	if (hasRequiredOpenProject) return openProject_1;
+	hasRequiredOpenProject = 1;
+	const path = require$$1;
+	const fs = require$$0;
+	const open = require$$2;
+	const ora = require$$3;
+	const { consoleTag } = neoParams.__require();
+	const { errorLog } = common.__require();
+
+	/**
+	 * 打开自定义组件项目
+	 */
+	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);
+	};
+
+	openProject_1 = openProject;
+	return openProject_1;
+}
+
+exports.__require = requireOpenProject;

package/dist/utils/projectUtils/updatePublishLog.js

@@ -0,0 +1,47 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const require$$0 = require('node:fs');
+require('lodash');
+const pathUtils = require('../pathUtils.js');
+
+var updatePublishLog;
+var hasRequiredUpdatePublishLog;
+
+function requireUpdatePublishLog () {
+	if (hasRequiredUpdatePublishLog) return updatePublishLog;
+	hasRequiredUpdatePublishLog = 1;
+	const fs = require$$0;
+	const { resolveToCurrentRoot } = pathUtils.__require();
+	/**
+	 * 更新发布日志
+	 */
+	updatePublishLog = 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));
+	};
+	return updatePublishLog;
+}
+
+exports.__require = requireUpdatePublishLog;

package/dist/utils/replaceInFilesByMap.js

@@ -0,0 +1,71 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const require$$0 = require('fs-extra');
+const require$$1 = require('node:path');
+
+var replaceInFilesByMap_1;
+var hasRequiredReplaceInFilesByMap;
+
+function requireReplaceInFilesByMap () {
+	if (hasRequiredReplaceInFilesByMap) return replaceInFilesByMap_1;
+	hasRequiredReplaceInFilesByMap = 1;
+	const fs = require$$0;
+	const path = require$$1;
+
+	/**
+	 * 全局替换项目中的指定字符串
+	 * @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);
+	  }
+	}
+
+	replaceInFilesByMap_1 = replaceInFilesByMap;
+	return replaceInFilesByMap_1;
+}
+
+exports.__require = requireReplaceInFilesByMap;