@bdsoft/element 1.1.13 → 1.1.14

package/src/utils/hookPage.js

@@ -0,0 +1,49 @@
+// 分页hook函数 参考说明 components/Pagination/readme.md
+import { reactive, toRefs } from 'vue'
+
+export function usePage(changeFn) {
+  //
+
+  let page = reactive({
+    // 数据服务分页参数值
+    pageHeader: {
+      startindex: 0,
+      pagesize: 30,
+      carrytotal: true
+    },
+    currentPage: 1,
+    pageSizes: [30, 60, 90],
+    pageSize: 30,
+    total: 0
+  })
+
+  function handleSizeChange(val) {
+    page.pageSize = val
+    // page.pageHeader.mend = val
+    changeFn()
+  }
+  function handleCurrentChange(val) {
+    page.currentPage = val
+    page.pageHeader.startindex = val - 1
+    changeFn()
+  }
+  /**
+   *
+   * @param {*} pageobj  { page: currentPage.value, pageSize: val }
+   */
+  function handlePagination(pageobj) {
+    let pageIndex = pageobj.page
+    let pageSize = pageobj.pageSize
+    page.currentPage = pageIndex
+    page.pageSize = pageSize
+    page.pageHeader.startindex = (pageIndex - 1) * pageSize
+    page.pageHeader.pagesize = pageSize
+    changeFn()
+  }
+  return {
+    ...toRefs(page),
+    handleSizeChange,
+    handleCurrentChange,
+    handlePagination
+  }
+}

package/src/utils/index.js

@@ -0,0 +1,5 @@
+export * from './message.js'
+export * from './func.js'
+// export * from './usewerter.js'
+// export * from './filter.js'
+// export * from './bus.js'

package/src/utils/lib/console.js

@@ -0,0 +1,39 @@
+/**
+ * 格式化日志信息
+ * 
+ * @param {String} type - 日志类型，如 'tip' 或 'err'
+ * @param {String} msg - 日志消息内容
+ * @param {Object} rule - 可选参数，与日志相关的规则对象
+ * @returns {String} - 返回格式化后的日志字符串
+ */
+export function format(type, msg, rule) {
+    // 使用模板字符串构建日志信息，包含日志类型和消息内容
+    let logMsg = `[form-create ${type}]: ${msg}`;
+    // 如果提供了规则对象，则将其转换为JSON字符串并添加到日志信息中
+    if (rule) {
+        logMsg += `\n\nrule: ${JSON.stringify(rule.getRule ? rule.getRule() : rule)}`;
+    }
+    // 返回格式化后的日志字符串
+    return logMsg;
+}
+
+/**
+ * 输出格式化的提示信息到控制台
+ * 
+ * @param {String} msg - 提示信息的内容
+ * @param {Object} rule - 可选参数，与提示信息相关的规则对象
+ */
+export function tip(msg, rule) {
+    // 使用 format 函数格式化提示信息，并通过 console.warn 输出到控制台
+    console.warn(format('tip', msg, rule));
+}
+
+
+export function err(msg, rule) {
+    console.error(format('err', msg, rule));
+}
+
+export function logError(e) {
+    err(e.toString());
+    console.error(e);
+}

package/src/utils/lib/debounce.js

@@ -0,0 +1,19 @@
+/**
+ * 防抖函数，用于限制函数的执行频率。
+ * 
+ * @param {Function} fn - 需要防抖的函数。
+ * @param {number} wait - 防抖的时间间隔，单位为毫秒。
+ * @returns {Function} - 返回一个新的函数，该函数在指定的时间间隔内只会执行一次。
+ */
+export default function debounce(fn, wait) {
+    // 用于存储定时器的变量
+    var timeout = null;
+    // 返回一个新的函数，该函数在指定的时间间隔内只会执行一次
+    return function (...arg) {
+        // 如果定时器已经存在，则清除定时器
+        if (timeout !== null)
+            clearTimeout(timeout);
+        // 设置新的定时器，在指定的时间间隔后执行传入的函数
+        timeout = setTimeout(() => fn.call(this, ...arg), wait);
+    }
+}

package/src/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/src/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/src/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/src/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/src/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/src/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/src/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/src/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/src/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/src/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/src/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/src/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/src/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/src/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/src/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/src/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';
+}