neo-cmp-cli 1.8.7 → 1.8.8

package/dist/utils/cmpUtils/createCmpByZip.js

@@ -0,0 +1,433 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const require$$0 = require('fs-extra');
+const require$$1 = require('node:path');
+const require$$0$1 = require('axios');
+const require$$3 = require('ora');
+const require$$2 = require('adm-zip');
+const require$$2$1 = require('lodash');
+const neoParams = require('../neoParams.js');
+const hasCmpTypeByDir = require('./hasCmpTypeByDir.js');
+const hasNeoProject = require('../projectUtils/hasNeoProject.js');
+const common = require('../common.js');
+
+var createCmpByZip_1;
+var hasRequiredCreateCmpByZip;
+
+function requireCreateCmpByZip () {
+	if (hasRequiredCreateCmpByZip) return createCmpByZip_1;
+	hasRequiredCreateCmpByZip = 1;
+	const fs = require$$0;
+	const path = require$$1;
+	const axios = require$$0$1;
+	const ora = require$$3;
+	const AdmZip = require$$2;
+	const _ = require$$2$1;
+	const { consoleTag } = neoParams.__require(); // 输出标记
+	const hasCmpTypeByDir$1 = hasCmpTypeByDir.__require();
+	const hasNeoProject$1 = hasNeoProject.__require();
+	const { errorLog, warningLog, successLog, parseTsConfigWithTypeScript } = common.__require();
+
+	/**
+	 * 检查对象键名是否需要加引号
+	 * @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$1()) {
+	    errorLog(
+	      `当前（${process.cwd()}）还不是自定义组件项目，请先创建一个自定义组件项目（neo init / neo create project）。`
+	    );
+	    process.exit(1);
+	  }
+
+	  if (hasCmpTypeByDir$1(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;
+	  }
+	}
+
+	createCmpByZip_1 = createCmpByZip;
+	return createCmpByZip_1;
+}
+
+exports.__require = requireCreateCmpByZip;

package/dist/utils/cmpUtils/createCommonModulesCode.js

@@ -0,0 +1,139 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const require$$0 = require('node:fs');
+const pathUtils = require('../pathUtils.js');
+const require$$2 = require('lodash');
+
+var createCommonModulesCode_1;
+var hasRequiredCreateCommonModulesCode;
+
+function requireCreateCommonModulesCode () {
+	if (hasRequiredCreateCommonModulesCode) return createCommonModulesCode_1;
+	hasRequiredCreateCommonModulesCode = 1;
+	const fs = require$$0;
+	const { resolveToCurrentRoot } = pathUtils.__require();
+	const { isPlainObject } = require$$2;
+
+	/**
+	 * 获取组件预览代码
+	 * @param {*} cmpsDir 自定义组件目录
+	 * @param {*} cmpName 自定义组件名称
+	 * @returns 组件预览代码
+	 */
+	const createCommonModulesCode = (neoCommonModule, cmpTypes) => {
+	  const { exports: exports$1, remoteDeps } = neoCommonModule;
+
+	  if (!exports$1 && !remoteDeps) {
+	    return '';
+	  }
+	  // 记录当前自定义组件共享出去的模块
+	  const CustomCmpCommonModules = {};
+	  // 记录当前自定义组件需要的远程依赖组件
+	  const CustomCmpRemoteDeps = {};
+
+	  // 根据 exports 获取共享的依赖模块
+	  if (Array.isArray(exports$1) && exports$1.length > 0) {
+	    exports$1.forEach((module) => {
+	      CustomCmpCommonModules[module] = require(module);
+	    });
+	  } else if (isPlainObject(exports$1) && Object.keys(exports$1).length > 0) {
+	    Object.keys(exports$1).forEach((moduleId) => {
+	      CustomCmpCommonModules[moduleId] = `require('${exports$1[moduleId]}')`;
+	    });
+	  } else if (exports$1) {
+	    console.error(
+	      'exports 格式不正确，请检查 neo.config.js 文件中的 neoCommonModule / exports 配置'
+	    );
+	    process.exit(1);
+	  }
+
+	  // 根据 cmpTypes 和 remoteDeps 设置远程依赖组件信息
+	  if (Array.isArray(remoteDeps) && remoteDeps.length > 0) {
+	    cmpTypes.forEach((cmpType) => {
+	      CustomCmpRemoteDeps[cmpType] = remoteDeps;
+	    });
+	  }
+
+	  // 构建 CustomCmpCommonModules 对象的代码字符串
+	  let customCmpCommonModulesCode = '{\n';
+	  const moduleEntries = Object.entries(CustomCmpCommonModules);
+	  moduleEntries.forEach(([moduleId, moduleValue], index) => {
+	    const isLast = index === moduleEntries.length - 1;
+	    customCmpCommonModulesCode += `  "${moduleId}": ${moduleValue}${isLast ? '' : ','}\n`;
+	  });
+	  customCmpCommonModulesCode += '}';
+
+	  const commonModulesCode = `
+/**
+ * 自定义组件 共享出来的依赖模块
+ * 备注：可在其他模块中通过 neoRequire 中使用
+ */
+import { isPlainObject } from 'lodash';
+const CustomCmpCommonModules = ${customCmpCommonModulesCode};
+const CustomCmpRemoteDeps = ${JSON.stringify(CustomCmpRemoteDeps)};
+
+// 用于添加共享的依赖模块
+const addNeoCommonModules = (modules) => {
+  if (!window.__NeoCommonModules) {
+    window.__NeoCommonModules = {}
+  }
+  if (isPlainObject(modules)) {
+    const moduleIds = Object.keys(modules)
+    moduleIds.forEach((moduleId) => {
+      const curModule = modules[moduleId];
+      const curCommonModule = window.__NeoCommonModules[moduleId];
+      
+      if (curCommonModule && Object.keys(curCommonModule).length < 3) {
+        window.__NeoCommonModules[moduleId] = Object.assign(window.__NeoCommonModules[moduleId], curModule);
+
+        // 处理模块中的特殊属性
+        if (curModule.__esModule !== undefined) {
+          window.__NeoCommonModules[moduleId].__esModule = curModule.__esModule;
+        }
+        if (curModule.default !== undefined) {
+          window.__NeoCommonModules[moduleId].default = curModule.default;
+        }
+      } else {
+        window.__NeoCommonModules[moduleId] = curModule;
+      }
+    })
+  }
+}
+
+// 用于添加自定义组件的远程依赖组件（关联使用）
+const addNeoRemoteDeps = (remoteDeps) => {
+  if (!window.__NeoCommonModules) {
+    window.__NeoCommonModules = {}
+  }
+  if (!window.__NeoCommonModules.__neoRemoteDeps) {
+    window.__NeoCommonModules.__neoRemoteDeps = {}
+  }
+  if (isPlainObject(remoteDeps)) {
+    window.__NeoCommonModules.__neoRemoteDeps = Object.assign(window.__NeoCommonModules.__neoRemoteDeps, remoteDeps)
+  }
+}
+
+addNeoCommonModules(CustomCmpCommonModules);
+addNeoRemoteDeps(CustomCmpRemoteDeps);
+  `;
+
+	  // 创建存放 cli 的临时目录
+	  const cliTempDir = resolveToCurrentRoot('./.neo-cli');
+	  if (!fs.existsSync(cliTempDir)) {
+	    fs.mkdirSync(cliTempDir);
+	  }
+
+	  // 将 commonModulesCode 写入到临时目录中
+	  const commonModulesFilePath = `${cliTempDir}/commonModules.js`;
+	  fs.writeFileSync(commonModulesFilePath, commonModulesCode);
+
+	  return commonModulesFilePath;
+	};
+
+	createCommonModulesCode_1 = createCommonModulesCode;
+	return createCommonModulesCode_1;
+}
+
+exports.__require = requireCreateCommonModulesCode;

package/dist/utils/cmpUtils/deleteCmp.js

@@ -0,0 +1,81 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const require$$3 = require('ora');
+const neoService = require('../../neo/neoService.js');
+const common = require('../common.js');
+
+var deleteCmp_1;
+var hasRequiredDeleteCmp;
+
+function requireDeleteCmp () {
+	if (hasRequiredDeleteCmp) return deleteCmp_1;
+	hasRequiredDeleteCmp = 1;
+	const ora = require$$3;
+	const NeoService = neoService.__require();
+	const { errorLog, successLog } = common.__require();
+
+	/**
+	 * 从 NeoCRM 删除自定义组件
+	 * @param {string} cmpType 自定义组件类型
+	 * @param {object} authConfig 授权配置
+	 * @param {object} _neoService 可选的 NeoService 实例（用于复用已获取的组件列表）
+	 *
+	 * 删除流程说明
+	 * 1. 获取当前租户下的自定义组件列表
+	 * 2. 验证组件是否存在
+	 * 3. 调用删除 API 删除组件
+	 */
+	const deleteCmp = async (cmpType, authConfig, _neoService) => {
+	  if (!authConfig) {
+	    errorLog('未找到 NeoCRM 平台授权配置（neo.config.js / authConfig）。');
+	    return;
+	  }
+
+	  const spinner = ora('正在删除组件...').start();
+
+	  try {
+	    let neoService = _neoService;
+	    let cmpList = [];
+	    let cmpInfo = null;
+
+	    if (_neoService) {
+	      // 使用传入的 neoService 实例
+	      cmpList = _neoService.cmpList || [];
+	    } else {
+	      // 创建新的 neoService 实例
+	      neoService = new NeoService(authConfig);
+
+	      // 获取自定义组件列表
+	      spinner.info('正在获取自定义组件列表...');
+	      cmpList = await neoService.getCustomCmpList();
+	    }
+
+	    if (cmpList.length === 0) {
+	      errorLog('删除失败，当前租户暂无任何自定义组件。', spinner);
+	      process.exit(1);
+	    }
+
+	    // 获取自定义组件信息
+	    cmpInfo = neoService.getCmpInfoByCmpType(cmpType);
+	    if (!cmpInfo) {
+	      errorLog(`删除失败，当前租户不存在${cmpType}自定义组件。`, spinner);
+	      process.exit(1);
+	    }
+
+	    // 调用删除 API
+	    spinner.info(`正在删除${cmpType}自定义组件...`);
+	    await neoService.deleteCmp(cmpType);
+	    successLog(`已成功删除${cmpType}自定义组件！\n`, spinner);
+	  } catch (error) {
+	    errorLog(`删除自定义组件失败: ${error.message}`, spinner);
+	    process.exit(1);
+	  }
+	};
+
+	deleteCmp_1 = deleteCmp;
+	return deleteCmp_1;
+}
+
+exports.__require = requireDeleteCmp;