@smallwei/avue 3.8.5 → 3.8.6

package/es/src/ui/element-plus/index.mjs

@@ -0,0 +1,132 @@
+/*! Avue.js v3.8.6 | (c) 2017-2026 Smallwei | Released under the MIT License. */
+import '../../../packages/element-plus/count-up/index.mjs';
+import '../../../packages/element-plus/article/index.mjs';
+import '../../../packages/element-plus/crud/index.mjs';
+import '../../../packages/element-plus/card/index.mjs';
+import '../../../packages/element-plus/chat/index.mjs';
+import '../../../packages/element-plus/comment/index.mjs';
+import '../../../packages/element-plus/form/index.mjs';
+import '../../../packages/element-plus/checkbox/index.mjs';
+import '../../../packages/element-plus/date/index.mjs';
+import '../../../packages/element-plus/draggable/index.mjs';
+import '../../../packages/element-plus/flow/index.mjs';
+import '../../../packages/element-plus/group/index.mjs';
+import '../../../packages/element-plus/license/index.mjs';
+import '../../../packages/element-plus/time/index.mjs';
+import '../../../packages/element-plus/input/index.mjs';
+import '../../../packages/element-plus/radio/index.mjs';
+import '../../../packages/element-plus/select/index.mjs';
+import '../../../packages/element-plus/cascader/index.mjs';
+import '../../../packages/element-plus/input-color/index.mjs';
+import '../../../packages/element-plus/input-number/index.mjs';
+import '../../../packages/element-plus/input-tree/index.mjs';
+import '../../../packages/element-plus/input-map/index.mjs';
+import '../../../packages/element-plus/input-icon/index.mjs';
+import '../../../packages/element-plus/input-tag/index.mjs';
+import '../../../packages/element-plus/input-table/index.mjs';
+import '../../../packages/element-plus/input-cron/index.mjs';
+import '../../../packages/element-plus/mention/index.mjs';
+import '../../../packages/element-plus/verify/index.mjs';
+import '../../../packages/element-plus/switch/index.mjs';
+import '../../../packages/element-plus/rate/index.mjs';
+import '../../../packages/element-plus/upload/index.mjs';
+import '../../../packages/element-plus/sign/index.mjs';
+import '../../../packages/element-plus/slider/index.mjs';
+import '../../../packages/element-plus/tree/index.mjs';
+import '../../../packages/element-plus/title/index.mjs';
+import '../../../packages/element-plus/search/index.mjs';
+import '../../../packages/element-plus/tabs/index.mjs';
+import '../../../packages/element-plus/dynamic/index.mjs';
+import '../../../packages/element-plus/video/index.mjs';
+import '../../../packages/element-plus/login/index.mjs';
+import '../../../packages/element-plus/array/index.mjs';
+import '../../../packages/element-plus/text-ellipsis/index.mjs';
+import script from '../../../packages/element-plus/login/index2.mjs';
+import script$1 from '../../../packages/element-plus/sign/index2.mjs';
+import script$2 from '../../../packages/element-plus/text-ellipsis/index2.mjs';
+import script$3 from '../../../packages/element-plus/verify/index2.mjs';
+import script$4 from '../../../packages/element-plus/video/index2.mjs';
+import script$5 from '../../../packages/element-plus/dynamic/index2.mjs';
+import script$6 from '../../../packages/element-plus/tabs/index2.mjs';
+import script$7 from '../../../packages/element-plus/search/index2.mjs';
+import script$8 from '../../../packages/element-plus/title/index2.mjs';
+import script$9 from '../../../packages/element-plus/tree/index2.mjs';
+import script$a from '../../../packages/element-plus/slider/index2.mjs';
+import script$b from '../../../packages/element-plus/upload/index2.mjs';
+import script$c from '../../../packages/element-plus/rate/index2.mjs';
+import script$d from '../../../packages/element-plus/switch/index2.mjs';
+import script$e from '../../../packages/element-plus/mention/index2.mjs';
+import script$f from '../../../packages/element-plus/input-cron/index2.mjs';
+import script$g from '../../../packages/element-plus/input-table/index2.mjs';
+import script$h from '../../../packages/element-plus/input-tag/index2.mjs';
+import script$i from '../../../packages/element-plus/input-map/index2.mjs';
+import script$j from '../../../packages/element-plus/input-icon/index2.mjs';
+import script$k from '../../../packages/element-plus/input-tree/index2.mjs';
+import script$l from '../../../packages/element-plus/input-number/index2.mjs';
+import script$m from '../../../packages/element-plus/input-color/index2.mjs';
+import script$n from '../../../packages/element-plus/cascader/index2.mjs';
+import script$o from '../../../packages/element-plus/select/index2.mjs';
+import script$p from '../../../packages/element-plus/radio/index2.mjs';
+import script$q from '../../../packages/element-plus/input/index2.mjs';
+import script$r from '../../../packages/element-plus/time/index2.mjs';
+import script$s from '../../../packages/element-plus/license/index2.mjs';
+import script$t from '../../../packages/element-plus/group/index2.mjs';
+import script$u from '../../../packages/element-plus/flow/index2.mjs';
+import script$v from '../../../packages/element-plus/draggable/index2.mjs';
+import script$w from '../../../packages/element-plus/count-up/index2.mjs';
+import script$x from '../../../packages/element-plus/date/index2.mjs';
+import script$y from '../../../packages/element-plus/checkbox/index2.mjs';
+import script$z from '../../../packages/element-plus/form/index2.mjs';
+import script$A from '../../../packages/element-plus/comment/index2.mjs';
+import script$B from '../../../packages/element-plus/chat/index2.mjs';
+import script$C from '../../../packages/element-plus/card/index2.mjs';
+import script$D from '../../../packages/element-plus/crud/index2.mjs';
+import script$E from '../../../packages/element-plus/article/index2.mjs';
+import script$F from '../../../packages/element-plus/array/index2.mjs';
+
+const elementComponents = {
+    Arrays: script$F,
+    Article: script$E,
+    Crud: script$D,
+    Card: script$C,
+    Chat: script$B,
+    Comment: script$A,
+    Form: script$z,
+    Checkbox: script$y,
+    Date: script$x,
+    CountUp: script$w,
+    Draggable: script$v,
+    Flow: script$u,
+    Group: script$t,
+    License: script$s,
+    Time: script$r,
+    Input: script$q,
+    Radio: script$p,
+    Select: script$o,
+    Cascader: script$n,
+    InputColor: script$m,
+    InputNumber: script$l,
+    InputTree: script$k,
+    InputIcon: script$j,
+    InputMap: script$i,
+    InputTag: script$h,
+    InputTable: script$g,
+    InputCron: script$f,
+    Mention: script$e,
+    Switchs: script$d,
+    Rate: script$c,
+    Upload: script$b,
+    Slider: script$a,
+    Tree: script$9,
+    Title: script$8,
+    Search: script$7,
+    Tabs: script$6,
+    Dynamic: script$5,
+    Video: script$4,
+    Verifys: script$3,
+    textEllipsis: script$2,
+    Sign: script$1,
+    Login: script,
+};
+
+export { elementComponents as default };

package/es/src/ui/index.mjs

@@ -0,0 +1,7 @@
+/*! Avue.js v3.8.6 | (c) 2017-2026 Smallwei | Released under the MIT License. */
+import elementComponents from './element-plus/index.mjs';
+import dataComponents from './data/index.mjs';
+
+const components = { ...elementComponents, ...dataComponents };
+
+export { components as default };

package/es/src/utils/bem.mjs

@@ -0,0 +1,32 @@
+/*! Avue.js v3.8.6 | (c) 2017-2026 Smallwei | Released under the MIT License. */
+const ELEMENT = '__';
+const MODS = '--';
+const join = (name, el, symbol) => (el ? name + symbol + el : name);
+const prefix = (name, mods) => {
+    if (typeof mods === 'string') {
+        return join(name, mods, MODS);
+    }
+    if (Array.isArray(mods)) {
+        return mods.map((item) => prefix(name, item));
+    }
+    const ret = {};
+    Object.keys(mods || {}).forEach((key) => {
+        ret[name + MODS + key] = mods[key];
+    });
+    return ret;
+};
+var bem = {
+    methods: {
+        b(el, mods) {
+            const { name } = this.$options;
+            if (el && typeof el !== 'string') {
+                mods = el;
+                el = '';
+            }
+            el = join(name, el, ELEMENT);
+            return mods ? [el, prefix(el, mods)] : el;
+        },
+    },
+};
+
+export { bem as default };

package/es/src/utils/mock.mjs

@@ -0,0 +1,141 @@
+/*! Avue.js v3.8.6 | (c) 2017-2026 Smallwei | Released under the MIT License. */
+import packages from '../core/packages.mjs';
+
+var mock = (column, dicData, defaultForm, run) => {
+    if (!run)
+        return;
+    const win = window;
+    if (!win.Mock) {
+        packages.logs('mock');
+        return;
+    }
+    const mockjs = win.Mock;
+    const Random = (mockjs || {}).Random;
+    const form = {};
+    function createName({ en }) {
+        if (en) {
+            return Random.name(true);
+        }
+        return Random.cname();
+    }
+    function createImage({ size, text, base64 }) {
+        const imageSize = size || Random.natural(200, 400);
+        const textColor = text ? '#000000' : Random.color();
+        const bgColor = text ? '#ffffff' : Random.color();
+        if (base64) {
+            return Random.dataImage(imageSize, text);
+        }
+        return Random.image(imageSize, bgColor, textColor, 'png', text || Random.name());
+    }
+    function createId({ uuid }) {
+        if (uuid) {
+            return mockjs.mock('@guid');
+        }
+        return mockjs.mock('@id');
+    }
+    function createTel() {
+        return mockjs.mock(/^1[3-9]\d{9}$/);
+    }
+    function createNumber({ max, min, precision }) {
+        if (precision) {
+            const number = Random.float(min, max, precision) + '';
+            const index = number.indexOf('.') + 1;
+            return Number(number.substring(0, index + precision));
+        }
+        return Random.integer(min, max);
+    }
+    function createUrl({ header }) {
+        let url = Random.url();
+        const index = url.indexOf('://');
+        if (header === false) {
+            url = url.substring(index + 3);
+        }
+        else {
+            url = 'http://' + url.substring(index + 3);
+        }
+        return url;
+    }
+    function createDatetime({ format, now }) {
+        if (now) {
+            return Random.now(format);
+        }
+        return Random.datetime(format);
+    }
+    function createText({ min, max }) {
+        return Random.csentence(min, max);
+    }
+    function createCounty() {
+        return Random.county(true);
+    }
+    function createDic({ dic, props, columnType, multiple }) {
+        const value = props.value || 'value';
+        const len = dic.length;
+        if (len === 0)
+            return;
+        if (['checkbox'].includes(columnType) || multiple) {
+            const number = createNumber({
+                min: 1,
+                max: len,
+            });
+            const result = [];
+            for (let i = 0; i < number; i++) {
+                let flag = true;
+                while (flag) {
+                    const numbers = createNumber({
+                        min: 0,
+                        max: len - 1,
+                    });
+                    const values = dic[numbers][value];
+                    if (!result.includes(values)) {
+                        result.push(values);
+                        flag = false;
+                    }
+                }
+            }
+            return result;
+        }
+        const number = createNumber({
+            min: 0,
+            max: len - 1,
+        });
+        return dic[number][value];
+    }
+    function create() {
+        Object.keys(column).forEach((index) => {
+            const ele = column[index];
+            const isObject = typeof ele.mock === 'object';
+            const params = isObject ? ele.mock || {} : {};
+            params.dic = dicData[ele.prop] || [];
+            params.props = ele.props || {};
+            params.columnType = ele.type;
+            params.multiple = ele.multiple;
+            const dataGenerator = {
+                name: createName,
+                number: createNumber,
+                datetime: createDatetime,
+                word: createText,
+                tel: createTel,
+                id: createId,
+                image: createImage,
+                url: createUrl,
+                county: createCounty,
+                dic: createDic,
+            };
+            if (isObject && dataGenerator[params.type]) {
+                if (params.array) {
+                    form[ele.prop] = Array.from({ length: params.array }, () => dataGenerator[params.type](params));
+                }
+                else {
+                    form[ele.prop] = dataGenerator[params.type](params);
+                }
+            }
+            else if (ele.mock instanceof Function) {
+                form[ele.prop] = ele.mock(defaultForm, mockjs);
+            }
+        });
+    }
+    create();
+    return form;
+};
+
+export { mock as default };

package/es/src/utils/util.mjs

@@ -0,0 +1,374 @@
+/*! Avue.js v3.8.6 | (c) 2017-2026 Smallwei | Released under the MIT License. */
+import { validatenull } from './validate.mjs';
+import { typeList, DIC_PROPS, CHILDREN_LIST } from '../global/variable.mjs';
+import _get from 'lodash/get';
+import _set from 'lodash/set';
+import _cloneDeep from 'lodash/cloneDeep';
+
+const isMediaType = (url, type) => {
+    if (validatenull(url))
+        return;
+    if (typeList.audio.test(url) || typeList.audio.test(type) || type == 'audio') {
+        return 'audio';
+    }
+    else if (typeList.video.test(url) || typeList.video.test(type) || type == 'video') {
+        return 'video';
+    }
+    else if (typeList.img.test(url) || typeList.img.test(type) || type == 'img') {
+        return 'img';
+    }
+    return;
+};
+const uuid = () => {
+    const s = [];
+    const hexDigits = '0123456789abcdef';
+    for (let i = 0; i < 36; i++) {
+        s[i] = hexDigits.substr(Math.floor(Math.random() * 0x10), 1);
+    }
+    s[14] = '4';
+    s[19] = hexDigits.substr(((s[19] & 0x3) | 0x8), 1);
+    s[8] = s[13] = s[18] = s[23] = '-';
+    return s.join('');
+};
+function getFixed(val = 0, len = 2) {
+    return Number(val.toFixed(len));
+}
+function getAsVal(obj, bind = '') {
+    const result = deepClone(obj);
+    if (validatenull(bind))
+        return result;
+    return _get(obj, bind);
+}
+function setAsVal(obj, bind = '', value) {
+    _set(obj, bind, value);
+    return obj;
+}
+const loadScript = (type = 'js', url, dom = 'body') => {
+    let flag = false;
+    return new Promise((resolve) => {
+        const head = dom == 'head' ? document.getElementsByTagName('head')[0] : document.body;
+        for (let i = 0; i < head.children.length; i++) {
+            const ele = head.children[i];
+            if ((ele.src || '').indexOf(url) !== -1) {
+                flag = true;
+                resolve();
+            }
+        }
+        if (flag)
+            return;
+        let script;
+        if (type === 'js') {
+            script = document.createElement('script');
+            script.type = 'text/javascript';
+            script.src = url || '';
+        }
+        else {
+            script = document.createElement('link');
+            script.rel = 'stylesheet';
+            script.type = 'text/css';
+            script.href = url || '';
+        }
+        head.appendChild(script);
+        script.onload = function () {
+            resolve();
+        };
+    });
+};
+function downFile(url, saveName) {
+    if (typeof url === 'object' && url instanceof Blob) {
+        url = URL.createObjectURL(url);
+    }
+    const aLink = document.createElement('a');
+    aLink.href = url;
+    aLink.download = saveName || '';
+    let event;
+    if (window.MouseEvent) {
+        event = new MouseEvent('click');
+    }
+    else {
+        event = document.createEvent('MouseEvents');
+        event.initMouseEvent('click', true, false, window, 0, 0, 0, 0, 0, false, false, false, false, 0, null);
+    }
+    aLink.dispatchEvent(event);
+}
+function extend(...args) {
+    let target = args[0] || {};
+    let deep = false;
+    const arr = Array.prototype.slice.call(args);
+    let i = 1;
+    let options;
+    let src;
+    let key;
+    let copy;
+    let isArray = false;
+    if (typeof target === 'boolean') {
+        deep = target;
+        i++;
+        target = args[1];
+    }
+    for (; i < arr.length; i++) {
+        if ((options = arr[i]) != null) {
+            for (key in options) {
+                copy = options[key];
+                src = target[key];
+                if (deep &&
+                    (Object.prototype.toString.call(copy) === '[object Object]' ||
+                        (isArray = Object.prototype.toString.call(copy) == '[object Array]'))) {
+                    if (isArray) {
+                        src = Object.prototype.toString.call(src) === '[object Array]' ? src : [];
+                    }
+                    else {
+                        src = Object.prototype.toString.call(src) === '[object Object]' ? src : {};
+                    }
+                    target[key] = extend(deep, src, copy);
+                }
+                else if (copy !== undefined && copy !== src) {
+                    target[key] = copy;
+                }
+            }
+        }
+    }
+    return target;
+}
+function createObj(obj, bind) {
+    const list = bind.split('.');
+    const first = list.splice(0, 1)[0];
+    const deep = {};
+    deep[first] = {};
+    if (list.length >= 2) {
+        let start = '{';
+        let end = '}';
+        let result = '';
+        list.forEach((ele) => {
+            result = `${result}${start}"${ele}":`;
+        });
+        result = `${result}""`;
+        for (let i = 0; i < list.length; i++) {
+            result = `${result}${end}`;
+        }
+        deep[first] = JSON.parse(result);
+    }
+    obj = extend(true, obj, deep);
+    return obj;
+}
+function dataURLtoFile(dataurl, filename) {
+    var _a;
+    const arr = dataurl.split(',');
+    const mime = ((_a = arr[0].match(/:(.*?);/)) === null || _a === void 0 ? void 0 : _a[1]) || '';
+    const bstr = atob(arr[1]);
+    let n = bstr.length;
+    const u8arr = new Uint8Array(n);
+    while (n--) {
+        u8arr[n] = bstr.charCodeAt(n);
+    }
+    return new File([u8arr], filename, { type: mime });
+}
+function findObject(list = [], value, prop = 'prop') {
+    const props = { value: prop };
+    let result = findNode(list, props, value);
+    if (result)
+        return result;
+    for (const ele of list) {
+        const column = ele.column ||
+            (ele.children && CHILDREN_LIST.includes(ele.type) ? ele.children.column : null);
+        if (column) {
+            result = findNode(column, props, value);
+            if (result)
+                return result;
+        }
+    }
+    return result;
+}
+function randomId() {
+    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
+    const maxPos = chars.length;
+    let id = '';
+    for (let i = 0; i < 16; i++) {
+        id += chars.charAt(Math.floor(Math.random() * maxPos));
+    }
+    return id;
+}
+const getObjType = (obj) => {
+    const map = {
+        '[object Boolean]': 'boolean',
+        '[object Number]': 'number',
+        '[object String]': 'string',
+        '[object Function]': 'function',
+        '[object Array]': 'array',
+        '[object Date]': 'date',
+        '[object RegExp]': 'regExp',
+        '[object Undefined]': 'undefined',
+        '[object Null]': 'null',
+        '[object Object]': 'object',
+    };
+    if (obj instanceof Element) {
+        return 'element';
+    }
+    return map[Object.prototype.toString.call(obj)];
+};
+const isJson = (str) => {
+    if (Array.isArray(str)) {
+        return str[0] instanceof Object;
+    }
+    else if (str instanceof Object) {
+        return true;
+    }
+    return false;
+};
+const deepClone = (data) => {
+    return _cloneDeep(data);
+};
+const getColumn = (column) => {
+    let columnList = [];
+    if (Array.isArray(column)) {
+        columnList = column;
+    }
+    else {
+        for (const o in column) {
+            column[o].prop = o;
+            columnList.push(column[o]);
+        }
+    }
+    return columnList;
+};
+const setPx = (val, defval = '') => {
+    if (validatenull(val))
+        val = defval;
+    if (validatenull(val))
+        return '';
+    val = val + '';
+    if (val.indexOf('%') === -1) {
+        val = val + 'px';
+    }
+    return val;
+};
+const detailDataType = (value, type) => {
+    if (validatenull(value))
+        return value;
+    if (type === 'number') {
+        return Number(value);
+    }
+    else if (type === 'string') {
+        return value + '';
+    }
+    else {
+        return value;
+    }
+};
+const getDicValue = (list, value, props = {}) => {
+    if (validatenull(list))
+        return value;
+    const isArray = Array.isArray(value);
+    value = isArray ? value : [value];
+    const result = [];
+    const labelKey = props[DIC_PROPS.label] || DIC_PROPS.label;
+    const groupsKey = props[DIC_PROPS.groups] || DIC_PROPS.groups;
+    let dic = deepClone(list);
+    dic.forEach((ele) => {
+        if (ele[groupsKey]) {
+            dic = dic.concat(ele[groupsKey]);
+            delete ele[groupsKey];
+        }
+    });
+    value.forEach((val) => {
+        if (Array.isArray(val)) {
+            const arrayResult = [];
+            val.forEach((arrayVal) => {
+                const obj = findNode(dic, props, arrayVal) || {};
+                arrayResult.push(obj[labelKey] || arrayVal);
+            });
+            result.push(arrayResult);
+        }
+        else {
+            const obj = findNode(dic, props, val) || {};
+            result.push(obj[labelKey] || val);
+        }
+    });
+    return isArray ? result : result.join('');
+};
+const filterParams = (form, list = ['', '$'], deep = true) => {
+    const data = deep ? deepClone(form) : form;
+    for (const o in data) {
+        if (list.includes('')) {
+            if (validatenull(data[o]))
+                delete data[o];
+        }
+        if (list.includes('$')) {
+            if (o.indexOf('$') !== -1)
+                delete data[o];
+        }
+    }
+    return data;
+};
+const findArray = (list = [], value, valueKey = DIC_PROPS.value, index = false) => {
+    if (index) {
+        return list.findIndex((ele) => ele[valueKey] == value);
+    }
+    return list.find((ele) => ele[valueKey] == value);
+};
+const findNode = (list = [], props = {}, value) => {
+    const valueKey = props.value || DIC_PROPS.value;
+    const childrenKey = props.children || DIC_PROPS.children;
+    for (const ele of list) {
+        if (ele[valueKey] === value) {
+            return ele;
+        }
+        const children = ele[childrenKey];
+        if (Array.isArray(children)) {
+            const node = findNode(children, props, value);
+            if (node)
+                return node;
+        }
+    }
+    return undefined;
+};
+const getPasswordChar = (result = '', char) => {
+    const len = result.toString().length;
+    result = '';
+    for (let i = 0; i < len; i++) {
+        result = result + char;
+    }
+    return result;
+};
+const arraySort = (list = [], prop, callback) => {
+    return list
+        .filter((ele) => !validatenull(ele[prop]))
+        .sort((a, b) => callback(a, b))
+        .concat(list.filter((ele) => validatenull(ele[prop])));
+};
+const blankVal = (value) => {
+    if (validatenull(value))
+        return value;
+    const type = getObjType(value);
+    if (type === 'array')
+        value = [];
+    else if (type === 'object')
+        value = {};
+    else if (['number', 'boolean'].includes(type))
+        value = undefined;
+    else
+        value = '';
+    return value;
+};
+const clearVal = (obj, propList, list = []) => {
+    if (!obj)
+        return {};
+    propList.forEach((ele) => {
+        if (list.includes(ele))
+            return;
+        else if (ele.includes('$'))
+            delete obj[ele];
+        else if (!validatenull(obj[ele])) {
+            obj[ele] = blankVal(obj[ele]);
+        }
+    });
+    return obj;
+};
+const validData = (val, dafult) => {
+    if (typeof val === 'boolean') {
+        return val;
+    }
+    return !validatenull(val) ? val : dafult;
+};
+
+export { arraySort, blankVal, clearVal, createObj, dataURLtoFile, deepClone, detailDataType, downFile, extend, filterParams, findArray, findNode, findObject, getAsVal, getColumn, getDicValue, getFixed, getObjType, getPasswordChar, isJson, isMediaType, loadScript, randomId, setAsVal, setPx, uuid, validData };