neo-cmp-cli 1.5.1 → 1.5.3

package/src/neo/neoService.js

@@ -3,14 +3,14 @@ const FormData = require('form-data');
 const fs = require('fs');
 const path = require('path');
 const _ = require('lodash');
-const updatePublishLog = require('../cmpUtils/updatePublishLog');
+const updatePublishLog = require('../projectUtils/updatePublishLog');
 
 // NeoCRM 平台默认 API 配置
 const NeoCrmAPI = {
   neoBaseURL: 'https://crm.xiaoshouyi.com', // 平台根地址
-  tokenAPI: 'https://login.crm.xiaoshouyi.com/auc/oauth2/token', // Token 获取接口地址
+  tokenAPI: 'https://login.xiaoshouyi.com/auc/oauth2/token', // Token 获取接口地址
   uploadAPI: '/rest/metadata/v3.0/ui/customComponents/actions/upload', // 文件上传接口地址
-  saveAPI: '/rest/metadata/v3.0/ui/customComponents/actions/saveComponent' // 组件信息保存接口地址
+  saveAPI: '/rest/metadata/v3.0/ui/customComponents/actions/saveOrUpdateComponent' // 创建或者保存接口地址
 };
 
 /**
@@ -23,32 +23,32 @@ class NeoService {
    * @param {object} config 配置信息
    * @param {string} config.neoBaseURL Neo 平台根地址
    * @param {string} config.tokenAPI Token 获取接口地址
-   * @param {object} config.authorization 授权信息
-   * @param {string} config.authorization.client_id 客户端 ID
-   * @param {string} config.authorization.client_secret 客户端密钥
-   * @param {string} config.authorization.username 用户名
-   * @param {string} config.authorization.password 密码
+   * @param {object} config.authConfig 授权信息
+   * @param {string} config.authConfig.client_id 客户端 ID
+   * @param {string} config.authConfig.client_secret 客户端密钥
+   * @param {string} config.authConfig.username 用户名
+   * @param {string} config.authConfig.password 密码
    */
   constructor(config = {}) {
-    const { assetsRoot, neoBaseURL, tokenAPI, authorization } = config;
-    if (!authorization) {
-      throw new Error('authorization 不能为空');
+    const { assetsRoot, neoBaseURL, tokenAPI, authConfig } = config;
+    if (!authConfig) {
+      throw new Error('authConfig 不能为空');
     }
     if (
-      !authorization.client_id ||
-      !authorization.client_secret ||
-      !authorization.username ||
-      !authorization.password
+      !authConfig.client_id ||
+      !authConfig.client_secret ||
+      !authConfig.username ||
+      !authConfig.password
     ) {
       throw new Error(
-        'authorization 配置不完整，需要包含 client_id、client_secret、username、password'
+        'authConfig 配置不完整，需要包含 client_id、client_secret、username、password'
       );
     }
 
     this.assetsRoot = assetsRoot;
     this.neoBaseURL = neoBaseURL || NeoCrmAPI.neoBaseURL;
     this.tokenAPI = tokenAPI || NeoCrmAPI.tokenAPI;
-    this.authorization = authorization;
+    this.authConfig = authConfig;
 
     // Token 缓存
     this.tokenCache = {
@@ -101,29 +101,30 @@ class NeoService {
       console.info('使用缓存的 token');
       return this.tokenCache.token;
     }
+    console.info('获取 token...');
 
-    console.info('正在获取 token...');
+    // 构建表单数据格式的请求参数
+    const formData = new URLSearchParams();
+    formData.append('grant_type', 'password');
+    formData.append('client_id', this.authConfig.client_id);
+    formData.append('client_secret', this.authConfig.client_secret);
+    formData.append('username', this.authConfig.username);
+    formData.append('password', this.authConfig.password);
+
+    const tokenUrl = this.buildFullUrl(this.tokenAPI);
 
     try {
-      // 构建请求参数
-      const params = new URLSearchParams();
-      params.append('grant_type', 'password');
-      params.append('client_id', this.authorization.client_id);
-      params.append('client_secret', this.authorization.client_secret);
-      params.append('username', this.authorization.username);
-      params.append('password', this.authorization.password);
-
-      const tokenUrl = this.buildFullUrl(this.tokenAPI);
-      const response = await axios.post(tokenUrl, params, {
+      const response = await axios.post(tokenUrl, formData.toString(), {
         headers: {
           'Content-Type': 'application/x-www-form-urlencoded'
         }
       });
 
-      const { access_token, expires_in } = response.data;
+      const { access_token, expires_in } = response.data || {};
 
       if (!access_token) {
-        throw new Error('获取 token 失败：响应中未包含 access_token');
+        console.error('\n获取 token 失败：响应中未包含 access_token', response.data);
+        process.exit(1);
       }
 
       // 缓存 token（提前 60 秒过期，避免边缘情况）
@@ -132,15 +133,15 @@ class NeoService {
         token: access_token,
         expiresAt: Date.now() + (expiresIn - 60) * 1000
       };
-
-      console.info('token 获取成功');
       return access_token;
     } catch (error) {
-      console.error('获取 token 失败:', error.message);
+      console.error('\n获取 token 失败:', error.message);
+      console.error('\ntoken 授权地址:', tokenUrl);
+      console.error('\ntoken 请求参数:', formData);
       if (error.response) {
         console.error('响应数据:', error.response.data);
       }
-      throw error;
+      process.exit(1);
     }
   }
 
@@ -163,7 +164,9 @@ class NeoService {
    * @returns {Promise<string>} 有效的 token
    */
   async ensureValidToken() {
-    if (this.isTokenExpired()) {
+    if (!this.tokenCache.token) {
+      return await this.getToken();
+    } else if (this.isTokenExpired()) {
       console.info('token 已过期，正在刷新...');
       return await this.refreshToken();
     }
@@ -174,59 +177,155 @@ class NeoService {
    * 上传文件到 Neo 平台
    * @param {string} filePath 文件路径
    * @param {object} options 可选配置
-   * @param {string} options.fieldName 表单字段名，默认为 'file'
+   * @param {string} options.fieldName 表单字段名，默认为 'customComponentCode'
+   * @param {number} options.maxSize 最大文件大小（字节），默认 50MB
+   * @param {number} options.timeout 超时时间（毫秒），默认 60000
    * @returns {Promise<string>} CDN 地址或文件 URL
    */
   async uploadFile(filePath, options = {}) {
     // 确保 token 有效
     const token = await this.ensureValidToken();
 
+    // 验证文件路径
+    if (!filePath || typeof filePath !== 'string') {
+      throw new Error(`文件路径无效: ${filePath}`);
+    }
+
+    // 检查文件是否存在
     if (!fs.existsSync(filePath)) {
       throw new Error(`文件不存在: ${filePath}`);
     }
 
-    console.info('正在上传文件...');
+    // 检查文件状态
+    const fileStat = fs.statSync(filePath);
+    if (!fileStat.isFile()) {
+      throw new Error(`路径不是文件: ${filePath}`);
+    }
+
+    // 检查文件大小
+    const maxSize = options.maxSize || 50 * 1024 * 1024; // 默认 50MB
+    if (fileStat.size > maxSize) {
+      const sizeMB = (fileStat.size / 1024 / 1024).toFixed(2);
+      const maxSizeMB = (maxSize / 1024 / 1024).toFixed(2);
+      throw new Error(`文件大小超过限制: ${sizeMB}MB > ${maxSizeMB}MB`);
+    }
+
+    if (fileStat.size === 0) {
+      throw new Error(`文件为空: ${filePath}`);
+    }
+
+    const fileName = path.basename(filePath);
+    const fileSizeKB = (fileStat.size / 1024).toFixed(2);
+    console.info(`正在上传文件: ${fileName} (${fileSizeKB}KB)...`);
 
     try {
+      // 创建 FormData
       const formData = new FormData();
       const fieldName = options.fieldName || 'customComponentCode';
-      formData.append(fieldName, fs.createReadStream(filePath));
+      
+      // 使用文件流而不是读取整个文件到内存（对大文件更友好）
+      const fileContent = fs.createReadStream(filePath);
+
+      // 追加文件到 FormData，第三个参数指定文件名
+      formData.append(fieldName, fileContent, fileName);
 
+      // 构建完整的上传 API 地址
       const fullUploadAPI = this.uploadAPI();
-      const response = await axios.post(fullUploadAPI, formData, {
+
+      // 配置请求选项
+      const timeout = options.timeout || 60000; // 默认 60 秒
+      const requestConfig = {
         headers: {
           Authorization: `Bearer ${token}`,
+          'xsy-inner-source': 'bff',
+          // 无需手动设置 Content-Type，formData.getHeaders() 会自动设置正确的 multipart/form-data 和 boundary
           ...formData.getHeaders()
-        }
-      });
+        },
+        timeout,
+        // 确保 axios 正确处理大文件和流
+        maxContentLength: Infinity, // 不限制响应内容长度
+        maxBodyLength: Infinity // 不限制请求体长度（适用于文件上传）
+      };
 
-      // 处理不同的响应格式
+      // 发送上传请求
+      const response = await axios.post(fullUploadAPI, formData, requestConfig);
+
+      // 处理响应数据
       let resultData;
-      if (typeof response.data === 'string') {
-        resultData = response.data;
-      } else if (response.data && response.data.data) {
-        resultData = response.data.data;
-      } else if (response.data && response.data.code === 200) {
-        resultData = response.data.data;
-      } else {
-        resultData = response.data;
+      const responseData = response.data;
+
+      // 检查响应状态码
+      if (response.status !== 200 && response.status !== 201) {
+        throw new Error(`上传失败: HTTP ${response.status}`);
       }
 
-      if (response.data && response.data.code && response.data.code !== 200) {
-        throw new Error(`上传失败: ${response.data.message || '未知错误'}`);
+      // 处理不同的响应格式
+      if (typeof responseData === 'string') {
+        // 如果响应是字符串，直接使用
+        resultData = responseData.trim();
+      } else if (responseData && typeof responseData === 'object') {
+        // 检查是否有错误码
+        if (responseData.code !== undefined && responseData.code !== 200 && responseData.code !== 0) {
+          const errorMsg = responseData.message || responseData.msg || '未知错误';
+          throw new Error(`上传失败: ${errorMsg} (code: ${responseData.code})`);
+        }
+
+        // 提取数据
+        if (responseData.data !== undefined) {
+          resultData = responseData.data;
+        } else if (responseData.url !== undefined) {
+          resultData = responseData.url;
+        } else if (responseData.fileUrl !== undefined) {
+          resultData = responseData.fileUrl;
+        } else {
+          resultData = responseData;
+        }
+      } else {
+        throw new Error(`响应数据格式不正确: ${typeof responseData}`);
       }
 
-      if (!resultData || (typeof resultData !== 'string' && !resultData.url)) {
-        throw new Error(`返回的文件地址格式不正确: ${JSON.stringify(resultData)}`);
+      // 验证返回的文件地址
+      if (!resultData) {
+        throw new Error(`返回的文件地址为空`);
       }
 
-      const fileUrl = typeof resultData === 'string' ? resultData : resultData.url;
+      // 格式化文件 URL
+      let fileUrl;
+      if (typeof resultData === 'string') {
+        fileUrl = resultData;
+      } else if (resultData && typeof resultData === 'object' && resultData.url) {
+        fileUrl = resultData.url;
+      }
+      console.info(`\n文件上传成功: ${fileName} -> ${fileUrl}`);
       return fileUrl;
     } catch (error) {
-      console.error('上传文件失败:', error.message);
+      console.error(`\n上传文件失败: ${error.message}，`);
+      console.error(`文件路径: ${filePath}。\n`);
+      
+      // 输出详细的错误信息
       if (error.response) {
-        console.error('响应数据:', error.response.data);
+        const status = error.response.status;
+        const statusText = error.response.statusText;
+        const responseData = error.response.data;
+        const requestUrl = error.config?.url || this.uploadAPI();
+        
+        console.error(`\n========== 上传请求详情 ==========`);
+        console.error(`请求 URL: ${requestUrl}`);
+        console.error(`HTTP 状态码: ${status} ${statusText}`);
+        console.error(`响应数据:`, responseData);
+        console.error(`==================================\n`);
+        
+        if (status === 404) {
+          throw new Error(
+            `上传 API 不存在 (404): ${requestUrl}\n` +
+            `请检查 neo.config.js 中的 neoBaseURL 配置是否正确，或者 API 路径是否存在。\n` +
+            `当前配置的 API 路径: ${NeoCrmAPI.uploadAPI}`
+          );
+        }
+      } else if (error.request) {
+        console.error('请求已发送但未收到响应，请检查网络连接或代理配置。');
       }
+      
       throw error;
     }
   }
@@ -238,7 +337,7 @@ class NeoService {
    * @param {array} fileExtensions 需要上传的文件类型，默认 ['.js', '.css']
    */
   async publish2oss(cmpType, fileExtensions = ['.js', '.css']) {
-    if (!fs.existsSync(cmpType)) {
+    if (!cmpType) {
       console.error(`自定义组件名称不能为空: ${cmpType}`);
       return;
     }
@@ -262,7 +361,7 @@ class NeoService {
       // const fileExt = path.extname(file);
       const fileInfo = path.parse(filePath);
       if (fileStat.isFile() && fileExtensions.includes(fileInfo.ext)) {
-        let widgetName = _.kebabCase(cmpType);
+        let widgetName = _.camelCase(cmpType);
 
         if (file.indexOf(widgetName) < 0) {
           return;
@@ -271,7 +370,7 @@ class NeoService {
         try {
           // 上传文件
           const fileUrl = await this.uploadFile(filePath);
-          
+
           if (file.indexOf('Model') > -1) {
             curCmpInfo.modelAsset = fileUrl;
           } else if (file.endsWith('.css')) {
@@ -279,15 +378,15 @@ class NeoService {
           } else {
             curCmpInfo.asset = fileUrl;
           }
-
         } catch (error) {
-          console.error(`文件上传失败（${file}）：\n`, error);
+          console.error(`文件上传失败（${file}）：\n`);
+          process.exit(1);
         }
       }
     });
 
     await Promise.all(uploadPromises);
-    
+
     if (curCmpInfo && curCmpInfo.cmpType) {
       console.info('上传至 OSS 的文件信息：\n', curCmpInfo);
       // 更新发布日志
@@ -298,7 +397,6 @@ class NeoService {
 
   /**
    * 更新自定义组件
-   * @param {string} updateAPI 更新接口地址（相对或绝对路径）
    * @param {object} componentData 组件数据
    * @returns {Promise<object>} 更新结果
    */
@@ -313,26 +411,29 @@ class NeoService {
     console.info('正在更新自定义组件...');
 
     try {
-      const fullUpdateAPI = this.updateAPI();
+      const fullUpdateAPI = this.saveAPI();
       const response = await axios.post(fullUpdateAPI, componentData, {
         headers: {
           Authorization: `Bearer ${token}`,
+          'xsy-inner-source': 'bff',
           'Content-Type': 'application/json'
         }
       });
+      const {code, message} = response.data || {};
 
-      if (response.data && response.data.code && response.data.code !== 200) {
+      if (code && code !== 200) {
         throw new Error(`更新组件失败: ${response.data.message || '未知错误'}`);
       }
+      
 
-      console.info('组件更新成功:', response.data);
-      return response.data;
+      console.info(message ? `组件更新成功: ${message}。` : '组件更新成功。');
     } catch (error) {
-      console.error('更新组件失败:', error.message);
-      if (error.response) {
-        console.error('响应数据:', error.response.data);
+      if (error.message) {
+        console.error('更新组件失败:', error.message);
+      } else {
+        console.error('响应数据:', error);
       }
-      throw error;
+      process.exit(1);
     }
   }
 
@@ -361,6 +462,7 @@ class NeoService {
         params,
         headers: {
           Authorization: `Bearer ${token}`,
+          'xsy-inner-source': 'bff',
           ...headers
         }
       });

package/src/neo/wrapperContent.js

@@ -1,6 +1,7 @@
 /**
  * 注入 neoRequire 函数
  * 备注：用于实现和 Neo 平台共享依赖
+ * 特别说明：这个文件只是用于说明 AddNeoRequirePlugin 中会插入的代码内容，实际内容内置在 AddNeoRequirePlugin 方法中。
  */
 (function(NeoCustomCmpFileFactory) {
   if (!window.neoRequire) {
@@ -12,4 +13,4 @@
    * 这里放自定义组件相关内容代码
    * 备注: 自定义组件代码中的 require 函数 已被替换成 neoRequire 函数（require === neoRequire）。
    */
-});
+});

package/src/oss/publish2oss.js

@@ -4,7 +4,7 @@ const path = require('path');
 const _ = require('lodash');
 const { catchCurPackageJson } = require('../utils/pathUtils');
 const getConfigObj = require('../utils/getConfigObj');
-const updatePublishLog = require('../cmpUtils/updatePublishLog');
+const updatePublishLog = require('../projectUtils/updatePublishLog');
 
 // 获取当前项目的package文件
 const currentPackageJsonDir = catchCurPackageJson();

package/src/plugins/AddNeoRequirePlugin.js

@@ -1,5 +1,6 @@
 const { ConcatSource } = require('webpack-sources');
-
+const fs = require('fs');
+const path = require('path');
 /**
  * 注入 neoRequire 函数
  * 备注：用于实现和 Neo 平台共享依赖
@@ -163,7 +164,9 @@ class AddNeoRequirePlugin {
 })(function(require) {
                 `;
 
-    const Footer = `})`;
+    // const NeoUMDContent = fs.readFileSync(path.join(__dirname, '../neo/NeoUMDContent.js'), 'utf8');
+    // const Footer = `}); \n${NeoUMDContent}`;
+    const Footer = `});`;
 
     // 创建新的资源
     const newSource = new ConcatSource(Header, content, Footer);

package/src/projectUtils/createCmpProjectByTemplate.js

@@ -0,0 +1,55 @@
+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 hasNeoProject = require('./hasNeoProject');
+
+const cmpTemplateList = {
+  'react-ts': {
+    projectName: 'empty-custom-cmp-template',
+    dir: path.resolve(__dirname, '../template/empty-custom-cmp-template')
+  }
+};
+
+/**
+ * 通过拷贝模板创建自定义组件
+ * @param {*} projectName 自定义组件项目名称
+ * @param {*} type 自定义组件类型
+ */
+module.exports = function (projectName, type = 'react-ts') {
+  const finalProjectPath = path.resolve(process.cwd(), projectName);
+
+  if (hasNeoProject()) {
+    console.error(`${consoleTag}创建自定义组件项目失败，当前目录（${process.cwd()}）已经是一个 自定义组件项目，请勿重复创建。`);
+    process.exit(1);
+  }
+
+  if (fs.existsSync(finalProjectPath)) {
+    console.error(`${consoleTag}创建自定义组件项目失败，当前已存在（${projectName}）项目，请勿创建重名项目。`);
+    process.exit(1);
+  }
+
+  const curCmpTemplate = cmpTemplateList[type];
+  if (!curCmpTemplate) {
+    console.error(`${consoleTag}创建自定义组件项目失败，当前不支持${type}类型。`);
+    process.exit(1);
+  }
+
+  const currentTemplateDir = curCmpTemplate.dir;
+  const finalProjectName = projectName || 'neoCustomCmp';
+
+  fs.copy(currentTemplateDir, finalProjectPath)
+    .then(() => {
+      replaceInPackage(finalProjectPath, curCmpTemplate.projectName, finalProjectName);
+      replaceInPackage(finalProjectPath, 'wibetter', 'xxx');
+      replaceInPackage(finalProjectPath, 'neo自定义组件模板', 'neo自定义组件');
+      resetPackageVersion(finalProjectPath);
+
+      console.log(`${consoleTag}已创建自定义组件项目（${finalProjectName}）!`);
+      // 自动切换到项目根目录
+      autoEntryRootDir(finalProjectPath);
+    })
+    .catch((err) => console.error(`${consoleTag}自定义组件模板下载失败：`, err));
+};

package/src/{cmpUtils → projectUtils}/getEntriesWithAutoRegister.js

@@ -2,8 +2,8 @@ const fs = require('fs');
 const path = require('path');
 const _ = require('lodash');
 const { resolveToCurrentRoot } = require('../utils/pathUtils');
-const getCmpRegister = require('./getCmpRegister');
-const getCmpModelRegister = require('./getCmpModelRegister');
+const getCmpRegisterCode = require('../cmpUtils/getCmpRegisterCode');
+const getCmpModelRegisterCode = require('../cmpUtils/getCmpModelRegisterCode');
 /**
  * 从指定目录获取组件入口文件，并自动创建对应的注册文件
  * @param {*} defaultComponentsDir 默认组件目录
@@ -68,7 +68,7 @@ module.exports = (defaultComponentsDir = './src/components', cmpType) => {
           .forEach((filePath) => {
             if (filePath.match(/index\.[tj]sx?$/)) {
               // 自动创建对应的注册文件
-              const registerContent = getCmpRegister(componentsBaseDir, curCmpName);
+              const registerContent = getCmpRegisterCode(componentsBaseDir, curCmpName);
               const registerDir = `${cmpTempDir}/register.js`;
 
               // 写入注册文件
@@ -78,7 +78,7 @@ module.exports = (defaultComponentsDir = './src/components', cmpType) => {
               linkDebugEntries.index.push(registerDir);
             } else if (filePath.match(/model\.[tj]sx?$/)) {
               // 自动创建对应的模型注册文件
-              const modelRegisterContent = getCmpModelRegister(componentsBaseDir, curCmpName);
+              const modelRegisterContent = getCmpModelRegisterCode(componentsBaseDir, curCmpName);
               const modelRegisterDir = `${cmpTempDir}/model.js`;
 
               // 写入模型注册文件

package/src/projectUtils/hasNeoProject.js

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

package/src/template/antd-custom-cmp-template/README.md

@@ -37,10 +37,10 @@ $ npm run preview
 $ npm run linkDebug
 ```
 
-4. **发布到对象存储服务中**
+4. **发布到 NeoCRM 平台**
 > 需要确保 package.json 中的 name 值唯一，version 值不重复。
 ```bash
-$ npm run publish2oss
+$ npm run pushCmp
 ```
 
 ### 配置项说明（neo-cmp-cli）

package/src/template/antd-custom-cmp-template/neo.config.js

@@ -41,10 +41,12 @@ module.exports = {
   // 用于添加 Neo 共享依赖模块和剔除模块
   /*
   neoCommonModule: {
-    remotes: ['chart-widget'], // 远程自定义组件，表示当前自定义组件会用到的远程组件
-    neoExternals: ['chart-widget'], // 自定义组件中需要剔除的模块，仅支持数组写法，需要和 remotes 配合使用
     // neoExports: ['xxModule'], // 自定义组件 共享出来的模块，支持数组和对象形式
-    // neoExports: { 'xxModule': path.resolve('./src/components/xxModule') }, // 对象写法
+    neoExports: { // 对象写法
+      'xx-module': path.resolve('./src/components/xx-module'), // 导出 xx组件 或 xx模块
+    },
+    // remoteDeps: ['xxCmpType'], // 远程依赖组件，表示当前自定义组件会用到的依赖组件，需要和 neoExternals 配合使用
+    // neoExternals: ['xxModule'], // 自定义组件中需要剔除的模块（仅支持数组写法）
   },
   */
   preview: {
@@ -95,23 +97,29 @@ module.exports = {
     }
     */
   },
-  publish2oss: {
-    // 用于构建并发布至 OSS 的相关配置
+  pushCmp: {
+    // 用于构建并发布至 NeoCRM 的相关配置
+    neoBaseURL: 'https://crm-cd.xiaoshouyi.com', // 平台根地址（默认：https://crm.xiaoshouyi.com）
+    tokenAPI: 'https://login-cd.xiaoshouyi.com/auc/oauth2/token', // Token 获取接口地址（默认：https://login.xiaoshouyi.com/auc/oauth2/token）
+    // NeoCRM 授权配置
+    authConfig: {
+      client_id: 'xx', // 客户端 ID，从创建连接器的客户端信息中获取（Client_Id）
+      client_secret: 'xxx', // 客户端秘钥，从创建连接器的客户端信息中获取（Client_Secret）
+      username: 'xx', // 用户在销售易系统中的用户名
+      /**
+       * password 为 用户在销售易系统中的账号密码加上 8 位安全令牌。
+       * 例如，用户密码为 123456，安全令牌为 ABCDEFGH，则 password 的值应为 123456ABCDEFGH。
+       */
+      password: 'xx xx' // 用户账户密码 + 8 位安全令牌
+    },
     /*
     【特别说明】以下配置项都自带默认值，非必填。如需自定义请自行配置。
     NODE_ENV: 'production',
     entry: { // 根据 src/components 目录下的文件自动生成 entry 相关配置
-      InfoCardModel: './src/components/info-card/model.ts',
-      infoCard: './src/components/info-card/register.ts'
+      InfoCardModel: './src/components/entity-form/model.ts',
+      infoCard: './src/components/entity-form/register.ts'
     },
     cssExtract: false, // 不额外提取css文件
-    ossType: 'ali', // oss类型：ali、baidu
-    ossConfig: {
-      endpoint: 'https://oss-cn-beijing.aliyuncs.com',
-      AccessKeyId: 'xxx',
-      AccessKeySecret: 'xx',
-      bucket: 'neo-widgets' // 存储桶名称
-    },
     assetsRoot: resolve('dist') // 上传指定目录下的脚本文件
     */
   },

package/src/template/antd-custom-cmp-template/package.json

@@ -10,9 +10,9 @@
   "author": "wibetter",
   "license": "MIT",
   "scripts": {
-    "preview": "neo preview --cmpType=data-dashboard",
+    "preview": "neo preview",
     "linkDebug": "neo linkDebug",
-    "publish2oss": "neo publish2oss",
+    "pushCmp": "neo pushCmp",
     "format": "prettier --write \"src/**/**/*.{js,jsx,ts,tsx,vue,scss,json}\""
   },
   "files": [
@@ -47,7 +47,7 @@
     "@commitlint/config-conventional": "^9.1.1",
     "@types/react": "^16.9.11",
     "@types/react-dom": "^16.9.15",
-    "neo-cmp-cli": "^1.3.8",
+    "neo-cmp-cli": "^1.5.3",
     "husky": "^4.2.5",
     "lint-staged": "^10.2.9",
     "prettier": "^2.0.5"

package/src/template/develop/neo-custom-cmp-template/neo.config.js

@@ -46,8 +46,8 @@ module.exports = {
       'chart-widget': path.resolve('./src/components/chart-widget'), // 导出图表自定义组件
       'neo-register': 'neo-register', // 导出 Neo 注册模块
     },
+    // remoteDeps: ['xxModule'], // 远程依赖组件，表示当前自定义组件会用到的远程依赖组件，需要和 neoExternals 配合使用
     // neoExternals: ['xxModule'], // 自定义组件中需要剔除的模块，仅支持数组写法
-    // remotes: ['xxModule'], // 远程组件，表示当前自定义组件会用到的远程组件，需要和 neoExternals 配合使用
   },
   */
   preview: {