@bdsoft/element 1.1.0

package/utils/lib/deepextend.js

@@ -0,0 +1,51 @@
+import {$set} from './modify';
+import is from './type';
+
+export default function deepExtend(origin, target = {}, mode) {
+    let isArr = false;
+    for (let key in target) {
+        if (Object.prototype.hasOwnProperty.call(target, key)) {
+            let clone = target[key];
+            if ((isArr = Array.isArray(clone)) || is.Object(clone)) {
+                let nst = origin[key] === undefined;
+                if (isArr) {
+                    isArr = false;
+                    nst && $set(origin, key, []);
+                } else if (clone._clone && mode !== undefined) {
+                    if (mode) {
+                        clone = clone.getRule();
+                        nst && $set(origin, key, {});
+                    } else {
+                        $set(origin, key, clone._clone());
+                        continue;
+                    }
+                } else {
+                    nst && $set(origin, key, {});
+                }
+                origin[key] = deepExtend(origin[key], clone, mode);
+            } else {
+                $set(origin, key, clone);
+                if (!is.Undef(clone)) {
+                    if (!is.Undef(clone.__json)) {
+                        origin[key].__json = clone.__json;
+                    }
+                    if (!is.Undef(clone.__origin)) {
+                        origin[key].__origin = clone.__origin;
+                    }
+                }
+            }
+        }
+    }
+    return (mode !== undefined && Array.isArray(origin)) ? origin.filter(v => !v || !v.__ctrl) : origin
+}
+
+export function deepCopy(value) {
+    return deepExtend({}, {value}).value;
+}
+
+export function deepExtendArgs(origin, ...lst) {
+    lst.forEach(target => {
+        origin = deepExtend(origin, target);
+    });
+    return origin;
+}

package/utils/lib/deepset.js

@@ -0,0 +1,14 @@
+export default function deepSet(data, idx, val) {
+    let _data = data, to;
+    (idx || '').split('.').forEach(v => {
+        if (to) {
+            if (!_data[to] || typeof _data[to] != 'object') {
+                _data[to] = {}
+            }
+            _data = _data[to];
+        }
+        to = v;
+    })
+    _data[to] = val;
+    return _data;
+}

package/utils/lib/extend.js

@@ -0,0 +1,28 @@
+import {$set} from './modify';
+
+const _extends = Object.assign || function (a) {
+    for (let b, c = 1; c < arguments.length; c++) {
+        for (let d in b = arguments[c], b) {
+            Object.prototype.hasOwnProperty.call(b, d) && ($set(a, d, b[d]));
+        }
+    }
+
+    return a;
+}
+/**
+ * 将传入的多个对象合并成一个新的对象，并返回这个新对象。
+ * 
+ * @returns {Object} - 合并后的新对象。
+ */
+export default function extend() {
+    // 使用 _extends 函数将传入的所有对象合并成一个新的对象，并返回这个新对象
+    return _extends.apply(this, arguments);
+}
+
+export function copy(obj) {
+    // 如果 obj 不是对象或者为 null，则直接返回 obj
+    if (typeof obj !== 'object' || obj === null) return obj;
+    // 如果 obj 是数组，则使用扩展运算符复制数组
+    // 如果 obj 是对象，则使用扩展运算符复制对象
+    return obj instanceof Array ? [...obj] : {...obj};
+}

package/utils/lib/index.js

@@ -0,0 +1,13 @@
+export {default as debounce} from './debounce';
+export {default as toArray} from './toarray';
+export {default as toString} from './tostring';
+export {default as toLine} from './toline';
+export {default as toDate} from './todate';
+export {default as deepExtend, deepExtendArgs, deepCopy} from './deepextend';
+export {default as extend, copy} from './extend';
+export {parseJson, toJson} from './json';
+export {$set, $del} from './modify';
+export {default as is} from './type';
+export {default as uniqueId} from './unique';
+export {default as getSlot} from './slot';
+export {default as deepSet} from './deepset';

package/utils/lib/json.js

@@ -0,0 +1,90 @@
+import deepExtend from './deepextend';
+import {err} from './console';
+import is from './type';
+
+const PREFIX = '[[FORM-CREATE-PREFIX-';
+const SUFFIX = '-FORM-CREATE-SUFFIX]]';
+
+export function toJson(obj, space) {
+    return JSON.stringify(deepExtend(Array.isArray(obj) ? [] : {}, obj, true), function (key, val) {
+        if (val && val._isVue === true)
+            return undefined;
+
+        if (typeof val !== 'function') {
+            return val;
+        }
+        if (val.__json) {
+            return val.__json;
+        }
+        if (val.__origin)
+            val = val.__origin;
+
+        if (val.__emit)
+            return undefined;
+        return PREFIX + val + SUFFIX;
+    }, space);
+}
+
+function makeFn(fn) {
+    return (new Function('return ' + fn))();
+}
+
+export function parseFn(fn, mode) {
+    if (fn && is.String(fn) && fn.length > 4) {
+        let v = fn.trim();
+        let flag = false;
+        try {
+            if (v.indexOf(SUFFIX) > 0 && v.indexOf(PREFIX) === 0) {
+                v = v.replace(SUFFIX, '').replace(PREFIX, '');
+                flag = true;
+            } else if (v.indexOf('$FN:') === 0) {
+                v = v.substring(4);
+                flag = true;
+            } else if (v.indexOf('$EXEC:') === 0) {
+                v = v.substring(6);
+                flag = true;
+            } else if (v.indexOf('$GLOBAL:') === 0) {
+                const name = v.substring(8);
+                v = function (...args) {
+                    const callback = args[0].api.getGlobalEvent(name);
+                    if (callback) {
+                        return callback.call(this, ...args);
+                    }
+                    return undefined;
+                }
+                v.__json = fn;
+                v.__inject = true;
+                return v;
+            } else if (v.indexOf('$FNX:') === 0) {
+                v = makeFn('function($inject){' + v.substring(5) + '}');
+                v.__json = fn;
+                v.__inject = true;
+                return v;
+            } else if (!mode && v.indexOf('function ') === 0 && v !== 'function ') {
+                flag = true;
+            } else if (!mode && v.indexOf('function(') === 0 && v !== 'function(') {
+                flag = true;
+            }
+            if (!flag) return fn;
+            let val;
+            try{
+                val = makeFn(v);
+            }catch (e){
+                val = makeFn('function ' + v);
+            }
+            val.__json = fn;
+            return val;
+        } catch (e) {
+            err(`解析失败:${v}\n\nerr: ${e}`);
+            return undefined;
+        }
+    }
+    return fn;
+}
+
+export function parseJson(json, mode) {
+    return JSON.parse(json, function (k, v) {
+        if (is.Undef(v) || !v.indexOf) return v;
+        return parseFn(v, mode);
+    });
+}

package/utils/lib/mergeprops.js

@@ -0,0 +1,62 @@
+export const normalMerge = ['props'];
+export const toArrayMerge = ['class', 'style', 'directives'];
+export const functionalMerge = ['on', 'hook'];
+
+const mergeProps = (objects, initial = {}, opt = {}) => {
+    const _normalMerge = [...normalMerge, ...opt['normal'] || []];
+    const _toArrayMerge = [...toArrayMerge, ...opt['array'] || []];
+    const _functionalMerge = [...functionalMerge, ...opt['functional'] || []];
+    const propsMerge = opt['props'] || [];
+
+    return objects.reduce((a, b) => {
+        for (const key in b) {
+            if (a[key]) {
+                if (propsMerge.indexOf(key) > -1) {
+                    a[key] = mergeProps([b[key]], a[key]);
+                } else if (_normalMerge.indexOf(key) > -1) {
+                    a[key] = {...a[key], ...b[key]}
+                } else if (_toArrayMerge.indexOf(key) > -1) {
+                    const arrA = a[key] instanceof Array ? a[key] : [a[key]];
+                    const arrB = b[key] instanceof Array ? b[key] : [b[key]];
+                    a[key] = [...arrA, ...arrB]
+                } else if (_functionalMerge.indexOf(key) > -1) {
+                    for (const event in b[key]) {
+                        if (a[key][event]) {
+                            const arrA = a[key][event] instanceof Array ? a[key][event] : [a[key][event]];
+                            const arrB = b[key][event] instanceof Array ? b[key][event] : [b[key][event]];
+                            a[key][event] = [...arrA, ...arrB]
+                        } else {
+                            a[key][event] = b[key][event]
+                        }
+                    }
+                } else if (key === 'hook') {
+                    for (let hook in b[key]) {
+                        if (a[key][hook]) {
+                            a[key][hook] = mergeFn(a[key][hook], b[key][hook])
+                        } else {
+                            a[key][hook] = b[key][hook]
+                        }
+                    }
+                } else {
+                    a[key] = b[key]
+                }
+            } else {
+                if (_normalMerge.indexOf(key) > -1 || _functionalMerge.indexOf(key) > -1 || propsMerge.indexOf(key) > -1) {
+                    a[key] = {...b[key]}
+                } else if (_toArrayMerge.indexOf(key) > -1) {
+                    a[key] = b[key] instanceof Array ? [...b[key]] : (typeof b[key] === 'object' ? {...b[key]} : b[key]);
+                } else
+                    a[key] = b[key];
+            }
+        }
+        return a
+    }, initial);
+}
+
+const mergeFn = (fn1, fn2) =>
+    function () {
+        fn1 && fn1.apply(this, arguments);
+        fn2 && fn2.apply(this, arguments);
+    };
+
+export default mergeProps;

package/utils/lib/mitt.js

@@ -0,0 +1,43 @@
+// https://github.com/developit/mitt
+
+export default function Mitt(all) {
+    all = all || new Map();
+
+    const mitt = {
+
+        $on(type, handler) {
+            const handlers = all.get(type);
+            const added = handlers && handlers.push(handler);
+            if (!added) {
+                all.set(type, [handler]);
+            }
+        },
+
+        $once(type, handler) {
+            handler._once = true;
+            mitt.$on(type, handler);
+        },
+
+        $off(type, handler) {
+            const handlers = all.get(type);
+            if (handlers) {
+                handlers.splice(handlers.indexOf(handler) >>> 0, 1);
+            }
+        },
+
+        $emit(type, ...args) {
+            (all.get(type) || []).slice().map((handler) => {
+                if (handler._once) {
+                    mitt.$off(type, handler);
+                    delete handler._once;
+                }
+                handler(...args);
+            });
+            (all.get('*') || []).slice().map((handler) => {
+                handler(type, args);
+            });
+        }
+    };
+
+    return mitt;
+}

package/utils/lib/modify.js

@@ -0,0 +1,8 @@
+
+export function $set(target, field, value) {
+    target[field] = value;
+}
+
+export function $del(target, field) {
+    delete target[field];
+}

package/utils/lib/slot.js

@@ -0,0 +1,19 @@
+/**
+ * 从给定的 slots 对象中筛选出不需要排除的键值对，并返回一个新的对象。
+ * 
+ * @param {Object} slots - 包含键值对的对象，键是字符串，值是函数。
+ * @param {Array} [exclude] - 可选的数组，包含需要排除的键。
+ * @returns {Object} - 包含不需要排除的键值对的新对象。
+ */
+export default function getSlot(slots, exclude) {
+    // 使用 reduce 方法遍历 slots 对象的所有键
+    return Object.keys(slots).reduce((lst, name) => {
+        // 检查 exclude 是否存在，并且当前键是否不在 exclude 数组中
+        if (!exclude || exclude.indexOf(name) === -1) {
+            // 如果不需要排除，则将当前键值对添加到结果对象中
+            lst[name] = slots[name];
+        }
+        // 返回结果对象，继续下一次迭代
+        return lst;
+    }, {}); // 初始值为空对象
+}

package/utils/lib/toarray.js

@@ -0,0 +1,5 @@
+export default function toArray(value) {
+    return Array.isArray(value)
+        ? value
+        : ([null, undefined, ''].indexOf(value) > -1 ? [] : [value]);
+}

package/utils/lib/tocase.js

@@ -0,0 +1,11 @@
+export default function toCase(str) {
+    const to = str.replace(/(-[a-z])/g, function (v) {
+        return v.replace('-', '').toLocaleUpperCase();
+    });
+
+    return lower(to);
+}
+
+export function lower(str) {
+    return str.replace(str[0], str[0].toLowerCase());
+}

package/utils/lib/todate.js

@@ -0,0 +1,10 @@
+import is from './type';
+
+export default function toDate(timeStamp) {
+    if (is.Date(timeStamp))
+        return timeStamp;
+    else {
+        let date = new Date(timeStamp);
+        return date.toString() === 'Invalid Date' ? timeStamp : date;
+    }
+}

package/utils/lib/toline.js

@@ -0,0 +1,10 @@
+export default function toLine(name) {
+    let line = name.replace(/([A-Z])/g, '-$1').toLocaleLowerCase();
+    if (line.indexOf('-') === 0)
+        line = line.substr(1);
+    return line;
+}
+
+export function upper(str) {
+    return str.replace(str[0], str[0].toLocaleUpperCase());
+}

package/utils/lib/tostring.js

@@ -0,0 +1,7 @@
+export default function toString(val) {
+    return val == null
+        ? ''
+        : typeof val === 'object'
+            ? JSON.stringify(val, null, 2)
+            : String(val)
+}

package/utils/lib/type.js

@@ -0,0 +1,45 @@
+const is = {
+    type(arg, type) {
+        return Object.prototype.toString.call(arg) === '[object ' + type + ']'
+    },
+    Undef(v) {
+        return v === undefined || v === null
+    },
+    Element(arg) {
+        return typeof arg === 'object' && arg !== null && arg.nodeType === 1 && !is.Object(arg)
+    },
+    trueArray(data) {
+        return Array.isArray(data) && data.length > 0;
+    },
+    Function(v) {
+        const type = this.getType(v);
+        return type === 'Function' || type === 'AsyncFunction';
+    },
+    getType(v) {
+        const str = Object.prototype.toString.call(v)
+        return /^\[object (.*)\]$/.exec(str)[1]
+    },
+    empty(value) {
+        if (value === undefined || value === null) {
+            return true;
+        }
+
+        if (Array.isArray(value) && Array.isArray(value) && !value.length) {
+            return true;
+        }
+
+        return typeof value === 'string' && !value;
+    }
+};
+
+['Date', 'Object', 'String', 'Boolean', 'Array', 'Number'].forEach(t => {
+    is[t] = function (arg) {
+        return is.type(arg, t);
+    }
+})
+
+export function hasProperty(rule, k) {
+    return ({}).hasOwnProperty.call(rule, k)
+}
+
+export default is;

package/utils/lib/unique.js

@@ -0,0 +1,6 @@
+let id = 0;
+
+export default function uniqueId() {
+    const num = 370 + (++id);
+    return 'F' + Math.random().toString(36).substr(3, 3) + Number(`${Date.now()}`).toString(36) + num.toString(36) + 'c';
+}

package/utils/message.js

@@ -0,0 +1,166 @@
+import { ElMessage, ElMessageBox, ElNotification, ElLoading, ElButton, ElIcon } from 'element-plus'
+import { Warning } from '@element-plus/icons-vue'
+import { h } from 'vue'
+// !!!如果有方法报错 在执行方法外面添加nextTrick函数处理
+export function showsuccess(msg, duration = 3000, showClose = true) {
+  ElMessage({
+    message: msg || '保存成功',
+    type: 'success',
+    duration: duration,
+    showClose: showClose
+  })
+}
+
+export function showerror(msg, duration = 3000, showClose = true) {
+  ElMessage({
+    message: msg || '保存失败',
+    type: 'error',
+    duration: duration,
+    showClose: showClose
+  })
+}
+
+export function showwarning(msg, duration = 3000, showClose = true, clostFn) {
+  ElMessage({
+    message: msg || '警告内容',
+    type: 'warning',
+    duration: duration,
+    showClose: showClose,
+    onClose: clostFn
+  })
+}
+
+export function showinfo(msg, duration = 3000, showClose = true) {
+  ElMessage({
+    message: msg || '提示信息',
+    duration: duration,
+    showClose: showClose
+  })
+}
+
+export function hideloading(msg) {
+  ElMessage.closeAll()
+}
+
+export function showconfirm(done, confirmtitle = '确认关闭?', showtext = { title: '提示', confirmButtonText: '确定', cancelButtonText: '取消' }, cancle) {
+  return ElMessageBox.confirm(confirmtitle, showtext.title, {
+    confirmButtonText: showtext.confirmButtonText,
+    cancelButtonText: showtext.cancelButtonText,
+    distinguishCancelAndClose: true,
+    type: 'warning'
+  })
+    .then((_) => {
+      done(_)
+    })
+    .catch((_) => {
+      console.info('showconfirm catch')
+      console.info(_)
+      cancle && cancle(_)
+    })
+}
+
+/**
+ * 信息提示框
+ * @param {*} msg 
+ * @param {*} type 
+ * @param {*} title 
+ * @param {*} position 
+ * @param {*} dangerouslyUseHTMLString 
+ */
+export function shownotiinfo(msg, type = 'info',title='提示',position='bottom-right',dangerouslyUseHTMLString=false) {
+  ElNotification({
+    title: title,
+    position: position,
+    message: msg,
+    dangerouslyUseHTMLString:dangerouslyUseHTMLString,
+    type: type
+  })
+}
+
+export function showconfirminfo(
+  msg = '确认删除？',
+  showtext = { type: '', position: 'bottom-right', title: '提示', dangerouslyUseHTMLString: true },
+  fn1,
+  fn2
+) {
+  // 按钮
+  const btn1 = h(ElButton, {
+    innerText: '立即刷新',
+    type: 'primary',
+    size: 'small',
+    style: { marginLeft: '16px', float: 'right' },
+    onclick: (_) => {
+      fn1(_)
+    }
+  })
+  const btn2 = h(ElButton, {
+    innerText: '暂不更新',
+    style: { float: 'right' },
+    size: 'small',
+    onclick: (_) => {
+      fn2(_)
+    }
+  })
+  // 信息div
+  const div = h('div', { style: { marginLeft: '8px', marginBottom: '16px', marginTop: '16px' } }, msg)
+  // 图标
+  const icon1 = h(Warning)
+  const icon = h(ElIcon, { style: { fontSize: '18px' } }, [icon1])
+  // 整体div
+  const msgDiv = h('div', { style: { display: 'flex', alignItems: 'center' } }, [icon, div])
+  ElNotification({
+    class: 'custom-notification',
+    title: showtext.title,
+    position: showtext.position,
+    dangerouslyUseHTMLString: showtext.dangerouslyUseHTMLString,
+    message: h('div', [msgDiv, btn1, btn2]),
+    type: showtext.type,
+    duration: 0,
+    showClose: false
+  })
+}
+
+export function showalert(done, alertMsg = 'This is a message', type = 'info', showtext = { title: '提示', confirmButtonText: '确定' }) {
+  return ElMessageBox.alert(alertMsg, showtext.title, {
+    confirmButtonText: showtext.confirmButtonText,
+    type: type
+  })
+    .then((_) => {
+      done(_)
+    })
+    .catch((_) => {
+      console.info('showalert catch')
+      console.info(_)
+    })
+}
+
+export function confirm(confirmtitle = '确认关闭?') {
+  return ElMessageBox.confirm(confirmtitle)
+}
+
+
+export function showloading(msg, duration = 0, showClose = true) {
+  ElMessage({
+    // <svg viewBox="0 0 1024 1024" focusable="false" data-icon="loading" width="1em" height="1em" fill="currentColor" aria-hidden="true"><path d="M988 548c-19.9 0-36-16.1-36-36 0-59.4-11.6-117-34.6-171.3a440.45 440.45 0 00-94.3-139.9 437.71 437.71 0 00-139.9-94.3C629 83.6 571.4 72 512 72c-19.9 0-36-16.1-36-36s16.1-36 36-36c69.1 0 136.2 13.5 199.3 40.3C772.3 66 827 103 874 150c47 47 83.9 101.8 109.7 162.7 26.7 63.1 40.2 130.2 40.2 199.3.1 19.9-16 36-35.9 36z"></path></svg>
+    icon: 'loadsvg',
+    message: msg || '正在保存,请稍后...',
+    duration: duration,
+    showClose: showClose
+  })
+}
+
+// loading加载 closeLoading
+let loadingObj = null
+export function showLoading(msg) {
+  loadingObj = ElLoading.service({
+    lock: true,
+    text: msg || '加载中...',
+    spinner: 'el-icon-loading',
+    background: 'rgba(0, 0, 0, 0.7)'
+  })
+}
+
+export function closeLoading() {
+  loadingObj.close()
+}
+export { ElMessage, ElMessageBox, ElNotification, ElLoading }

package/utils/package.json

@@ -0,0 +1,16 @@
+{
+    "name": "@bdsoft-element/utils",
+    "version": "1.0.1",
+    "description": "",
+    "main": "./index.js",
+    "scripts": {
+        "test": "echo \"Error: no test specified\" && exit 1"
+    },
+    "files": [
+        "README.md",
+        "package.json"
+    ],
+    "keywords": [],
+    "author": "lbq",
+    "license": "MIT"
+}

package/utils/type.js

@@ -0,0 +1,45 @@
+const is = {
+    type(arg, type) {
+        return Object.prototype.toString.call(arg) === '[object ' + type + ']'
+    },
+    Undef(v) {
+        return v === undefined || v === null
+    },
+    Element(arg) {
+        return typeof arg === 'object' && arg !== null && arg.nodeType === 1 && !is.Object(arg)
+    },
+    trueArray(data) {
+        return Array.isArray(data) && data.length > 0;
+    },
+    Function(v) {
+        const type = this.getType(v);
+        return type === 'Function' || type === 'AsyncFunction';
+    },
+    getType(v) {
+        const str = Object.prototype.toString.call(v)
+        return /^\[object (.*)\]$/.exec(str)[1]
+    },
+    empty(value) {
+        if (value === undefined || value === null) {
+            return true;
+        }
+
+        if (Array.isArray(value) && Array.isArray(value) && !value.length) {
+            return true;
+        }
+
+        return typeof value === 'string' && !value;
+    }
+};
+
+['Date', 'Object', 'String', 'Boolean', 'Array', 'Number'].forEach(t => {
+    is[t] = function (arg) {
+        return is.type(arg, t);
+    }
+})
+
+export function hasProperty(rule, k) {
+    return ({}).hasOwnProperty.call(rule, k)
+}
+
+export default is;