jinbi-utils 1.0.21 → 1.0.23

package/dist/chunk-optimizer.cjs

@@ -0,0 +1,703 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var fs = require('fs');
+var path = require('path');
+
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+var __assign = function() {
+    __assign = Object.assign || function __assign(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+
+function __spreadArrays() {
+    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+    for (var r = Array(s), k = 0, i = 0; i < il; i++)
+        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+            r[k] = a[j];
+    return r;
+}
+
+/**
+ * 依赖读取器类
+ */
+var DependencyReader = /** @class */ (function () {
+    function DependencyReader(packageJsonPath) {
+        this.packageJson = null;
+        // 默认使用项目根目录的 package.json
+        this.packageJsonPath = packageJsonPath || path.resolve(process.cwd(), 'package.json');
+    }
+    /**
+     * 读取 package.json
+     */
+    DependencyReader.prototype.readPackageJson = function () {
+        if (this.packageJson) {
+            return this.packageJson;
+        }
+        if (!fs.existsSync(this.packageJsonPath)) {
+            throw new Error("package.json not found at: " + this.packageJsonPath);
+        }
+        try {
+            var content = fs.readFileSync(this.packageJsonPath, 'utf-8');
+            this.packageJson = JSON.parse(content);
+            return this.packageJson;
+        }
+        catch (error) {
+            throw new Error("Failed to parse package.json: " + error);
+        }
+    };
+    /**
+     * 获取所有依赖信息
+     */
+    DependencyReader.prototype.getDependencies = function () {
+        var pkg = this.readPackageJson();
+        var dependencies = [];
+        // 读取生产依赖
+        if (pkg.dependencies) {
+            Object.entries(pkg.dependencies).forEach(function (_a) {
+                var name = _a[0], version = _a[1];
+                dependencies.push({
+                    name: name,
+                    version: version,
+                    isDev: false,
+                });
+            });
+        }
+        // 读取开发依赖
+        if (pkg.devDependencies) {
+            Object.entries(pkg.devDependencies).forEach(function (_a) {
+                var name = _a[0], version = _a[1];
+                dependencies.push({
+                    name: name,
+                    version: version,
+                    isDev: true,
+                });
+            });
+        }
+        return dependencies;
+    };
+    /**
+     * 检测项目使用的框架
+     */
+    DependencyReader.prototype.detectFramework = function () {
+        var pkg = this.readPackageJson();
+        var allDeps = __assign(__assign({}, pkg.dependencies), pkg.devDependencies);
+        // 检测 Vue
+        if (allDeps['vue']) {
+            return 'vue';
+        }
+        // 检测 React
+        if (allDeps['react']) {
+            return 'react';
+        }
+        // 检测 Angular
+        if (allDeps['@angular/core']) {
+            return 'angular';
+        }
+        // 检测 Svelte
+        if (allDeps['svelte']) {
+            return 'svelte';
+        }
+        // 默认返回 auto
+        return 'auto';
+    };
+    /**
+     * 检查是否存在某个依赖
+     */
+    DependencyReader.prototype.hasDependency = function (name) {
+        var _a, _b;
+        var pkg = this.readPackageJson();
+        return !!(((_a = pkg.dependencies) === null || _a === void 0 ? void 0 : _a[name]) || ((_b = pkg.devDependencies) === null || _b === void 0 ? void 0 : _b[name]));
+    };
+    /**
+     * 获取依赖版本
+     */
+    DependencyReader.prototype.getDependencyVersion = function (name) {
+        var _a, _b;
+        var pkg = this.readPackageJson();
+        return (((_a = pkg.dependencies) === null || _a === void 0 ? void 0 : _a[name]) || ((_b = pkg.devDependencies) === null || _b === void 0 ? void 0 : _b[name]) ||
+            null);
+    };
+    return DependencyReader;
+}());
+
+/**
+ * Vue 生态规则
+ */
+var vueRules = [
+    // Vue 核心
+    { match: 'vue', category: 'vendor-vue', priority: 100, description: 'Vue 核心框架' },
+    { match: /^@vue\//, category: 'vendor-vue', priority: 100, description: 'Vue 官方包' },
+    // 状态管理
+    { match: 'pinia', category: 'vendor-vue', priority: 100, description: 'Pinia 状态管理' },
+    { match: 'vuex', category: 'vendor-state', priority: 90, description: 'Vuex 状态管理' },
+    // 路由
+    { match: 'vue-router', category: 'vendor-router', priority: 100, description: 'Vue Router' },
+    // UI 框架
+    { match: 'element-plus', category: 'vendor-element', priority: 80, description: 'Element Plus UI' },
+    { match: 'ant-design-vue', category: 'vendor-ui', priority: 80, description: 'Ant Design Vue' },
+    { match: 'naive-ui', category: 'vendor-ui', priority: 80, description: 'Naive UI' },
+    { match: 'vant', category: 'vendor-ui', priority: 80, description: 'Vant UI' },
+    { match: 'arco-design', category: 'vendor-ui', priority: 80, description: 'Arco Design' },
+    // VueUse
+    { match: /^@vueuse\//, category: 'vendor-vueuse', priority: 70, description: 'VueUse 工具集' },
+    // 国际化
+    { match: 'vue-i18n', category: 'vendor-i18n', priority: 60, description: 'Vue I18n' },
+    { match: /^@intlify\//, category: 'vendor-i18n', priority: 60, description: 'Intlify' },
+];
+/**
+ * React 生态规则
+ */
+var reactRules = [
+    // React 核心
+    { match: 'react', category: 'vendor-react', priority: 100, description: 'React 核心' },
+    { match: 'react-dom', category: 'vendor-react', priority: 100, description: 'React DOM' },
+    // 状态管理
+    { match: 'redux', category: 'vendor-state', priority: 90, description: 'Redux' },
+    { match: 'react-redux', category: 'vendor-state', priority: 90, description: 'React Redux' },
+    { match: 'zustand', category: 'vendor-state', priority: 90, description: 'Zustand' },
+    { match: 'mobx', category: 'vendor-state', priority: 90, description: 'MobX' },
+    { match: 'mobx-react', category: 'vendor-state', priority: 90, description: 'MobX React' },
+    // 路由
+    { match: 'react-router', category: 'vendor-router', priority: 100, description: 'React Router' },
+    { match: 'react-router-dom', category: 'vendor-router', priority: 100, description: 'React Router DOM' },
+    // UI 框架
+    { match: 'antd', category: 'vendor-ui', priority: 80, description: 'Ant Design' },
+    { match: '@ant-design/icons', category: 'vendor-icons', priority: 70, description: 'Ant Design Icons' },
+    { match: '@mui/material', category: 'vendor-ui', priority: 80, description: 'Material UI' },
+    { match: 'chakra-ui', category: 'vendor-ui', priority: 80, description: 'Chakra UI' },
+];
+/**
+ * Angular 生态规则
+ */
+var angularRules = [
+    { match: /^@angular\//, category: 'vendor-angular', priority: 100, description: 'Angular 框架' },
+];
+/**
+ * Svelte 生态规则
+ */
+var svelteRules = [
+    { match: 'svelte', category: 'vendor-svelte', priority: 100, description: 'Svelte 框架' },
+];
+/**
+ * 获取框架规则
+ */
+function getFrameworkRules(framework) {
+    switch (framework) {
+        case 'vue':
+            return vueRules;
+        case 'react':
+            return reactRules;
+        case 'angular':
+            return angularRules;
+        case 'svelte':
+            return svelteRules;
+        default:
+            return __spreadArrays(vueRules, reactRules, angularRules, svelteRules);
+    }
+}
+
+/**
+ * 工具库规则
+ */
+var utilsRules = [
+    // 日期时间
+    { match: 'dayjs', category: 'vendor-utils', priority: 60, description: '日期时间库' },
+    { match: 'moment', category: 'vendor-utils', priority: 60, description: 'Moment.js' },
+    { match: 'date-fns', category: 'vendor-utils', priority: 60, description: 'date-fns' },
+    // HTTP 请求
+    { match: 'axios', category: 'vendor-utils', priority: 70, description: 'Axios HTTP 客户端' },
+    { match: 'ky', category: 'vendor-utils', priority: 70, description: 'Ky HTTP 客户端' },
+    // 工具函数
+    { match: 'lodash', category: 'vendor-utils', priority: 60, description: 'Lodash' },
+    { match: 'lodash-es', category: 'vendor-utils', priority: 60, description: 'Lodash ES' },
+    { match: 'ramda', category: 'vendor-utils', priority: 60, description: 'Ramda' },
+    // Cookie & Storage
+    { match: 'js-cookie', category: 'vendor-utils', priority: 50, description: 'JS Cookie' },
+    { match: 'localforage', category: 'vendor-utils', priority: 50, description: 'LocalForage' },
+    { match: 'responsive-storage', category: 'vendor-utils', priority: 50, description: 'Responsive Storage' },
+    // 查询字符串
+    { match: 'qs', category: 'vendor-utils', priority: 50, description: 'Query String' },
+    // 事件总线
+    { match: 'mitt', category: 'vendor-utils', priority: 50, description: 'Mitt 事件总线' },
+    { match: 'eventemitter3', category: 'vendor-utils', priority: 50, description: 'EventEmitter3' },
+    // 数学计算
+    { match: 'decimal.js', category: 'vendor-utils', priority: 50, description: 'Decimal.js' },
+    { match: 'big.js', category: 'vendor-utils', priority: 50, description: 'Big.js' },
+    // 拖拽
+    { match: 'sortablejs', category: 'vendor-utils', priority: 50, description: 'SortableJS' },
+    // 动画
+    { match: 'animate.css', category: 'vendor-utils', priority: 40, description: 'Animate.css' },
+    { match: '@vueuse/motion', category: 'vendor-utils', priority: 40, description: 'VueUse Motion' },
+    // 其他工具
+    { match: 'nprogress', category: 'vendor-utils', priority: 40, description: 'NProgress' },
+    { match: 'path-browserify', category: 'vendor-utils', priority: 40, description: 'Path Browserify' },
+];
+/**
+ * 图标库规则
+ */
+var iconRules = [
+    { match: /^@iconify\//, category: 'vendor-icons', priority: 60, description: 'Iconify' },
+    { match: 'unplugin-icons', category: 'vendor-icons', priority: 60, description: 'Unplugin Icons' },
+    { match: /-icons?$/, category: 'vendor-icons', priority: 50, description: '图标库（通用匹配）' },
+];
+/**
+ * 表单和验证规则
+ */
+var formRules = [
+    { match: 'vee-validate', category: 'vendor-utils', priority: 50, description: 'VeeValidate' },
+    { match: 'yup', category: 'vendor-utils', priority: 50, description: 'Yup 验证' },
+    { match: 'zod', category: 'vendor-utils', priority: 50, description: 'Zod 验证' },
+    { match: '@zxcvbn-ts/core', category: 'vendor-utils', priority: 40, description: 'Zxcvbn 密码强度' },
+];
+/**
+ * 图表库规则
+ */
+var chartRules = [
+    { match: 'echarts', category: 'vendor-charts', priority: 70, description: 'ECharts' },
+    { match: 'chart.js', category: 'vendor-charts', priority: 70, description: 'Chart.js' },
+    { match: 'd3', category: 'vendor-charts', priority: 70, description: 'D3.js' },
+    { match: /^@antv\//, category: 'vendor-charts', priority: 70, description: 'AntV 图表' },
+];
+/**
+ * 富文本编辑器规则
+ */
+var editorRules = [
+    { match: 'quill', category: 'vendor-editor', priority: 60, description: 'Quill 编辑器' },
+    { match: '@wangeditor/editor', category: 'vendor-editor', priority: 60, description: 'wangEditor' },
+    { match: 'tinymce', category: 'vendor-editor', priority: 60, description: 'TinyMCE' },
+    { match: '@tiptap/vue-3', category: 'vendor-editor', priority: 60, description: 'Tiptap' },
+];
+/**
+ * 表格库规则
+ */
+var tableRules = [
+    { match: 'vxe-table', category: 'vendor-table', priority: 70, description: 'VXE Table' },
+    { match: 'ag-grid', category: 'vendor-table', priority: 70, description: 'AG Grid' },
+];
+/**
+ * 中国特色库规则
+ */
+var chinaRules = [
+    { match: 'china-area-data', category: 'vendor-utils', priority: 40, description: '中国地区数据' },
+    { match: 'pinyin-pro', category: 'vendor-utils', priority: 40, description: '拼音转换' },
+];
+/**
+ * 业务组件库规则
+ */
+var businessRules = [
+    { match: 'plus-pro-components', category: 'vendor-pro', priority: 70, description: 'Plus Pro Components' },
+    { match: 'vue-tippy', category: 'vendor-utils', priority: 40, description: 'Vue Tippy' },
+    { match: 'vue-types', category: 'vendor-utils', priority: 40, description: 'Vue Types' },
+];
+/**
+ * 获取所有通用规则
+ */
+function getCommonRules() {
+    return __spreadArrays(utilsRules, iconRules, formRules, chartRules, editorRules, tableRules, chinaRules, businessRules);
+}
+
+/**
+ * 获取所有规则
+ */
+function getAllRules(framework) {
+    if (framework === void 0) { framework = 'auto'; }
+    var frameworkRules = getFrameworkRules(framework === 'auto' ? 'all' : framework);
+    var commonRules = getCommonRules();
+    return __spreadArrays(frameworkRules, commonRules);
+}
+/**
+ * 根据优先级排序规则
+ */
+function sortRulesByPriority(rules) {
+    return rules.sort(function (a, b) { return (b.priority || 0) - (a.priority || 0); });
+}
+
+/**
+ * 依赖分类器
+ */
+var DependencyClassifier = /** @class */ (function () {
+    function DependencyClassifier(framework, customRules, exclude) {
+        if (framework === void 0) { framework = 'auto'; }
+        if (customRules === void 0) { customRules = {}; }
+        if (exclude === void 0) { exclude = []; }
+        // 获取并排序规则（按优先级）
+        this.rules = sortRulesByPriority(getAllRules(framework));
+        this.customRules = customRules;
+        this.exclude = exclude;
+    }
+    /**
+     * 检查是否应该排除某个包
+     */
+    DependencyClassifier.prototype.shouldExclude = function (packageName) {
+        return this.exclude.some(function (pattern) {
+            if (pattern.includes('*')) {
+                // 支持通配符匹配
+                var regex = new RegExp('^' + pattern.replace(/\*/g, '.*') + '$');
+                return regex.test(packageName);
+            }
+            return packageName === pattern;
+        });
+    };
+    /**
+     * 匹配规则
+     */
+    DependencyClassifier.prototype.matchRule = function (packageName, rule) {
+        if (typeof rule.match === 'string') {
+            return packageName === rule.match;
+        }
+        else {
+            return rule.match.test(packageName);
+        }
+    };
+    /**
+     * 对单个依赖进行分类
+     */
+    DependencyClassifier.prototype.classifyDependency = function (dep) {
+        // 检查是否应该排除
+        if (this.shouldExclude(dep.name)) {
+            return null;
+        }
+        // 优先使用自定义规则
+        if (this.customRules[dep.name]) {
+            return this.customRules[dep.name];
+        }
+        // 检查自定义规则中的通配符
+        for (var _i = 0, _a = Object.entries(this.customRules); _i < _a.length; _i++) {
+            var _b = _a[_i], pattern = _b[0], category = _b[1];
+            if (pattern.includes('*')) {
+                var regex = new RegExp('^' + pattern.replace(/\*/g, '.*') + '$');
+                if (regex.test(dep.name)) {
+                    return category;
+                }
+            }
+        }
+        // 使用预定义规则
+        for (var _c = 0, _d = this.rules; _c < _d.length; _c++) {
+            var rule = _d[_c];
+            if (this.matchRule(dep.name, rule)) {
+                return rule.category;
+            }
+        }
+        // 默认分类
+        return 'vendor-libs';
+    };
+    /**
+     * 对所有依赖进行分类
+     */
+    DependencyClassifier.prototype.classifyAll = function (dependencies) {
+        var _this = this;
+        return dependencies.map(function (dep) { return (__assign(__assign({}, dep), { category: _this.classifyDependency(dep) || undefined })); });
+    };
+    /**
+     * 获取分类统计
+     */
+    DependencyClassifier.prototype.getCategoryStats = function (dependencies) {
+        var stats = {};
+        dependencies.forEach(function (dep) {
+            if (dep.category) {
+                stats[dep.category] = (stats[dep.category] || 0) + 1;
+            }
+        });
+        return stats;
+    };
+    /**
+     * 打印分类信息（调试用）
+     */
+    DependencyClassifier.prototype.printClassification = function (dependencies) {
+        console.log('\n📦 Chunk Optimizer - Dependency Classification\n');
+        var categorized = this.classifyAll(dependencies);
+        var stats = this.getCategoryStats(categorized);
+        // 按分类分组
+        var grouped = {};
+        categorized.forEach(function (dep) {
+            if (dep.category) {
+                if (!grouped[dep.category]) {
+                    grouped[dep.category] = [];
+                }
+                grouped[dep.category].push(dep.name);
+            }
+        });
+        // 打印每个分类
+        Object.entries(grouped)
+            .sort(function (_a, _b) {
+            var a = _a[0];
+            var b = _b[0];
+            return a.localeCompare(b);
+        })
+            .forEach(function (_a) {
+            var category = _a[0], packages = _a[1];
+            console.log("\n" + category + " (" + packages.length + "):");
+            packages.forEach(function (pkg) {
+                console.log("  - " + pkg);
+            });
+        });
+        console.log('\n📊 Summary:');
+        console.log("  Total dependencies: " + dependencies.length);
+        console.log("  Categorized: " + categorized.filter(function (d) { return d.category; }).length);
+        console.log("  Categories: " + Object.keys(stats).length);
+        console.log('');
+    };
+    return DependencyClassifier;
+}());
+
+/**
+ * Chunk 生成器
+ */
+var ChunkGenerator = /** @class */ (function () {
+    function ChunkGenerator(dependencies, sourceCodeStrategy, debug) {
+        var _this = this;
+        if (sourceCodeStrategy === void 0) { sourceCodeStrategy = {}; }
+        if (debug === void 0) { debug = false; }
+        // 构建依赖名称到分类的映射
+        this.dependencyMap = new Map();
+        dependencies.forEach(function (dep) {
+            if (dep.category) {
+                _this.dependencyMap.set(dep.name, dep.category);
+            }
+        });
+        this.sourceCodeStrategy = __assign({ views: true, components: true, utils: true, store: true }, sourceCodeStrategy);
+        this.debug = debug;
+    }
+    /**
+     * 从模块 ID 中提取包名
+     */
+    ChunkGenerator.prototype.extractPackageName = function (id) {
+        var match = id.match(/node_modules\/(@[^/]+\/[^/]+|[^/]+)/);
+        return match ? match[1] : null;
+    };
+    /**
+     * 处理 node_modules 依赖
+     */
+    ChunkGenerator.prototype.handleNodeModules = function (id) {
+        var packageName = this.extractPackageName(id);
+        if (!packageName) {
+            return undefined;
+        }
+        // 查找依赖分类
+        var category = this.dependencyMap.get(packageName);
+        if (this.debug && category) {
+            console.log("[Chunk] " + packageName + " -> " + category);
+        }
+        return category;
+    };
+    /**
+     * 处理业务代码
+     */
+    ChunkGenerator.prototype.handleSourceCode = function (id) {
+        // 处理 views 目录
+        if (this.sourceCodeStrategy.views && id.includes('/src/views/')) {
+            var match = id.match(/\/src\/views\/([^/]+)\//);
+            if (match) {
+                return "chunk-" + match[1];
+            }
+            return 'chunk-views';
+        }
+        // 处理 components 目录
+        if (this.sourceCodeStrategy.components && id.includes('/src/components/')) {
+            return 'chunk-components';
+        }
+        // 处理 utils 和 config 目录
+        if (this.sourceCodeStrategy.utils) {
+            if (id.includes('/src/utils/') || id.includes('/src/config/')) {
+                return 'chunk-common';
+            }
+        }
+        // 处理 store 目录
+        if (this.sourceCodeStrategy.store && id.includes('/src/store/')) {
+            return 'chunk-store';
+        }
+        // 处理自定义规则
+        if (this.sourceCodeStrategy.custom) {
+            for (var _i = 0, _a = this.sourceCodeStrategy.custom; _i < _a.length; _i++) {
+                var rule = _a[_i];
+                if (rule.pattern.test(id)) {
+                    return rule.chunkName;
+                }
+            }
+        }
+        return undefined;
+    };
+    /**
+     * 生成 manualChunks 函数
+     */
+    ChunkGenerator.prototype.generate = function () {
+        var _this = this;
+        return function (id) {
+            // 处理 node_modules 依赖
+            if (id.includes('node_modules')) {
+                return _this.handleNodeModules(id);
+            }
+            // 处理业务代码
+            return _this.handleSourceCode(id);
+        };
+    };
+    /**
+     * 获取依赖统计信息
+     */
+    ChunkGenerator.prototype.getStats = function () {
+        var categories = new Set();
+        this.dependencyMap.forEach(function (category) {
+            categories.add(category);
+        });
+        return {
+            totalDependencies: this.dependencyMap.size,
+            categorizedDependencies: this.dependencyMap.size,
+            categories: Array.from(categories).sort(),
+        };
+    };
+    /**
+     * 打印统计信息
+     */
+    ChunkGenerator.prototype.printStats = function () {
+        var _this = this;
+        var stats = this.getStats();
+        console.log('\n🎯 Chunk Optimizer - Statistics\n');
+        console.log("Total dependencies: " + stats.totalDependencies);
+        console.log("Categorized: " + stats.categorizedDependencies);
+        console.log("\nChunk categories (" + stats.categories.length + "):");
+        stats.categories.forEach(function (category) {
+            var count = Array.from(_this.dependencyMap.values()).filter(function (c) { return c === category; }).length;
+            console.log("  - " + category + ": " + count + " packages");
+        });
+        console.log('');
+    };
+    return ChunkGenerator;
+}());
+
+/**
+ * Vite Chunk Optimizer
+ * 智能分包优化工具 - 自动分析依赖并生成最优的 manualChunks 配置
+ *
+ * @author Your Name
+ * @license MIT
+ */
+/**
+ * Chunk 优化器类
+ */
+var ChunkOptimizer = /** @class */ (function () {
+    function ChunkOptimizer(options) {
+        if (options === void 0) { options = {}; }
+        this.generator = null;
+        // 设置默认选项
+        this.options = {
+            framework: options.framework || 'auto',
+            strategy: options.strategy || 'balanced',
+            customRules: options.customRules || {},
+            exclude: options.exclude || ['@types/*'],
+            minChunkSize: options.minChunkSize || 0,
+            debug: options.debug || false,
+            sourceCodeStrategy: __assign({ views: true, components: true, utils: true, store: true }, options.sourceCodeStrategy),
+            packageJsonPath: options.packageJsonPath || '',
+        };
+        // 初始化依赖读取器
+        this.reader = new DependencyReader(this.options.packageJsonPath);
+        // 自动检测框架
+        if (this.options.framework === 'auto') {
+            this.options.framework = this.reader.detectFramework();
+            if (this.options.debug) {
+                console.log("\uD83D\uDD0D Detected framework: " + this.options.framework);
+            }
+        }
+        // 初始化分类器
+        this.classifier = new DependencyClassifier(this.options.framework, this.options.customRules, this.options.exclude);
+    }
+    /**
+     * 分析依赖
+     */
+    ChunkOptimizer.prototype.analyze = function () {
+        var dependencies = this.reader.getDependencies();
+        var classified = this.classifier.classifyAll(dependencies);
+        var stats = this.classifier.getCategoryStats(classified);
+        return {
+            dependencies: classified,
+            detectedFramework: this.options.framework,
+            categoryStats: stats,
+        };
+    };
+    /**
+     * 生成 manualChunks 函数
+     */
+    ChunkOptimizer.prototype.generate = function () {
+        if (this.generator) {
+            return this.generator.generate();
+        }
+        // 分析依赖
+        var result = this.analyze();
+        // 如果开启调试模式，打印分类信息
+        if (this.options.debug) {
+            this.classifier.printClassification(result.dependencies);
+        }
+        // 创建生成器
+        this.generator = new ChunkGenerator(result.dependencies, this.options.sourceCodeStrategy, this.options.debug);
+        // 如果开启调试模式，打印统计信息
+        if (this.options.debug) {
+            this.generator.printStats();
+        }
+        return this.generator.generate();
+    };
+    /**
+     * 获取分析结果
+     */
+    ChunkOptimizer.prototype.getAnalysisResult = function () {
+        return this.analyze();
+    };
+    /**
+     * 打印分析报告
+     */
+    ChunkOptimizer.prototype.printReport = function () {
+        var result = this.analyze();
+        console.log('\n' + '='.repeat(60));
+        console.log('📦 Vite Chunk Optimizer - Analysis Report');
+        console.log('='.repeat(60) + '\n');
+        console.log("Framework: " + result.detectedFramework);
+        console.log("Strategy: " + this.options.strategy);
+        console.log("Total Dependencies: " + result.dependencies.length + "\n");
+        console.log('Chunk Distribution:');
+        Object.entries(result.categoryStats)
+            .sort(function (_a, _b) {
+            var a = _a[1];
+            var b = _b[1];
+            return b - a;
+        })
+            .forEach(function (_a) {
+            var category = _a[0], count = _a[1];
+            var percentage = ((count / result.dependencies.length) * 100).toFixed(1);
+            console.log("  " + category.padEnd(25) + " " + count.toString().padStart(3) + " (" + percentage + "%)");
+        });
+        console.log('\n' + '='.repeat(60) + '\n');
+    };
+    return ChunkOptimizer;
+}());
+/**
+ * 创建 Chunk 优化器（工厂函数）
+ */
+function createChunkOptimizer(options) {
+    if (options === void 0) { options = {}; }
+    return new ChunkOptimizer(options);
+}
+
+exports.ChunkOptimizer = ChunkOptimizer;
+exports.createChunkOptimizer = createChunkOptimizer;
+exports["default"] = createChunkOptimizer;