@jiangood/springboot-admin-starter 0.0.2 → 0.0.4

package/src/framework/utils/StringUtils.ts

@@ -0,0 +1,410 @@
+/**
+ * 字符串工具类
+ */
+export class StringUtils {
+
+    /**
+     * 移除字符串前缀
+     * @param str 原始字符串
+     * @param ch 要移除的前缀
+     * @returns 移除前缀后的字符串，或原字符串
+     */
+    static removePrefix(str: string | null | undefined, ch: string): string | null | undefined {
+        if (str != null && str.startsWith(ch)) {
+            return str.substring(ch.length);
+        }
+        return str;
+    }
+
+    /**
+     * 移除字符串后缀
+     * @param str 原始字符串
+     * @param ch 要移除的后缀
+     * @returns 移除后缀后的字符串，或原字符串
+     */
+    static removeSuffix(str: string | null | undefined, ch: string): string | null | undefined {
+        if (str != null && str.endsWith(ch)) {
+            return str.substring(0, str.length - ch.length);
+        }
+        return str;
+    }
+
+    /**
+     * 生成指定长度的随机字符串
+     * @param length 随机字符串的长度
+     * @returns 生成的随机字符串
+     */
+    static random(length: number): string {
+        const characters: string = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+        let result: string = '';
+        for (let i = 0; i < length; i++) {
+            result += characters.charAt(Math.floor(Math.random() * characters.length));
+        }
+        return result;
+    }
+
+    /**
+     * 处理空值，返回 "key未定义"
+     * @param key 键名
+     * @returns 处理后的字符串
+     */
+    static nullText(key: string | null | undefined): string {
+        return (key || '') + '未定义';
+    }
+
+    /**
+     * 检查字符串是否包含子字符串
+     * @param str 原始字符串
+     * @param subStr 要检查的子字符串
+     * @returns 如果包含则返回 true，否则返回 false
+     */
+    static contains(str: string | null | undefined, subStr: string): boolean {
+        if (!str) {
+            return false;
+        }
+        return str.includes(subStr);
+    }
+
+    /**
+     * 统计子字符串在原始字符串中出现的次数
+     * @param str 原始字符串
+     * @param subStr 要统计的子字符串
+     * @returns 出现的次数
+     */
+    static count(str: string | null | undefined, subStr: string): number {
+        if (str == null || str.length === 0) {
+            return 0;
+        }
+        let count: number = 0;
+        let index: number = 0;
+
+        while (true) {
+            index = str.indexOf(subStr, index);
+            if (index === -1) {
+                break;
+            }
+            count++;
+            index += subStr.length;
+        }
+
+        return count;
+    }
+
+    /**
+     * 将字符串的首字母转换为大写
+     * @param str 原始字符串
+     * @returns 首字母大写后的字符串，或原值
+     */
+    static capitalize(str: string | null | undefined): string | null | undefined {
+        if (str == null) {
+            return str;
+        }
+        return str.charAt(0).toUpperCase() + str.slice(1);
+    }
+
+    /**
+     * 颠倒字符串的顺序
+     * @param str 原始字符串
+     * @returns 颠倒顺序后的字符串，或原值
+     */
+    static reverse(str: string | null | undefined): string | null | undefined {
+        if (str == null) {
+            return str;
+        }
+        return str.split('').reverse().join('');
+    }
+
+    /**
+     * 截取字符串，返回子字符串后面部分。如果不包含，则原样返回
+     * @param source 原始字符串
+     * @param str 分隔符
+     * @returns 分隔符后面的字符串，或原字符串
+     */
+    static subAfter(source: string | null | undefined, str: string): string | null | undefined {
+        if (source == null) {
+            return source;
+        }
+        const index = source.indexOf(str);
+        return index === -1 ? source : source.substring(index + str.length); // 修正：应为 index + str.length
+    }
+
+    /**
+     * 截取字符串，返回最后一个子字符串后面的部分。如果不包含，则原样返回
+     * @param source 原始字符串
+     * @param str 分隔符
+     * @returns 最后一个分隔符后面的字符串，或原字符串
+     */
+    static subAfterLast(source: string | null | undefined, str: string): string | null | undefined {
+        if (source == null) {
+            return source;
+        }
+        const index = source.lastIndexOf(str);
+        return index === -1 ? source : source.substring(index + str.length); // 修正：应为 index + str.length
+    }
+
+    /**
+     * 截取字符串，返回子字符串前面的部分。如果不包含，则原样返回
+     * @param s 原始字符串
+     * @param sub 分隔符
+     * @returns 分隔符前面的字符串，或原字符串
+     */
+    static subBefore(s: string | null | undefined, sub: string): string | null | undefined {
+        if (s == null) {
+            return s;
+        }
+        const index = s.indexOf(sub);
+        return index === -1 ? s : s.substring(0, index);
+    }
+
+    /**
+     * 混淆字符串 (通过在每个字符后添加 '1')
+     * @param str 原始字符串
+     * @returns 混淆后的字符串
+     */
+    static obfuscateString(str: string | null | undefined): string | null | undefined {
+        if (str == null) {
+            return str;
+        }
+        return str.split('').map(char => char + '1').join('');
+    }
+
+    /**
+     * 补零或补指定字符
+     * @param input 输入值（字符串或数字）
+     * @param totalLen 总长度
+     * @param padChar 填充字符，默认为 '0'
+     * @returns 填充后的字符串
+     */
+    static pad(input: string | number | null | undefined, totalLen: number, padChar: string = '0'): string {
+        if (input == null) {
+            return padChar.repeat(totalLen);
+        }
+        let str = String(input);
+        const charsNeeded: number = totalLen - str.length;
+        if (charsNeeded > 0) {
+            str = padChar.repeat(charsNeeded) + str;
+        }
+        return str;
+    }
+
+    /**
+     * 简单加密：将每个字符的 ASCII 码加 1，并转换为四位十六进制表示
+     * @param str 原始字符串
+     * @returns 加密后的十六进制字符串
+     */
+    static encrypt(str: string | null | undefined): string | null | undefined {
+        if (str == null) {
+            return str;
+        }
+        let encrypted: string = '';
+        for (let i = 0; i < str.length; i++) {
+            let charCode: number = str.charCodeAt(i);
+            charCode += 1;
+            // 转换为四位的十六进制表示，并确保至少四位
+            encrypted += ('0000' + charCode.toString(16)).slice(-4);
+        }
+        return encrypted;
+    }
+
+    /**
+     * 简单解密：还原加密字符串
+     * @param hexString 加密后的十六进制字符串
+     * @returns 解密后的字符串
+     */
+    static decrypt(hexString: string | null | undefined): string | null | undefined {
+        if (hexString == null) {
+            return hexString;
+        }
+        let decrypted: string = '';
+        // 确保是 4 的倍数，否则可能无法正确解密
+        if (hexString.length % 4 !== 0) {
+            // 应该抛出错误或根据业务逻辑处理，这里为兼容原 js 逻辑，简单返回
+            return hexString;
+        }
+
+        for (let i = 0; i < hexString.length; i += 4) {
+            const hexCharCode: string = hexString.substring(i, i + 4);
+            let charCode: number = parseInt(hexCharCode, 16); // 将十六进制转换为十进制
+            if (isNaN(charCode)) {
+                // 如果解析失败，也应根据业务逻辑处理
+                return hexString;
+            }
+            charCode -= 1;
+            decrypted += String.fromCharCode(charCode);
+        }
+        return decrypted;
+    }
+
+    /**
+     * 获取字符串的显示宽度：英文字符 1 宽，中文字符 2 宽
+     * @param str 原始字符串
+     * @returns 字符串的显示宽度
+     */
+    static getWidth(str: string | null | undefined): number {
+        if (str == null || str.length === 0) {
+            return 0;
+        }
+        // 使用非空断言 ! 简化
+        return str!.split('').reduce((pre, cur) => {
+            const charCode: number = cur.charCodeAt(0);
+            // 假设 0-128 为半角字符
+            if (charCode >= 0 && charCode <= 128) {
+                return pre + 1;
+            }
+            // 其它视为全角字符
+            return pre + 2;
+        }, 0);
+    }
+
+    /**
+     * 按显示宽度截取字符串
+     * @param str 原始字符串
+     * @param maxWidth 最大显示宽度
+     * @returns 截取后的字符串
+     */
+    static cutByWidth(str: string, maxWidth: number): string {
+        let showLength: number = 0;
+        return str.split('').reduce((pre, cur) => {
+            const charCode: number = cur.charCodeAt(0);
+            let charWidth: number = (charCode >= 0 && charCode <= 128) ? 1 : 2;
+
+            if (showLength + charWidth <= maxWidth) {
+                showLength += charWidth;
+                return pre + cur;
+            }
+            return pre;
+        }, '');
+    }
+
+
+    /**
+     * 字符串省略处理（按显示宽度计算）
+     * @param str 原始字符串
+     * @param len 字符长度（宽度），注：中文字符算 2
+     * @param suffix 省略号后缀，默认为 '...'
+     * @returns 处理后的字符串
+     */
+    static ellipsis(str: string | null | undefined, len: number, suffix: string = '...'): string | null | undefined {
+        if (str == null) {
+            return str;
+        }
+        if (!StringUtils.isStr(str)) { // 使用类方法调用
+            return str;
+        }
+
+        // 快速判断
+        if (str.length * 2 < len) {
+            return str;
+        }
+
+        const fullLength: number = StringUtils.getWidth(str);
+
+        if (fullLength <= len) {
+            return str;
+        }
+
+        // 截取
+        return StringUtils.cutByWidth(str, len) + suffix;
+    }
+
+    /**
+     * 判断值是否为字符串类型
+     * @param value 任意值
+     * @returns 是否为字符串
+     */
+    static isStr(value: any): value is string {
+        return typeof value === 'string';
+    }
+
+
+    /**
+     * 将下划线或连字符分隔的字符串转为驼峰命名
+     * @param str 原始字符串
+     * @param firstLower 转换后首字母是否小写，默认为 true
+     * @returns 转换后的驼峰字符串
+     */
+    static toCamelCase(str: string, firstLower: boolean = true): string {
+        // 匹配下划线或连字符后跟一个字母
+        let result: string = str.replace(/[-_](\w)/g, function (all, letter) {
+            return letter.toUpperCase();
+        });
+
+        if (firstLower) {
+            // 确保首字母小写
+            result = result.substring(0, 1).toLowerCase() + result.substring(1);
+        }
+
+        return result;
+    }
+
+    /**
+     * 将驼峰命名字符串转为下划线命名
+     * @param name 驼峰命名字符串
+     * @returns 下划线命名字符串
+     */
+    static toUnderlineCase(name: string | null | undefined): string | null | undefined {
+        if (name == null) {
+            return null;
+        }
+        // 在大写字母前添加下划线，并全部转小写
+        let result: string = name.replace(/([A-Z])/g, '_$1').toLowerCase();
+
+        // 移除开头多余的下划线
+        if (result.startsWith('_')) {
+            result = result.substring(1);
+        }
+        return result;
+    }
+
+    /**
+     * 比较两个字符串是否相等，忽略大小写
+     * @param a 字符串 a
+     * @param b 字符串 b
+     * @returns 是否相等（忽略大小写）
+     */
+    static equalsIgnoreCase(a: string | null | undefined, b: string | null | undefined): boolean {
+        if (a === b) { // 引用相同，或同时为 null/undefined
+            return true;
+        }
+
+        if (a != null && b != null) {
+            return a.toLowerCase() === b.toLowerCase();
+        }
+
+        // 只有在 a === b 时，null/undefined 才是 true
+        return false;
+    }
+
+    /**
+     * 分割字符串
+     * @param str
+     * @param sp
+     */
+    static split(str: any, sp: string):null|string[] {
+        if(str == null || str.length === 0){
+            return undefined
+        }
+        if(Array.isArray(str)){
+            return str;
+        }
+
+        return str.split(sp)
+    }
+
+    /**
+     * 连接字符串
+     * @param arr
+     * @param sp 分隔符
+     */
+    static join(arr, sp: string) {
+        if (arr == null) {
+            return  []
+        }
+
+        if(!Array.isArray(arr)){
+            return arr;
+        }
+
+        return arr.join(sp);
+    }
+}

package/src/framework/utils/TreeUtils.ts

@@ -0,0 +1,248 @@
+import {ArrUtils} from "./ArrUtils"; // 假设 ArrUtil 已经被正确定义和导出
+
+/**
+ * 🌳 通用树节点接口
+ * 假设默认的 id, pid, children 字段存在，但支持其他字段
+ * @template T 节点数据的类型
+ */
+export interface TreeNode<T = any> {
+    /** 节点的唯一标识 */
+    id: string | number;
+    /** 父节点的标识 */
+    pid: string | number | null;
+    /** 子节点数组 */
+    children?: TreeNode<T>[];
+
+    /** 节点携带的额外数据 */
+    [key: string]: any;
+}
+
+/**
+ * 🌲 树结构操作工具类
+ * 将数组和树结构互相转换，并提供常用的遍历、查找功能。
+ */
+export class TreeUtils {
+
+    // --- 内部辅助函数 ---
+
+    /**
+     * 递归将树转换为列表的实现。
+     * @param tree 树节点数组
+     * @param level 当前层级
+     * @param result 结果列表，用于累积结果
+     * @returns 包含层级信息的列表
+     */
+    private static _treeToList<T extends TreeNode>(tree: T[], level: number, result: (T & { level: number })[]): (T & {
+        level: number
+    })[] {
+        for (const node of tree) {
+            // 复制节点并添加 level 字段
+            const newNode = {...node, level: level} as T & { level: number };
+            result.push(newNode);
+
+            if (node.children && node.children.length > 0) {
+                // 递归调用，层级加 1
+                this._treeToList(node.children as T[], level + 1, result);
+            }
+        }
+        return result;
+    }
+
+// --- 核心工具方法 ---
+
+    /**
+     * 🌲 将树结构转换为列表结构 (扁平化)。
+     * 节点会被添加一个 `level` 字段表示其层级 (从 1 开始)。
+     * @param tree 树节点数组
+     * @returns 包含层级信息的扁平化列表
+     */
+    public static treeToList<T extends TreeNode>(tree: T[]): (T & { level: number }) {
+        return TreeUtils._treeToList(tree, 1, []);
+    }
+
+    /**
+     * 🔎 根据层级查找所有节点的 ID 列表。
+     * @param tree 树节点数组
+     * @param level 要查找的层级，-1 表示所有层级的 ID。
+     * @returns 匹配层级的 ID 数组。
+     */
+    public static findKeysByLevel<T extends TreeNode>(tree: T[], level: number): (string | number)[] {
+        const list = TreeUtils.treeToList(tree);
+        // 如果 level 为 -1，则返回所有节点的 id；否则返回匹配 level 的节点 id
+        return list
+            .filter(t => level === -1 || t.level === level)
+            .map(t => t.id);
+    }
+
+    /**
+     * 🏗️ 将扁平数组转换为树结构。
+     * 默认使用 `id` 作为节点标识，`pid` 作为父节点标识。
+     * @param list 扁平化节点数组
+     * @param idKey 节点 ID 的字段名，默认为 'id'
+     * @param pidKey 父节点 ID 的字段名，默认为 'pid'
+     * @returns 根节点数组
+     */
+    public static buildTree<T extends TreeNode>(list: T[], idKey: keyof T | 'id' = 'id', pidKey: keyof T | 'pid' = 'pid'): T[] {
+        // 使用 Map 存储所有节点，方便通过 ID 查找
+        const map = new Map<string | number, T>();
+        list.forEach(node => {
+            const id = node[idKey] as string | number;
+            map.set(id, node);
+        });
+
+        const root: T[] = [];
+        for (const node of list) {
+            const pid = node[pidKey] as string | number | null | undefined;
+            // 通过 pidKey 查找父节点
+            const parent = pid ? map.get(pid) : undefined;
+
+            if (parent) {
+                // 如果找到父节点，将当前节点挂载到父节点的 children 数组
+                if (!parent.children) {
+                    parent.children = [];
+                }
+                // TypeScript 确保 children 数组的类型正确
+                (parent.children as T[]).push(node);
+            } else {
+                // 如果没有父节点 (或找不到)，则视为根节点
+                root.push(node);
+            }
+        }
+
+        return root;
+    }
+
+    /**
+     * 🚶 深度优先遍历树节点。
+     * @param tree 树节点数组
+     * @param callback 对每个节点执行的回调函数
+     */
+    public static walk<T extends TreeNode>(tree: T[], callback: (node: T) => void): void {
+        for (const node of tree) {
+            callback(node); // 执行回调函数
+
+            // 遍历子节点
+            if (node.children && node.children.length > 0) {
+                TreeUtils.walk(node.children as T[], callback);
+            }
+        }
+    }
+
+    /**
+     * 🔑 根据键值深度查找单个节点。
+     * @param key 要查找的键值 (例如: 节点的 id)
+     * @param list 树节点数组
+     * @param keyName 要匹配的字段名，默认为 'id'
+     * @returns 找到的节点，如果未找到则返回 undefined
+     */
+    public static findByKey<T extends TreeNode>(key: string | number, list: T[], keyName: keyof T | 'id' = 'id'): T | undefined {
+        for (const item of list) {
+            // 匹配当前节点
+            if (item[keyName] === key) {
+                return item;
+            }
+            // 递归查找子节点
+            if (item.children && item.children.length) {
+                const rs = TreeUtils.findByKey(key, item.children as T[], keyName);
+                if (rs) {
+                    return rs;
+                }
+            }
+        }
+        return undefined;
+    }
+
+
+    /**
+     * 📜 根据键值列表查找所有匹配的节点列表。
+     * @param treeData 树节点数组
+     * @param keyList 要查找的键值列表
+     * @returns 匹配的节点数组
+     */
+    public static findByKeyList<T extends TreeNode>(treeData: T[], keyList: (string | number)[]): T[] {
+        const itemList: T[] = [];
+
+        TreeUtils.walk(treeData, (item) => {
+            // 优先使用 key 字段，其次使用 id 字段
+            const key = item.key || item.id;
+
+            if (ArrUtils.contains(keyList, key)) {
+                itemList.push(item);
+            }
+        });
+
+        return itemList;
+    }
+
+    /**
+     * 获得指定节点下的所有子节点 (扁平化列表，包含自身)。
+     * @param treeNode 树节点
+     * @param buffer 结果列表，用于递归累积
+     * @returns 包含所有子节点的扁平化列表 (包含自身)
+     */
+    private static _getChild<T extends TreeNode>(treeNode: T, buffer: T[]): T[] {
+        if (treeNode.children != null && treeNode.children.length > 0) {
+            treeNode.children.forEach((c) => {
+                buffer.push(c as T);
+                TreeUtils._getChild(c as T, buffer);
+            });
+        }
+        return buffer;
+    }
+
+    /**
+     * 获得给定根节点列表下的所有节点 (扁平化列表)。
+     * @param treeNodeList 树节点数组
+     * @returns 包含所有节点的扁平化列表
+     */
+    public static getSimpleList<T extends TreeNode>(treeNodeList: T[]): T[] {
+        const buffer: T[] = [];
+
+        if (treeNodeList != null) {
+            treeNodeList.forEach((t) => {
+                buffer.push(t);
+                TreeUtils._getChild(t, buffer);
+            });
+        }
+        return buffer;
+    }
+
+
+    /**
+     * 向上追溯，获取从根节点到指定值节点的完整 Key 路径。
+     * 假设节点包含 `id` / `key` 和 `pid` / `parentKey` 字段。
+     * @param tree 完整的树结构数组
+     * @param value 目标节点的 ID 或 Key
+     * @returns 从根节点开始到目标节点的 ID/Key 数组 (包含根和目标节点)
+     */
+    public static getKeyList<T extends TreeNode>(tree: T[], value: string | number): (string | number)[] {
+        const list = TreeUtils.getSimpleList(tree);
+
+        // 使用 Map 快速通过 ID/Key 查找节点
+        const map = new Map<string | number, T>();
+        list.forEach((t) => {
+            const key = t.key || t.id;
+            map.set(key, t);
+        });
+
+        const targetNode = map.get(value);
+        if (targetNode == null) {
+            return []; // 未找到目标节点
+        }
+
+        const keys: (string | number)[] = [targetNode.key || targetNode.id];
+        let parentKey = targetNode.parentKey || targetNode.pid;
+
+        // 向上追溯
+        while (parentKey != null) {
+            const parent = map.get(parentKey);
+            if (parent == null) {
+                break; // 找不到父节点，停止追溯
+            }
+            keys.push(parent.key || parent.id);
+            parentKey = parent.parentKey || parent.pid;
+        }
+
+        return keys.reverse(); // 从根节点到目标节点的路径
+    }
+}