neo-cmp-cli 1.8.7 → 1.8.8

package/dist/utils/cmpUtils/getCmpModelRegisterCode.js

@@ -0,0 +1,47 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+require('node:fs');
+const pathUtils = require('../pathUtils.js');
+
+var getCmpModelRegisterCode_1;
+var hasRequiredGetCmpModelRegisterCode;
+
+function requireGetCmpModelRegisterCode () {
+	if (hasRequiredGetCmpModelRegisterCode) return getCmpModelRegisterCode_1;
+	hasRequiredGetCmpModelRegisterCode = 1;
+	const { resolveToCurrentRoot } = pathUtils.__require();
+
+	/**
+	 * 获取组件注册文件内容
+	 * @param {*} cmpsDir 自定义组件目录
+	 * @param {*} cmpName 自定义组件名称
+	 * @returns 组件注册文件内容
+	 */
+	const getCmpModelRegisterCode = (cmpsDir, cmpName) => {
+	  const cpmModelDir = resolveToCurrentRoot(`${cmpsDir}/${cmpName}/model`);
+
+	  /*
+	  if (!fs.existsSync(cpmModelDir)) {
+	    console.error(`未找到 ${cmpName} 组件模型文件，请检查 ${cpmModelDir} 是否存在。`);
+
+	    // 退出进程
+	    process.exit(1);
+	  }
+	  */
+
+	  return `
+// @ts-ignore
+import { registerNeoEditorModel } from 'neo-register';
+import CustomCmpModel from '${cpmModelDir}';
+
+registerNeoEditorModel(CustomCmpModel, '${cmpName}');
+  `;
+	};
+
+	getCmpModelRegisterCode_1 = getCmpModelRegisterCode;
+	return getCmpModelRegisterCode_1;
+}
+
+exports.__require = requireGetCmpModelRegisterCode;

package/dist/utils/cmpUtils/getCmpPreviewCode.js

@@ -0,0 +1,60 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const require$$0 = require('node:fs');
+const pathUtils = require('../pathUtils.js');
+
+var getCmpPreviewCode_1;
+var hasRequiredGetCmpPreviewCode;
+
+function requireGetCmpPreviewCode () {
+	if (hasRequiredGetCmpPreviewCode) return getCmpPreviewCode_1;
+	hasRequiredGetCmpPreviewCode = 1;
+	const fs = require$$0;
+	const { resolveToCurrentRoot } = pathUtils.__require();
+
+	/**
+	 * 获取组件预览代码
+	 * @param {*} cmpsDir 自定义组件目录
+	 * @param {*} cmpName 自定义组件名称
+	 * @returns 组件预览代码
+	 */
+	const getCmpPreviewCode = (cmpsDir, cmpName) => {
+	  const cpmDir = resolveToCurrentRoot(`${cmpsDir}/${cmpName}`);
+	  const cpmModelDir = resolveToCurrentRoot(`${cmpsDir}/${cmpName}/model`);
+
+	  if (!fs.existsSync(cpmDir)) {
+	    console.error(`未找到 ${cmpName} 组件入口文件，请检查 ${cpmDir} 是否存在。`);
+
+	    // 退出进程
+	    process.exit(1);
+	  }
+
+	  return `
+import * as React from 'react';
+import ReactDOM from 'react-dom';
+import { autoConvertVueComponent } from 'neo-register';
+import CustomCmp from '${cpmDir}';
+import CustomCmpModel from '${cpmModelDir}';
+
+// 获取组件模型中的默认属性
+const curDefaultComProps = new CustomCmpModel().defaultComProps;
+const previewComProps = new CustomCmpModel().previewComProps;
+const curPreviewComProps = Object.assign(curDefaultComProps, previewComProps);
+
+const NewCustomCmp = autoConvertVueComponent(CustomCmp);
+
+// 预览 自定义组件
+ReactDOM.render(
+  <NewCustomCmp {...curPreviewComProps} />,
+  document.getElementById('root'),
+);
+  `;
+	};
+
+	getCmpPreviewCode_1 = getCmpPreviewCode;
+	return getCmpPreviewCode_1;
+}
+
+exports.__require = requireGetCmpPreviewCode;

package/dist/utils/cmpUtils/getCmpRegisterCode.js

@@ -0,0 +1,47 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+require('node:fs');
+const pathUtils = require('../pathUtils.js');
+
+var getCmpRegisterCode_1;
+var hasRequiredGetCmpRegisterCode;
+
+function requireGetCmpRegisterCode () {
+	if (hasRequiredGetCmpRegisterCode) return getCmpRegisterCode_1;
+	hasRequiredGetCmpRegisterCode = 1;
+	const { resolveToCurrentRoot } = pathUtils.__require();
+
+	/**
+	 * 获取组件注册文件内容
+	 * @param {*} cmpsDir 自定义组件目录
+	 * @param {*} cmpName 自定义组件名称
+	 * @returns 组件注册文件内容
+	 */
+	const getCmpRegisterCode = (cmpsDir, cmpName) => {
+	  const cpmIndexDir = resolveToCurrentRoot(`${cmpsDir}/${cmpName}/index`);
+
+	  /*
+	  if (!fs.existsSync(cpmIndexDir)) {
+	    console.error(`未找到 ${cmpName} 组件入口文件，请检查 ${cpmIndexDir} 是否存在。`);
+
+	    // 退出进程
+	    process.exit(1);
+	  }
+	  */
+
+	  return `
+// @ts-ignore
+import { registerNeoCmp } from 'neo-register';
+import CustomCmp from '${cpmIndexDir}';
+
+registerNeoCmp(CustomCmp, '${cmpName}');
+  `;
+	};
+
+	getCmpRegisterCode_1 = getCmpRegisterCode;
+	return getCmpRegisterCode_1;
+}
+
+exports.__require = requireGetCmpRegisterCode;

package/dist/utils/cmpUtils/getCmpTypeByDir.js

@@ -0,0 +1,59 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const require$$0 = require('node:fs');
+const require$$1 = require('node:path');
+const pathUtils = require('../pathUtils.js');
+
+var getCmpTypeByDir_1;
+var hasRequiredGetCmpTypeByDir;
+
+function requireGetCmpTypeByDir () {
+	if (hasRequiredGetCmpTypeByDir) return getCmpTypeByDir_1;
+	hasRequiredGetCmpTypeByDir = 1;
+	const fs = require$$0;
+	const path = require$$1;
+	const { resolveToCurrentRoot } = pathUtils.__require();
+	/**
+	 * 根据当前组件目录，获取所有组件类型
+	 * @param {*} componentsBaseDir 自定义组件目录
+	 * @returns 组件类型列表
+	 */
+	const getCmpTypeByDir = (componentsBaseDir = './src/components') => {
+	  const componentsDir = resolveToCurrentRoot(componentsBaseDir);
+	  if (!fs.existsSync(componentsDir)) {
+	    console.error(`未找到自定义组件目录，请检查 ${componentsDir} 目录是否存在。`);
+	    // 退出进程
+	    process.exit(1);
+	  }
+
+	  try {
+	    // 读取组件目录下的所有子目录
+	    const dirs = fs.readdirSync(componentsDir);
+	    const cmpTypes = [];
+
+	    // 遍历所有目录，过滤出有效的组件类型
+	    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);
+	      }
+	    });
+
+	    return cmpTypes;
+	  } catch (error) {
+	    console.error('获取组件类型失败（getCmpTypeByDir）:', error);
+	    // 退出进程
+	    process.exit(1);
+	  }
+	};
+
+	getCmpTypeByDir_1 = getCmpTypeByDir;
+	return getCmpTypeByDir_1;
+}
+
+exports.__require = requireGetCmpTypeByDir;

package/dist/utils/cmpUtils/hasCmpTypeByDir.js

@@ -0,0 +1,27 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const getCmpTypeByDir = require('./getCmpTypeByDir.js');
+
+var hasCmpTypeByDir;
+var hasRequiredHasCmpTypeByDir;
+
+function requireHasCmpTypeByDir () {
+	if (hasRequiredHasCmpTypeByDir) return hasCmpTypeByDir;
+	hasRequiredHasCmpTypeByDir = 1;
+	const getCmpTypeByDir$1 = getCmpTypeByDir.__require();
+	/**
+	 * 判断当前组件目录是否已经存在该组件类型
+	 * @param {*} componentsBaseDir 自定义组件目录
+	 * @param {*} cmpType 组件类型
+	 * @returns Boolean
+	 */
+	hasCmpTypeByDir = (cmpType) => {
+	  const cmpTypes = getCmpTypeByDir$1();
+	  return cmpTypes.includes(cmpType);
+	};
+	return hasCmpTypeByDir;
+}
+
+exports.__require = requireHasCmpTypeByDir;

package/dist/utils/cmpUtils/previewCmp.js

@@ -0,0 +1,75 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const require$$0 = require('node:fs');
+const require$$0$1 = require('akfun');
+const neoParams = require('../neoParams.js');
+const pathUtils = require('../pathUtils.js');
+const getCmpPreviewCode = require('./getCmpPreviewCode.js');
+
+var previewCmp;
+var hasRequiredPreviewCmp;
+
+function requirePreviewCmp () {
+	if (hasRequiredPreviewCmp) return previewCmp;
+	hasRequiredPreviewCmp = 1;
+	const fs = require$$0;
+	const akfun = require$$0$1;
+	const { consoleTag } = neoParams.__require(); // 输出标记
+	const { resolveToCurrentRoot } = pathUtils.__require();
+	const getCmpPreviewCode$1 = getCmpPreviewCode.__require(); // 获取自定义组件预览代码
+
+	/**
+	 * 用于预览指定自定义组件的脚本
+	 */
+	previewCmp = (config, cmpName, defaultComponentsDir = './src/components') => {
+	  const cmpsDir = config.componentsDir || defaultComponentsDir;
+	  const curCmpsDir = resolveToCurrentRoot(cmpsDir);
+
+	  if (!fs.existsSync(curCmpsDir)) {
+	    console.error(`未找到组件目录，请检查 ${cmpsDir} 目录是否存在`);
+	    process.exit(1);
+	  }
+
+	  // 判断当前自定义组件是否存在
+	  const cpmDir = `${curCmpsDir}/${cmpName}`;
+	  if (!fs.existsSync(cpmDir)) {
+	    console.error(`${consoleTag}自定义组件 ${cmpName} 不存在。`);
+	    process.exit(1);
+	  }
+
+	  // 创建 cli 的临时目录
+	  const cliTempDir = resolveToCurrentRoot('./.neo-cli');
+	  if (!fs.existsSync(cliTempDir)) {
+	    fs.mkdirSync(cliTempDir);
+	  }
+
+	  // 当前自定义组件临时目录
+	  const cmpTempDir = `${cliTempDir}/${cmpName}`;
+	  if (!fs.existsSync(cmpTempDir)) {
+	    fs.mkdirSync(cmpTempDir);
+	  }
+
+	  const cmpPreviewContent = getCmpPreviewCode$1(cmpsDir, cmpName);
+	  fs.writeFileSync(`${cmpTempDir}/preview.jsx`, cmpPreviewContent);
+
+	  // 将临时预览文件添加到预览配置中
+	  if (!config.dev.entry) {
+	    config.dev.entry = {};
+	  }
+	  // 添加预览入口文件
+	  config.dev.entry.index = `${cmpTempDir}/preview.jsx`;
+
+	  if (config.webpack.projectDir) {
+	    config.webpack.projectDir.push(cmpTempDir);
+	  } else {
+	    config.webpack.projectDir = [cmpTempDir];
+	  }
+
+	  akfun.dev(config, consoleTag);
+	};
+	return previewCmp;
+}
+
+exports.__require = requirePreviewCmp;

package/dist/utils/cmpUtils/pullCmp.js

@@ -0,0 +1,126 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+require('lodash');
+const require$$0 = require('akfun');
+const pathUtils = require('../pathUtils.js');
+const require$$3 = require('ora');
+const neoService = require('../../neo/neoService.js');
+const common = require('../common.js');
+const getCmpTypeByDir = require('./getCmpTypeByDir.js');
+const createCmpByZip = require('./createCmpByZip.js');
+
+var pullCmp_1;
+var hasRequiredPullCmp;
+
+function requirePullCmp () {
+	if (hasRequiredPullCmp) return pullCmp_1;
+	hasRequiredPullCmp = 1;
+	const { getConfigObj } = require$$0;
+	const { catchCurPackageJson } = pathUtils.__require();
+	const ora = require$$3;
+	const NeoService = neoService.__require();
+	const { getFramework, errorLog, successLog } = common.__require();
+	const getCmpTypeByDir$1 = getCmpTypeByDir.__require();
+	const createCmpByZip$1 = createCmpByZip.__require();
+
+	// 获取当前项目的package文件
+	const currentPackageJsonDir = catchCurPackageJson();
+	const currentPackageJson = getConfigObj(currentPackageJsonDir);
+	const framework = getFramework(currentPackageJson.framework);
+
+	/**
+	 * 从 NeoCRM 拉取自定义组件
+	 * @param {string} cmpType 自定义组件类型
+	 * @param {object} authConfig 授权配置
+	 *
+	 * 拉取流程说明
+	 * 1. 获取当前租户下的自定义组件列表
+	 * 2. 验证组件是否存在、是否已存在本地、技术栈是否一致
+	 * 3. 下载组件源码 zip 包到临时目录（`.neo-cli/zip-source`）
+	 * 4. 解压并解析组件源码到 `src/components` 目录
+	 * 5. 合并 `package.json` 中的依赖配置（如有新增依赖会提示安装）
+	 * 6. 清理解压目录，保留 zip 源文件（便于后续问题排查）
+	 */
+	const pullCmp = async (cmpType, authConfig, _neoService) => {
+	  if (!authConfig) {
+	    errorLog('未找到 NeoCRM 平台授权配置（neo.config.js / authConfig）。');
+	    return;
+	  }
+
+	  const cmpTypes = getCmpTypeByDir$1(); // 获取当前项目目录中已存在的自定义组件类型
+	  if (cmpTypes.indexOf(cmpType) > -1) {
+	    errorLog(`当前项目目录中已存在${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) {
+	      errorLog('拉取失败，当前租户暂无任何自定义组件。', spinner);
+	      process.exit(1);
+	    }
+
+	    // 获取自定义组件信息
+	    cmpInfo = neoService.getCmpInfoByCmpType(cmpType);
+	    if (!cmpInfo) {
+	      errorLog(`拉取失败，当前租户不存在${cmpType}自定义组件。`, spinner);
+	      process.exit(1);
+	    }
+
+	    // 判断拉取的组件和当前项目是否为同一技术栈
+	    if (cmpInfo.framework && cmpInfo.framework !== framework) {
+	      errorLog(`拉取失败，${cmpType}自定义组件与当前项目技术栈不一致。`, spinner);
+	      process.exit(1);
+	    }
+
+	    // 下载源码文件并解析到 src/components 目录下
+	    const codeLib = neoService.getCodeLibByCmpType(cmpType); // 源码文件地址（zip包地址）
+
+	    // 确保 token 有效
+	    const token = await neoService.ensureValidToken();
+
+	    // 将zip 包里面的自定义组件源码解析到 src/components 目录下
+	    const cmpResult = await createCmpByZip$1(codeLib, {
+	      token,
+	      cmpName: cmpType,
+	      componentBaseDir: './src/components'
+	    });
+	    if (!cmpResult) {
+	      errorLog(`拉取失败，${cmpType}自定义组件源码解析失败，请检查源码文件是否正确。`, spinner);
+	      process.exit(1);
+	    }
+
+	    successLog(`已成功拉取${cmpType}自定义组件！\n`, spinner);
+	  } catch (error) {
+	    errorLog(`拉取自定义组件失败: ${error.message}`, spinner);
+	    throw error;
+	  }
+	};
+
+	pullCmp_1 = pullCmp;
+	return pullCmp_1;
+}
+
+exports.__require = requirePullCmp;

package/dist/utils/cmpUtils/pushCmp.js

@@ -0,0 +1,254 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const require$$0$1 = require('node:fs');
+const require$$1 = require('node:path');
+const require$$2 = require('lodash');
+const require$$0 = require('akfun');
+const pathUtils = require('../pathUtils.js');
+const require$$3 = require('ora');
+const neoService = require('../../neo/neoService.js');
+const common = require('../common.js');
+const createCmpProjectZip = require('../projectUtils/createCmpProjectZip.js');
+
+var pushCmp_1;
+var hasRequiredPushCmp;
+
+function requirePushCmp () {
+	if (hasRequiredPushCmp) return pushCmp_1;
+	hasRequiredPushCmp = 1;
+	const fs = require$$0$1;
+	const path = require$$1;
+	const _ = require$$2;
+	const { getConfigObj } = require$$0;
+	const { catchCurPackageJson } = pathUtils.__require();
+	const ora = require$$3;
+	const NeoService = neoService.__require();
+	const { getFramework, errorLog, successLog } = common.__require();
+	const createCmpProjectZip$1 = createCmpProjectZip.__require();
+
+	// 获取当前项目的package文件
+	const currentPackageJsonDir = catchCurPackageJson();
+	const currentPackageJson = getConfigObj(currentPackageJsonDir);
+
+	// 获取属性 propsSchema 数据结构
+	const getPropsSchema = (propsSchema = []) => {
+	  return propsSchema.map((item) => {
+	    return {
+	      label: item.label,
+	      description: item.description,
+	      propSchema: JSON.stringify(item)
+	    };
+	  });
+	};
+
+	/**
+	 * 构建组件数据映射
+	 * @param {string} assetsRoot 构建产物的目录
+	 * @param {object} cmpInfo 自定义组件信息
+	 * @returns {Promise<object|null>} 自定义组件数据（含自定义组件模型信息）
+	 */
+	const buildComponentData = async (assetsRoot, cmpInfo) => {
+	  if (!cmpInfo || !cmpInfo.cmpType) {
+	    errorLog('自定义组件信息或组件名称不能为空');
+	    return null;
+	  }
+
+	  const { cmpType } = cmpInfo;
+
+	  if (!assetsRoot || !fs.existsSync(assetsRoot)) {
+	    errorLog(`未找到自定义组件目录: ${assetsRoot}`);
+	    return null;
+	  }
+	  const widgetName = _.camelCase(cmpType);
+	  const modelFile = path.join(assetsRoot, `${widgetName}Model.js`);
+
+	  // 为 Node.js 环境设置全局 window 对象（模型文件可能需要）
+	  // 使用 globalThis 以确保在 Node.js 和浏览器环境中都能工作
+	  const originalWindow = globalThis.window;
+	  if (!globalThis.window) {
+	    globalThis.window = {
+	      console: console,
+	      neoRequire: () => {},
+	      postMessage: () => {}
+	      // 可以添加其他常用的 window 属性
+	    };
+	  }
+
+	  try {
+	    // 加载自定义组件模型资源文件
+	    if (fs.existsSync(modelFile)) {
+	      // 加载自定义组件模型资源文件
+	      let modelModule = require(modelFile);
+	      // 获取导出的模型类（可能是 default 导出或命名导出）
+	      // const CatchCustomCmpModelClass = modelModule.default || modelModule;
+	    } else {
+	      errorLog(`未找到自定义组件模型文件，请检查以下路径是否存在：${modelFile}`);
+	      process.exit(1);
+	    }
+	    if (!globalThis.window || !globalThis.window.NEOEditorCustomModels) {
+	      errorLog(
+	        `模型文件未导出有效模型方法（CatchCustomCmpModelClass），模型文件地址： ${modelFile} `
+	      );
+	      process.exit(1);
+	    }
+
+	    const ModelClass = globalThis.window.NEOEditorCustomModels[cmpType];
+	    if (!ModelClass) {
+	      errorLog(`未找到自定义组件模型类（${cmpType}），模型文件地址： ${modelFile} `);
+	      process.exit(1);
+	    }
+	    // 实例化模型类
+	    const modelInstance = new ModelClass();
+
+	    if (!modelInstance) {
+	      errorLog(`未找到自定义组件模型信息（${cmpType}），模型文件地址： ${modelFile} `);
+	      process.exit(1);
+	    }
+
+	    // 构建组件数据，合并模型实例的信息
+	    const curCmpInfo = {
+	      ...cmpInfo,
+	      version: currentPackageJson.version || '1.0.0',
+	      // 技术栈标识: 从 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 || '',
+	      componentCategory: (modelInstance.tags || ['自定义组件']).join(','),
+	      targetPage: modelInstance.targetPage || ['customPage'], // 支持的页面类型
+	      targetObject: modelInstance.targetObject || ['all'], // 支持的实体类型
+	      targetApplication: modelInstance.targetApplication || ['all'], // 支持的应用类型
+	      targetDevice: modelInstance.targetDevice || 'all', // 支持的设备类型。只有这个字段是字符串数值，其他都是数组
+	      iconUrl: modelInstance.iconSrc || modelInstance.iconUrl,
+	      defaultProps: JSON.stringify(modelInstance.defaultComProps || {}),
+	      previewProps: JSON.stringify(modelInstance.previewComProps || {}),
+	      props: getPropsSchema(modelInstance.propsSchema || []),
+	      events: modelInstance.events || [],
+	      functions: modelInstance.functions || modelInstance.actions || [],
+	      // 如果模型实例中有其他属性，也可以添加
+	      exposedToDesigner:
+	        modelInstance.exposedToDesigner !== undefined ? modelInstance.exposedToDesigner : true,
+	      namespace: modelInstance.namespace || 'neo-cmp-cli',
+	      enableDuplicate:
+	        modelInstance.enableDuplicate !== undefined ? modelInstance.enableDuplicate : true
+	    };
+
+	    console.log(
+	      `自定义组件模型信息（${cmpType}）:`,
+	      _.omit(curCmpInfo, ['assetFile', 'modelAssetFile', 'cssAssetFile', 'codeLibFile'])
+	    );
+	    return curCmpInfo;
+	  } catch (error) {
+	    errorLog(`自定义组件模型文件解析失败 (${modelFile || '未知路径'}): ${error.message}`);
+	    errorLog(error.stack);
+	    return null;
+	  } finally {
+	    // 恢复原始的 window 对象（如果之前存在）
+	    if (originalWindow === undefined) {
+	      delete globalThis.window;
+	    } else {
+	      globalThis.window = originalWindow;
+	    }
+	  }
+	};
+
+	/**
+	 * 发布组件到 NeoCRM
+	 * @param {object} config 配置信息
+	 * @param {string} cmpType 自定义组件类型
+	 *
+	 * 发布流程说明
+	 * 1. 打包源码文件：将自定义组件源码打包成 zip 文件
+	 * 2. 上传构建产物到 OSS：将构建后的资源文件上传到 NeoCRM 平台提供的 CDN
+	 * 3. 构建组件数据：从组件模型文件中提取组件信息
+	 * 4. 保存组件信息到 NeoCRM 平台：将组件信息保存到平台数据库
+	 */
+	const pushCmp = async (config, cmpType) => {
+	  const spinner = ora('正在发布组件...').start();
+
+	  try {
+	    // 步骤 1: 初始化 NeoService
+	    let neoService = new NeoService(config);
+	    // 获取 token
+	    await neoService.ensureValidToken();
+
+	    // 步骤 2: 打包源码文件（打包单个自定义组件源码）
+	    spinner.start(`[1/4] 打包源码文件（含单个自定义组件源码）...`);
+	    let zipPath;
+	    try {
+	      zipPath = createCmpProjectZip$1(cmpType, process.cwd(), config.assetsRoot);
+	      if (!zipPath) {
+	        errorLog('[1/4] 源码文件打包失败，未返回 zip 文件路径。', spinner);
+	      } else {
+	        successLog(`[1/4] 源码文件打包完成: ${path.basename(zipPath)}。`, spinner);
+	      }
+	    } catch (error) {
+	      errorLog(`[1/4] 源码文件打包失败。`, spinner);
+	    }
+
+	    /*
+	    // 步骤 3: 上传构建后资源文件（改放在保存时直接上传组件资源文件）
+	    spinner.start(`[2/4] 上传自定义组件构建产物到 OSS...`);
+	    let cmpInfo;
+	    try {
+	      cmpInfo = await neoService.publish2oss(cmpType);
+	      if (!cmpInfo || !cmpInfo.cmpType) {
+	        errorLog('[2/4] 上传构建产物失败，未获取到组件信息。', spinner);
+	      } else {
+	        successLog(`[2/4] 构建产物上传完成。`, spinner);
+	      }
+	    } catch (error) {
+	      errorLog(`[2/4] 构建产物上传失败。`, spinner);
+	    }
+	    */
+	    spinner.start(`[2/4] 获取自定义组件构建产物...`);
+	    const cmpInfo = await neoService.getCmpAssets(cmpType);
+
+	    // 步骤 4: 构建组件数据
+	    spinner.start(`[3/4] 构建组件数据...`);
+	    let componentInfo;
+	    try {
+	      componentInfo = await buildComponentData(config.assetsRoot, cmpInfo);
+	      if (!componentInfo) {
+	        errorLog(`[3/4] 未获取到自定义组件模型信息（${cmpType}）。`, spinner);
+	      } else {
+	        successLog(`[3/4] 组件数据构建完成。`, spinner);
+	      }
+	    } catch (error) {
+	      errorLog(`[3/4] 组件数据构建失败: ${error.message}`, spinner);
+	    }
+
+	    // 步骤 5: 保存组件信息
+	    spinner.start(`[4/4] 保存组件信息到 NeoCRM 平台...`);
+	    try {
+	      await neoService.updateCustomComponent(componentInfo);
+	      successLog(`[4/4] 组件信息保存成功`, spinner);
+	    } catch (error) {
+	      errorLog(`[4/4] 组件信息保存失败`, spinner);
+	    }
+
+	    // 最终成功提示
+	    console.log('\n✅ 自定义组件发布成功！');
+	  } catch (error) {
+	    // 内层 catch 已经处理了步骤错误并显示了 spinner 失败状态
+	    // 这里处理未预期的错误（如果 spinner 还在运行）
+	    try {
+	      // ora 的 spinner 对象可能没有 isSpinning 属性，使用 try-catch 安全访问
+	      if (spinner && spinner.isSpinning) {
+	        errorLog(`❌ 自定义组件发布失败: ${error.message}`, spinner);
+	      }
+	    } catch {
+	      // 如果访问失败或 spinner 已停止，直接输出错误信息
+	      errorLog(`\n❌ 自定义组件发布失败: ${error.message}`);
+	    }
+	    throw error;
+	  }
+	};
+
+	pushCmp_1 = pushCmp;
+	return pushCmp_1;
+}
+
+exports.__require = requirePushCmp;