@bams-app/ui-dev-server 0.0.1

package/src/views/LoginView.vue

@@ -0,0 +1,22 @@
+<template>
+  <UiLoginComponent :callback-url="callbackUrl" :sys-code="sysCode" @login-success="onLoginSuccess" />
+</template>
+
+<script setup>
+  import { computed } from "vue";
+  import { useRoute } from "vue-router";
+  import { auth } from "@bams-app/utils";
+  // 编译阶段根据环境变量通过通用插槽别名选择组件
+  import UiLoginComponent from "@configurable/login";
+
+  const route = useRoute();
+  const sysCode = computed(() => auth.getSysCode());
+  const callbackUrl = computed(() => route.query.callback_url || "/");
+  console.log("回调地址：", decodeURIComponent(callbackUrl.value));
+
+  const onLoginSuccess = ({ token, userData }) => {
+    console.log("登录成功回调", { token, userData });
+  };
+</script>
+
+<style scoped></style>

package/utils.js

@@ -0,0 +1,466 @@
+const path = require('path');
+const fs = require('fs');
+
+/** 启用颜色输出的条件 */
+const ENABLE_COLOR = process.stdout.isTTY && process.env.NO_COLOR === undefined;
+/** ANSI 颜色码映射 */
+const ANSI = {
+    reset: '\x1b[0m',
+    bold: '\x1b[1m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    cyan: '\x1b[36m',
+    gray: '\x1b[90m'
+};
+
+/**
+ * 获取项目根目录
+ * - 优先使用 WORK_PROJECT_ROOT 环境变量（由 work-cli 注入）
+ * - 回退为包目录上溯三层（仓库内 work/cli/ui-dev-server 或作为依赖安装时均指向项目根）
+ * @returns {string} 项目根目录
+ */
+function getRootDir() {
+    return process.env.WORK_PROJECT_ROOT || path.resolve(__dirname, '../../../');
+}
+
+/**
+ * 加载项目根 package.json
+ * @param {string} [rootDir] - 项目根目录，缺省时使用 getRootDir()
+ * @returns {Object} package.json 内容
+ */
+function getProjectPackageJson(rootDir) {
+    const projectDir = rootDir || getRootDir();
+    return require(path.join(projectDir, 'package.json'));
+}
+
+/**
+ * 判断目标路径是否为目录
+ * @param {string} targetPath - 目标路径
+ * @returns {boolean} 是否为目录
+ */
+function isDirectory(targetPath) {
+    return fs.existsSync(targetPath) && fs.statSync(targetPath).isDirectory();
+}
+
+/**
+ * 标准化路径用于显示（统一使用 / 分隔符）
+ * @param {string} targetPath - 目标路径
+ * @returns {string} 标准化后的路径
+ */
+function normalizePathForDisplay(targetPath) {
+    return targetPath.split(path.sep).join('/');
+}
+
+/**
+ * 将目录名添加到 scope 映射中
+ * @param {Object} scopes - scope 到目录的映射
+ * @param {string} dirName - 目录名
+ */
+function addScopeDir(scopes, dirName) {
+    // 排除不是 ui 相关的目录
+    if (['work', 'bams-components', 'bams-ui'].includes(dirName)) {
+        if (!scopes['bams-app']) scopes['bams-app'] = [];
+        if (!scopes['bams-app'].includes(dirName)) {
+            scopes['bams-app'].push(dirName);
+        }
+    } else {
+        // 其他目录用目录名作为 scope
+        if (!scopes[dirName]) scopes[dirName] = [];
+        if (!scopes[dirName].includes(dirName)) {
+            scopes[dirName].push(dirName);
+        }
+    }
+}
+
+/**
+ * 从项目根目录查找 -ui 结尾的目录并补充到 scope 映射
+ * @param {Object} scopes - scope 到目录的映射
+ * @param {string} rootDir - 项目根目录
+ */
+function appendUiDirsFromRoot(scopes, rootDir) {
+    if (!rootDir || !isDirectory(rootDir)) {
+        return;
+    }
+
+    const dirEntries = fs.readdirSync(rootDir, { withFileTypes: true });
+    dirEntries.forEach((entry) => {
+        if (!entry.isDirectory() || !entry.name.endsWith('-ui')) {
+            return;
+        }
+
+        addScopeDir(scopes, entry.name);
+    });
+}
+
+/**
+ * 从 workspaces 配置中解析出 scope 和目录映射
+ * @param {Object} packageJson - package.json 对象
+ * @param {string} rootDir - 项目根目录
+ * @returns {Object} scope 到目录的映射
+ */
+function parseScopesFromWorkspaces(packageJson, rootDir) {
+    const workspaces = packageJson.workspaces || [];
+    const scopes = {};
+
+    workspaces.forEach(pattern => {
+        // 跳过排除项
+        if (pattern.startsWith('!')) return;
+
+        // 处理类似 "pds-ui/*" 或 "pds-ui" 这样的模式
+        const match = pattern.match(/^([^/*]+)(\/\*)?$/);
+        if (match) {
+            addScopeDir(scopes, match[1]);
+        }
+    });
+
+    appendUiDirsFromRoot(scopes, rootDir);
+
+    // 默认总是包含 bams-app 的 fallback
+    if (!scopes['bams-app']) scopes['bams-app'] = [];
+    if (!scopes['bams-app'].includes('work/packages')) {
+        scopes['bams-app'].push('work/packages');
+    }
+
+    return scopes;
+}
+
+/**
+ * 获取所有 workspace 条目
+ * @param {Object} packageJson - package.json 对象
+ * @param {string} rootDir - 项目根目录
+ * @returns {Array<{scope: string, dir: string}>} workspace 条目列表
+ */
+function getWorkspaceEntries(packageJson, rootDir) {
+    const scopes = parseScopesFromWorkspaces(packageJson, rootDir);
+    const entries = [];
+
+    for (const [scope, dirs] of Object.entries(scopes)) {
+        for (const dir of dirs) {
+            entries.push({ scope, dir });
+        }
+    }
+
+    return entries;
+}
+
+/**
+ * 创建组件候选对象
+ * @param {string} scope - scope 名称
+ * @param {string} dir - 目录路径
+ * @param {string} componentDirName - 组件目录名
+ * @param {string} componentPath - 组件完整路径
+ * @param {string} requestedName - 用户请求的原始组件名
+ * @returns {Object} 组件候选对象
+ */
+function createCandidate(scope, dir, componentDirName, componentPath, requestedName) {
+    return {
+        scope,
+        dir,
+        requestedName,
+        componentDirName,
+        componentPath,
+        packageName: `@${scope}/${componentDirName}`,
+        displayPath: normalizePathForDisplay(path.join(dir, componentDirName))
+    };
+}
+
+/**
+ * 根据组件名在所有 workspaces 中查找候选组件
+ * @param {string} componentName - 组件名
+ * @param {string} rootDir - 项目根目录
+ * @param {Object} packageJson - package.json 对象
+ * @returns {Array<Object>} 组件候选列表
+ */
+function findComponentCandidates(componentName, rootDir, packageJson) {
+    const candidates = [];
+    const seen = new Set();
+    const searchNames = [componentName];
+
+    // 如果没有前缀，自动尝试添加 ui- 和 page- 前缀
+    if (!componentName.startsWith('ui-') && !componentName.startsWith('page-')) {
+        searchNames.push(`ui-${componentName}`, `page-${componentName}`);
+    }
+
+    for (const { scope, dir } of getWorkspaceEntries(packageJson, rootDir)) {
+        for (const searchName of searchNames) {
+            const componentPath = path.resolve(rootDir, dir, searchName);
+
+            // 跳过不存在或不是目录的路径
+            if (!isDirectory(componentPath)) {
+                continue;
+            }
+
+            const packageName = `@${scope}/${searchName}`;
+            // 跳过重复的 packageName
+            if (seen.has(packageName)) {
+                continue;
+            }
+
+            seen.add(packageName);
+            candidates.push(createCandidate(scope, dir, searchName, componentPath, componentName));
+        }
+    }
+
+    return candidates;
+}
+
+/**
+ * 根据 componentName 自动识别作用域
+ * @param {string} componentName - 组件名
+ * @param {string} rootDir - 根目录路径
+ * @param {Object} packageJson - package.json 对象
+ * @returns {string} 完整的包名
+ */
+function getComponentScope(componentName, rootDir, packageJson) {
+    const candidates = findComponentCandidates(componentName, rootDir, packageJson);
+
+    if (candidates.length > 0) {
+        return candidates[0].packageName;
+    }
+
+    // 默认回退到 bams-app
+    return `@bams-app/${componentName}`;
+}
+
+/**
+ * 解析组件名，返回完整的包名或路径
+ * @param {string} componentName - 组件名
+ * @param {string} rootDir - 根目录路径
+ * @param {Object} packageJson - package.json 对象
+ * @returns {string} 完整的包名或路径
+ */
+function resolveComponent(componentName, rootDir, packageJson) {
+    // 优先识别完整包名（以 @ 开头）
+    if (componentName.startsWith('@')) {
+        return componentName;
+    }
+    // 再识别路径（包含 / 但不是包名）
+    if (componentName.includes('/')) {
+        return path.resolve(rootDir, componentName);
+    }
+    // 最后尝试自动识别 scope
+    return getComponentScope(componentName, rootDir, packageJson);
+}
+
+/**
+ * 从组件名或路径中提取组件入口名（用于前端渲染）
+ * @param {string} componentName - 组件名或路径
+ * @returns {string} 组件入口名
+ */
+function getComponentEntryName(componentName) {
+    if (!componentName) {
+        return 'ui-component-demo';
+    }
+
+    // 完整包名：@scope/package-name -> package-name
+    if (componentName.startsWith('@')) {
+        const [, packageName] = componentName.split('/');
+        return packageName || componentName;
+    }
+
+    // 路径形式：/path/to/component -> component
+    return path.basename(componentName);
+}
+
+/**
+ * 将 kebab-case 组件名转换为 camelCase（用于前端变量名）
+ * @param {string} componentName - 组件名或路径
+ * @returns {string} camelCase 组件名
+ */
+function toCamelComponentName(componentName) {
+    return getComponentEntryName(componentName).replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+
+// ==================== CLI 相关辅助方法 ====================
+
+/**
+ * 给文本添加 ANSI 颜色（仅在 TTY 环境且未禁用颜色时生效）
+ * @param {string} text - 原始文本
+ * @param {string} color - 颜色名称（对应 ANSI 码键名）
+ * @returns {string} 带颜色的文本
+ */
+function colorize(text, color) {
+    if (!ENABLE_COLOR || !ANSI[color]) {
+        return text;
+    }
+
+    return `${ANSI[color]}${text}${ANSI.reset}`;
+}
+
+/**
+ * 解析命令行参数
+ * @param {string[]} argv - process.argv
+ * @returns {Object} 解析结果
+ * @returns {string} returns.componentName - 组件名
+ * @returns {string} returns.layout - 布局类型
+ * @returns {string[]} returns.vueCliArgs - 传递给 Vue CLI 的参数
+ */
+function parseCliArgs(argv) {
+    const args = argv.slice(2);
+    let componentName = 'ui-component-demo';
+    let layout = 'pc';
+    const vueCliArgs = [];
+
+    let i = 0;
+    while (i < args.length) {
+        const arg = args[i];
+
+        // --component 或 -c 参数
+        if (arg === '--component' || arg === '-c') {
+            componentName = args[i + 1];
+            i += 2;
+        } else if (arg.startsWith('--component=')) {
+            componentName = arg.split('=')[1];
+            i++;
+        } else if (arg.startsWith('-c=')) {
+            componentName = arg.split('=')[1];
+            i++;
+            // --layout 或 -l 参数
+        } else if (arg === '--layout' || arg === '-l') {
+            layout = args[i + 1];
+            i += 2;
+        } else if (arg.startsWith('--layout=')) {
+            layout = arg.split('=')[1];
+            i++;
+        } else if (arg.startsWith('-l=')) {
+            layout = arg.split('=')[1];
+            i++;
+            // Vue CLI 参数（以 -- 开头）
+        } else if (arg.startsWith('--')) {
+            vueCliArgs.push(arg);
+            // 处理带值的选项
+            if (i + 1 < args.length && !args[i + 1].startsWith('-')) {
+                vueCliArgs.push(args[i + 1]);
+                i += 2;
+            } else {
+                i++;
+            }
+            // 其他参数：作为组件名
+        } else {
+            componentName = arg;
+            i++;
+        }
+    }
+
+    return {
+        componentName,
+        layout,
+        vueCliArgs
+    };
+}
+
+/**
+ * 判断输入是否为文件系统路径
+ * @param {string} input - 输入字符串
+ * @returns {boolean} 是否为文件系统路径
+ */
+function isFileSystemPath(input) {
+    return path.isAbsolute(input)
+        || input.startsWith('./')
+        || input.startsWith('../')
+        || (input.includes('/') && !input.startsWith('@'));
+}
+
+/**
+ * 动态加载 inquirer（用于交互式选择）
+ * @returns {Promise<Object>} inquirer 实例
+ */
+async function loadInquirer() {
+    const inquirerModule = await import('inquirer');
+    return inquirerModule.default || inquirerModule;
+}
+
+/**
+ * 使用 inquirer 提示用户选择候选组件
+ * @param {string} componentInput - 用户输入的原始组件名
+ * @param {Array<Object>} candidates - 组件候选列表
+ * @returns {Promise<Object>} 用户选中的候选对象
+ */
+async function promptForCandidate(componentInput, candidates) {
+    const inquirer = await loadInquirer();
+    const prompt = inquirer.createPromptModule ? inquirer.createPromptModule() : inquirer.prompt;
+    const choices = candidates.map((candidate) => ({
+        name: `${colorize(candidate.packageName, 'cyan')} ${colorize(`(${candidate.displayPath})`, 'gray')}`,
+        value: candidate
+    }));
+
+    // 显示提示信息
+    console.log(colorize(`[ui-dev-server] 发现多个同名组件 "${componentInput}"`, 'yellow'));
+    console.log(colorize('[ui-dev-server] 使用方向键选择，按回车确认。', 'blue'));
+
+    // 显示选择菜单
+    const answers = await prompt([
+        {
+            type: 'list',
+            name: 'selectedCandidate',
+            loop: false,
+            pageSize: Math.min(Math.max(candidates.length, 2), 10),
+            message: colorize('请选择要启动的组件', 'bold'),
+            choices
+        }
+    ]);
+
+    return answers.selectedCandidate;
+}
+
+/**
+ * 解析用户输入的组件名
+ * - 如果是路径或完整包名：直接返回
+ * - 如果是短名：在所有 workspaces 中查找，有多个时交互式选择
+ * @param {string} componentInput - 用户输入的组件名
+ * @param {string} rootDir - 项目根目录
+ * @param {Object} packageJson - package.json 对象
+ * @returns {Promise<string>} 最终解析后的组件名或路径
+ */
+async function resolveComponentInput(componentInput, rootDir, packageJson) {
+    // 路径或完整包名直接返回
+    if (!componentInput || isFileSystemPath(componentInput) || componentInput.startsWith('@')) {
+        return componentInput;
+    }
+
+    const candidates = findComponentCandidates(componentInput, rootDir, packageJson);
+
+    // 只有一个候选：直接返回
+    if (candidates.length === 1) {
+        return candidates[0].packageName;
+    }
+
+    // 多个候选：交互式选择
+    if (candidates.length > 1) {
+        // 非 TTY 环境无法交互：报错并退出
+        if (!process.stdin.isTTY || !process.stdout.isTTY) {
+            console.error(colorize(`[ui-dev-server] 发现多个同名组件 "${componentInput}"，当前环境无法交互式选择：`, 'red'));
+            candidates.forEach((candidate) => {
+                console.error(`  - ${candidate.packageName} (${candidate.displayPath})`);
+            });
+            console.error(colorize('[ui-dev-server] 请改为传入完整包名或绝对路径后重试。', 'yellow'));
+            process.exit(1);
+        }
+
+        const selected = await promptForCandidate(componentInput, candidates);
+        return selected.packageName;
+    }
+
+    // 没有候选：原样返回
+    return componentInput;
+}
+
+module.exports = {
+    getRootDir,
+    getProjectPackageJson,
+    parseScopesFromWorkspaces,
+    getWorkspaceEntries,
+    createCandidate,
+    findComponentCandidates,
+    getComponentScope,
+    resolveComponent,
+    getComponentEntryName,
+    toCamelComponentName,
+    colorize,
+    parseCliArgs,
+    isFileSystemPath,
+    promptForCandidate,
+    resolveComponentInput
+};

package/vue.config.base.js

@@ -0,0 +1,75 @@
+const fs = require('fs');
+const path = require('path');
+const { merge, applyCommonConfig } = require('./config-utils');
+const { getRootDir, getProjectPackageJson } = require('./utils');
+
+/**
+ * 内置默认开发代理，可被项目级配置覆盖
+ */
+const builtinProxy = Object.fromEntries(
+    ['/bams-assets', '/bams-ui-umd', '/bams-app', '/admin-api', '/preview'].map((p) => [p, { target: process.env.PROXY_TARGET }])
+);
+
+/**
+ * 生成通用基础配置（原仓库根 vue.config.js 的核心逻辑）
+ * - externals（vue / vue-router / pinia）
+ * - md 文件 raw-loader
+ * - @components-entry 动态别名（存在 build-components-entry.js 时指向它，否则指向空入口）
+ * - @configurable/* 可配置组件别名（基于环境变量与默认插槽映射）
+ * - devServer 代理合并（项目配置优先 + 内置默认补充缺失前缀）
+ * @param {Object} [options]
+ * @param {string} options.rootDir 项目根目录
+ * @param {Object} options.packageJson 项目根 package.json
+ * @param {Object} [options.devServer] 项目级 devServer 配置
+ * @returns {Object} 基础 vue 配置对象
+ */
+function getBaseConfig(options = {}) {
+    const rootDir = options.rootDir || getRootDir();
+    const packageJson = options.packageJson || getProjectPackageJson(rootDir);
+    const devServer = options.devServer || {};
+
+    // 项目配置优先，覆盖内置默认值；代理键序以项目配置为准，内置默认仅补充缺失前缀
+    const devProxy = devServer.proxy || {};
+    const mergedProxy = Object.fromEntries([
+        ...Object.entries(devProxy),
+        ...Object.entries(builtinProxy).filter(([k]) => !(k in devProxy)),
+    ]);
+
+    // 动态检测组件入口文件，实现“无感”加载的基础配置
+    const componentsEntryPath = path.resolve(rootDir, 'build-components-entry.js');
+    const hasComponentsEntry = fs.existsSync(componentsEntryPath);
+
+    const commonContext = applyCommonConfig({ rootDir, packageJson });
+
+    return {
+        transpileDependencies: true,
+        publicPath: process.env.BASE_URL || '/',
+        configureWebpack: {
+            externals: {
+                vue: 'Vue',
+                'vue-router': 'VueRouter',
+                pinia: 'Pinia',
+            },
+            module: {
+                rules: [
+                    {
+                        test: /\.md$/,
+                        use: 'raw-loader',
+                    },
+                ],
+            },
+            resolve: {
+                // 保留默认相对查找，并追加用户项目 node_modules（组件/能力包位于用户项目时从该处解析）
+                modules: ['node_modules', path.resolve(rootDir, 'node_modules')],
+                alias: {
+                    // 设置别名，如果文件不存在则指向空文件，保证编译不报错
+                    '@components-entry': hasComponentsEntry ? componentsEntryPath : path.resolve(__dirname, 'empty-entry.js'),
+                    ...commonContext.aliases,
+                },
+            },
+        },
+        devServer: merge({}, devServer, { proxy: mergedProxy }),
+    };
+}
+
+module.exports = { getRootDir, getProjectPackageJson, getBaseConfig };

package/vue.config.build.js

@@ -0,0 +1,35 @@
+const { defineConfig } = require('@vue/cli-service')
+const path = require('path')
+const { getBaseConfig } = require('./vue.config.base')
+const { getRootDir, getProjectPackageJson, resolveComponent, findComponentCandidates, getComponentEntryName } = require('./utils')
+
+const rootDir = getRootDir();
+const packageJson = getProjectPackageJson(rootDir);
+const baseConfig = getBaseConfig({ rootDir, packageJson });
+
+const componentName = process.env.COMPONENT || 'ui-component-demo';
+
+const resolvedComponent = resolveComponent(componentName, rootDir, packageJson);
+// COMPONENT 环境变量可能是 @scope/name 完整包名，查找候选时需用短名
+const candidates = findComponentCandidates(getComponentEntryName(componentName), rootDir, packageJson);
+// 命中候选时别名指向组件目录绝对路径（避免从包目录解析用户项目组件失败）
+const component = candidates.length > 0 ? candidates[0].componentPath : resolvedComponent;
+console.log('🎉 当前开发组件：', resolvedComponent);
+
+module.exports = defineConfig({
+    transpileDependencies: baseConfig.transpileDependencies,
+    outputDir: path.resolve(rootDir, 'dist'),
+    publicPath: process.env.BASE_URL || '/',
+    configureWebpack: {
+        externals: baseConfig.configureWebpack.externals,
+        module: baseConfig.configureWebpack.module,
+        resolve: {
+            modules: baseConfig.configureWebpack.resolve?.modules || ['node_modules'],
+            alias: {
+                ...(baseConfig.configureWebpack.resolve?.alias || {}),
+                '@target-component': component
+            }
+        }
+    },
+    devServer: baseConfig.devServer
+})

package/vue.config.dev.js

@@ -0,0 +1,44 @@
+const { defineConfig } = require('@vue/cli-service')
+const path = require('path')
+const { getBaseConfig } = require('./vue.config.base')
+const { getRootDir, getProjectPackageJson, resolveComponent, findComponentCandidates, getComponentEntryName, toCamelComponentName } = require('./utils')
+
+const rootDir = getRootDir();
+const packageJson = getProjectPackageJson(rootDir);
+const baseConfig = getBaseConfig({ rootDir, packageJson });
+
+const componentName = process.env.COMPONENT || 'ui-component-demo';
+const layout = process.env.LAYOUT || 'pc';
+const camelComponentName = toCamelComponentName(componentName);
+
+const resolvedComponent = resolveComponent(componentName, rootDir, packageJson);
+// COMPONENT 环境变量可能是 @scope/name 完整包名，查找候选时需用短名
+const candidates = findComponentCandidates(getComponentEntryName(componentName), rootDir, packageJson);
+// 命中候选时别名指向组件目录绝对路径（避免从包目录解析用户项目组件失败）
+const component = candidates.length > 0 ? candidates[0].componentPath : resolvedComponent;
+console.log('🎉 当前开发组件：', resolvedComponent);
+
+module.exports = defineConfig({
+    transpileDependencies: baseConfig.transpileDependencies,
+    outputDir: path.resolve(rootDir, 'dist'),
+    publicPath: '/',
+    configureWebpack: {
+        externals: baseConfig.configureWebpack.externals,
+        module: baseConfig.configureWebpack.module,
+        resolve: {
+            modules: baseConfig.configureWebpack.resolve?.modules || ['node_modules'],
+            alias: {
+                ...(baseConfig.configureWebpack.resolve?.alias || {}),
+                '@target-component': component
+            }
+        }
+    },
+    chainWebpack: (config) => {
+        config.plugin('define').tap((args) => {
+            args[0]['process.env.VUE_APP_COMPONENT_NAME'] = JSON.stringify(camelComponentName);
+            args[0]['process.env.VUE_APP_LAYOUT'] = JSON.stringify(layout);
+            return args;
+        });
+    },
+    devServer: baseConfig.devServer
+})

package/vue.config.js

@@ -0,0 +1,20 @@
+const { defineConfig } = require('@vue/cli-service')
+const path = require('path')
+const rootDir = path.resolve(__dirname, '../../../')
+
+// 根据环境加载不同的配置文件
+const NODE_ENV = process.env.NODE_ENV || 'development'
+const isDev = NODE_ENV === 'development'
+const isProd = NODE_ENV === 'production'
+const isUmd = process.env.BUILD_TYPE === 'umd'
+
+if (isUmd) {
+    // 打包umd
+    module.exports = require('./vue.config.umd.js')
+} else if (isProd) {
+    // 生产环境
+    module.exports = require('./vue.config.build.js')
+} else {
+    // 开发环境
+    module.exports = require('./vue.config.dev.js')
+}

package/vue.config.umd.js

@@ -0,0 +1,31 @@
+const { defineConfig } = require('@vue/cli-service')
+const path = require('path')
+const { getBaseConfig } = require('./vue.config.base')
+const { getRootDir, getProjectPackageJson } = require('./utils')
+
+const rootDir = getRootDir();
+const packageJson = getProjectPackageJson(rootDir);
+const baseConfig = getBaseConfig({ rootDir, packageJson });
+
+const entryFile = process.env.ENTRY_FILE || path.resolve(rootDir, 'build-components-entry.js');
+const outputDir = process.env.OUTPUT_DIR || path.resolve(rootDir, 'dist/umd');
+const outputName = process.env.OUTPUT_NAME || 'bams-components';
+
+console.log('🎉 当前打包配置：');
+console.log('  入口文件：', entryFile);
+console.log('  输出目录：', outputDir);
+console.log('  输出名称：', outputName);
+
+module.exports = defineConfig({
+    transpileDependencies: baseConfig.transpileDependencies,
+    publicPath: './',
+    outputDir: outputDir,
+    configureWebpack: {
+        externals: baseConfig.configureWebpack.externals,
+        module: baseConfig.configureWebpack.module
+    },
+    css: {
+        // 当作为一个库构建时，你也可以将其设置为 false 免得用户自己导入 CSS。
+        extract: false
+    }
+})