neo-cmp-cli 1.5.6 → 1.6.0-beta.10

package/src/utils/cmpUtils/createCmpByZip.js

@@ -0,0 +1,87 @@
+const fs = require('fs-extra');
+const path = require('path');
+const axios = require('axios');
+const ora = require('ora');
+const AdmZip = require('adm-zip');
+const { consoleTag } = require('../neoParams'); // 输出标记
+const hasCmpTypeByDir = require('./hasCmpTypeByDir');
+const hasNeoProject = require('../projectUtils/hasNeoProject');
+
+/**
+ * 从 zip 包中创建自定义组件
+ * @param {*} cmpZipUrl 自定义组件源码文件地址（zip包地址）
+ * @param {*} cmpName 自定义组件名称
+ * @param {*} componentBaseDir 自定义组件目录
+ */
+module.exports = async function (cmpZipUrl, cmpName, componentBaseDir = './src/components') {
+  const finalCmpName = cmpName || 'neoCustomCmp';
+
+  if (!hasNeoProject()) {
+    console.error(
+      `${consoleTag}当前（${process.cwd()}）还不是自定义组件项目，请先创建一个自定义组件项目（neo init / neo createProject）。`
+    );
+    process.exit(1);
+  }
+
+  if (hasCmpTypeByDir(finalCmpName)) {
+    console.error(`${consoleTag}当前项目已经存在${finalCmpName}自定义组件。`);
+    process.exit(1);
+  }
+
+  // 创建临时目录
+  const tempDir = path.join(process.cwd(), '.neo-cli', 'zip-source');
+
+  // 下载源码文件并解析到 src/components 目录下
+  try {
+    await fs.ensureDir(tempDir); // 如果目录不存在，会自动创建（包括所有必要的父目录）
+
+    // 下载 zip 文件
+    const spinner = ora(`${consoleTag}正在下载组件源码...`).start();
+    const zipFilePath = path.join(tempDir, `${finalCmpName}.zip`);
+
+    const response = await axios({
+      url: cmpZipUrl,
+      method: 'GET',
+      responseType: 'arraybuffer'
+    });
+
+    // 保存 zip 文件到临时目录
+    await fs.writeFile(zipFilePath, response.data);
+
+    // 解压 zip 文件
+    spinner.text(`${consoleTag}正在解压组件源码...`);
+    const zip = new AdmZip(zipFilePath);
+    const extractPath = path.join(tempDir, finalCmpName);
+    zip.extractAllTo(extractPath, true);
+
+    // 查找解压后的 src/components 目录
+    const cmpSourcePath = path.join(extractPath, componentBaseDir, finalCmpName);
+
+    if (!fs.existsSync(cmpSourcePath)) {
+      spinner.fail(`${consoleTag}解压后的 zip 包中未找到 ${finalCmpName} 组件源码目录。`);
+      await fs.remove(tempDir);
+      process.exit(1);
+    }
+
+    // 确保目标目录存在
+    const targetComponentsDir = path.resolve(process.cwd(), componentBaseDir, finalCmpName);
+    await fs.ensureDir(targetComponentsDir);
+
+    // 复制 src/components 目录下的所有内容到目标目录
+    await fs
+      .copy(cmpSourcePath, targetComponentsDir)
+      .catch((err) => spinner.fail(`${consoleTag}自定义组件模板下载失败：${err.message || err}`));
+
+    // 清理临时目录
+    await fs.remove(tempDir);
+    spinner.succeed(`${consoleTag}已成功从 zip 包解析自定义组件（${finalCmpName}）!`);
+
+    return true;
+  } catch (error) {
+    spinner.fail(`${consoleTag}从 zip 包创建自定义组件失败（${finalCmpName}）：`, error.message);
+    // 清理临时目录
+    await fs.remove(tempDir);
+
+    return false;
+  }
+};

package/src/{cmpUtils → utils/cmpUtils}/createCommonModulesCode.js

@@ -1,5 +1,5 @@
 const fs = require('fs');
-const { resolveToCurrentRoot } = require('../utils/pathUtils');
+const { resolveToCurrentRoot } = require('../pathUtils');
 const { isPlainObject } = require('lodash');
 
 /**
@@ -9,7 +9,7 @@ const { isPlainObject } = require('lodash');
  * @returns 组件预览代码
  */
 const createCommonModulesCode = (neoCommonModule, cmpTypes) => {
-  const {neoExports, remoteDeps} = neoCommonModule;
+  const { neoExports, remoteDeps } = neoCommonModule;
 
   if (!neoExports && !remoteDeps) {
     return '';

package/src/{cmpUtils → utils/cmpUtils}/getCmpModelRegisterCode.js

@@ -1,5 +1,5 @@
 const fs = require('fs');
-const { resolveToCurrentRoot } = require('../utils/pathUtils');
+const { resolveToCurrentRoot } = require('../pathUtils');
 
 /**
  * 获取组件注册文件内容

package/src/{cmpUtils → utils/cmpUtils}/getCmpPreviewCode.js

@@ -1,5 +1,5 @@
 const fs = require('fs');
-const { resolveToCurrentRoot } = require('../utils/pathUtils');
+const { resolveToCurrentRoot } = require('../pathUtils');
 
 /**
  * 获取组件预览代码

package/src/{cmpUtils → utils/cmpUtils}/getCmpRegisterCode.js

@@ -1,5 +1,5 @@
 const fs = require('fs');
-const { resolveToCurrentRoot } = require('../utils/pathUtils');
+const { resolveToCurrentRoot } = require('../pathUtils');
 
 /**
  * 获取组件注册文件内容

package/src/{cmpUtils → utils/cmpUtils}/getCmpTypeByDir.js

@@ -1,6 +1,6 @@
 const fs = require('fs');
 const path = require('path');
-const { resolveToCurrentRoot } = require('../utils/pathUtils');
+const { resolveToCurrentRoot } = require('../pathUtils');
 /**
  * 根据当前组件目录，获取所有组件类型
  * @param {*} componentsBaseDir 自定义组件目录
@@ -23,7 +23,7 @@ const getCmpTypeByDir = (componentsBaseDir = './src/components') => {
     dirs.forEach((dir) => {
       const dirPath = path.join(componentsDir, dir);
       const stat = fs.statSync(dirPath);
-      
+
       // 只处理目录，过滤掉隐藏目录和 node_modules
       if (stat.isDirectory() && !dir.startsWith('.') && dir !== 'node_modules') {
         cmpTypes.push(dir);

package/src/{cmpUtils → utils/cmpUtils}/hasCmpTypeByDir.js

@@ -8,4 +8,4 @@ const getCmpTypeByDir = require('./getCmpTypeByDir');
 module.exports = (cmpType) => {
   const cmpTypes = getCmpTypeByDir();
   return cmpTypes.includes(cmpType);
-};;
+};

package/src/{cmpUtils → utils/cmpUtils}/previewCmp.js

@@ -1,8 +1,8 @@
 const fs = require('fs');
 const akfun = require('akfun');
-const { consoleTag } = require('../utils/neoParams'); // 输出标记
-const { resolveToCurrentRoot } = require('../utils/pathUtils');
-const getCmpPreviewCode = require('../cmpUtils/getCmpPreviewCode'); // 获取自定义组件预览代码
+const { consoleTag } = require('../neoParams'); // 输出标记
+const { resolveToCurrentRoot } = require('../pathUtils');
+const getCmpPreviewCode = require('./getCmpPreviewCode'); // 获取自定义组件预览代码
 
 /**
  * 用于预览指定自定义组件的脚本

package/src/utils/cmpUtils/pullCmp.js

@@ -0,0 +1,95 @@
+const _ = require('lodash');
+const { catchCurPackageJson } = require('../pathUtils');
+const getConfigObj = require('../getConfigObj');
+const ora = require('ora');
+const NeoService = require('../../neo/neoService');
+const { getFramework } = require('../common');
+const getCmpTypeByDir = require('./getCmpTypeByDir.js');
+const createCmpByZip = require('./createCmpByZip.js');
+
+// 获取当前项目的package文件
+const currentPackageJsonDir = catchCurPackageJson();
+const currentPackageJson = getConfigObj(currentPackageJsonDir);
+const framework = getFramework(currentPackageJson.framework);
+
+/**
+ * 从 NeoCRM 拉取自定义组件
+ * @param {string} cmpType 自定义组件类型
+ * @param {object} authConfig 授权配置
+ */
+const pullCmp = async (cmpType, authConfig, _neoService) => {
+  if (!authConfig) {
+    console.error('未找到 NeoCRM 平台授权配置（neo.config.js / authConfig）。');
+    return;
+  }
+
+  const cmpTypes = getCmpTypeByDir(); // 获取当前项目目录中已存在的自定义组件类型
+  if (cmpTypes.indexOf(cmpType) > -1) {
+    console.error(`当前项目目录中已存在${cmpType}自定义组件。（./src/components 目录下）`);
+    process.exit(1);
+  }
+
+  const spinner = ora('正在拉取组件...').start();
+
+  try {
+    let neoService = _neoService;
+    let cmpList = [],
+      cmpInfoMap = {};
+    let cmpInfo = null;
+
+    if (_neoService) {
+      // 使用传入的 neoService 实例
+      cmpList = _neoService.cmpList || [];
+      cmpInfoMap = _neoService.cmpInfoMap || {};
+    } else {
+      // 创建新的 neoService 实例
+      neoService = new NeoService(authConfig);
+
+      // 获取自定义组件列表
+      spinner.info('正在获取自定义组件列表...');
+      cmpList = await neoService.getCustomCmpList();
+      cmpInfoMap = neoService.cmpInfoMap || {};
+    }
+
+    if (cmpList.length === 0) {
+      spinner.fail('拉取失败，当前租户暂无任何自定义组件。');
+      process.exit(1);
+    }
+
+    // 获取自定义组件信息
+    cmpInfo = neoService.getCmpInfoByCmpType(cmpType);
+    if (!cmpInfo) {
+      spinner.fail(`拉取失败，当前租户不存在${cmpType}自定义组件。`);
+      process.exit(1);
+    }
+
+    // 判断拉取的组件和当前项目是否为同一技术栈
+    if (cmpInfo.framework !== framework) {
+      spinner.fail(`拉取失败，${cmpType}自定义组件与当前项目技术栈不一致。`);
+      process.exit(1);
+    }
+
+    // 获取当前源码
+    if (!cmpInfo.codeLib) {
+      spinner.fail(`拉取失败，${cmpType}自定义组件未记录对应的源码文件。`);
+      process.exit(1);
+    }
+
+    // 下载源码文件并解析到 src/components 目录下
+    const codeLib = cmpInfo.codeLib; // 源码文件地址（zip包地址）
+
+    // 将zip 包里面的自定义组件源码解析到 src/components 目录下
+    const cmpResult = await createCmpByZip(codeLib, cmpType, './src/components');
+    if (!cmpResult) {
+      spinner.fail(`拉取失败，${cmpType}自定义组件源码解析失败，请检查源码文件是否正确。`);
+      process.exit(1);
+    }
+
+    spinner.succeed(`已成功拉取${cmpType}自定义组件！\n`);
+  } catch (error) {
+    spinner.fail(`拉取自定义组件失败: ${error.message}`);
+    throw error;
+  }
+};
+
+module.exports = pullCmp;

package/src/{cmpUtils → utils/cmpUtils}/pushCmp.js

@@ -1,53 +1,17 @@
 const fs = require('fs');
 const path = require('path');
 const _ = require('lodash');
-const { catchCurPackageJson } = require('../utils/pathUtils');
-const getConfigObj = require('../utils/getConfigObj');
+const { catchCurPackageJson } = require('../pathUtils');
+const getConfigObj = require('../getConfigObj');
 const ora = require('ora');
-const NeoService = require('../neo/neoService');
-const { consoleTag } = require('../utils/neoParams');
+const NeoService = require('../../neo/neoService');
+const { getFramework } = require('../common');
 const createCmpProjectZip = require('../projectUtils/createCmpProjectZip');
 
 // 获取当前项目的package文件
 const currentPackageJsonDir = catchCurPackageJson();
 const currentPackageJson = getConfigObj(currentPackageJsonDir);
 
-/**
- * 获取技术栈标识
- * 目的：兼容用户非标准写法
- * 0: React, 1: vue2, 2: jQuery, 3: vue3
- */
-function getFramework(_framework) {
-  let defaultFramework = '0'; // 默认 React 技术栈
-  if (!_framework) {
-    return defaultFramework;
-  }
-  let curFramework = _framework.toLowerCase().trim();
-  switch (curFramework) {
-    case 'jquery':
-    case 'jq':
-      curFramework = '2';
-      break;
-    case 'vue2':
-    case 'vue 2':
-    case 'vue2.0':
-    case 'vue 2.0':
-      curFramework = '1';
-      break;
-    case 'vue':
-    case 'vue3':
-    case 'vue 3':
-    case 'vue3.0':
-    case 'vue 3.0':
-      curFramework = '3';
-      console.error(`${consoleTag} 暂不支持 vue3.0 技术栈。`);
-      break;
-    default:
-      curFramework = '0';
-  }
-  return curFramework;
-}
-
 /**
  * 构建组件数据映射
  * @param {string} assetsRoot 构建产物的目录
@@ -61,7 +25,7 @@ const buildComponentData = async (assetsRoot, cmpInfo) => {
   }
 
   const { cmpType } = cmpInfo;
-  
+
   if (!assetsRoot || !fs.existsSync(assetsRoot)) {
     console.error(`未找到自定义组件目录: ${assetsRoot}`);
     return null;
@@ -76,7 +40,7 @@ const buildComponentData = async (assetsRoot, cmpInfo) => {
     globalThis.window = {
       console: console,
       neoRequire: () => {},
-      postMessage: () => {},
+      postMessage: () => {}
       // 可以添加其他常用的 window 属性
     };
   }
@@ -88,17 +52,18 @@ const buildComponentData = async (assetsRoot, cmpInfo) => {
       let modelModule = require(modelFile);
       // 获取导出的模型类（可能是 default 导出或命名导出）
       // const CatchCustomCmpModelClass = modelModule.default || modelModule;
-    }
-    else {
+    } else {
       console.error(`未找到自定义组件模型文件，请检查以下路径是否存在：`, modelFile);
       return null;
     }
-    if (!window.NEOEditorCustomModels) {
-      console.error(`模型文件未导出有效模型方法（CatchCustomCmpModelClass），模型文件地址： ${modelFile} `);
+    if (!globalThis.window || !globalThis.window.NEOEditorCustomModels) {
+      console.error(
+        `模型文件未导出有效模型方法（CatchCustomCmpModelClass），模型文件地址： ${modelFile} `
+      );
       return null;
     }
 
-    const ModelClass = window.NEOEditorCustomModels[cmpType];
+    const ModelClass = globalThis.window.NEOEditorCustomModels[cmpType];
     if (!ModelClass) {
       console.error(`未找到自定义组件模型类（${cmpType}），模型文件地址： ${modelFile} `);
       return null;
@@ -116,7 +81,8 @@ const buildComponentData = async (assetsRoot, cmpInfo) => {
       ...cmpInfo,
       plugin: cmpInfo.modelAsset,
       version: currentPackageJson.version || '1.0.0',
-      framework: currentPackageJson.framework ? getFramework(currentPackageJson.framework) : '0', // 0: React, 1: vue2, 2: jQuery, 3: vue3
+      // 技术栈标识: 从 package.json / framework 字段获取，没有则默认 为 react ts 技术栈
+      framework: currentPackageJson.framework ? getFramework(currentPackageJson.framework) : 0, // 0: React, 1: vue2, 2: jQuery, 3: vue3
       // 从模型实例中提取并设置组件信息
       label: modelInstance.label || cmpType,
       description: modelInstance.description || '',
@@ -128,9 +94,11 @@ const buildComponentData = async (assetsRoot, cmpInfo) => {
       events: modelInstance.events || [],
       actions: modelInstance.actions || [],
       // 如果模型实例中有其他属性，也可以添加
-      exposedToDesigner: modelInstance.exposedToDesigner !== undefined ? modelInstance.exposedToDesigner : true,
+      exposedToDesigner:
+        modelInstance.exposedToDesigner !== undefined ? modelInstance.exposedToDesigner : true,
       namespace: modelInstance.namespace || 'neo-cmp-cli',
-      enableDuplicate: modelInstance.enableDuplicate !== undefined ? modelInstance.enableDuplicate : true
+      enableDuplicate:
+        modelInstance.enableDuplicate !== undefined ? modelInstance.enableDuplicate : true
     };
 
     console.log(`自定义组件模型信息（${cmpType}）:`, curCmpInfo);
@@ -152,15 +120,13 @@ const buildComponentData = async (assetsRoot, cmpInfo) => {
 /**
  * 发布组件到 NeoCRM
  * @param {object} config 配置信息
- * @param {string} assetsRoot 构建产物的目录
+ * @param {string} cmpType 自定义组件类型
  */
 const pushCmp = async (config, cmpType) => {
-  const {
-    authConfig: credentials
-  } = config;
+  const { auth: credentials } = config;
 
   if (!credentials) {
-    console.error('未找到 NeoCRM 平台授权配置（neo.config.js / pushCmp / authConfig）。');
+    console.error('未找到 NeoCRM 平台授权配置（neo.config.js / neoConfig）');
     return;
   }
 
@@ -168,33 +134,77 @@ const pushCmp = async (config, cmpType) => {
 
   try {
     // 步骤 1: 初始化 NeoService
-    spinner.text = '发布自定义组件：初始化 NeoService...';
-    const neoService = new NeoService(config);
+    let neoService = new NeoService(config);
+    // 获取 token
+    await neoService.ensureValidToken();
 
     // 步骤 2: 打包源码文件（打包单个自定义组件源码）
-    spinner.text = '发布自定义组件：打包源码文件（含单个自定义组件源码）...';
-    createCmpProjectZip(cmpType, process.cwd(), config.assetsRoot);
+    spinner.start(`[1/4] 打包源码文件（含单个自定义组件源码）...`);
+    let zipPath;
+    try {
+      zipPath = createCmpProjectZip(cmpType, process.cwd(), config.assetsRoot);
+      if (!zipPath) {
+        spinner.fail('[1/4] 源码文件打包失败，未返回 zip 文件路径。');
+      } else {
+        spinner.succeed(`[1/4] 源码文件打包完成: ${path.basename(zipPath)}。`);
+      }
+    } catch (error) {
+      spinner.fail(`[1/4] 源码文件打包失败。`);
+    }
 
     // 步骤 3: 上传构建后资源文件
-    spinner.text = '发布自定义组件：上传自定义组件构建产物到 OSS...';
-    const cmpInfo = await neoService.publish2oss(cmpType);
-
-    // 步骤 5: 构建组件数据
-    spinner.text = '发布自定义组件：构建组件数据...';
-    const componentInfo = await buildComponentData(config.assetsRoot, cmpInfo);
-    if (!componentInfo) {
-      throw new Error(`构建组件数据失败，未获取到自定义组件模型信息。（${cmpType}）`);
+    spinner.start(`[2/4] 上传自定义组件构建产物到 OSS...`);
+    let cmpInfo;
+    try {
+      cmpInfo = await neoService.publish2oss(cmpType);
+      if (!cmpInfo || !cmpInfo.cmpType) {
+        spinner.fail('[2/4] 上传构建产物失败，未获取到组件信息。');
+      } else {
+        spinner.succeed(`[2/4] 构建产物上传完成。`);
+      }
+    } catch (error) {
+      spinner.fail(`[2/4] 构建产物上传失败。`);
     }
 
-    // 步骤 6: 保存组件信息
-    spinner.text = '发布自定义组件：保存组件信息...';
-    await neoService.updateCustomComponent(componentInfo);
+    // 步骤 4: 构建组件数据
+    spinner.start(`[3/4] 构建组件数据...`);
+    let componentInfo;
+    try {
+      componentInfo = await buildComponentData(config.assetsRoot, cmpInfo);
+      if (!componentInfo) {
+        spinner.fail(`[3/4] 未获取到自定义组件模型信息（${cmpType}）。`);
+      } else {
+        spinner.succeed(`[3/4] 组件数据构建完成。`);
+      }
+    } catch (error) {
+      spinner.fail(`[3/4] 组件数据构建失败: `, error.message);
+    }
 
-    spinner.succeed('自定义组件发布成功！\n', componentInfo);
+    // 步骤 5: 保存组件信息
+    spinner.start(`[4/4] 保存组件信息到 NeoCRM 平台...`);
+    try {
+      await neoService.updateCustomComponent(componentInfo);
+      spinner.succeed(`[4/4] 组件信息保存成功`);
+    } catch (error) {
+      spinner.fail(`[4/4] 组件信息保存失败`);
+    }
+
+    // 最终成功提示
+    console.log('\n✅ 自定义组件发布成功！');
   } catch (error) {
-    spinner.fail(`自定义组件发布失败: ${error.message}`);
+    // 内层 catch 已经处理了步骤错误并显示了 spinner 失败状态
+    // 这里处理未预期的错误（如果 spinner 还在运行）
+    try {
+      // ora 的 spinner 对象可能没有 isSpinning 属性，使用 try-catch 安全访问
+      if (spinner && spinner.isSpinning) {
+        spinner.fail(`❌ 自定义组件发布失败: ${error.message}`);
+      }
+    } catch {
+      // 如果访问失败或 spinner 已停止，直接输出错误信息
+      console.error(`\n❌ 自定义组件发布失败: ${error.message}`);
+    }
     throw error;
   }
 };
 
-module.exports = pushCmp;
+module.exports = pushCmp;

package/src/utils/common.js

@@ -0,0 +1,48 @@
+const { consoleTag } = require('./neoParams');
+/**
+ * 获取技术栈标识
+ * 目的：兼容用户非标准写法
+ * 0: React, 1: vue2, 2: jQuery, 3: vue3
+ */
+function getFramework(_framework) {
+  let defaultFramework = 0; // 默认 React 技术栈
+  if (!_framework) {
+    return defaultFramework;
+  }
+  let curFramework = _framework.toLowerCase().trim();
+  switch (curFramework) {
+    case 'jquery':
+    case 'jq':
+      curFramework = 2;
+      break;
+    case 'vue2':
+    case 'vue 2':
+    case 'vue2.0':
+    case 'vue 2.0':
+      curFramework = 1;
+      break;
+    case 'vue':
+    case 'vue3':
+    case 'vue 3':
+    case 'vue3.0':
+    case 'vue 3.0':
+      curFramework = 3;
+      console.error(`${consoleTag} 暂不支持 vue3.0 技术栈。`);
+      break;
+    case 'react-js':
+      console.error(`${consoleTag} 暂不支持 react-js 技术栈。`);
+      curFramework = 0;
+      break;
+    case 'react':
+    case 'react-ts':
+      curFramework = 0;
+      break;
+    default:
+      curFramework = 0;
+  }
+  return curFramework;
+}
+
+module.exports = {
+  getFramework
+};

package/src/utils/generateEntries.js

@@ -0,0 +1,73 @@
+const getEntries = require('./projectUtils/getEntries');
+const getEntriesWithAutoRegister = require('./projectUtils/getEntriesWithAutoRegister');
+
+/**
+ * 生成 entry 配置
+ * @param {object} options 配置选项
+ * @param {object} options.configEntry 当前配置中的 entry（如果已存在则直接返回）
+ * @param {boolean} options.disableAutoRegister 是否禁用自动注册
+ * @param {string} options.componentsDir 组件目录路径
+ * @param {string} options.entryType entry 类型：'widget' | 'linkDebug'，默认为 'widget'
+ * @param {string} [options.cmpType] 可选的组件类型，如果指定则只生成该组件的 entry
+ * @param {boolean} [options.forceGetCmpTypes] 即使 entry 已存在，也强制获取 cmpTypes，默认为 false
+ * @returns {object} { entries: object, cmpTypes: array } 如果 configEntry 已存在且 forceGetCmpTypes 为 false，则返回 { entries: configEntry, cmpTypes: [] }
+ */
+function generateEntries({
+  configEntry,
+  disableAutoRegister,
+  componentsDir,
+  entryType = 'widget',
+  cmpType,
+  forceGetCmpTypes = false
+}) {
+  // 如果已配置 entry 且不需要强制获取 cmpTypes，直接返回
+  if (configEntry && Object.keys(configEntry).length > 0 && !forceGetCmpTypes) {
+    return {
+      entries: configEntry,
+      cmpTypes: []
+    };
+  }
+
+  // 根据 disableAutoRegister 选择不同的生成方法
+  let entriesResult;
+  if (disableAutoRegister) {
+    // disableAutoRegister 为 true 时，仅自动生成入口文件（不自动注册）
+    entriesResult = getEntries(componentsDir, cmpType);
+  } else {
+    // 自动生成入口文件（并自动创建对应的注册文件）
+    entriesResult = getEntriesWithAutoRegister(componentsDir, cmpType);
+  }
+
+  // 根据 entryType 选择对应的 entries
+  let entries;
+  if (entryType === 'linkDebug') {
+    entries = entriesResult.linkDebugEntries || {};
+  } else {
+    entries = entriesResult.widgetEntries || {};
+  }
+
+  const cmpTypes = entriesResult.cmpTypes || [];
+
+  // 如果 entry 已存在但需要获取 cmpTypes，使用已存在的 entry
+  if (configEntry && Object.keys(configEntry).length > 0 && forceGetCmpTypes) {
+    entries = configEntry;
+  }
+
+  // 验证 entries 是否有效（仅在需要生成新 entry 时验证）
+  if (
+    (!configEntry || Object.keys(configEntry).length === 0) &&
+    (!entries || Object.keys(entries).length === 0)
+  ) {
+    const defaultComponentsDir = componentsDir || './src/components';
+    throw new Error(
+      `未识别到自定义组件，请检查 ${defaultComponentsDir} 目录下是否存在自定义组件。`
+    );
+  }
+
+  return {
+    entries: entries || configEntry || {},
+    cmpTypes
+  };
+}
+
+module.exports = generateEntries;

package/src/{projectUtils → utils/projectUtils}/createCmpProjectByTemplate.js

@@ -1,15 +1,15 @@
 const fs = require('fs-extra');
 const path = require('path');
-const { consoleTag } = require('../utils/neoParams'); // 输出标记
-const { replaceInPackage } = require('../utils/replaceInPackage');
-const { resetPackageVersion } = require('../utils/resetPackageVersion');
-const autoEntryRootDir = require('../utils/autoEntryRootDir');
+const { consoleTag } = require('../neoParams'); // 输出标记
+const { replaceInPackage } = require('../replaceInPackage');
+const { resetPackageVersion } = require('../resetPackageVersion');
+const autoEntryRootDir = require('../autoEntryRootDir');
 const hasNeoProject = require('./hasNeoProject');
 
 const cmpTemplateList = {
   'react-ts': {
     projectName: 'empty-custom-cmp-template',
-    dir: path.resolve(__dirname, '../template/empty-custom-cmp-template')
+    dir: path.resolve(__dirname, '../../template/empty-custom-cmp-template')
   }
 };
 
@@ -22,12 +22,16 @@ module.exports = function (projectName, type = 'react-ts') {
   const finalProjectPath = path.resolve(process.cwd(), projectName);
 
   if (hasNeoProject()) {
-    console.error(`${consoleTag}创建自定义组件项目失败，当前目录（${process.cwd()}）已经是一个自定义组件项目，请勿重复创建。`);
+    console.error(
+      `${consoleTag}创建自定义组件项目失败，当前目录（${process.cwd()}）已经是一个自定义组件项目，请勿重复创建。`
+    );
     process.exit(1);
   }
 
   if (fs.existsSync(finalProjectPath)) {
-    console.error(`${consoleTag}创建自定义组件项目失败，当前已存在（${projectName}）项目，请勿创建重名项目。`);
+    console.error(
+      `${consoleTag}创建自定义组件项目失败，当前已存在（${projectName}）项目，请勿创建重名项目。`
+    );
     process.exit(1);
   }