neo-cmp-cli 1.8.6 → 1.8.8

package/dist/utils/common.js

@@ -0,0 +1,125 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const require$$0 = require('chalk');
+const typescript = require('../node_modules/typescript/lib/typescript.js');
+const neoParams = require('./neoParams.js');
+
+var common;
+var hasRequiredCommon;
+
+function requireCommon () {
+	if (hasRequiredCommon) return common;
+	hasRequiredCommon = 1;
+	const chalk = require$$0;
+	const ts = typescript.__require();
+	const { consoleTag } = neoParams.__require();
+
+	/**
+	 * 获取技术栈标识
+	 * 目的：兼容用户非标准写法
+	 * 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;
+	      errorLog('暂不支持 vue3.0 技术栈。');
+	      break;
+	    case 'react-js':
+	      errorLog('暂不支持 react-js 技术栈。');
+	      curFramework = 0;
+	      break;
+	    case 'react':
+	    case 'react-ts':
+	      curFramework = 0;
+	      break;
+	    default:
+	      curFramework = 0;
+	  }
+	  return curFramework;
+	}
+
+	// 输出红色字体的错误日志
+	function errorLog(message, spinner) {
+	  const errorMessage = `${consoleTag} ${chalk.red(message)}`;
+	  if (spinner) {
+	    spinner.fail(errorMessage);
+	  } else {
+	    console.error(errorMessage);
+	  }
+	}
+
+	// 输出黄色字体的警告日志
+	function warningLog(message, spinner) {
+	  const warningMessage = `${consoleTag} ${chalk.yellow(message)}`;
+	  if (spinner) {
+	    spinner.warn(warningMessage);
+	  } else {
+	    console.warn(warningMessage);
+	  }
+	}
+
+	// 输出绿色字体的成功日志
+	function successLog(message, spinner) {
+	  const successMessage = `${consoleTag} ${chalk.green(message)}`;
+	  if (spinner) {
+	    spinner.succeed(successMessage);
+	  } else {
+	    console.log(successMessage);
+	  }
+	}
+
+	/**
+	 * 使用 TypeScript 官方 API 解析 tsconfig.json（推荐）
+	 * 需要安装: npm install typescript --save-dev
+	 * 优点: 官方支持，能正确处理 extends、注释等所有特性
+	 */
+	function parseTsConfigWithTypeScript(configPath) {
+	  try {
+	    const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
+
+	    if (configFile.error) {
+	      throw new Error(`解析 tsconfig.json 失败: ${configFile.error.messageText}`);
+	    }
+
+	    return configFile.config;
+	  } catch (error) {
+	    if (error.code === 'MODULE_NOT_FOUND') {
+	      throw new Error('请先安装 typescript: npm install typescript --save-dev');
+	    }
+	    throw error;
+	  }
+	}
+
+	common = {
+	  getFramework,
+	  errorLog,
+	  warningLog,
+	  successLog,
+	  parseTsConfigWithTypeScript
+	};
+	return common;
+}
+
+exports.__require = requireCommon;

package/dist/utils/configureNeoBuild.js

@@ -0,0 +1,129 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const require$$2 = require('lodash');
+const AddNeoRequirePlugin = require('../plugins/AddNeoRequirePlugin.js');
+const createCommonModulesCode = require('./cmpUtils/createCommonModulesCode.js');
+const neoRequire = require('../neo/neoRequire.js');
+const index = require('../config/index.js');
+
+var configureNeoBuild_1;
+var hasRequiredConfigureNeoBuild;
+
+function requireConfigureNeoBuild () {
+	if (hasRequiredConfigureNeoBuild) return configureNeoBuild_1;
+	hasRequiredConfigureNeoBuild = 1;
+	const _ = require$$2;
+	const AddNeoRequirePlugin$1 = AddNeoRequirePlugin.__require();
+	const createCommonModulesCode$1 = createCommonModulesCode.__require();
+	const { getExternalsByNeoCommonModules } = neoRequire.__require();
+	const curConfig = index.__require(); // 获取当前项目根目录下的配置文件
+
+	// neo.config.js 中的添加的 Neo 共享依赖模块配置
+	const neoCommonModule = curConfig.neoCommonModule || {};
+	// 自定义组件 需要剔除的依赖模块
+	const cmpNeoExternals = neoCommonModule.externals || [];
+
+	// 组件目录
+	curConfig.componentsDir || './src/components';
+
+	/**
+	 * 添加 AddNeoRequirePlugin 到 webpack 配置
+	 * @param {object} webpackConfig webpack 配置对象
+	 * @param {object} [options] 选项
+	 * @param {boolean} [options.verbose] 是否启用详细日志，默认为 false
+	 */
+	function addNeoRequirePlugin(webpackConfig, options = {}) {
+	  const { verbose = false } = options;
+	  const plugin = new AddNeoRequirePlugin$1({ verbose });
+
+	  if (webpackConfig && webpackConfig.plugins && Array.isArray(webpackConfig.plugins)) {
+	    webpackConfig.plugins.push(plugin);
+	  } else {
+	    webpackConfig.plugins = [plugin];
+	  }
+	}
+
+	/**
+	 * 添加 Neo externals 配置
+	 * @param {object} config 配置对象（dev 或 build2lib）
+	 * @param {object} externalsConfig 现有的 externals 配置
+	 */
+	function addNeoExternals(config, externalsConfig) {
+	  const externals = getExternalsByNeoCommonModules(cmpNeoExternals);
+	  if (externalsConfig && _.isPlainObject(externalsConfig)) {
+	    config.externals = Object.assign(externalsConfig, externals);
+	  } else {
+	    config.externals = externals;
+	  }
+	}
+
+	/**
+	 * 创建并注入 commonModulesCode 到 entry
+	 * @param {object} config 配置对象（dev 或 build2lib）
+	 * @param {array} cmpTypes 组件类型列表
+	 * @param {object} [options] 选项
+	 * @param {boolean} [options.excludeModel] 是否排除 Model 结尾的 entry，默认为 false
+	 */
+	function injectCommonModulesCode(config, options = {}) {
+	  const { cmpTypes, defaultExports, excludeModel = false } = options;
+
+	  // 添加默认导出
+	  if (defaultExports && _.isPlainObject(defaultExports)) {
+	    if (neoCommonModule.exports && _.isPlainObject(neoCommonModule.exports)) {
+	      neoCommonModule.exports = Object.assign(neoCommonModule.exports, defaultExports);
+	    } else if (neoCommonModule.exports && _.isArray(neoCommonModule.exports)) {
+	      // 先将数组格式改成对象格式
+	      neoCommonModule.exports.forEach((item) => {
+	        if (_.isString(item)) {
+	          neoCommonModule.exports[item] = item;
+	        }
+	      });
+	      neoCommonModule.exports = Object.assign(neoCommonModule.exports, defaultExports);
+	    } else {
+	      neoCommonModule.exports = defaultExports;
+	    }
+	  }
+
+	  const commonModulesFilePath = createCommonModulesCode$1(neoCommonModule, cmpTypes);
+
+	  if (commonModulesFilePath && config.entry) {
+	    Object.keys(config.entry).forEach((name) => {
+	      // 如果 excludeModel 为 true，排除 Model 结尾的文件
+	      if (!excludeModel || !name.endsWith('Model')) {
+	        config.entry[name] = [commonModulesFilePath].concat(config.entry[name]);
+	      }
+	    });
+	  }
+	}
+
+	/**
+	 * 配置 webpack 插件、externals 和 commonModulesCode（用于 linkDebug、publish2oss、pushCmp）
+	 * @param {object} config 配置对象（dev 或 build2lib）
+	 * @param {object} [options] 选项
+	 * @param {array} [options.cmpTypes] 组件类型列表
+	 * @param {object} [options.defaultExports] 默认导出
+	 * @param {boolean} [options.verbose] 是否启用详细日志，默认为 false
+	 * @param {boolean} [options.excludeModel] 是否排除 Model 结尾的 entry，默认为 false
+	 */
+	function configureNeoBuild(config, options = {}) {
+	  const { cmpTypes, defaultExports, verbose = false, excludeModel = false } = options;
+
+	  // 添加自定义 webpack 插件
+	  addNeoRequirePlugin(curConfig.webpack, { verbose });
+
+	  // 添加内置 Neo 的 externals 配置
+	  addNeoExternals(config, config.externals);
+
+	  // 创建并注入 commonModulesCode
+	  injectCommonModulesCode(config, { cmpTypes, defaultExports, excludeModel });
+	}
+
+	configureNeoBuild_1 = {
+	  configureNeoBuild
+	};
+	return configureNeoBuild_1;
+}
+
+exports.__require = requireConfigureNeoBuild;

package/dist/utils/generateEntries.js

@@ -0,0 +1,80 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const getEntries = require('./projectUtils/getEntries.js');
+const getEntriesWithAutoRegister = require('./projectUtils/getEntriesWithAutoRegister.js');
+
+var generateEntries_1;
+var hasRequiredGenerateEntries;
+
+function requireGenerateEntries () {
+	if (hasRequiredGenerateEntries) return generateEntries_1;
+	hasRequiredGenerateEntries = 1;
+	const getEntries$1 = getEntries.__require();
+	const getEntriesWithAutoRegister$1 = getEntriesWithAutoRegister.__require();
+
+	/**
+	 * 生成 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
+	 */
+	function generateEntries({
+	  configEntry,
+	  disableAutoRegister,
+	  componentsDir,
+	  entryType = 'widget',
+	  cmpType
+	}) {
+	  // 如果已配置 entry 且不需要强制获取 cmpTypes，直接返回
+	  if (configEntry && Object.keys(configEntry).length > 0) {
+	    return {
+	      entries: configEntry,
+	      cmpTypes: []
+	    };
+	  }
+
+	  // 根据 disableAutoRegister 选择不同的生成方法
+	  let entriesResult;
+	  if (disableAutoRegister) {
+	    // disableAutoRegister 为 true 时，仅自动生成入口文件（不自动注册）
+	    entriesResult = getEntries$1(componentsDir, cmpType);
+	  } else {
+	    // 自动生成入口文件（并自动创建对应的注册文件）
+	    entriesResult = getEntriesWithAutoRegister$1(componentsDir, cmpType);
+	  }
+
+	  // 根据 entryType 选择对应的 entries
+	  let entries;
+	  if (entryType === 'linkDebug') {
+	    entries = entriesResult.linkDebugEntries || {};
+	  } else {
+	    entries = entriesResult.widgetEntries || {};
+	  }
+
+	  const cmpTypes = entriesResult.cmpTypes || [];
+
+	  // 验证 entries 是否有效（仅在需要生成新 entry 时验证）
+	  if (!entries || Object.keys(entries).length === 0) {
+	    const defaultComponentsDir = componentsDir || './src/components';
+	    throw new Error(
+	      `未识别到自定义组件，请检查 ${defaultComponentsDir} 目录下是否存在自定义组件。`
+	    );
+	  }
+
+	  return {
+	    entries: entries || configEntry || {},
+	    cmpTypes,
+	    defaultExports: entriesResult.defaultExports || {}
+	  };
+	}
+
+	generateEntries_1 = generateEntries;
+	return generateEntries_1;
+}
+
+exports.__require = requireGenerateEntries;

package/dist/utils/neoConfigInit.js

@@ -0,0 +1,30 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const require$$1 = require('node:path');
+const require$$0 = require('akfun');
+
+var neoConfigInit;
+var hasRequiredNeoConfigInit;
+
+function requireNeoConfigInit () {
+	if (hasRequiredNeoConfigInit) return neoConfigInit;
+	hasRequiredNeoConfigInit = 1;
+	const path = require$$1;
+	const { createFile } = require$$0;
+
+	// 将脚手架的默认配置文件拷贝到当前项目根目录
+	const createDefaultConfig = function (_configProjectName) {
+	  const configProjectName = _configProjectName || 'neo.config.js';
+	  createFile(
+	    path.resolve(__dirname, `../initData/${configProjectName}`),
+	    path.resolve(process.cwd(), `./${configProjectName}`)
+	  );
+	};
+
+	neoConfigInit = createDefaultConfig;
+	return neoConfigInit;
+}
+
+exports.__require = requireNeoConfigInit;

package/dist/utils/neoParams.js

@@ -0,0 +1,26 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+var neoParams;
+var hasRequiredNeoParams;
+
+function requireNeoParams () {
+	if (hasRequiredNeoParams) return neoParams;
+	hasRequiredNeoParams = 1;
+	let consoleTag = '[neo-cmp-cli]'; // 输出标记
+
+	function setConsoleTag(newText) {
+	  consoleTag = newText;
+	}
+
+	neoParams = {
+	  get consoleTag() {
+	    return consoleTag;
+	  },
+	  setConsoleTag
+	};
+	return neoParams;
+}
+
+exports.__require = requireNeoParams;

package/dist/utils/pathUtils.js

@@ -0,0 +1,40 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const require$$1 = require('node:path');
+const require$$0 = require('node:fs');
+
+var pathUtils;
+var hasRequiredPathUtils;
+
+function requirePathUtils () {
+	if (hasRequiredPathUtils) return pathUtils;
+	hasRequiredPathUtils = 1;
+	const path = require$$1;
+	const fs = require$$0;
+
+	// 当前命令执行的路径
+	const currentRoot = () => fs.realpathSync(process.cwd());
+	const resolveToCurrentRoot = (filePath) => path.resolve(currentRoot(), filePath);
+	const resolveToCurrentDist = (filePath, outDir) =>
+	  path.resolve(currentRoot(), outDir || 'dist/', filePath);
+	const currentSrc = () => resolveToCurrentRoot('src');
+	const currentBuild = () => resolveToCurrentRoot('build');
+
+	// 获取当前项目的package文件（从当前命令执行的路径下查找）
+	const catchCurPackageJson = () => resolveToCurrentRoot('package.json');
+
+	pathUtils = {
+	  currentRoot,
+	  resolveToCurrentRoot,
+	  resolveToCurrentDist,
+	  resolve: resolveToCurrentRoot,
+	  currentSrc,
+	  currentBuild,
+	  catchCurPackageJson
+	};
+	return pathUtils;
+}
+
+exports.__require = requirePathUtils;

package/dist/utils/projectNameValidator.js

@@ -0,0 +1,90 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+/**
+ * 文件名验证工具
+ * 验证规则：
+ * 1. 至少5个字符
+ * 2. 必须以字母开头
+ * 3. 只能包含字母、数字、连字符(-)
+ */
+
+var projectNameValidator;
+var hasRequiredProjectNameValidator;
+
+function requireProjectNameValidator () {
+	if (hasRequiredProjectNameValidator) return projectNameValidator;
+	hasRequiredProjectNameValidator = 1;
+	/**
+	 * 验证文件名是否符合规范
+	 * @param {string} ProjectName 文件名（不包含路径和扩展名）
+	 * @returns {Object} 验证结果对象
+	 */
+	function validateProjectName(ProjectName) {
+	  const errors = [];
+
+	  // 检查文件名是否为空
+	  if (!ProjectName || ProjectName.trim().length === 0) {
+	    errors.push('文件名不能为空');
+	    return { isValid: false, errors };
+	  }
+
+	  // 检查长度是否至少5个字符
+	  if (ProjectName.length < 5) {
+	    errors.push(`文件名长度必须至少5个字符，当前长度: ${ProjectName.length}`);
+	  }
+
+	  // 检查是否以字母开头
+	  if (!/^[a-zA-Z]/.test(ProjectName)) {
+	    errors.push('文件名必须以字母开头');
+	  }
+
+	  // 检查是否只包含字母、数字、连字符
+	  if (!/^[a-zA-Z][a-zA-Z0-9-]*$/.test(ProjectName)) {
+	    errors.push('文件名只能包含字母、数字和连字符(-)，且必须以字母开头');
+	  }
+
+	  // 检查是否包含连续连字符
+	  if (ProjectName.includes('--')) {
+	    errors.push('文件名不能包含连续连字符(--)');
+	  }
+
+	  // 检查是否以连字符结尾
+	  if (ProjectName.endsWith('-')) {
+	    errors.push('文件名不能以连字符结尾');
+	  }
+
+	  return {
+	    isValid: errors.length === 0,
+	    errors
+	  };
+	}
+
+	/**
+	 * 验证文件名并返回布尔值
+	 * @param {string} ProjectName 文件名
+	 * @returns {boolean} 是否有效
+	 */
+	function isValidProjectName(ProjectName) {
+	  return validateProjectName(ProjectName).isValid;
+	}
+
+	/**
+	 * 获取文件名验证的错误信息
+	 * @param {string} ProjectName 文件名
+	 * @returns {Array} 错误信息数组
+	 */
+	function getProjectNameErrors(ProjectName) {
+	  return validateProjectName(ProjectName).errors;
+	}
+
+	projectNameValidator = {
+	  validateProjectName,
+	  isValidProjectName,
+	  getProjectNameErrors
+	};
+	return projectNameValidator;
+}
+
+exports.__require = requireProjectNameValidator;

package/dist/utils/projectUtils/createCmpProjectByTemplate.js

@@ -0,0 +1,81 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const require$$0 = require('fs-extra');
+const require$$1 = require('node:path');
+const neoParams = require('../neoParams.js');
+const replaceInPackage = require('../replaceInPackage.js');
+const resetPackageVersion = require('../resetPackageVersion.js');
+const autoEntryRootDir = require('../autoEntryRootDir.js');
+const hasNeoProject = require('./hasNeoProject.js');
+
+var createCmpProjectByTemplate;
+var hasRequiredCreateCmpProjectByTemplate;
+
+function requireCreateCmpProjectByTemplate () {
+	if (hasRequiredCreateCmpProjectByTemplate) return createCmpProjectByTemplate;
+	hasRequiredCreateCmpProjectByTemplate = 1;
+	const fs = require$$0;
+	const path = require$$1;
+	const { consoleTag } = neoParams.__require(); // 输出标记
+	const { replaceInPackage: replaceInPackage$1 } = replaceInPackage.__require();
+	const { resetPackageVersion: resetPackageVersion$1 } = resetPackageVersion.__require();
+	const autoEntryRootDir$1 = autoEntryRootDir.__require();
+	const hasNeoProject$1 = hasNeoProject.__require();
+
+	const cmpTemplateList = {
+	  'react-ts': {
+	    projectName: 'empty-custom-cmp-template',
+	    dir: path.resolve(__dirname, '../../../template/empty-custom-cmp-template')
+	  }
+	};
+
+	/**
+	 * 通过拷贝模板创建自定义组件
+	 * @param {*} projectName 自定义组件项目名称
+	 * @param {*} type 自定义组件类型
+	 */
+	createCmpProjectByTemplate = function (projectName, type = 'react-ts') {
+	  const finalProjectPath = path.resolve(process.cwd(), projectName);
+
+	  if (hasNeoProject$1()) {
+	    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$1(finalProjectPath, curCmpTemplate.projectName, finalProjectName);
+	      replaceInPackage$1(finalProjectPath, 'wibetter', 'xxx');
+	      replaceInPackage$1(finalProjectPath, 'neo自定义组件模板', 'neo自定义组件');
+	      resetPackageVersion$1(finalProjectPath);
+
+	      console.log(`${consoleTag}已创建自定义组件项目（${finalProjectName}）!`);
+	      // 自动切换到项目根目录
+	      autoEntryRootDir$1(finalProjectPath);
+	    })
+	    .catch((err) => console.error(`${consoleTag}自定义组件模板下载失败：`, err));
+	};
+	return createCmpProjectByTemplate;
+}
+
+exports.__require = requireCreateCmpProjectByTemplate;