@smallwei/avue 3.8.4 → 3.8.6

package/es/src/core/dataformat.mjs

@@ -0,0 +1,188 @@
+/*! Avue.js v3.8.6 | (c) 2017-2026 Smallwei | Released under the MIT License. */
+import { validatenull } from '../utils/validate.mjs';
+import { DIC_SPLIT, MULTIPLE_LIST, ARRAY_VALUE_LIST, RANGE_LIST, ARRAY_LIST, SELECT_LIST, KEY_COMPONENT_NAME, DATE_LIST, INPUT_LIST } from '../global/variable.mjs';
+import { detailDataType, createObj, findObject } from '../utils/util.mjs';
+import { t } from '../locale/index.mjs';
+
+let count = 0;
+const calcCascader = (list = []) => {
+    list.forEach((ele) => {
+        const cascader = ele.cascader;
+        if (!validatenull(cascader)) {
+            const parentProp = ele.prop;
+            cascader.forEach((citem) => {
+                const column = findObject(list, citem);
+                if (column)
+                    column.parentProp = parentProp;
+            });
+        }
+    });
+    return list;
+};
+const calcCount = (ele, spanDefault = 12, init = false) => {
+    const spanAll = 24;
+    if (init)
+        count = 0;
+    const currentSpan = (ele.span || spanDefault) + (ele.offset || 0);
+    count += currentSpan;
+    if (ele.row && count < spanAll) {
+        ele.count = spanAll - count;
+        count = 0;
+    }
+    else if (count >= spanAll) {
+        count = 0;
+    }
+    return ele;
+};
+const initVal = (value, safe) => {
+    let { type, multiple, dataType, separator = DIC_SPLIT, alone, emitPath, range } = safe;
+    let list = value;
+    if ((MULTIPLE_LIST.includes(type) && multiple == true) ||
+        (ARRAY_VALUE_LIST.includes(type) && emitPath !== false) ||
+        (RANGE_LIST.includes(type) && range == true)) {
+        if (!Array.isArray(list)) {
+            if (validatenull(list)) {
+                list = [];
+            }
+            else {
+                if (dataType == 'json') {
+                    list = JSON.parse(list);
+                }
+                else {
+                    list = (list + '').split(separator) || [];
+                }
+            }
+        }
+        list.forEach((ele, index) => {
+            list[index] = detailDataType(ele, dataType);
+        });
+        if (ARRAY_LIST.includes(type) && validatenull(list) && alone)
+            list = [''];
+    }
+    else {
+        list = detailDataType(list, dataType);
+    }
+    return list;
+};
+const getSearchType = (column) => {
+    const type = column.type;
+    const range = column.searchRange;
+    let result = type;
+    if (column.searchType)
+        return column.searchType;
+    if (['radio', 'checkbox', 'switch'].includes(type)) {
+        result = 'select';
+    }
+    else if (DATE_LIST.includes(type)) {
+        const rangeKey = 'range';
+        if (range) {
+            if (!type.includes(rangeKey)) {
+                result = type + rangeKey;
+            }
+            else {
+                result = type;
+            }
+        }
+        else
+            result = type.replace(rangeKey, '');
+    }
+    else if (['textarea'].includes(type)) {
+        result = 'input';
+    }
+    return result;
+};
+const getComponent = (type, component) => {
+    let result = type || 'input';
+    if (!validatenull(component)) {
+        return component;
+    }
+    else if (ARRAY_LIST.includes(type || '')) {
+        result = 'array';
+    }
+    else if (['time', 'timerange'].includes(type || '')) {
+        result = 'time';
+    }
+    else if (DATE_LIST.includes(type || '')) {
+        result = 'date';
+    }
+    else if ([
+        'password',
+        'textarea',
+        'search',
+        'phone',
+        'currency',
+        'bankCard',
+        'bank-card',
+        'idCard',
+        'id-card',
+        'email',
+        'code',
+        'plate',
+        'ip',
+        'mac',
+        'uscc',
+    ].includes(type || '')) {
+        result = 'input';
+    }
+    else if (type === 'cron') {
+        result = 'input-cron';
+    }
+    else if (INPUT_LIST.includes(type || '')) {
+        result = 'input-' + type;
+    }
+    return KEY_COMPONENT_NAME + result;
+};
+const formInitVal = (list = []) => {
+    let tableForm = {};
+    list.forEach((ele) => {
+        if (['rate', 'slider', 'number'].includes(ele.type) ||
+            ele.dataType === 'number' ||
+            (ele.type == 'select' && ele.virtualize == true)) {
+            tableForm[ele.prop] = undefined;
+        }
+        else if ((ARRAY_VALUE_LIST.includes(ele.type) &&
+            ele.emitPath !== false &&
+            ele.dataType != 'json') ||
+            (MULTIPLE_LIST.includes(ele.type) && ele.multiple) ||
+            ele.dataType === 'array') {
+            tableForm[ele.prop] = [];
+        }
+        else if (RANGE_LIST.includes(ele.type) && ele.range == true) {
+            tableForm[ele.prop] = [0, 0];
+        }
+        else {
+            tableForm[ele.prop] = '';
+        }
+        if (ele.bind) {
+            tableForm = createObj(tableForm, ele.bind);
+        }
+        if (!validatenull(ele.value)) {
+            tableForm[ele.prop] = ele.value;
+        }
+    });
+    return tableForm;
+};
+const getPlaceholder = function (column, type) {
+    const placeholder = column.placeholder;
+    const label = column.label;
+    if (type === 'search') {
+        const searchPlaceholder = column.searchPlaceholder;
+        if (!validatenull(searchPlaceholder)) {
+            return searchPlaceholder;
+        }
+        else {
+            return label;
+        }
+    }
+    else if (validatenull(placeholder)) {
+        if (SELECT_LIST.includes(column.type)) {
+            return `${t('tip.select')} ${label}`;
+        }
+        else {
+            return `${t('tip.input')} ${label}`;
+        }
+    }
+    return placeholder;
+};
+
+export { calcCascader, calcCount, formInitVal, getComponent, getPlaceholder, getSearchType, initVal };

package/es/src/core/detail.mjs

@@ -0,0 +1,78 @@
+/*! Avue.js v3.8.6 | (c) 2017-2026 Smallwei | Released under the MIT License. */
+import { validatenull } from '../utils/validate.mjs';
+import { getAsVal, detailDataType, getPasswordChar, getDicValue } from '../utils/util.mjs';
+import { MULTIPLE_LIST, ARRAY_VALUE_LIST, DIC_SPLIT, DATE_LIST, DIC_SHOW_SPLIT } from '../global/variable.mjs';
+import dayjs from '../../_virtual/dayjs.min.mjs';
+
+const detail = (row = {}, column = {}, option = {}, dic = []) => {
+    let result = row[column.prop];
+    const type = column.type;
+    const separator = column.separator;
+    if (column.bind)
+        result = getAsVal(row, column.bind);
+    if (!validatenull(result)) {
+        const selectFlag = MULTIPLE_LIST.includes(column.type) && column.multiple;
+        const arrayFlag = ARRAY_VALUE_LIST.includes(column.type) && column.emitPath !== false;
+        if ((selectFlag || arrayFlag) && !Array.isArray(result) && !column.dataType)
+            column.dataType = 'string';
+        if (column.dataType) {
+            if (selectFlag || arrayFlag) {
+                if (!Array.isArray(result)) {
+                    if (column.dataType == 'json') {
+                        result = JSON.parse(result);
+                    }
+                    else {
+                        result = result.split(separator || DIC_SPLIT);
+                    }
+                }
+                result.forEach((ele, index) => {
+                    result[index] = detailDataType(ele, column.dataType);
+                });
+            }
+            else {
+                result = detailDataType(result, column.dataType);
+            }
+        }
+        if (type === 'password') {
+            result = getPasswordChar(result, '*');
+        }
+        else if (DATE_LIST.includes(type) && column.format) {
+            const format = column.format;
+            const formatValue = dayjs().format('YYYY-MM-DD');
+            if (['dates', 'years', 'months'].includes(type)) {
+                if (typeof result === 'string') {
+                    result = result.split(',');
+                }
+                if (Array.isArray(result)) {
+                    result = result.map((date) => dayjs(date).format(format)).join(column.separator || ',');
+                }
+            }
+            else if (type.indexOf('range') !== -1) {
+                let [date1 = '', date2 = ''] = result;
+                if (type === 'timerange') {
+                    date1 = `${formatValue} ${date1}`;
+                    date2 = `${formatValue} ${date2}`;
+                }
+                result = [dayjs(date1).format(format), dayjs(date2).format(format)].join(column.separator || '~');
+            }
+            else {
+                if (type === 'time') {
+                    result = `${formatValue} ${result}`;
+                }
+                result = dayjs(result).format(format);
+            }
+        }
+    }
+    if (!validatenull(dic)) {
+        result = getDicValue(dic, result, column.props || option.props);
+    }
+    if (typeof column.formatter === 'function') {
+        result = column.formatter(row, row[column.prop], result, column);
+    }
+    else if (Array.isArray(result) && !validatenull(dic)) {
+        result = result.join(separator || DIC_SHOW_SPLIT);
+    }
+    return result;
+};
+
+export { detail };

package/es/src/core/dic.mjs

@@ -0,0 +1,216 @@
+/*! Avue.js v3.8.6 | (c) 2017-2026 Smallwei | Released under the MIT License. */
+import { getAsVal, detailDataType } from '../utils/util.mjs';
+import { validatenull } from '../utils/validate.mjs';
+import { DIC_PROPS } from '../global/variable.mjs';
+
+const key = 'key';
+function getDataType(list = [], props = {}, type) {
+    const valueKey = props.value || DIC_PROPS.value;
+    const childrenKey = props.children || DIC_PROPS.children;
+    list.forEach((ele) => {
+        ele[valueKey] = detailDataType(ele[valueKey], type);
+        if (ele[childrenKey])
+            getDataType(ele[childrenKey], props, type);
+    });
+    return list;
+}
+function getResData(data, props, dataType) {
+    const bind = props.res;
+    let res = data;
+    const deep = data.data;
+    if (bind) {
+        res = getAsVal(res, bind);
+    }
+    else if (deep) {
+        res = Array.isArray(deep) ? deep : [deep];
+    }
+    if (dataType)
+        res = getDataType(res, props, dataType);
+    return res;
+}
+const loadCascaderDic = (columnOption, safe) => {
+    return new Promise((resolve) => {
+        const list = [];
+        const result = {};
+        const columnList = columnOption.filter((ele) => ele.parentProp);
+        safe.data.forEach((ele, index) => {
+            if (!safe.cascaderDIC[index])
+                safe.cascaderDIC[index] = {};
+            columnList.forEach((column) => {
+                if (column.hide !== true && column.dicFlag !== false) {
+                    list.push(new Promise((resolve) => {
+                        if (ele[column.parentProp]) {
+                            sendDic({
+                                url: column.dicUrl,
+                                props: column.props,
+                                method: column.dicMethod,
+                                headers: column.dicHeaders,
+                                formatter: column.dicFormatter,
+                                query: column.dicQuery,
+                                dataType: column.dataType,
+                                form: ele,
+                                value: ele[column.parentProp],
+                            }, safe).then((res) => {
+                                const obj = {
+                                    prop: column.prop,
+                                    data: res,
+                                    index,
+                                };
+                                safe.cascaderDIC[index][obj.prop] = obj.data;
+                                resolve(obj);
+                            });
+                        }
+                        else {
+                            const obj = {
+                                prop: column.prop,
+                                data: [],
+                                index,
+                            };
+                            safe.cascaderDIC[index][obj.prop] = obj.data;
+                            resolve(obj);
+                        }
+                    }));
+                }
+            });
+        });
+        Promise.all(list).then((data) => {
+            data.forEach((ele) => {
+                if (!result[ele.index])
+                    result[ele.index] = {};
+                result[ele.index][ele.prop] = ele.data;
+            });
+            resolve(result);
+        });
+    });
+};
+const loadDic = (option, safe) => {
+    return new Promise((resolve) => {
+        const list = [];
+        const result = {};
+        let notList = [];
+        const nameList = [];
+        const column = option.column || [];
+        column.forEach((ele) => {
+            const url = ele.dicUrl;
+            const prop = ele.prop;
+            const parentProp = ele.parentProp;
+            notList = notList.concat(ele.cascader || []);
+            const flag = ele.dicFlag === false || ele.lazy === true || notList.includes(prop);
+            if (url && !parentProp && !flag) {
+                list.push(new Promise((resolve) => {
+                    sendDic({
+                        url,
+                        method: ele.dicMethod,
+                        headers: ele.dicHeaders,
+                        formatter: ele.dicFormatter,
+                        props: ele.props,
+                        dataType: ele.dataType,
+                        query: ele.dicQuery,
+                    }, safe).then((res) => {
+                        safe.DIC[prop] = res;
+                        resolve(res);
+                    });
+                }));
+                nameList.push(prop);
+            }
+        });
+        Promise.all(list).then((res) => {
+            nameList.forEach((ele, index) => {
+                result[ele] = res[index];
+            });
+            resolve(result);
+        });
+    });
+};
+const loadLocalDic = (option, safe) => {
+    const columnData = {};
+    const optionData = option.dicData || {};
+    option.column.forEach((ele) => {
+        const dic = ele.dicData;
+        const prop = ele.prop;
+        if (dic instanceof Function) {
+            const dicResult = dic(ele);
+            if (dicResult instanceof Promise) {
+                dicResult.then((res) => {
+                    safe.DIC[prop] = getDataType(res, ele.props, ele.dataType);
+                });
+            }
+            else {
+                columnData[prop] = getDataType(dicResult, ele.props, ele.dataType);
+            }
+        }
+        else if (dic instanceof Array) {
+            columnData[prop] = getDataType(dic, ele.props, ele.dataType);
+        }
+    });
+    const result = { ...optionData, ...columnData };
+    Object.keys(result).forEach((ele) => {
+        safe.DIC[ele] = result[ele];
+    });
+    return result;
+};
+const sendDic = (params, safe) => {
+    let { url, query, method, props, formatter, headers, value, column = {}, form = {}, dataType, } = params;
+    url = column.dicUrl || url;
+    method = (column.dicMethod || method || 'get').toLowerCase();
+    headers = column.dicHeaders || headers || {};
+    query = column.dicQuery || query || {};
+    formatter = column.dicFormatter || formatter;
+    props = column.props || props || {};
+    const list = url.match(/[^\{\}]+(?=\})/g) || [];
+    list.forEach((ele) => {
+        let result = ele === key ? value : form[ele];
+        if (validatenull(result))
+            result = '';
+        url = url.replace(`{{${ele}}}`, result);
+    });
+    const getKey = (data) => {
+        const result = {};
+        Object.keys(data).forEach((ele) => {
+            const eleKey = data[ele];
+            if (typeof eleKey === 'string' && eleKey.match(/\{{|}}/g)) {
+                const prop = eleKey.replace(/\{{|}}/g, '');
+                result[ele] = prop == key ? value : form[prop];
+            }
+            else {
+                result[ele] = eleKey;
+            }
+        });
+        return result;
+    };
+    return new Promise((resolve, reject) => {
+        if (!url)
+            resolve([]);
+        const callback = (res) => {
+            let currentList = [];
+            res = res.data || {};
+            if (typeof formatter === 'function') {
+                currentList = formatter(res, form);
+            }
+            else {
+                currentList = getResData(res, props, dataType);
+            }
+            resolve(currentList);
+        };
+        const getData = () => {
+            const data = getKey(query);
+            if (method == 'get')
+                return { params: data };
+            return { data };
+        };
+        safe
+            .$axios(Object.assign({
+            url,
+            method,
+            headers: getKey(headers),
+        }, getData()))
+            .then(function (res) {
+            callback(res);
+        })
+            .catch((err) => {
+            reject(err);
+        });
+    });
+};
+
+export { loadCascaderDic, loadDic, loadLocalDic, sendDic };

package/es/src/core/locale.mjs

@@ -0,0 +1,12 @@
+/*! Avue.js v3.8.6 | (c) 2017-2026 Smallwei | Released under the MIT License. */
+import { t } from '../locale/index.mjs';
+
+var locale = {
+    methods: {
+        t(...args) {
+            return t.apply(this, args);
+        },
+    },
+};
+
+export { locale as default };

package/es/src/core/packages.mjs

@@ -0,0 +1,65 @@
+/*! Avue.js v3.8.6 | (c) 2017-2026 Smallwei | Released under the MIT License. */
+import log from '../plugin/logs/index.mjs';
+
+const list = {
+    AliOSS: {
+        url: 'https://cdn.staticfile.org/ali-oss/6.17.1/aliyun-oss-sdk.min.js',
+        title: '阿里云图片上传，需要引入 OSS 的 SDK',
+        github: 'https://github.com/ali-sdk/ali-oss/',
+    },
+    Map: {
+        url: 'https://webapi.amap.com/maps?v=1.4.11&key=xxxxx&plugin=AMap.PlaceSearch,https://webapi.amap.com/ui/1.0/main.js?v=1.0.11',
+        title: '地图组件，需要引入高德 SDK',
+    },
+    MapUi: {
+        url: 'https://webapi.amap.com/ui/1.0/main.js?v=1.0.11',
+        title: '地图组件，需要引入高德 UI SDK',
+    },
+    Sortable: {
+        url: 'https://cdn.staticfile.org/Sortable/1.10.0-rc2/Sortable.min.js',
+        title: '拖拽功能，需要引入 SortableJS',
+        github: 'https://github.com/SortableJS/Sortable',
+    },
+    Screenshot: {
+        url: 'https://cdn.staticfile.org/html2canvas/0.5.0-beta4/html2canvas.min.js',
+        title: '需要引入 html2canvas 依赖包',
+        github: 'https://github.com/niklasvh/html2canvas/',
+    },
+    COS: {
+        url: 'https://avuejs.com/cdn/cos-js-sdk-v5.min.js',
+        title: '腾讯云图片上传，需要引入 COS',
+    },
+    CryptoJS: {
+        url: 'https://avuejs.com/cdn/CryptoJS.js',
+        title: '七牛云图片上传，需要引入 CryptoJS',
+    },
+    'file-saver': {
+        url: 'https://cdn.staticfile.org/FileSaver.js/2014-11-29/FileSaver.min.js',
+        title: '需要引入文件操作包',
+        github: 'https://github.com/eligrey/FileSaver.js',
+    },
+    xlsx: {
+        url: 'https://cdn.staticfile.org/xlsx/0.18.2/xlsx.full.min.js',
+        title: '需要引入 Excel 操作包',
+        github: 'https://github.com/protobi/js-xlsx',
+    },
+    mock: {
+        url: 'https://cdn.staticfile.org/Mock.js/1.0.1-beta3/mock-min.js',
+        title: '需要引入 Mock 模拟数据包',
+        github: 'https://github.com/Colingo/mock',
+    },
+};
+var packages = (() => {
+    return {
+        logs(name) {
+            const obj = list[name];
+            if (!obj)
+                return;
+            log.capsule(name, obj.title, 'warning');
+            log.warning('CDN:' + (obj.url || '-'));
+            log.warning('GITHUB:' + (obj.github || '-'));
+        },
+    };
+})();
+
+export { packages as default };

package/es/src/core/slot.mjs

@@ -0,0 +1,35 @@
+/*! Avue.js v3.8.6 | (c) 2017-2026 Smallwei | Released under the MIT License. */
+var slot = {
+    methods: {
+        getSlotName(item = {}, type = 'D', slot) {
+            const result = {
+                F: '-form',
+                H: '-header',
+                E: '-error',
+                L: '-label',
+                S: '-search',
+                T: '-type',
+                D: '',
+            };
+            const name = item.prop + result[type];
+            if (slot)
+                return slot[name];
+            return name;
+        },
+        getSlotList(list = [], slot, propList) {
+            const propNames = propList.map((ele) => ele.prop);
+            return Object.keys(slot).filter((ele) => {
+                let result = false;
+                if (!propNames.includes(ele)) {
+                    list.forEach((name) => {
+                        if (ele.includes(name))
+                            result = true;
+                    });
+                }
+                return result;
+            });
+        },
+    },
+};
+
+export { slot as default };

package/es/src/global/variable.mjs

@@ -0,0 +1,83 @@
+/*! Avue.js v3.8.6 | (c) 2017-2026 Smallwei | Released under the MIT License. */
+const KEY_COMPONENT_NAME = 'avue-';
+const KEY_ECHART_NAME = 'echart-';
+const DIC_PROPS = {
+    rowKey: 'id',
+    rowParentKey: 'parentId',
+    nodeKey: 'id',
+    label: 'label',
+    value: 'value',
+    type: 'type',
+    desc: 'desc',
+    groups: 'groups',
+    title: 'title',
+    leaf: 'leaf',
+    children: 'children',
+    hasChildren: 'hasChildren',
+    labelText: '名称',
+    disabled: 'disabled',
+};
+const DIC_HTTP_PROPS = {
+    name: 'name',
+    url: 'url',
+    fileType: 'type',
+    fileName: 'file',
+    res: '',
+};
+const DATE_LIST = [
+    'dates',
+    'date',
+    'datetime',
+    'datetimerange',
+    'daterange',
+    'time',
+    'timerange',
+    'week',
+    'month',
+    'months',
+    'monthrange',
+    'year',
+    'years',
+    'yearrange',
+];
+const CHILDREN_LIST = ['table', 'dynamic'];
+const INPUT_LIST = ['tree', 'number', 'icon', 'color', 'table', 'map', 'tag'];
+const ARRAY_LIST = ['img', 'array', 'url'];
+const MULTIPLE_LIST = ['cascader', 'tree', 'select', 'table'];
+const RANGE_LIST = ['slider'];
+const ARRAY_VALUE_LIST = ARRAY_LIST.concat([
+    'tag',
+    'upload',
+    'dynamic',
+    'map',
+    'checkbox',
+    'cascader',
+    'timerange',
+    'monthrange',
+    'daterange',
+    'yearrange',
+    'datetimerange',
+    'dates',
+    'months',
+    'years',
+]);
+const SELECT_LIST = DATE_LIST.concat([
+    'select',
+    'checkbox',
+    'radio',
+    'cascader',
+    'tree',
+    'color',
+    'icon',
+    'table',
+    'map',
+]);
+const DIC_SHOW_SPLIT = ' | ';
+const DIC_SPLIT = ',';
+const typeList = {
+    img: /(\.|^)(gif|jpg|jpeg|png|webp|svg|GIF|JPG|JPEG|PNG|WEBP|SVG)/,
+    video: /(\.|^)(swf|avi|flv|mpg|rm|mov|wav|asf|3gp|mkv|rmvb|ogg|mp4)/,
+    audio: /(\.|^)(mp3|wav|MP3|WAV)/,
+};
+
+export { ARRAY_LIST, ARRAY_VALUE_LIST, CHILDREN_LIST, DATE_LIST, DIC_HTTP_PROPS, DIC_PROPS, DIC_SHOW_SPLIT, DIC_SPLIT, INPUT_LIST, KEY_COMPONENT_NAME, KEY_ECHART_NAME, MULTIPLE_LIST, RANGE_LIST, SELECT_LIST, typeList };

package/es/src/icon.mjs

@@ -0,0 +1,13 @@
+/*! Avue.js v3.8.6 | (c) 2017-2026 Smallwei | Released under the MIT License. */
+import * as Icons from '@element-plus/icons-vue';
+
+var createIcon = (app) => {
+    for (const key in Icons) {
+        app.component(transElIconName(key), Icons[key]);
+    }
+};
+function transElIconName(iconName) {
+    return 'el-icon' + iconName.replace(/[A-Z]/g, (match) => '-' + match.toLowerCase());
+}
+
+export { createIcon as default };