jinbi-utils 1.0.19 → 1.0.21

package/package.json

@@ -1,46 +1,19 @@
 {
   "name": "jinbi-utils",
-  "version": "1.0.19",
+  "version": "1.0.21",
   "description": "",
   "main": "dist/index.umd.min.js",
   "module": "dist/index.esm.min.js",
   "typings": "types/index.d.ts",
-  "files": [
-    "dist",
-    "types",
-    "README.md",
-    "CHANGELOG.md"
-  ],
-  "exports": {
-    ".": {
-      "types": "./types/index.d.ts",
-      "import": "./dist/index.esm.min.js",
-      "require": "./dist/index.umd.min.js",
-      "default": "./dist/index.esm.min.js"
-    },
-    "./chunk-optimizer": {
-      "types": "./types/build/chunk-optimizer/index.d.ts",
-      "require": "./dist/chunk-optimizer.min.cjs",
-      "default": "./dist/chunk-optimizer.min.cjs"
-    }
-  },
   "scripts": {
     "dev": "cross-env NODE_ENV=development rollup -w -c",
-    "build": "npm run build:main && npm run build:chunk-optimizer && npm run build:docs",
-    "build:main": "cross-env NODE_ENV=production rollup -c",
-    "build:chunk-optimizer": "rollup -c rollup.config.chunk-optimizer.js",
+    "build": "cross-env NODE_ENV=production rollup -c && npm run build:docs",
     "watch:dist": "nodemon --watch ./dist --exec 'yalc publish --force'",
     "build:docs": "typedoc",
     "lint:fix": "eslint src/** --fix",
     "lint": "eslint src/**",
     "test": "jest --coverage",
-    "test:dev": "jest --watch --coverage",
-    "prepublishOnly": "npm run build",
-    "release:major": "npm run build && standard-version --release-as major && npm publish && git push --follow-tags",
-    "release:minor": "npm run build && standard-version --release-as minor && npm publish && git push --follow-tags",
-    "release:patch": "npm run build && standard-version --release-as patch && npm publish && git push --follow-tags",
-    "release:beta": "npm run build && standard-version --prerelease beta && npm publish --tag beta && git push --follow-tags",
-    "release": "npm run release:patch"
+    "test:dev": "jest --watch --coverage"
   },
   "keywords": [
     "fe-utils",
@@ -63,7 +36,6 @@
     "@commitlint/cli": "^11.0.0",
     "@commitlint/config-conventional": "^11.0.0",
     "@types/jest": "^25.2.3",
-    "@types/node": "^24.10.0",
     "@typescript-eslint/eslint-plugin": "^3.0.2",
     "@typescript-eslint/parser": "^3.0.2",
     "axios": "1.8.2",
@@ -85,9 +57,7 @@
     "rollup-plugin-serve": "^1.0.1",
     "rollup-plugin-terser": "^6.1.0",
     "rollup-plugin-typescript2": "^0.27.1",
-    "standard-version": "^9.5.0",
     "ts-jest": "^26.0.0",
-    "tslib": "^2.8.1",
     "typedoc": "^0.17.8",
     "typedoc-plugin-external-module-name": "^4.0.3",
     "typescript": "^3.9.3"
@@ -103,7 +73,10 @@
       "commit-msg": "exit 0"
     }
   },
-  "optionalDependencies": {
-    "fsevents": "^2.3.2"
+  "dependencies": {
+    "@wecom/jssdk": "^2.3.1",
+    "pinia": "^2.1.7",
+    "tslib": "^2.8.1",
+    "vue": "^3.4.0"
   }
 }

package/rollup.config.chunk-optimizer.js

@@ -0,0 +1,32 @@
+import babel from 'rollup-plugin-babel';
+import typescript from 'rollup-plugin-typescript2';
+import { terser } from 'rollup-plugin-terser';
+
+const output = [
+  {
+    file: 'dist/chunk-optimizer.cjs',
+    format: 'cjs',
+  },
+];
+
+if (process.env.NODE_ENV === 'production') {
+  output.push({
+    file: 'dist/chunk-optimizer.min.cjs',
+    format: 'cjs',
+    plugins: [terser()],
+  });
+}
+
+export default {
+  input: 'src/build/chunk-optimizer/index.ts',
+  output,
+  external: ['fs', 'path'],
+  plugins: [
+    typescript({
+      useTsconfigDeclarationDir: true,
+    }),
+    babel({
+      exclude: 'node_modules/**',
+    }),
+  ],
+};

package/rollup.config.js

@@ -0,0 +1,73 @@
+import babel from 'rollup-plugin-babel';
+import { eslint } from "rollup-plugin-eslint";
+import typescript from 'rollup-plugin-typescript2';
+import cleaner from 'rollup-plugin-cleaner';
+import { terser } from "rollup-plugin-terser";
+import serve from 'rollup-plugin-serve';
+import pkg from './package.json';
+
+// 端口
+const PORT = 3001;
+// 是否是生产
+const IS_PROD = process.env.NODE_ENV === 'production';
+
+const formats = ['umd', 'esm'];
+const output = formats.map((format) => ({
+  file: `dist/index.${format}.js`,
+  format,
+  name: pkg.name,
+  globals: {
+    'axios': 'axios',
+    'pinia': 'pinia'
+  }
+}));
+
+// 生成模式生成压缩文件
+if (IS_PROD) {
+  formats.forEach((format) => {
+    output.push({
+      file: `dist/index.${format}.min.js`,
+      format,
+      name: pkg.name,
+      globals: {
+        'axios': 'axios',
+        'pinia': 'pinia'
+      },
+      plugins: [terser()],
+    });
+  });
+}
+
+export default {
+	input: 'src/index.ts',
+	output,
+  external: ['fsevents', 'axios', 'pinia', 'fs', 'path'],
+  plugins: [
+    eslint({
+      fix: true,
+      exclude: 'node_modules/**'
+    }),
+    // 使用 tsconfig.json 中定义 的 declarationDir
+    typescript({
+      useTsconfigDeclarationDir: true,
+    }),
+    babel({
+      exclude: 'node_modules/**',
+    }),
+    cleaner({
+      targets: [
+        './dist/',
+        './types/'
+      ]
+    }),
+    !IS_PROD && (
+      serve({
+        open: false,
+        contentBase: ['dist', 'example'],
+        historyApiFallback: true,
+        host: 'localhost',
+        port: PORT,
+      })
+    ),
+  ],
+};

package/src/array/index.ts

@@ -0,0 +1,85 @@
+/**
+ * 数组处理相关
+ * @packageDocumentation
+ * @module Array
+ * @preferred
+ */
+
+/**
+ * 从对象数组中提取指定 key 的值，组成新数组
+ * @param arr - 对象数组
+ * @param key - 要提取的键名
+ * @returns 提取的值数组
+ */
+export function getKeyList<T extends Record<string, any>>(
+  arr: T[],
+  key: string
+): any[] {
+  if (!Array.isArray(arr)) return [];
+
+  const result: any[] = [];
+  for (const item of arr) {
+    if (item && item[key] !== undefined && item[key] !== null) {
+      result.push(item[key]);
+    }
+  }
+
+  return result;
+}
+
+/**
+ * 判断父数组是否包含子数组的所有元素（深度比较）
+ * 注意：此函数需要配合深度比较工具使用
+ * @param parent - 父数组
+ * @param children - 子数组
+ * @param compareFn - 比较函数，用于判断两个元素是否相等
+ * @returns 是否包含所有子元素
+ */
+export function isIncludeAllChildren<T>(
+  parent: T[],
+  children: T[],
+  compareFn?: (a: T, b: T) => boolean
+): boolean {
+  if (!Array.isArray(parent) || !Array.isArray(children)) return false;
+
+  const defaultCompareFn = (a: T, b: T) => JSON.stringify(a) === JSON.stringify(b);
+  const compare = compareFn || defaultCompareFn;
+
+  return children.every(child => parent.some(item => compare(item, child)));
+}
+
+/**
+ * 判断数组或对象是否为空
+ * @param value - 待检查的值
+ * @returns 是否为空
+ */
+export function isAllEmpty(value: any): boolean {
+  if (value === null || value === undefined) return true;
+  if (typeof value === 'string') return value.trim().length === 0;
+  if (Array.isArray(value)) return value.length === 0;
+  if (typeof value === 'object') return Object.keys(value).length === 0;
+  return false;
+}
+
+/**
+ * 计算两个数组的交集
+ * @param arr1 - 数组1
+ * @param arr2 - 数组2
+ * @returns 交集数组
+ */
+export function intersection<T>(arr1: T[], arr2: T[]): T[] {
+  if (!Array.isArray(arr1) || !Array.isArray(arr2)) return [];
+  return arr1.filter(item => arr2.includes(item));
+}
+
+/**
+ * 数组求和
+ * @param arr - 数字数组
+ * @returns 数组元素之和
+ */
+export function sum(arr: number[]): number {
+  return Array.isArray(arr) && arr.length > 0
+    ? arr.reduce((acc, val) => acc + val, 0)
+    : 0;
+}
+

package/src/build/chunk-optimizer/ARCHITECTURE.md

@@ -0,0 +1,347 @@
+# Chunk Optimizer 架构设计文档
+
+## 📐 整体架构
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                      Vite Config                            │
+│  import { createChunkOptimizer } from './build/...'         │
+│  const optimizer = createChunkOptimizer(options)            │
+│  manualChunks: optimizer.generate()                         │
+└────────────────────┬────────────────────────────────────────┘
+                     │
+                     ▼
+┌─────────────────────────────────────────────────────────────┐
+│                  ChunkOptimizer (主类)                       │
+│  ┌──────────────────────────────────────────────────────┐  │
+│  │ 职责:                                                 │  │
+│  │ - 协调各个模块                                        │  │
+│  │ - 管理配置选项                                        │  │
+│  │ - 提供公共 API                                        │  │
+│  └──────────────────────────────────────────────────────┘  │
+└────────────────────┬────────────────────────────────────────┘
+                     │
+        ┌────────────┼────────────┐
+        ▼            ▼            ▼
+┌──────────────┐ ┌──────────────┐ ┌──────────────┐
+│ Dependency   │ │ Dependency   │ │   Chunk      │
+│   Reader     │→│  Classifier  │→│  Generator   │
+└──────────────┘ └──────────────┘ └──────────────┘
+        │            │                    │
+        ▼            ▼                    ▼
+┌──────────────┐ ┌──────────────┐ ┌──────────────┐
+│ package.json │ │  Rules DB    │ │ manualChunks │
+└──────────────┘ └──────────────┘ └──────────────┘
+```
+
+## 🧩 核心模块
+
+### 1. DependencyReader（依赖读取器）
+
+**职责：**
+- 读取和解析 `package.json`
+- 提取依赖信息
+- 自动检测项目框架
+
+**核心方法：**
+```typescript
+class DependencyReader {
+  getDependencies(): DependencyInfo[]
+  detectFramework(): Framework
+  hasDependency(name: string): boolean
+  getDependencyVersion(name: string): string | null
+}
+```
+
+**设计要点：**
+- 缓存 `package.json` 内容，避免重复读取
+- 区分生产依赖和开发依赖
+- 提供框架自动检测功能
+
+---
+
+### 2. DependencyClassifier（依赖分类器）
+
+**职责：**
+- 根据规则对依赖进行分类
+- 支持自定义规则
+- 处理排除规则
+
+**核心方法：**
+```typescript
+class DependencyClassifier {
+  classifyDependency(dep: DependencyInfo): DependencyCategory | null
+  classifyAll(dependencies: DependencyInfo[]): DependencyInfo[]
+  getCategoryStats(dependencies: DependencyInfo[]): Record<string, number>
+  printClassification(dependencies: DependencyInfo[]): void
+}
+```
+
+**分类优先级：**
+1. 自定义规则（最高优先级）
+2. 排除规则
+3. 预定义规则（按 priority 排序）
+4. 默认分类（vendor-libs）
+
+**规则匹配逻辑：**
+```typescript
+// 1. 精确匹配
+if (packageName === rule.match) return rule.category;
+
+// 2. 正则匹配
+if (rule.match.test(packageName)) return rule.category;
+
+// 3. 通配符匹配（自定义规则）
+if (pattern.includes('*')) {
+  const regex = new RegExp('^' + pattern.replace(/\*/g, '.*') + '$');
+  if (regex.test(packageName)) return category;
+}
+```
+
+---
+
+### 3. ChunkGenerator（Chunk 生成器）
+
+**职责：**
+- 生成 `manualChunks` 函数
+- 处理 node_modules 依赖
+- 处理业务代码分包
+
+**核心方法：**
+```typescript
+class ChunkGenerator {
+  generate(): ManualChunksFunction
+  getStats(): { totalDependencies, categorizedDependencies, categories }
+  printStats(): void
+}
+```
+
+**分包逻辑：**
+```typescript
+manualChunks(id: string) {
+  // 1. 处理 node_modules 依赖
+  if (id.includes('node_modules')) {
+    const packageName = extractPackageName(id);
+    return dependencyMap.get(packageName);
+  }
+  
+  // 2. 处理业务代码
+  if (id.includes('/src/views/')) {
+    return extractModuleName(id); // chunk-{module}
+  }
+  
+  if (id.includes('/src/components/')) {
+    return 'chunk-components';
+  }
+  
+  // ... 其他业务代码规则
+}
+```
+
+---
+
+### 4. Rules（规则库）
+
+**结构：**
+```
+rules/
+├── index.ts              # 规则导出和聚合
+├── framework-rules.ts    # 框架相关规则
+└── common-rules.ts       # 通用库规则
+```
+
+**规则定义：**
+```typescript
+interface Rule {
+  match: string | RegExp;     // 匹配模式
+  category: DependencyCategory; // 分类
+  priority?: number;          // 优先级（越大越高）
+  description?: string;       // 描述
+}
+```
+
+**规则分类：**
+- **框架规则**：Vue、React、Angular、Svelte
+- **通用规则**：工具库、图标库、UI 库、图表库等
+
+---
+
+## 🔄 工作流程
+
+### 1. 初始化阶段
+
+```typescript
+const optimizer = createChunkOptimizer(options);
+```
+
+1. 合并默认配置和用户配置
+2. 创建 `DependencyReader` 实例
+3. 自动检测框架（如果 `framework: 'auto'`）
+4. 创建 `DependencyClassifier` 实例
+
+### 2. 分析阶段
+
+```typescript
+const result = optimizer.analyze();
+```
+
+1. 读取 `package.json` 中的所有依赖
+2. 对每个依赖进行分类
+3. 生成分类统计信息
+4. 返回分析结果
+
+### 3. 生成阶段
+
+```typescript
+const manualChunks = optimizer.generate();
+```
+
+1. 执行分析（如果还未分析）
+2. 创建 `ChunkGenerator` 实例
+3. 构建依赖名称到分类的映射
+4. 生成并返回 `manualChunks` 函数
+
+### 4. 构建阶段
+
+```typescript
+// Vite 构建时调用
+manualChunks(id, { getModuleInfo })
+```
+
+1. Vite 对每个模块调用 `manualChunks` 函数
+2. 根据模块 ID 判断是 node_modules 还是业务代码
+3. 返回对应的 chunk 名称
+4. Vite 根据返回值进行分包
+
+---
+
+## 🎯 设计原则
+
+### 1. 单一职责原则（SRP）
+
+每个类只负责一个功能：
+- `DependencyReader` 只负责读取依赖
+- `DependencyClassifier` 只负责分类
+- `ChunkGenerator` 只负责生成配置
+
+### 2. 开闭原则（OCP）
+
+- 对扩展开放：可以添加新的规则、新的框架支持
+- 对修改封闭：核心逻辑不需要修改
+
+### 3. 依赖倒置原则（DIP）
+
+- 依赖抽象（接口/类型）而非具体实现
+- 使用 TypeScript 类型系统保证类型安全
+
+### 4. 可测试性
+
+- 每个模块都可以独立测试
+- 提供测试脚本和示例
+
+---
+
+## 🔌 扩展点
+
+### 1. 添加新的框架支持
+
+在 `rules/framework-rules.ts` 中添加：
+
+```typescript
+export const newFrameworkRules: Rule[] = [
+  { match: 'new-framework', category: 'vendor-framework', priority: 100 },
+  // ...
+];
+```
+
+### 2. 添加新的通用规则
+
+在 `rules/common-rules.ts` 中添加：
+
+```typescript
+export const newCategoryRules: Rule[] = [
+  { match: 'new-lib', category: 'vendor-new', priority: 60 },
+  // ...
+];
+```
+
+### 3. 自定义分包策略
+
+未来可以实现不同的策略类：
+
+```typescript
+interface Strategy {
+  name: string;
+  apply(dependencies: DependencyInfo[]): DependencyInfo[];
+}
+
+class BalancedStrategy implements Strategy { ... }
+class AggressiveStrategy implements Strategy { ... }
+class ConservativeStrategy implements Strategy { ... }
+```
+
+---
+
+## 📊 性能考虑
+
+### 1. 缓存机制
+
+- `package.json` 读取结果缓存
+- 依赖分类结果缓存
+- 避免重复计算
+
+### 2. 规则匹配优化
+
+- 规则按优先级排序，高优先级规则先匹配
+- 使用 Map 存储依赖分类映射，O(1) 查找
+- 正则表达式预编译
+
+### 3. 构建时性能
+
+- `manualChunks` 函数会被频繁调用
+- 使用简单的字符串匹配和 Map 查找
+- 避免复杂的计算和 I/O 操作
+
+---
+
+## 🚀 未来优化方向
+
+### 1. 包大小分析
+
+- 读取 `node_modules` 中的包大小
+- 根据大小动态调整分包策略
+- 大包单独分离，小包合并
+
+### 2. 依赖关系分析
+
+- 分析包之间的依赖关系
+- 将强相关的包打包在一起
+- 减少重复代码
+
+### 3. 智能策略
+
+- 基于项目类型自动选择策略
+- 基于历史构建数据优化分包
+- 机器学习预测最优分包方案
+
+### 4. 可视化工具
+
+- 提供 Web UI 查看分包结果
+- 可视化依赖关系图
+- 交互式调整分包规则
+
+---
+
+## 📝 总结
+
+这个架构设计具有以下优点：
+
+✅ **模块化** - 清晰的职责划分，易于维护  
+✅ **可扩展** - 易于添加新规则和新功能  
+✅ **类型安全** - 完整的 TypeScript 类型定义  
+✅ **高性能** - 优化的匹配算法和缓存机制  
+✅ **易用性** - 简单的 API，零配置即可使用  
+✅ **可测试** - 每个模块都可以独立测试  
+
+这是一个生产级别的工具，可以直接用于实际项目中。
+