neo-cmp-cli 1.8.7 → 1.8.8

package/src/plugins/README.md

@@ -1,109 +0,0 @@
-# AddNeoRequirePlugin 使用说明
-
-## 概述
-
-`AddNeoRequirePlugin` 是一个 webpack 插件，用于在构建过程中自动为 JavaScript 文件注入 `neoRequire` 包装代码，实现与 Neo 平台的依赖共享。
-
-## 使用方法
-
-### 基本使用
-
-```javascript
-const AddNeoRequirePlugin = require('./AddNeoRequirePlugin');
-
-module.exports = {
-  // ... 其他配置
-  plugins: [
-    new AddNeoRequirePlugin()
-  ]
-};
-```
-
-### 高级配置
-
-```javascript
-const AddNeoRequirePlugin = require('./AddNeoRequirePlugin');
-
-module.exports = {
-  // ... 其他配置
-  plugins: [
-    new AddNeoRequirePlugin({
-      // 启用详细日志
-      verbose: true,
-      
-      // 跳过已注入的文件（默认: true）
-      skipInjected: true,
-      
-      // 需要跳过的文件扩展名
-      skipExtensions: ['.css', '.map', '.txt', '.html', '.svg'],
-      
-      // 需要跳过的文件名模式（正则表达式）
-      skipPatterns: [
-        /\.map$/,
-        /\.LICENSE\.txt$/,
-        /\.html$/,
-        /vendor\./,
-        /chunk\./
-      ]
-    })
-  ]
-};
-```
-
-## 配置选项
-
-| 选项 | 类型 | 默认值 | 说明 |
-|------|------|--------|------|
-| `verbose` | boolean | false | 是否启用详细日志输出 |
-| `skipInjected` | boolean | true | 是否跳过已经注入过的文件 |
-| `skipExtensions` | string[] | ['.css', '.map', '.txt', '.html'] | 需要跳过的文件扩展名列表 |
-| `skipPatterns` | RegExp[] | [/\.map$/, /\.LICENSE\.txt$/, /\.html$/] | 需要跳过的文件名模式 |
-
-## 注入的代码结构
-
-插件会为每个 JavaScript 文件添加以下包装代码：
-
-```javascript
-(function(NeoCustomCmpFileFactory) {
-  if (!window.neoRequire) {
-    throw new Error('neoRequire 不存在，请在 NeoCRM 平台中加载此脚本。');
-  }
-  NeoCustomCmpFileFactory(window.neoRequire);
-})(function(require) {
-  // 原始文件内容
-});
-```
-
-## 日志输出示例
-
-```
-[AddNeoRequirePlugin] 开始处理资源文件...
-[AddNeoRequirePlugin] 跳过文件: main.css (匹配跳过规则)
-[AddNeoRequirePlugin] 跳过文件: main.js.map (匹配跳过规则)
-[AddNeoRequirePlugin] 成功处理文件: main.js
-[AddNeoRequirePlugin] 成功处理文件: chunk.1.js
-[AddNeoRequirePlugin] 处理完成 - 成功: 2, 跳过: 2, 错误: 0
-```
-
-## 故障排除
-
-### 1. 文件未被注入
-- 检查文件是否匹配跳过规则
-- 启用 `verbose: true` 查看详细日志
-- 确认文件内容有效且不为空
-
-### 2. 重复注入
-- 启用 `skipInjected: true` 选项
-- 检查文件是否已经被处理过
-
-### 3. 构建错误
-- 查看错误日志中的详细错误信息
-- 检查文件内容是否包含特殊字符
-- 确认 webpack 版本兼容性
-
-## 注意事项
-
-1. 插件会在 webpack 的 `processAssets` 阶段执行，优先级为 -100
-2. 只处理 JavaScript 文件，自动跳过 CSS、Map 等非 JS 文件
-3. 支持 SourceMap 文件，但不会修改它们
-4. 建议在生产环境中关闭详细日志以提高性能

package/src/utils/autoEntryRootDir.js

@@ -1,85 +0,0 @@
-const path = require('path');
-const fs = require('fs');
-const openProject = require('./projectUtils/openProject');
-
-/**
- * 自动进入指定项目的根目录
- *
- * ⚠️ 重要说明：子进程无法直接改变父 shell 的工作目录
- *
- * 原因：
- * 1. 进程隔离：每个进程都有独立的工作目录，子进程无法修改父进程的工作目录
- * 2. Shell 限制：cd 是 shell 的内置命令，必须在父 shell 进程中执行
- * 3. 安全机制：操作系统禁止子进程修改父进程的工作目录，防止安全问题
- *
- * 解决方案：
- * 1. 使用 process.chdir() 改变 Node.js 进程的工作目录（仅对后续 Node.js 操作有效）
- * 2. 输出 shell 命令让用户执行以改变 shell 的工作目录
- *
- * @param {string} projectPath 项目路径（可以是相对路径或绝对路径）
- * @param {object} options 配置选项
- * @param {boolean} options.outputShellCommand 是否输出 shell 命令让用户执行（默认：true）
- * @returns {boolean} 是否成功切换目录
- */
-module.exports = function (projectPath, options = {}) {
-  const { outputShellCommand = true } = options;
-
-  if (!projectPath) {
-    console.error('运行异常：未找到可用的项目路径。');
-    return false;
-  }
-
-  // 将路径解析为绝对路径
-  const absolutePath = path.isAbsolute(projectPath)
-    ? projectPath
-    : path.resolve(process.cwd(), projectPath);
-
-  // 检查目录是否存在
-  if (!fs.existsSync(absolutePath)) {
-    console.error(`运行异常：${projectPath} 目录不存在。`);
-    return false;
-  }
-
-  // 检查是否为目录
-  const stats = fs.statSync(absolutePath);
-  if (!stats.isDirectory()) {
-    console.error(`运行异常：${projectPath} 不是目录。`);
-    return false;
-  }
-
-  const projectName = path.relative(process.cwd(), absolutePath);
-
-  let success = false;
-
-  // 改变 Node.js 进程的工作目录（仅对后续 Node.js 操作有效）
-  try {
-    process.chdir(absolutePath);
-    success = true;
-  } catch (error) {
-    console.error(`错误：无法切换到目录 ${projectName}: ${error.message}`);
-    return false;
-  }
-
-  // 输出 shell 命令让用户执行（这样可以真正改变 shell 的工作目录）
-  if (outputShellCommand) {
-    // 输出提示信息
-    console.log('\n' + '='.repeat(60));
-    console.log('💡 提示：要切换到新建项目目录，请执行以下命令：');
-    console.log(`\n cd ${projectName} \n`);
-    console.log('='.repeat(60));
-    console.log('\n📝 说明1：组件开发工具（neo-cmp-cli）无法直接改变当前命令窗口工作目录，');
-    console.log(`   您需要手动执行上述命令才能进入刚创建的自定义组件项目（${projectName}）。`);
-    console.log(
-      `\n📝 说明2：组件开发工具（neo-cmp-cli）默认自动打开编辑器（cursor 或 vscode）: neo open -n ${projectName}。\n`
-    );
-
-    // 自动打开 IDE编辑器（异步执行，不需要等待）
-    openProject('auto', projectPath).catch((error) => {
-      // 错误已在 openProject 内部处理，这里只是防止未处理的 Promise 警告
-      console.error(`自动打开编辑器出错（neo open -n ${projectName}）: ${error.message}`);
-      console.error(`请手动执行命令 neo open -n ${projectName} 打开编辑器。`);
-    });
-  }
-
-  return success;
-};

package/src/utils/cmpUtils/createCmpByTemplate.js

@@ -1,60 +0,0 @@
-const fs = require('fs-extra');
-const path = require('path');
-const _ = require('lodash');
-const { consoleTag } = require('../neoParams'); // 输出标记
-const replaceInFilesByMap = require('../replaceInFilesByMap');
-const hasCmpTypeByDir = require('./hasCmpTypeByDir');
-const hasNeoProject = require('../projectUtils/hasNeoProject');
-
-// 自定义组件内容模板信息
-const curCmpTemplate = {
-  // 需要替换掉的字段信息（模板中的字段）
-  widgetInfo: {
-    cmpName: 'CustomCmp',
-    modelName: 'CmpModel',
-    cmpClassName: 'custom-cmp-container',
-    cmpType: 'xx-custom-cmp',
-    cmpLabel: 'xx组件'
-  },
-  dir: path.resolve(__dirname, '../../../template/empty-cmp')
-};
-
-/**
- * 创建自定义组件
- * @param {*} cmpName 自定义组件名称
- */
-module.exports = function (cmpName, componentBaseDir = './src/components') {
-  const currentTemplateDir = curCmpTemplate.dir;
-  const finalCmpName = cmpName || 'neoCustomCmp';
-  const finalCmpPath = path.resolve(process.cwd(), componentBaseDir, finalCmpName);
-
-  if (!hasNeoProject()) {
-    console.error(
-      `${consoleTag}当前（${process.cwd()}）还不是自定义组件项目，请先创建一个自定义组件项目（neo init / neo create project）。`
-    );
-    process.exit(1);
-  }
-
-  if (hasCmpTypeByDir(finalCmpName)) {
-    console.error(`${consoleTag}创建自定义组件失败，当前项目已经存在${finalCmpName}自定义组件。`);
-    process.exit(1);
-  }
-
-  fs.copy(currentTemplateDir, finalCmpPath)
-    .then(() => {
-      const curCmpName = _.camelCase(finalCmpName);
-      const cmpType = _.kebabCase(finalCmpName);
-
-      // 替换文件中的内容
-      replaceInFilesByMap(finalCmpPath, {
-        [curCmpTemplate.widgetInfo.modelName]: `${curCmpName}Model`,
-        [curCmpTemplate.widgetInfo.cmpName]: curCmpName,
-        [curCmpTemplate.widgetInfo.cmpClassName]: `${cmpType}-container`,
-        [curCmpTemplate.widgetInfo.cmpType]: cmpType,
-        [curCmpTemplate.widgetInfo.cmpLabel]: `${cmpType}组件`
-      });
-
-      console.log(`${consoleTag}已创建自定义组件（${finalCmpName}）!`);
-    })
-    .catch((err) => console.error(`${consoleTag}自定义组件创建失败（${finalCmpName}）：`, err));
-};

package/src/utils/cmpUtils/createCmpByZip.js

@@ -1,408 +0,0 @@
-const fs = require('fs-extra');
-const path = require('path');
-const axios = require('axios');
-const ora = require('ora');
-const AdmZip = require('adm-zip');
-const _ = require('lodash');
-const { consoleTag } = require('../neoParams'); // 输出标记
-const hasCmpTypeByDir = require('./hasCmpTypeByDir');
-const hasNeoProject = require('../projectUtils/hasNeoProject');
-const { errorLog, warningLog, successLog, parseTsConfigWithTypeScript } = require('../common');
-
-/**
- * 检查对象键名是否需要加引号
- * @param {string} key 键名
- * @returns {boolean} 是否需要加引号
- */
-function needsQuotes(key) {
-  // 如果键名包含特殊字符（如 @、-、空格等）或不是有效的 JavaScript 标识符，需要加引号
-  // 有效的 JavaScript 标识符：以字母、$、_ 开头，后续可以是字母、数字、$、_
-  const validIdentifierRegex = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
-  return !validIdentifierRegex.test(key);
-}
-
-/**
- * 格式化对象键名，如果需要则加引号
- * @param {string} key 键名
- * @returns {string} 格式化后的键名
- */
-function formatKey(key) {
-  if (needsQuotes(key)) {
-    return JSON.stringify(key);
-  }
-  return key;
-}
-
-/**
- * 将配置对象格式化为 JavaScript 代码字符串
- * @param {*} obj 配置对象
- * @param {number} indent 缩进级别
- * @param {string} fileDir 配置文件所在目录路径，用于将绝对路径转换回相对路径（resolve() 基于 __dirname）
- * @returns {string} 格式化后的字符串
- */
-function formatConfigObject(obj, indent = 0, fileDir = '') {
-  const indentStr = '  '.repeat(indent);
-  const nextIndentStr = '  '.repeat(indent + 1);
-
-  if (obj === null) {
-    return 'null';
-  }
-
-  if (obj === undefined) {
-    return 'undefined';
-  }
-
-  if (typeof obj === 'string') {
-    // 尝试将绝对路径转换回 resolve() 调用
-    if (fileDir && path.isAbsolute(obj)) {
-      try {
-        const relativePath = path.relative(fileDir, obj).replace(/\\/g, '/');
-        // 如果路径看起来像是通过 resolve() 生成的，转换回 resolve() 调用
-        // 排除包含 .. 的路径（这些可能是外部路径）
-        if (relativePath && !relativePath.startsWith('..') && relativePath !== '') {
-          // 确保路径使用正斜杠，并添加 ./ 前缀（如果需要）
-          const normalizedPath = relativePath.startsWith('.') ? relativePath : './' + relativePath;
-          return `resolve(${JSON.stringify(normalizedPath)})`;
-        }
-      } catch (e) {
-        // 如果路径转换失败，继续使用原始字符串
-      }
-    }
-    // 检查是否包含 resolve() 或 auth. 调用（从原始文件中提取的）
-    if (obj.includes('resolve(') || obj.includes('auth.')) {
-      return obj;
-    }
-    // 转义字符串中的特殊字符
-    return JSON.stringify(obj);
-  }
-
-  if (typeof obj === 'number' || typeof obj === 'boolean') {
-    return String(obj);
-  }
-
-  if (Array.isArray(obj)) {
-    if (obj.length === 0) {
-      return '[]';
-    }
-    const items = obj.map((item) => {
-      const formatted = formatConfigObject(item, indent + 1, fileDir);
-      return nextIndentStr + formatted;
-    });
-    return '[\n' + items.join(',\n') + '\n' + indentStr + ']';
-  }
-
-  if (typeof obj === 'object') {
-    const keys = Object.keys(obj);
-    if (keys.length === 0) {
-      return '{}';
-    }
-    const items = keys.map((key) => {
-      const value = obj[key];
-      const formattedValue = formatConfigObject(value, indent + 1, fileDir);
-      return nextIndentStr + formatKey(key) + ': ' + formattedValue;
-    });
-    return '{\n' + items.join(',\n') + '\n' + indentStr + '}';
-  }
-
-  // 对于函数或其他类型，尝试转换为字符串
-  return String(obj);
-}
-
-/**
- * 从 zip 包中创建自定义组件
- * @param {*} cmpZipUrl 自定义组件源码文件地址（zip包地址）
- * @param {*} cmpName 自定义组件名称
- * @param {*} componentBaseDir 自定义组件目录
- *
- * 拉取线上自定义组件源码 规则：
- * 1、对于 组件源码中 src/components 中的所有文件 copy 至 当前项目 src/components，非覆盖式（copy 前判断是否存在）；
- * 2、对于 组件源码中的 配置文件（neo.config.js）内容 和 当前项目配置 进行 非覆盖式 merge 处理；
- * 3、对于 组件源码中的 tsconfig.json 文件内容 和 当前项目 tsconfig  进行 非覆盖式 merge 处理；
- * 4、对于 组件源码中的 package.json 文件内容 和 当前项目 package.json  进行 非覆盖式 merge 处理，并识别新增 依赖，提示用户 重新安装依赖
- */
-async function createCmpByZip(cmpZipUrl, option = {}) {
-  const { token, cmpName, componentBaseDir = './src/components' } = option || {};
-  const finalCmpName = cmpName;
-
-  if (!hasNeoProject()) {
-    errorLog(
-      `当前（${process.cwd()}）还不是自定义组件项目，请先创建一个自定义组件项目（neo init / neo create project）。`
-    );
-    process.exit(1);
-  }
-
-  if (hasCmpTypeByDir(finalCmpName)) {
-    errorLog(`当前项目已经存在${finalCmpName}自定义组件。`);
-    process.exit(1);
-  }
-
-  // 创建临时目录
-  const tempDir = path.join(process.cwd(), '.neo-cli', 'zip-source');
-
-  const spinner = ora(`${consoleTag}正在下载组件源码...`).start();
-
-  // 下载源码文件并解析到 src/components 目录下
-  try {
-    await fs.ensureDir(tempDir); // 如果目录不存在，会自动创建（包括所有必要的父目录）
-
-    const zipFilePath = path.join(tempDir, `${finalCmpName}.zip`);
-
-    // 检查是否存在同名 zip 包，如果存在则先删除
-    if (await fs.pathExists(zipFilePath)) {
-      await fs.remove(zipFilePath);
-    }
-
-    // 下载 zip 文件
-    let response;
-    try {
-      response = await axios.get(cmpZipUrl, {
-        headers: {
-          Authorization: `Bearer ${token}`,
-          'xsy-inner-source': 'bff'
-        },
-        responseType: 'arraybuffer',
-        timeout: 60000, // 60秒超时
-        maxContentLength: Infinity,
-        maxBodyLength: Infinity,
-        maxRedirects: 5, // 支持重定向
-        validateStatus: function (status) {
-          // 接受 2xx 和 3xx 状态码（重定向）
-          return status >= 200 && status < 400;
-        }
-      });
-    } catch (axiosError) {
-      const errorMessage = axiosError.response
-        ? `下载文件失败: HTTP ${axiosError.response.status} - ${axiosError.message}`
-        : `下载文件失败: ${axiosError.message}`;
-      errorLog(errorMessage, spinner);
-      throw axiosError;
-    }
-
-    // 保存 zip 文件到临时目录
-    try {
-      let buffer;
-      // 处理不同的数据类型
-      if (Buffer.isBuffer(response.data)) {
-        // 如果已经是 Buffer，直接使用
-        buffer = response.data;
-      } else if (response.data instanceof ArrayBuffer) {
-        // 如果是 ArrayBuffer，转换为 Buffer
-        buffer = Buffer.from(response.data);
-      } else if (response.data.buffer instanceof ArrayBuffer) {
-        // 如果是 TypedArray (如 Uint8Array)，使用其 buffer
-        buffer = Buffer.from(response.data.buffer);
-      } else {
-        // 尝试直接转换
-        buffer = Buffer.from(response.data);
-      }
-
-      await fs.writeFile(zipFilePath, buffer);
-    } catch (writeError) {
-      errorLog(`读取组件源码文件失败: ${writeError.message}`, spinner);
-      throw writeError;
-    }
-
-    // 解压 zip 文件
-    spinner.info(`${consoleTag}正在解压组件源码...`);
-
-    const zip = new AdmZip(zipFilePath);
-    // 解压后的目录名称为组件名称：.neo-cli/zip-source/xxCmp
-    const extractPath = path.join(tempDir, finalCmpName);
-    zip.extractAllTo(extractPath, true); // 解压到临时目录
-
-    // 查找解压后的 src/components 目录
-    const cmpSourcePath = path.join(extractPath, componentBaseDir, finalCmpName);
-
-    if (!fs.existsSync(cmpSourcePath)) {
-      errorLog(`解压后的 zip 包中未找到 ${finalCmpName} 组件源码目录。`, spinner);
-      // 只删除解压目录，保留 zip 源文件
-      await fs.remove(extractPath);
-      return false;
-    }
-
-    // 确保目标目录存在
-    const targetComponentsDir = path.resolve(process.cwd(), componentBaseDir, finalCmpName);
-    await fs.ensureDir(targetComponentsDir);
-
-    // 复制 src/components 目录下的所有内容到目标目录
-    try {
-      await fs.copy(cmpSourcePath, targetComponentsDir);
-    } catch (err) {
-      errorLog(`自定义组件模板下载失败：${err.message || err}`, spinner);
-      // 只删除解压目录，保留 zip 源文件
-      await fs.remove(extractPath);
-      return false;
-    }
-
-    // 处理源码中其他文件
-    try {
-      // 标准化 componentBaseDir，去掉开头的 ./ 并统一路径分隔符
-      const normalizedComponentBaseDir = componentBaseDir.replace(/^\.\//, '').replace(/\\/g, '/');
-
-      /**
-       * 递归复制文件，排除 componentBaseDir 目录
-       * @param {string} sourceDir 源目录
-       * @param {string} targetRoot 目标根目录（项目根目录）
-       * @param {string} excludeDir 要排除的目录（相对于源目录）
-       */
-      const copyOtherFiles = async (sourceDir, targetRoot, excludeDir) => {
-        const items = await fs.readdir(sourceDir);
-
-        for (const item of items) {
-          const sourcePath = path.join(sourceDir, item); // 当前源文件路径
-          const stat = await fs.stat(sourcePath); // 当前源文件状态
-          const fileName = path.basename(sourcePath); // 当前源文件名称
-
-          // 计算相对于解压根目录的路径
-          const relativePath = path.relative(extractPath, sourcePath);
-          const normalizedRelativePath = relativePath.replace(/\\/g, '/');
-
-          // 跳过 componentBaseDir 目录及其子目录
-          if (
-            normalizedRelativePath.startsWith(excludeDir + '/') ||
-            normalizedRelativePath === excludeDir
-          ) {
-            continue;
-          }
-
-          const targetPath = path.join(targetRoot, relativePath); // 目标文件路径
-
-          if (stat.isDirectory()) {
-            // 如果是目录，递归处理
-            await copyOtherFiles(sourcePath, targetRoot, excludeDir);
-          } else if (stat.isFile()) {
-            // 如果是文件，检查目标文件是否存在
-            const targetExists = await fs.pathExists(targetPath);
-            if (!targetExists) {
-              // 确保目标目录存在
-              await fs.ensureDir(path.dirname(targetPath));
-              // 复制文件
-              await fs.copy(sourcePath, targetPath);
-            } else if (fileName === 'package.json') {
-              // 处理 package.json 文件（当目标文件已存在时）
-              const sourcePackageJson = await fs.readJson(sourcePath);
-              const targetPackageJson = await fs.readJson(targetPath);
-
-              const newPackageJsonDeps = _.omit(
-                sourcePackageJson.dependencies,
-                Object.keys(targetPackageJson.dependencies)
-              );
-              const newDeps = Object.keys(newPackageJsonDeps);
-              if (newDeps.length > 0) {
-                warningLog(
-                  `检测到 package.json 中新增了 ${newDeps.length} 个依赖包：${newDeps.join(', ')}`
-                );
-                warningLog(
-                  `为确保组件正常运行，请执行以下命令安装依赖：npm install 或 yarn install`
-                );
-              }
-              // 合并 package.json：将源文件的配置合并到目标文件中
-              // 注意：_.merge 会修改第一个参数，所以先克隆目标对象
-              const mergedPackageJson = _.merge({}, sourcePackageJson, targetPackageJson);
-              await fs.writeJson(targetPath, mergedPackageJson, { spaces: 2 });
-            } else if (fileName === 'neo.config.js') {
-              // 处理 neo.config.js 文件（当目标文件已存在时）
-              try {
-                // 清除 require 缓存，确保读取最新内容
-                const sourceResolvedPath = require.resolve(sourcePath);
-                const targetResolvedPath = require.resolve(targetPath);
-                delete require.cache[sourceResolvedPath];
-                delete require.cache[targetResolvedPath];
-
-                // 读取源文件和目标文件的原始内容
-                const sourceContent = await fs.readFile(sourcePath, 'utf8');
-                const targetContent = await fs.readFile(targetPath, 'utf8');
-
-                // 读取源文件和目标文件的配置对象（函数调用会被执行）
-                const sourceConfig = require(sourcePath);
-                const targetConfig = require(targetPath);
-
-                // 合并配置：源配置合并到目标配置（目标配置优先级更高）
-                const mergedConfig = _.merge({}, sourceConfig, targetConfig);
-
-                // 提取目标文件的头部（module.exports 之前的内容）
-                const moduleExportMatch = targetContent.match(
-                  /^([\s\S]*?)(module\.exports\s*=\s*\{[\s\S]*\};?\s*)$/
-                );
-                let fileHeader = '';
-                if (moduleExportMatch) {
-                  fileHeader = moduleExportMatch[1];
-                } else {
-                  // 如果没有找到 module.exports，尝试提取到最后一个大括号之前的内容
-                  const lastBraceIndex = targetContent.lastIndexOf('module.exports');
-                  if (lastBraceIndex > 0) {
-                    fileHeader = targetContent.substring(0, lastBraceIndex);
-                  } else {
-                    // 如果都没有找到，使用默认头部
-                    fileHeader =
-                      "'use strict';\nconst path = require('path');\n\n// 统一路径解析\nfunction resolve(dir) {\n  return path.resolve(__dirname, dir);\n}\n\n";
-                  }
-                }
-
-                // 获取目标文件的目录，用于路径转换（resolve() 基于 __dirname）
-                const targetFileDir = path.dirname(targetPath);
-
-                // 将合并后的配置对象转换为格式化的字符串
-                const configString = formatConfigObject(mergedConfig, 0, targetFileDir);
-
-                // 组合完整的文件内容
-                const mergedContent = fileHeader + 'module.exports = ' + configString + ';\n';
-
-                // 写回文件
-                await fs.writeFile(targetPath, mergedContent, 'utf8');
-              } catch (configError) {
-                spinner.warn(
-                  `${consoleTag}合并 neo.config.js 配置文件时出现警告：${
-                    configError.message || configError
-                  }`
-                );
-              }
-            } else if (fileName === 'tsconfig.json') {
-              // 处理 tsconfig.json 文件（当目标文件已存在时）
-              try {
-                const sourceTsconfigJson = parseTsConfigWithTypeScript(sourcePath);
-                // 先判断 targetPath 是否存在，如果存在则合并，否则直接写入
-                if (await fs.pathExists(targetPath)) {
-                  const targetTsconfigJson = parseTsConfigWithTypeScript(targetPath);
-                  // 合并配置：源配置合并到目标配置（目标配置优先级更高）
-                  const mergedTsconfigJson = _.merge({}, sourceTsconfigJson, targetTsconfigJson);
-                  // 使用 writeJson 写入，确保 JSON 格式正确（所有键名都会被正确序列化）
-                  await fs.writeJson(targetPath, mergedTsconfigJson, { spaces: 2 });
-                } else {
-                  await fs.writeJson(targetPath, sourceTsconfigJson, { spaces: 2 });
-                }
-              } catch (tsconfigError) {
-                spinner.warn(
-                  `${consoleTag}合并 tsconfig.json 配置文件时出现警告：${
-                    tsconfigError.message || tsconfigError
-                  }`
-                );
-              }
-            }
-          }
-        }
-      };
-      // 开始处理源码中其他文件
-      await copyOtherFiles(extractPath, process.cwd(), normalizedComponentBaseDir);
-    } catch (err) {
-      spinner.warn(`${consoleTag}处理源码文件出现警告：${err.message || err}`);
-    }
-
-    // 清理解压目录，保留 zip 源文件
-    await fs.remove(extractPath);
-    successLog(`已成功从 zip 包解析自定义组件（${finalCmpName}）!`, spinner);
-
-    return true;
-  } catch (error) {
-    errorLog(`从 zip 包创建自定义组件失败（${finalCmpName}）：${error.message || error}`, spinner);
-    // 清理解压目录，保留 zip 源文件
-    const extractPath = path.join(tempDir, finalCmpName);
-    if (await fs.pathExists(extractPath)) {
-      await fs.remove(extractPath);
-    }
-
-    return false;
-  }
-}
-
-module.exports = createCmpByZip;