@smallwei/avue 3.9.1 → 3.9.3

package/es/src/core/dic.mjs

@@ -1,216 +1,188 @@
-/*! Avue.js v3.9.1 | (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 };
+/*! Avue.js v3.9.3 | (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 = async (columnOption = [], safe) => {
+    const columnList = columnOption.filter((ele) => ele.parentProp);
+    const tasks = [];
+    (safe.data || []).forEach((form, index) => {
+        columnList.forEach((column) => {
+            if (column.hide === true || column.dicFlag === false)
+                return;
+            const value = form[column.parentProp];
+            if (validatenull(value)) {
+                tasks.push(Promise.resolve({ prop: column.prop, data: [], index }));
+                return;
+            }
+            tasks.push(sendDic({
+                url: column.dicUrl,
+                props: column.props,
+                method: column.dicMethod,
+                headers: column.dicHeaders,
+                formatter: column.dicFormatter,
+                query: column.dicQuery,
+                dataType: column.dataType,
+                form,
+                value,
+            }, safe).then((data) => ({ prop: column.prop, data, index })));
+        });
+    });
+    const result = {};
+    const data = await Promise.all(tasks);
+    data.forEach((item) => {
+        if (!result[item.index])
+            result[item.index] = {};
+        result[item.index][item.prop] = item.data;
+    });
+    return result;
+};
+const loadDic = async (option, safe) => {
+    let notList = [];
+    const tasks = [];
+    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)
+            return;
+        tasks.push(sendDic({
+            url,
+            method: ele.dicMethod,
+            headers: ele.dicHeaders,
+            formatter: ele.dicFormatter,
+            props: ele.props,
+            dataType: ele.dataType,
+            query: ele.dicQuery,
+        }, safe).then((data) => ({ prop, data })));
+    });
+    const result = {};
+    const data = await Promise.all(tasks);
+    data.forEach((item) => {
+        result[item.prop] = item.data;
+    });
+    return result;
+};
+const loadLocalDic = (option) => {
+    const columnData = {};
+    const optionData = option.dicData || {};
+    const tasks = [];
+    (option.column || []).forEach((ele) => {
+        const dic = ele.dicData;
+        const prop = ele.prop;
+        if (dic instanceof Function) {
+            try {
+                const dicResult = dic(ele);
+                if (dicResult && typeof dicResult.then === 'function') {
+                    tasks.push(Promise.resolve(dicResult).then((res) => ({
+                        prop,
+                        data: getDataType(res, ele.props, ele.dataType),
+                    })));
+                }
+                else {
+                    columnData[prop] = getDataType(dicResult, ele.props, ele.dataType);
+                }
+            }
+            catch (error) {
+                tasks.push(Promise.reject(error));
+            }
+        }
+        else if (dic instanceof Array) {
+            columnData[prop] = getDataType(dic, ele.props, ele.dataType);
+        }
+    });
+    return {
+        data: { ...optionData, ...columnData },
+        pending: Promise.all(tasks).then((items) => {
+            return items.reduce((result, item) => {
+                result[item.prop] = item.data;
+                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 || {};
+    if (!url)
+        return Promise.resolve([]);
+    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;
+    };
+    const getData = () => {
+        const data = getKey(query);
+        if (method == 'get')
+            return { params: data };
+        return { data };
+    };
+    return Promise.resolve()
+        .then(() => safe.$axios(Object.assign({
+        url,
+        method,
+        headers: getKey(headers),
+    }, getData())))
+        .then((res) => {
+        let currentList = [];
+        res = res.data || {};
+        if (typeof formatter === 'function') {
+            currentList = formatter(res, form);
+        }
+        else {
+            currentList = getResData(res, props, dataType);
+        }
+        return currentList;
+    });
+};
+
+export { loadCascaderDic, loadDic, loadLocalDic, sendDic };

package/es/src/core/locale.mjs

@@ -1,12 +1,12 @@
-/*! Avue.js v3.9.1 | (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 };
+/*! Avue.js v3.9.3 | (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/option.mjs

@@ -0,0 +1,211 @@
+/*! Avue.js v3.9.3 | (c) 2017-2026 Smallwei | Released under the MIT License. */
+import { DATE_LIST, SELECT_LIST } from '../global/variable.mjs';
+
+const warned = new Set();
+const KNOWN_TYPES = new Set([
+    '',
+    'input',
+    'textarea',
+    'password',
+    'phone',
+    'currency',
+    'bankCard',
+    'idCard',
+    'email',
+    'code',
+    'plate',
+    'ip',
+    'mac',
+    'uscc',
+    'number',
+    'switch',
+    'upload',
+    'img',
+    'array',
+    'url',
+    'dynamic',
+    'slider',
+    'rate',
+    'input-tag',
+    'tag',
+    'mention',
+    'input-table',
+    'input-tree',
+    'input-icon',
+    'input-map',
+    'input-color',
+    'input-number',
+    'input-cron',
+    'input-otp',
+    'cron',
+    'otp',
+    'title',
+    ...DATE_LIST,
+    ...SELECT_LIST,
+]);
+const isObject = (value) => {
+    return value && Object.prototype.toString.call(value) === '[object Object]';
+};
+const normalizeColumn = (column, path, warnings) => {
+    if (Array.isArray(column)) {
+        return column.map((item, index) => ({
+            item,
+            path: `${path}[${index}]`,
+        }));
+    }
+    if (isObject(column)) {
+        return Object.keys(column).map((prop) => ({
+            item: {
+                ...column[prop],
+                prop: column[prop].prop || prop,
+            },
+            path: `${path}.${prop}`,
+        }));
+    }
+    warnings.push({
+        path,
+        message: 'column 应为数组或对象格式',
+    });
+    return [];
+};
+const validSpan = (value) => {
+    return value === undefined || (Number(value) >= 1 && Number(value) <= 24);
+};
+const visitColumns = (column, path, warnings, propMap) => {
+    normalizeColumn(column, path, warnings).forEach(({ item, path: itemPath }) => {
+        if (!isObject(item)) {
+            warnings.push({
+                path: itemPath,
+                message: '字段配置应为对象',
+            });
+            return;
+        }
+        if (!item.prop) {
+            warnings.push({
+                path: itemPath,
+                message: '缺少 prop，字段无法稳定绑定表单值或表格列',
+            });
+        }
+        else if (propMap[item.prop]) {
+            warnings.push({
+                path: itemPath,
+                message: `prop "${item.prop}" 重复，已在 ${propMap[item.prop]} 出现`,
+            });
+        }
+        else {
+            propMap[item.prop] = itemPath;
+        }
+        if (!item.label && item.type !== 'title') {
+            warnings.push({
+                path: itemPath,
+                message: '建议补充 label，避免表头或表单标签为空',
+            });
+        }
+        if (!validSpan(item.span)) {
+            warnings.push({
+                path: `${itemPath}.span`,
+                message: 'span 应在 1 到 24 之间',
+            });
+        }
+        if (!validSpan(item.searchSpan)) {
+            warnings.push({
+                path: `${itemPath}.searchSpan`,
+                message: 'searchSpan 应在 1 到 24 之间',
+            });
+        }
+        if (item.type && !KNOWN_TYPES.has(item.type)) {
+            warnings.push({
+                path: `${itemPath}.type`,
+                message: `未知字段类型 "${item.type}"，请确认是否已注册自定义组件`,
+            });
+        }
+        if (item.dicData !== undefined && !Array.isArray(item.dicData)) {
+            warnings.push({
+                path: `${itemPath}.dicData`,
+                message: 'dicData 应为数组',
+            });
+        }
+        if (item.rules !== undefined && !Array.isArray(item.rules)) {
+            warnings.push({
+                path: `${itemPath}.rules`,
+                message: 'rules 应为数组',
+            });
+        }
+        if (item.props !== undefined && !isObject(item.props)) {
+            warnings.push({
+                path: `${itemPath}.props`,
+                message: 'props 应为对象',
+            });
+        }
+        if (item.cascader !== undefined && !Array.isArray(item.cascader)) {
+            warnings.push({
+                path: `${itemPath}.cascader`,
+                message: 'cascader 应为 prop 数组',
+            });
+        }
+        if (item.children && item.children.column) {
+            visitColumns(item.children.column, `${itemPath}.children.column`, warnings, propMap);
+        }
+    });
+};
+const validateOption = (option = {}, component = 'component') => {
+    const warnings = [];
+    if (!isObject(option)) {
+        return [
+            {
+                path: component,
+                message: 'option 应为对象',
+            },
+        ];
+    }
+    if (!validSpan(option.span)) {
+        warnings.push({
+            path: `${component}.span`,
+            message: 'span 应在 1 到 24 之间',
+        });
+    }
+    if (!validSpan(option.searchSpan)) {
+        warnings.push({
+            path: `${component}.searchSpan`,
+            message: 'searchSpan 应在 1 到 24 之间',
+        });
+    }
+    const propMap = {};
+    if (option.column) {
+        visitColumns(option.column, `${component}.column`, warnings, propMap);
+    }
+    else if (['crud', 'form', 'search'].includes(component)) {
+        warnings.push({
+            path: `${component}.column`,
+            message: '缺少 column 配置',
+        });
+    }
+    if (Array.isArray(option.group)) {
+        option.group.forEach((group, index) => {
+            if (!isObject(group)) {
+                warnings.push({
+                    path: `${component}.group[${index}]`,
+                    message: '分组配置应为对象',
+                });
+                return;
+            }
+            if (group.column) {
+                visitColumns(group.column, `${component}.group[${index}].column`, warnings, propMap);
+            }
+        });
+    }
+    return warnings;
+};
+const warnOption = (warnings = [], component = 'component') => {
+    warnings.forEach((warning) => {
+        const key = `${component}:${warning.path}:${warning.message}`;
+        if (warned.has(key))
+            return;
+        warned.add(key);
+        if (typeof console !== 'undefined' && console.warn) {
+            console.warn(`[Avue option warn][${component}] ${warning.path}: ${warning.message}`);
+        }
+    });
+};
+
+export { validateOption, warnOption };