@jiangood/springboot-admin-starter 0.0.1

package/src/framework/utils/eventBus.js

@@ -0,0 +1,70 @@
+/**
+ * 事件总线
+ * forked form https://github.com/scottcorgan/tiny-emitter
+ */
+
+export  class EventBus {
+    constructor () {
+        this.__stack = {}
+    }
+
+    on (name, callback, ctx) {
+        (this.__stack[ name ] || (this.__stack[ name ] = [])).push({
+            fn: callback,
+            ctx
+        })
+
+        return this // chainable
+    }
+
+    once (name, callback, ctx) {
+        const listener = (...args) => {
+            this.off(name, listener)
+            callback.apply(ctx, args)
+        }
+
+        listener.__callback = callback
+        return this.on(name, listener, ctx) // chainable
+    }
+
+    emit (name) {
+        const list = this.__stack[ name ]
+
+        if (list !== void 0) {
+            const params = [].slice.call(arguments, 1)
+            list.forEach(entry => {
+                entry.fn.apply(entry.ctx, params)
+            })
+        }
+
+        return this // chainable
+    }
+
+    off (name, callback) {
+        const list = this.__stack[ name ]
+
+        if (list === void 0) {
+            return this // chainable
+        }
+
+        if (callback === void 0) {
+            delete this.__stack[ name ]
+            return this // chainable
+        }
+
+        const liveEvents = list.filter(
+            entry => entry.fn !== callback && entry.fn.__callback !== callback
+        )
+
+        if (liveEvents.length !== 0) {
+            this.__stack[ name ] = liveEvents
+        }
+        else {
+            delete this.__stack[ name ]
+        }
+
+        return this // chainable
+    }
+}
+
+export const eventBus = new EventBus()

package/src/framework/utils/html.js

@@ -0,0 +1,13 @@
+
+export function getIframeCommonProps() {
+
+    return {
+        width: '100%',
+        frameBorder: 0,
+        marginHeight: 0,
+        marginWidth: 0
+    }
+}
+
+
+

package/src/framework/utils/index.js

@@ -0,0 +1,17 @@
+export * from "./date";
+export * from "./arr";
+export * from "./html";
+export * from "./url"
+export * from "./str"
+export * from "./eventBus";
+export * from "./color"
+export * from "./debounce";
+export * from "./dom"
+export * from "./uid";
+export * from './validate'
+
+export * from "./str"
+export * from "./tree";
+export * from './storage'
+export * from './browser'
+export * from './obj'

package/src/framework/utils/obj.js

@@ -0,0 +1,72 @@
+/**
+ *  于安全地获取深度嵌套的对象属性的值
+ *  如果属性链中的任何一级为 undefined 或 null，get 函数会返回一个默认值，而不是抛出错误。
+ *
+ *  const obj = { 'a': [{ 'b': { 'c': 3 } }] };
+ *
+ * const value = get(obj, 'a[0].b.c');
+ *
+ * @param obj
+ * @param path
+ * @param defaultValue
+ */
+export function get(obj, path, defaultValue = undefined){
+
+    const pathArray = Array.isArray(path) ? path : path.split('.');
+    let result = obj;
+
+    // 遍历路径
+    for (const segment of pathArray) {
+        if (result == null) {
+            return defaultValue;
+        }
+
+        // 尝试访问属性
+        result = result[segment];
+    }
+
+    // 如果结果还是 null 或 undefined，则返回默认值
+    return result != null ? result : defaultValue;
+
+}
+
+
+export class ObjUtil {
+
+    /**
+     * 复制对象属性
+     * 如果目标对象的属性存在才复制
+     * @param source
+     * @param target
+     */
+   static copyPropertyIfPresent(source, target){
+        if (!source || !target || typeof source !== 'object' || typeof target !== 'object') {
+            return;
+        }
+
+       const keys = Object.keys(target)
+        for (let key of keys) {
+            if(Object.hasOwn(source,key)){
+                let value = source[key];
+                target[key] = value
+            }
+        }
+    }
+
+
+    static copyProperty(source, target){
+        if (!source || !target || typeof source !== 'object' || typeof target !== 'object') {
+            return;
+        }
+
+        const keys = Object.keys(target)
+        for (let key of keys) {
+                let value = source[key];
+                if(value !== undefined){
+                    target[key] = value
+                }
+
+        }
+    }
+
+}

package/src/framework/utils/storage.js

@@ -0,0 +1,37 @@
+import {DateUtil} from "./date";
+
+
+const ENCRYPT = false;
+
+export const StorageUtil = {
+
+
+    get(key, defaultValue = null) {
+        let v = localStorage.getItem(key);
+        if (v == null) {
+            v = defaultValue;
+        }else {
+            const item = JSON.parse(v);
+            v = item.data
+        }
+
+
+        return v
+    },
+
+    set(key, value) {
+        if(value == null){
+            localStorage.removeItem(key)
+        }
+        const item = {
+            createTime: DateUtil.now(),
+            data: value
+        }
+        const dataStr = JSON.stringify(item)
+        localStorage.setItem(key, dataStr)
+    }
+
+}
+
+
+

package/src/framework/utils/str.js

@@ -0,0 +1,297 @@
+export const StrUtil = {
+
+
+
+    removePrefix(str, ch){
+      if(str != null && str.startsWith(ch)){
+       return    str.substring(ch.length)
+      }
+
+      return str;
+    },
+    removeSuffix(str, ch){
+        if(str != null && str.endsWith(ch)){
+            return  str.substring(0,str.length - ch.length)
+        }
+
+        return str;
+    },
+
+    random(length){
+            const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+            let result = '';
+            for (let i = 0; i < length; i++) {
+                result += characters.charAt(Math.floor(Math.random() * characters.length));
+            }
+            return result;
+
+    },
+
+    nullText(key){
+        return (key || '') + "未定义"
+    },
+
+
+    /**
+     * 包含
+     * @param subStr
+     * @returns {boolean}
+     */
+    contains(str, subStr) {
+        if (!str) {
+            return false
+        }
+        return str.includes(subStr);
+    },
+
+
+    /**
+     * 判断字符串出现的个数
+     * @param subStr
+     */
+    count(str, subStr) {
+        if (str == null || str.length == 0) {
+            return 0;
+        }
+        let count = 0;
+        let index = 0;
+
+        while (true) {
+            index = str.indexOf(subStr, index);
+            if (index === -1) {
+                break;
+            }
+            count++;
+            index += subStr.length;
+        }
+
+        return count;
+    },
+
+
+    /**
+     *  将字符串的首字母转换为大写
+     */
+    capitalize(str) {
+        if (str == null) {
+            return str
+        }
+        return str.charAt(0).toUpperCase() + str.slice(1);
+    },
+
+    /**
+     * 颠倒字符串的顺序
+     * @param str
+     * @returns {*}
+     */
+    reverse(str) {
+        if (str == null) {
+            return str;
+        }
+        return str.split('').reverse().join('');
+    },
+
+    /**
+     * 截取字符串, 如果不包含，则原样返回
+     * @param source
+     * @param str
+     * @returns {string|null}
+     */
+    subAfter(source, str) {
+        if (source == null) {
+            return source;
+        }
+        const index = source.indexOf(str)
+        return index === -1 ? source : source.substring(index + 1);
+    },
+
+    subAfterLast(source, str) {
+        if (source == null) {
+            return source;
+        }
+        const index = source.lastIndexOf(str)
+        return index === -1 ? source : source.substring(index + 1);
+    },
+
+    subBefore(s, sub) {
+        if (s == null) {
+            return s;
+        }
+        const index = s.indexOf(sub)
+        return index === -1 ? s : s.substring(0, index);
+    },
+
+    /**
+     * 混淆
+     * @param str
+     * @returns {*}
+     */
+    obfuscateString(str) {
+        if (str == null) {
+            return str
+        }
+        return str.split('').map(char => char + 1).join('');
+    },
+
+
+    /**
+     * 补零
+     * @param input 输入字符串说数字等
+     * @param totalLen 总长度，不狗
+     * @param padChar
+     * @returns {string}
+     */
+    pad(input, totalLen, padChar = '0') {
+        if (input == null) {
+            return padChar.repeat(totalLen)
+        }
+        var str = String(input);
+        var zerosNeeded = totalLen - str.length;
+        if (zerosNeeded > 0) {
+            str = padChar.repeat(zerosNeeded) + str;
+        }
+        return str;
+    },
+
+
+    /**
+     * 加密
+     * @param str
+     * @returns {string}
+     */
+    encrypt(str) {
+        if (str == null) {
+            return str
+        }
+        let encrypted = '';
+        for (let i = 0; i < str.length; i++) {
+            let charCode = str.charCodeAt(i);
+            charCode += 1;
+            encrypted += ('00' + charCode.toString(16)).slice(-4); // 转换为四位的十六进制表示
+        }
+        return encrypted;
+    },
+
+
+    decrypt(hexString) {
+        if (hexString == null) {
+            return hexString;
+        }
+        let decrypted = '';
+        for (let i = 0; i < hexString.length; i += 4) {
+            let hexCharCode = hexString.substr(i, 4);
+            let charCode = parseInt(hexCharCode, 16); // 将十六进制转换为十进制
+            charCode -= 1
+            decrypted += String.fromCharCode(charCode);
+        }
+        return decrypted;
+    },
+
+
+    /**
+     * 类似String.length, 区别在与中文字符占2位宽
+     * 获取字符串长度，英文字符 长度1，中文字符长度2
+     * @param {*} str
+     */
+    getWidth(str) {
+        if (str == null || str.length === 0) {
+            return 0
+        }
+        return str.split('').reduce((pre, cur) => {
+            const charCode = cur.charCodeAt(0);
+            if (charCode >= 0 && charCode <= 128) {
+                return pre + 1;
+            }
+            return pre + 2;
+        }, 0);
+    },
+
+    cutByWidth(str, maxWidth) {
+        let showLength = 0;
+        return str.split('').reduce((pre, cur) => {
+            const charCode = cur.charCodeAt(0);
+            if (charCode >= 0 && charCode <= 128) {
+                showLength += 1;
+            } else {
+                showLength += 2;
+            }
+            if (showLength <= maxWidth) {
+                return pre + cur;
+            }
+            return pre;
+        }, '');
+    },
+
+
+    /**
+     *
+     * @param str
+     * @param len 字符长度，注：中文字符算2
+     * @constructor
+     */
+    ellipsis(str, len, suffix = '...') {
+        if (str == null) {
+            return str;
+        }
+        if (!this.isStr(str)) {
+            return str;
+        }
+
+        // 快速判断2倍
+        if (str.length * 2 < len) {
+            return str
+        }
+
+        const fullLength = this.getWidth(str);
+        let isTooLong = fullLength > len;
+
+        if (!isTooLong) {
+            return str;
+        }
+
+        return this.cutByWidth(str, len) + suffix;
+    },
+
+    isStr(value) {
+        return typeof value === "string"
+    },
+
+
+    // 转驼峰
+    toCamelCase(str, firstLower = true) {
+        let result = str.replace(/\_(\w)/g, function (all, letter) {
+            return letter.toUpperCase();
+        });
+
+        if (firstLower) {
+            result = result.substring(0, 1).toLowerCase() + result.substring(1);
+        }
+
+        return result;
+    },
+
+    toUnderlineCase(name) {
+        if (name == null) {
+            return null;
+        }
+        let result = name.replace(/([A-Z])/g, '_$1').toLowerCase();
+        if (result.startsWith('_')) {
+            result = result.substring(1);
+        }
+        return result;
+    },
+
+    equalsIgnoreCase(a, b) {
+        if (a != null && b != null) {
+            if (a === b) {
+                return true;
+            }
+
+            if (a.toLowerCase() === b.toLowerCase()) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+}

package/src/framework/utils/tree.js

@@ -0,0 +1,175 @@
+// 数据结构 - tree
+
+// 为方便起见，默认 3个字段 id， pid， children
+
+
+import {ArrUtil} from "./arr";
+
+
+function treeToList(tree, level = 1, result = []) {
+    for (const node of tree) {
+        const newNode = {...node, level: level};
+        result.push(newNode);
+
+        if (node.children && node.children.length > 0) {
+            treeToList(node.children, level + 1, result);
+        }
+    }
+
+    return result;
+}
+
+
+export const TreeUtil = {
+    treeToList,
+
+    /**
+     *
+     * @param tree
+     * @param level -1所有
+     */
+    findKeysByLevel(tree, level) {
+        const list = this.treeToList(tree)
+        if (level === -1) {
+            return list.filter(t => t.level === level).map(t => t.id)
+        }
+        return list.filter(t => t.level === level).map(t => t.id)
+    },
+
+    /**
+     * 将数组转换为树
+     * @param list
+     * @param idKey
+     * @param pidKey
+     * @returns {*[]}
+     */
+    buildTree(list, idKey = 'id', pidKey = 'pid') {
+        const map = {};
+        for (let i = 0; i < list.length; i++) {
+            const node = list[i];
+            let id = node[idKey];
+            map[id] = node;
+        }
+
+        const root = [];
+        for (let i = 0; i < list.length; i++) {
+            const node = list[i];
+            let pid = node[pidKey];
+            let parent = map[pid]
+            if (parent) {
+                if (parent.children == null) {
+                    parent.children = []
+                }
+                parent.children.push(node)
+            } else {
+                root.push(node)
+            }
+        }
+
+        return root;
+    },
+
+
+    // 遍历树节点
+    walk(tree, callback) {
+        // 遍历当前层级的节点
+        for (let i = 0; i < tree.length; i++) {
+            const node = tree[i];
+            callback(node); // 执行回调函数
+
+            // 遍历子节点
+            if (node.children && node.children.length > 0) {
+                this.walk(node.children, callback);
+            }
+        }
+    },
+
+    findByKey(key, list, keyName = "id") {
+        for (let item of list) {
+            if (item[keyName] === key) {
+                return item;
+            }
+            if (item.children && item.children.length) {
+                const rs = this.findByKey(key, item.children, keyName)
+                if (rs) {
+                    return rs;
+                }
+            }
+        }
+    },
+
+
+    findByKeyList(treeData, keyList) {
+        const itemList = [];
+        this.traverseTree(treeData, (item) => {
+            const key = item.key || item.id;
+
+            if (ArrUtil.contains(keyList, key)) {
+                itemList.push(item);
+            }
+        })
+
+        return itemList;
+    },
+// id, pid
+    getSimpleList(treeNodeList) {
+        const buffer = [];
+
+        if (treeNodeList != null) {
+            treeNodeList.forEach((t) => {
+                buffer.push(t);
+                TreeUtil.getChild(t, buffer);
+            });
+        }
+        return buffer;
+    }
+
+    , getChild(treeNode, buffer) {
+        if (treeNode.children != null && treeNode.children.length > 0) {
+            treeNode.children.forEach((c) => {
+                buffer.push(c);
+                TreeUtil.getChild(c, buffer);
+            });
+        }
+        return buffer;
+    }
+
+    , getKeyList(tree, value) {
+        const list = TreeUtil.getSimpleList(tree);
+
+        const map = {};
+        list.forEach((t) => {
+            map[t.key || t.id] = t;
+        });
+
+        const t = map[value];
+        if (t == null) {
+            return [];
+        }
+
+        const keys = [t.key || t.id];
+        let parent = map[t.parentKey || t.pid];
+        while (parent != null) {
+            keys.push(parent.key || t.id);
+            parent = map[parent.parentKey || t.pid];
+        }
+
+        return keys.reverse();
+    },
+
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+