@smallwei/avue 3.8.4 → 3.8.6

package/es/core/dataformat.ts

@@ -1,190 +0,0 @@
-import { validatenull } from '../utils/validate';
-import {
-  KEY_COMPONENT_NAME,
-  DIC_SPLIT,
-  ARRAY_LIST,
-  DATE_LIST,
-  INPUT_LIST,
-  ARRAY_VALUE_LIST,
-  MULTIPLE_LIST,
-  SELECT_LIST,
-  RANGE_LIST,
-} from '../global/variable';
-import { detailDataType, findObject, createObj } from '../utils/util';
-import { t } from '../locale/index';
-
-let count = 0;
-
-export const calcCascader = (list: Record<string, any>[] = []) => {
-  list.forEach((ele) => {
-    const cascader = ele.cascader;
-    if (!validatenull(cascader)) {
-      const parentProp = ele.prop;
-      cascader.forEach((citem: string) => {
-        const column = findObject(list, citem);
-        if (column) column.parentProp = parentProp;
-      });
-    }
-  });
-  return list;
-};
-
-export const calcCount = (
-  ele: Record<string, any>,
-  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;
-};
-
-export const initVal = (value: any, safe: Record<string, any>) => {
-  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: any, index: number) => {
-      list[index] = detailDataType(ele, dataType);
-    });
-    if (ARRAY_LIST.includes(type) && validatenull(list) && alone) list = [''];
-  } else {
-    list = detailDataType(list, dataType);
-  }
-  return list;
-};
-
-export const getSearchType = (column: Record<string, any>) => {
-  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;
-};
-
-export const getComponent = (type?: string, component?: string) => {
-  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;
-};
-
-export const formInitVal = (list: Record<string, any>[] = []) => {
-  let tableForm: Record<string, any> = {};
-  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;
-};
-
-export const getPlaceholder = function (column: Record<string, any>, type?: string) {
-  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;
-};

package/es/core/detail.mjs

@@ -1,74 +0,0 @@
-import { validatenull } from '../utils/validate.mjs';
-import { getPasswordChar, getDicValue, getAsVal, detailDataType } from '../utils/util.mjs';
-import { DIC_SPLIT, DIC_SHOW_SPLIT, DATE_LIST, MULTIPLE_LIST, ARRAY_VALUE_LIST, } from '../global/variable.mjs';
-import dayjs from 'dayjs';
-export 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;
-};

package/es/core/detail.ts

@@ -1,81 +0,0 @@
-import { validatenull } from '../utils/validate';
-import { getPasswordChar, getDicValue, getAsVal, detailDataType } from '../utils/util';
-import {
-  DIC_SPLIT,
-  DIC_SHOW_SPLIT,
-  DATE_LIST,
-  MULTIPLE_LIST,
-  ARRAY_VALUE_LIST,
-} from '../global/variable';
-import dayjs from 'dayjs';
-
-export const detail = (
-  row: Record<string, any> = {},
-  column: Record<string, any> = {},
-  option: Record<string, any> = {},
-  dic: any[] = []
-) => {
-  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: any, index: number) => {
-          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;
-};

package/es/core/dic.mjs

@@ -1,213 +0,0 @@
-import { detailDataType, getAsVal } 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;
-}
-export 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);
-        });
-    });
-};
-export 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,
-                        name: prop,
-                        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);
-        });
-    });
-};
-export 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;
-};
-export 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);
-        });
-    });
-};