neo-cmp-cli 1.5.0-beta.5 → 1.5.0-beta.7

package/README.md

@@ -41,7 +41,7 @@ neo preview
 neo linkDebug
 
 # 构建并发布到 NeoCRM（需自行添加授权配置，并确保 package.json 的 name 唯一、version 不重复）
-neo publish2neo
+neo pushCmp
 ```
 
 ### 方法二：在现有业务项目中使用自定义组件开发工具
@@ -58,7 +58,7 @@ npm i neo-cmp-cli --save-dev
 ```bash
 "preview": "neo preview",
 "linkDebug": "neo linkDebug",
-"publish2neo": "neo publish2neo"
+"pushCmp": "neo pushCmp"
 ```
 ##### 3) 初始化配置文件
 ```bash
@@ -68,7 +68,7 @@ neo config init
 ```bash
 npm run preview
 npm run linkDebug
-npm run publish2oss
+npm run pushCmp
 ```
 
 ## 常用命令说明
@@ -76,11 +76,11 @@ npm run publish2oss
 - **neo preview**: 本地预览自定义组件内容，默认支持热更新与接口代理。
 - **neo linkDebug**: 外链调试模式，在平台端页面设计器中调试自定义组件。
 - **neo publish2oss**: 构建并上传到对象存储（可自定义配置对象存储）。
-- **neo publish2neo**: 构建并发布到NeoCRM平台（需自行添加授权配置）。
+- **neo pushCmp**: 构建并发布到NeoCRM平台（需自行添加授权配置）。
 
 ## 开发须知
 #### 1）默认自动识别自定义组件
-- **自动生成入口配置**: 当 `entry` 未配置时，自动从 `src/components` 目录下扫描并识别自定义组件，`src/components` 下的子目录名称作为自定义组件的 cmpType，并以其目录下的 `index.ts/.tsx/.js/.jsx` 文件作为组件内容文件，model.[tj]s 作为模型内容文件；
+- **自动生成入口配置**: 当 `entry` 未配置时，自动从 `src/components` 目录下扫描并识别自定义组件，`src/components` 下的子目录名称作为自定义组件的名称，并以其目录下的 `index.ts/.tsx/.js/.jsx` 文件作为组件内容文件，model.[tj]s 作为模型内容文件；
 - **自动注册自定义组件**: 当 `entry` 未配置时，自动生成自定义组件注册文件和模型注册文件，并注入到构建脚本中，无需用户手动编写注册文件（[neo-register](https://www.npmjs.com/package/neo-register)）。
 
 #### 2）设置自定义组件属性配置项
@@ -130,7 +130,7 @@ neo linkDebug
 将第 1 步生成的「外链脚本地址」添加进来，即可在此页面设计器 / 组件物料面板中看到对应自定义组件。
 
 #### 6）发布自定义组件至 NeoCRM
-执行 `neo publish2neo` 即可构建并发布自定义组件至 NeoCRM 平台，其构建后资源也会上传到 NeoCRM 平台端提供的 CDN 中。  
+执行 `neo pushCmp` 即可构建并发布自定义组件至 NeoCRM 平台，其构建后资源也会上传到 NeoCRM 平台端提供的 CDN 中。  
 
 ##### 发布前请确保
 - **package.json 的 name 唯一**
@@ -139,11 +139,11 @@ neo linkDebug
 ##### 需自行添加授权配置
 ```javascript
 module.exports = {
-  publishCmp: {
+  pushCmp: {
     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 授权配置
-    authorization: {
+    authConfig: {
       /**
        * 客户端 ID 和 客户端秘钥 需通过 创建连接器 获取，
        * 详细见：https://doc.xiaoshouyi.com / 创建连接器。
@@ -163,7 +163,7 @@ module.exports = {
 ```
 
 ##### 支持发布指定自定义组件
-执行 `neo publish2oss --cmpType=xxCmp`
+执行 `neo pushCmp --name=xxCmp`
 
 #### 7）发布自定义组件至CDN
 执行 `neo publish2oss` 即可构建对应自定义组件，并自动将构建后资源上传到对象存储（OSS）中。  
@@ -194,7 +194,7 @@ module.exports = {
 ```
 
 ##### 支持发布指定自定义组件
-执行 `neo publish2oss --cmpType=xxCmp`
+执行 `neo publish2oss --name=xxCmp`
 
 ## 项目工程配置说明（neo.config.js）
 neo-cmp-cli 默认提供完整配置； 
@@ -364,8 +364,8 @@ module.exports = {
 ```javascript
 module.exports = {
   neoCommonModule: {
-    remotes: ['neo-custom-cmpA'], // 远程自定义组件，表示当前自定义组件 B 会用到的自定义组件
-    neoExternals: ['xxModule_A'], // 自定义组件中需要剔除的模块（远程自定义组件中分享出来的模块），仅支持数组写法，需要和 remotes 配合使用
+    remoteDeps: ['neo-custom-cmpA'], // 远程自定义组件，表示当前自定义组件 B 会用到的自定义组件
+    neoExternals: ['xxModule_A'], // 自定义组件中需要剔除的模块（远程自定义组件中分享出来的模块），仅支持数组写法，需要和 remoteDeps 配合使用
   },
 }
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "neo-cmp-cli",
-  "version": "1.5.0-beta.5",
+  "version": "1.5.0-beta.7",
   "description": "前端脚手架：自定义组件开发工具，支持react 和 vue2.0技术栈。",
   "keywords": [
     "neo-cli",

package/src/cmpUtils/createCmpByTemplate.js

@@ -0,0 +1,50 @@
+const fs = require('fs-extra');
+const path = require('path');
+const _ = require('lodash');
+const { consoleTag } = require('../utils/neoParams'); // 输出标记
+const replaceInFilesByMap = require('../utils/replaceInFilesByMap');
+const hasCmpTypeByDir = require('./hasCmpTypeByDir');
+
+// 自定义组件内容模板信息
+const curCmpTemplate = {
+  // 需要替换掉的字段信息（模板中的字段）
+  widgetInfo: {
+    cmpName: 'CustomCmp',
+    modelName: 'CustomCmpModel',
+    cmpClassName: 'custom-cmp-container',
+    cmpType: 'xx-custom-cmp',
+    cmpLabel: 'xx组件',
+  },
+  dir: path.resolve(__dirname, '../template/empty-cmp')
+};
+
+/**
+ * 创建自定义组件
+ * @param {*} cmpName 自定义组件名称
+ */
+module.exports = function (cmpName) {
+  const currentTemplateDir = curCmpTemplate.dir;
+  const finalCmpName = cmpName || 'neoCustomCmp';
+  const finalCmpPath = path.resolve(process.cwd(), finalCmpName);
+
+  if (hasCmpTypeByDir(cmpType)) {
+    console.error(`${consoleTag}创建自定义组件失败，当前已经存在${cmpType}自定义组件。`);
+    process.exit(1);
+  }
+
+  fs.copy(currentTemplateDir, finalCmpPath)
+    .then(() => {
+      const curCmpName = _.camelCase(cmpName);
+      const cmpType = _.kebabCase(cmpName);
+      replaceInFilesByMap(finalCmpPath, {
+        [curCmpTemplate.widgetInfo.cmpName]: curCmpName,
+        [curCmpTemplate.widgetInfo.modelName]: `${curCmpName}Model`,
+        [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/cmpUtils/createCommonModulesCode.js

@@ -9,15 +9,15 @@ const { isPlainObject } = require('lodash');
  * @returns 组件预览代码
  */
 const createCommonModulesCode = (neoCommonModule, cmpTypes) => {
-  const {neoExports, remotes} = neoCommonModule;
+  const {neoExports, remoteDeps} = neoCommonModule;
 
-  if (!neoExports && !remotes) {
+  if (!neoExports && !remoteDeps) {
     return '';
   }
   // 记录当前自定义组件共享出去的模块
   const CustomCmpCommonModules = {};
-  // 记录当前自定义组件需要的远程组件
-  const CustomCmpRemotes = {};
+  // 记录当前自定义组件需要的远程依赖组件
+  const CustomCmpRemoteDeps = {};
 
   // 根据 neoExports 获取共享的依赖模块
   if (Array.isArray(neoExports) && neoExports.length > 0) {
@@ -35,10 +35,10 @@ const createCommonModulesCode = (neoCommonModule, cmpTypes) => {
     process.exit(1);
   }
 
-  // 根据 cmpTypes 和 remotes 设置远程组件信息
-  if (Array.isArray(remotes) && remotes.length > 0) {
+  // 根据 cmpTypes 和 remoteDeps 设置远程依赖组件信息
+  if (Array.isArray(remoteDeps) && remoteDeps.length > 0) {
     cmpTypes.forEach((cmpType) => {
-      CustomCmpRemotes[cmpType] = remotes;
+      CustomCmpRemoteDeps[cmpType] = remoteDeps;
     });
   }
 
@@ -58,7 +58,7 @@ const createCommonModulesCode = (neoCommonModule, cmpTypes) => {
  */
 import { isPlainObject } from 'lodash';
 const CustomCmpCommonModules = ${customCmpCommonModulesCode};
-const CustomCmpRemotes = ${JSON.stringify(CustomCmpRemotes)};
+const CustomCmpRemoteDeps = ${JSON.stringify(CustomCmpRemoteDeps)};
 
 // 用于添加共享的依赖模块
 const addNeoCommonModules = (modules) => {
@@ -88,21 +88,21 @@ const addNeoCommonModules = (modules) => {
   }
 }
 
-// 用于添加自定义组件的远程组件（关联使用）
-const addNeoRemotes = (remotes) => {
+// 用于添加自定义组件的远程依赖组件（关联使用）
+const addNeoRemoteDeps = (remoteDeps) => {
   if (!window.__NeoCommonModules) {
     window.__NeoCommonModules = {}
   }
-  if (!window.__NeoCommonModules.__neoRemotes) {
-    window.__NeoCommonModules.__neoRemotes = {}
+  if (!window.__NeoCommonModules.__neoRemoteDeps) {
+    window.__NeoCommonModules.__neoRemoteDeps = {}
   }
-  if (isPlainObject(remotes)) {
-    window.__NeoCommonModules.__neoRemotes = Object.assign(window.__NeoCommonModules.__neoRemotes, remotes)
+  if (isPlainObject(remoteDeps)) {
+    window.__NeoCommonModules.__neoRemoteDeps = Object.assign(window.__NeoCommonModules.__neoRemoteDeps, remoteDeps)
   }
 }
 
 addNeoCommonModules(CustomCmpCommonModules);
-addNeoRemotes(CustomCmpRemotes);
+addNeoRemoteDeps(CustomCmpRemoteDeps);
   `;
 
   // 创建存放 cli 的临时目录

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

@@ -7,7 +7,7 @@ const { resolveToCurrentRoot } = require('../utils/pathUtils');
  * @param {*} cmpName 自定义组件名称
  * @returns 组件注册文件内容
  */
-const getCmpModelRegister = (cmpsDir, cmpName) => {
+const getCmpModelRegisterCode = (cmpsDir, cmpName) => {
   const cpmModelDir = resolveToCurrentRoot(`${cmpsDir}/${cmpName}/model`);
 
   /*
@@ -28,4 +28,4 @@ registerNeoEditorModel(CustomCmpModel, '${cmpName}');
   `;
 };
 
-module.exports = getCmpModelRegister;
+module.exports = getCmpModelRegisterCode;

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

@@ -7,7 +7,7 @@ const { resolveToCurrentRoot } = require('../utils/pathUtils');
  * @param {*} cmpName 自定义组件名称
  * @returns 组件预览代码
  */
-const getCmpPreview = (cmpsDir, cmpName) => {
+const getCmpPreviewCode = (cmpsDir, cmpName) => {
   const cpmDir = resolveToCurrentRoot(`${cmpsDir}/${cmpName}`);
   const cpmModelDir = resolveToCurrentRoot(`${cmpsDir}/${cmpName}/model`);
 
@@ -37,4 +37,4 @@ ReactDOM.render(
   `;
 };
 
-module.exports = getCmpPreview;
+module.exports = getCmpPreviewCode;

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

@@ -7,7 +7,7 @@ const { resolveToCurrentRoot } = require('../utils/pathUtils');
  * @param {*} cmpName 自定义组件名称
  * @returns 组件注册文件内容
  */
-const getCmpRegister = (cmpsDir, cmpName) => {
+const getCmpRegisterCode = (cmpsDir, cmpName) => {
   const cpmIndexDir = resolveToCurrentRoot(`${cmpsDir}/${cmpName}/index`);
 
   /*
@@ -28,4 +28,4 @@ registerNeoCmp(CustomCmp, '${cmpName}');
   `;
 };
 
-module.exports = getCmpRegister;
+module.exports = getCmpRegisterCode;

package/src/cmpUtils/hasCmpTypeByDir.js

@@ -0,0 +1,11 @@
+const getCmpTypeByDir = require('./getCmpTypeByDir');
+/**
+ * 判断当前组件目录是否已经存在该组件类型
+ * @param {*} componentsBaseDir 自定义组件目录
+ * @param {*} cmpType 组件类型
+ * @returns Boolean
+ */
+module.exports = (cmpType) => {
+  const cmpTypes = getCmpTypeByDir();
+  return cmpTypes.includes(cmpType);
+};;

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

@@ -2,7 +2,7 @@ const fs = require('fs');
 const akfun = require('akfun');
 const { consoleTag } = require('../utils/neoParams'); // 输出标记
 const { resolveToCurrentRoot } = require('../utils/pathUtils');
-const getCmpPreview = require('../cmpUtils/getCmpPreview');
+const getCmpPreviewCode = require('../cmpUtils/getCmpPreviewCode'); // 获取自定义组件预览代码
 
 /**
  * 用于预览指定自定义组件的脚本
@@ -35,7 +35,7 @@ module.exports = (config, cmpName, defaultComponentsDir = './src/components') =>
     fs.mkdirSync(cmpTempDir);
   }
 
-  const cmpPreviewContent = getCmpPreview(cmpsDir, cmpName);
+  const cmpPreviewContent = getCmpPreviewCode(cmpsDir, cmpName);
   fs.writeFileSync(`${cmpTempDir}/preview.jsx`, cmpPreviewContent);
 
   // 将临时预览文件添加到预览配置中

package/src/cmpUtils/publishCmp.js

@@ -184,13 +184,13 @@ const buildComponentData = async (assetsRoot, cmpInfo) => {
  * @param {object} config 配置信息
  * @param {string} assetsRoot 构建产物的目录
  */
-const publishCmp = async (config, cmpType) => {
+const pushCmp = async (config, cmpType) => {
   const {
-    authorization: credentials
+    authConfig: credentials
   } = config;
 
   if (!credentials) {
-    console.error('未找到 NeoCRM 平台授权配置（neo.config.js / publishCmpConfig / credentials）。');
+    console.error('未找到 NeoCRM 平台授权配置（neo.config.js / pushCmp / authConfig）。');
     return;
   }
 
@@ -229,4 +229,4 @@ const publishCmp = async (config, cmpType) => {
   }
 };
 
-module.exports = publishCmp;
+module.exports = pushCmp;

package/src/config/default.config.js

@@ -133,7 +133,7 @@ const defaultNEOConfig = {
     },
     assetsRoot: resolve('dist') // 上传指定目录下的脚本文件
   },
-  publishCmp: {
+  pushCmp: {
     output: {
       filename: '[name].js',
       library: {

package/src/module/index.js

@@ -152,6 +152,81 @@ yargs
       neoConfigInit('neo.config.js');
     }
   )
+  .command(
+    'createProject [options]',
+    '创建自定义组件项目（含工程代码）',
+    (yargs) => {
+      yargs
+        .reset()
+        .usage(titleTip('Usage') + ': $0 preview [options]')
+        .option('name', {
+          alias: 'n',
+          describe: '自定义组件项目名称'
+        })
+        .alias('h', 'help');
+    },
+    (argv) => {
+      if (argv.name) {
+        mainAction.createCmpProjectByTemplate(argv.name);
+      } else {
+        questions.push({
+          name: 'name',
+          type: 'input',
+          message: '请设置自定义组件项目名称:',
+        });
+
+        inquirer.prompt(questions).then((ans) => {
+          // 验证项目名称是否合法
+          const { isValid, errors } = validateProjectName(ans.name);
+          if (!isValid) {
+            console.error(errors.join('\n'));
+            process.exit(1);
+          }
+  
+          if (!ans.name) {
+            console.error(errors.join('\n'));
+            process.exit(1);
+          } else {
+            mainAction.createCmpProjectByTemplate(argv.name);
+          }
+        });
+      }
+    }
+  )
+  .command(
+    'createCmp [options]',
+    '创建自定义组件',
+    (yargs) => {
+      yargs
+        .reset()
+        .usage(titleTip('Usage') + ': $0 preview [options]')
+        .option('name', {
+          alias: 'n',
+          describe: '自定义组件名称'
+        })
+        .alias('h', 'help');
+    },
+    (argv) => {
+      if (argv.name) {
+        mainAction.createCmpByTemplate(argv.name);
+      } else {
+        questions.push({
+          name: 'name',
+          type: 'input',
+          message: '请设置自定义组件名称:',
+        });
+
+        inquirer.prompt(questions).then((ans) => {
+          if (!ans.name) {
+            console.error('自定义组件名称不能为空。');
+            process.exit(1);
+          } else {
+            mainAction.createCmpByTemplate(argv.name);
+          }
+        });
+      }
+    }
+  )
   .command(
     'preview [options]',
     '预览指定自定义组件（仅预览组件本身内容）',
@@ -159,18 +234,18 @@ yargs
       yargs
         .reset()
         .usage(titleTip('Usage') + ': $0 preview [options]')
-        .option('cmpType', {
-          alias: 't',
-          describe: '自定义组件项目名称'
+        .option('name', {
+          alias: 'n',
+          describe: '自定义组件名称'
         })
         .alias('h', 'help');
     },
     (argv) => {
-      if (argv.cmpType) {
-        mainAction.previewCmp(argv.cmpType);
+      if (argv.name) {
+        mainAction.previewCmp(argv.name);
       } else {
         const cmpTypes = getCmpTypeByDir();
-        if (!cmpTypes.lenth || cmpTypes.length === 0) {
+        if (cmpTypes.length === 0) {
           console.error('当前自定义组件目录中未找到自定义组件。（./src/components 目录下）');
           process.exit(1);
         }
@@ -255,18 +330,18 @@ yargs
       yargs
         .reset()
         .usage(titleTip('Usage') + ': $0 publish2oss [options]')
-        .option('cmpType', {
-          alias: 't',
+        .option('name', {
+          alias: 'n',
           describe: '自定义组件名称'
         })
         .alias('h', 'help');
     },
     (argv) => {
-      if (argv.cmpType) {
-        mainAction.publish2oss(argv.cmpType); // 构建并发布脚本到oss
+      if (argv.name) {
+        mainAction.publish2oss(argv.name); // 构建并发布脚本到oss
       } else {
         const cmpTypes = getCmpTypeByDir();
-        if (!cmpTypes.lenth || cmpTypes.length === 0) {
+        if (cmpTypes.length === 0) {
           console.error('当前自定义组件目录中未找到自定义组件。（./src/components 目录下）');
           process.exit(1);
         }
@@ -293,24 +368,24 @@ yargs
     }
   )
   .command(
-    'publishCmp [options]',
+    'pushCmp [options]',
     '发布组件到 NeoCRM 平台',
     (yargs) => {
       yargs
         .reset()
-        .usage(titleTip('Usage') + ': $0 publishCmp [options]')
-        .option('cmpType', {
-          alias: 't',
+        .usage(titleTip('Usage') + ': $0 pushCmp [options]')
+        .option('name', {
+          alias: 'n',
           describe: '自定义组件名称'
         })
         .alias('h', 'help');
     },
     (argv) => {
-      if (argv.cmpType) {
-        mainAction.publishCmp(argv.cmpType); // 构建并发布组件到 NeoCRM
+      if (argv.name) {
+        mainAction.pushCmp(argv.name); // 构建并发布组件到 NeoCRM
       } else {
         const cmpTypes = getCmpTypeByDir();
-        if (!cmpTypes.lenth || cmpTypes.length === 0) {
+        if (cmpTypes.length === 0) {
           console.error('当前自定义组件目录中未找到自定义组件。（./src/components 目录下）');
           process.exit(1);
         }
@@ -331,7 +406,7 @@ yargs
             console.error('未选择要发布的自定义组件。');
             process.exit(1);
           }
-          mainAction.publishCmp(ans.cmpType);
+          mainAction.pushCmp(ans.cmpType);
         });
       }
     }

package/src/module/main.js

@@ -7,14 +7,16 @@ const neoConfigInit = require('../utils/neoConfigInit.js');
 const { consoleTag } = require('../utils/neoParams');
 const curConfig = require('../config/index'); // 获取当前项目根目录下的配置文件
 const publish2oss = require('../oss/publish2oss');
-const publishCmp = require('../cmpUtils/publishCmp');
-const getEntries = require('../cmpUtils/getEntries');
-const getEntriesWithAutoRegister = require('../cmpUtils/getEntriesWithAutoRegister');
-const previewCmp = require('./previewCmp');
+const pushCmp = require('../cmpUtils/pushCmp');
+const previewCmp = require('../cmpUtils/previewCmp');
+const getEntries = require('../projectUtils/getEntries');
+const getEntriesWithAutoRegister = require('../projectUtils/getEntriesWithAutoRegister');
 const AddNeoRequirePlugin = require('../plugins/AddNeoRequirePlugin');
 const { getExternalsByNeoCommonModules } = require('../neo/neoRequire');
 // const { MFPlugins } = require('../neo/webpack.mf');
 const createCommonModulesCode = require('../cmpUtils/createCommonModulesCode');
+const createCmpProjectByTemplate = require('../projectUtils/createCmpProjectByTemplate');
+const createCmpByTemplate = require('../projectUtils/createCmpByTemplate');
 
 const getValue = (originValue, defaultValue) => {
   return originValue !== undefined ? originValue : defaultValue;
@@ -29,6 +31,8 @@ module.exports = {
   neoInitByCopy,
   inspect,
   neoConfigInit,
+  createCmpProjectByTemplate,
+  createCmpByTemplate,
   dev: () => {
     if (!curConfig.dev) {
       console.error('未找到 dev 相关配置。');
@@ -272,10 +276,10 @@ module.exports = {
     });
   },
   // 发布组件到 NeoCRM 平台
-  publishCmp: (cmpType) => {
-    // 将 publishCmp 相关配置设置给 build2lib
-    const publishCmpConfig = curConfig.publishCmp;
-    curConfig.build2lib = Object.assign(curConfig.build2lib, publishCmpConfig);
+  pushCmp: (cmpType) => {
+    // 将 pushCmp 相关配置设置给 build2lib
+    const pushCmpConfig = curConfig.pushCmp;
+    curConfig.build2lib = Object.assign(curConfig.build2lib, pushCmpConfig);
 
     const curEntry = curConfig.build2lib.entry;
     let curCmpTypes = [];
@@ -315,7 +319,7 @@ module.exports = {
     /*
     // 说明：自定义组件和平台模块联邦使用异常，所以暂时注释掉
     // 添加模块联邦插件
-    if (curConfig.publishCmp.enableMF) {
+    if (curConfig.pushCmp.enableMF) {
       curConfig.webpack.plugins.push(...MFPlugins);
     }
     */
@@ -355,8 +359,8 @@ module.exports = {
     }
 
     akfun.build('lib', curConfig, consoleTag, () => {
-      // 构建完成后，执行 publishCmp
-      publishCmp(publishCmpConfig, cmpType);
+      // 构建完成后，执行 pushCmp
+      pushCmp(pushCmpConfig, cmpType);
     });
   },
   build2esm: (fileName) => akfun.build2esm(fileName, curConfig, consoleTag) // 构建esm输出模块

package/src/module/neoInit.js

@@ -2,6 +2,7 @@ const { gitClone } = require('akfun');
 const { consoleTag } = require('../utils/neoParams'); // 输出标记
 const { replaceInPackage } = require('../utils/replaceInPackage');
 const { resetPackageVersion } = require('../utils/resetPackageVersion');
+const autoEntryRootDir = require('../utils/autoEntryRootDir');
 
 const templateList = {
   react: {
@@ -43,6 +44,8 @@ const neoInit = function (type, projectName) {
       replaceInPackage(finalProjectPath, 'wibetter', 'xxx');
       replaceInPackage(finalProjectPath, 'neo自定义组件模板', 'neo自定义组件');
       resetPackageVersion(finalProjectPath);
+      // 自动切换到项目根目录
+      autoEntryRootDir(finalProjectPath);
     },
     consoleTag
   );

package/src/module/neoInitByCopy.js

@@ -3,6 +3,7 @@ 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 templateList = {
   react: {
@@ -50,6 +51,8 @@ const neoInitByCopy = function (type, projectName) {
       resetPackageVersion(finalProjectPath);
 
       console.log(`${consoleTag}已创建自定义组件（${finalProjectName}）!`);
+      // 自动切换到项目根目录
+      autoEntryRootDir(finalProjectPath);
     })
     .catch((err) => console.error(`${consoleTag}自定义组件模板下载失败：`, err));
 };

package/src/neo/neoRequire.js

@@ -67,16 +67,16 @@ const addNeoCommonModules = (modules) => {
   }
 }
 
-// 用于添加自定义组件的远程组件
-const addNeoRemotes = (remotes) => {
+// 用于添加自定义组件的远程依赖组件
+const addNeoRemoteDeps = (remoteDeps) => {
   if (!window.__NeoCommonModules) {
     window.__NeoCommonModules = {}
   }
-  if (!window.__NeoCommonModules.__neoRemotes) {
-    window.__NeoCommonModules.__neoRemotes = {}
+  if (!window.__NeoCommonModules.__neoRemoteDeps) {
+    window.__NeoCommonModules.__neoRemoteDeps = {}
   }
-  if (_.isPlainObject(remotes)) {
-    window.__NeoCommonModules.__neoRemotes = Object.assign(window.__NeoCommonModules.__neoRemotes, remotes);
+  if (_.isPlainObject(remoteDeps)) {
+    window.__NeoCommonModules.__neoRemoteDeps = Object.assign(window.__NeoCommonModules.__neoRemoteDeps, remoteDeps);
   }
 }
 
@@ -110,6 +110,6 @@ const neoRequire = (moduleName) => {
 module.exports = {
   initNeoRequire,
   addNeoCommonModules,
-  addNeoRemotes,
+  addNeoRemoteDeps,
   getExternalsByNeoCommonModules
 };