@smallwei/avue 3.8.2 → 3.8.3

package/lib/avue.min.ts

@@ -0,0 +1,2 @@
+export * from './index';
+export { default } from './index';

package/lib/avue.ts

@@ -0,0 +1,2 @@
+export * from './index';
+export { default } from './index';

package/lib/core/create.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = create;
+const bem_js_1 = __importDefault(require("../utils/bem.js"));
+const variable_js_1 = require("../global/variable.js");
+function create(sfc) {
+    sfc.name = variable_js_1.KEY_COMPONENT_NAME + sfc.name;
+    sfc.mixins = sfc.mixins || [];
+    sfc.mixins.push(bem_js_1.default);
+    return sfc;
+}

package/lib/core/create.ts

@@ -0,0 +1,16 @@
+import bem from '../utils/bem';
+import { KEY_COMPONENT_NAME } from '../global/variable';
+
+type SfcComponent = {
+  name: string;
+  mixins?: any[];
+  [key: string]: any;
+};
+
+export default function create<S extends SfcComponent>(sfc: S): S {
+  sfc.name = KEY_COMPONENT_NAME + sfc.name;
+  sfc.mixins = sfc.mixins || [];
+  sfc.mixins.push(bem);
+
+  return sfc;
+}

package/lib/core/dataformat.js

@@ -0,0 +1,194 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPlaceholder = exports.formInitVal = exports.getComponent = exports.getSearchType = exports.initVal = exports.calcCount = exports.calcCascader = void 0;
+const validate_js_1 = require("../utils/validate.js");
+const variable_js_1 = require("../global/variable.js");
+const util_js_1 = require("../utils/util.js");
+const index_js_1 = require("../locale/index.js");
+let count = 0;
+const calcCascader = (list = []) => {
+    list.forEach((ele) => {
+        const cascader = ele.cascader;
+        if (!(0, validate_js_1.validatenull)(cascader)) {
+            const parentProp = ele.prop;
+            cascader.forEach((citem) => {
+                const column = (0, util_js_1.findObject)(list, citem);
+                if (column)
+                    column.parentProp = parentProp;
+            });
+        }
+    });
+    return list;
+};
+exports.calcCascader = calcCascader;
+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;
+};
+exports.calcCount = calcCount;
+const initVal = (value, safe) => {
+    let { type, multiple, dataType, separator = variable_js_1.DIC_SPLIT, alone, emitPath, range } = safe;
+    let list = value;
+    if ((variable_js_1.MULTIPLE_LIST.includes(type) && multiple == true) ||
+        (variable_js_1.ARRAY_VALUE_LIST.includes(type) && emitPath !== false) ||
+        (variable_js_1.RANGE_LIST.includes(type) && range == true)) {
+        if (!Array.isArray(list)) {
+            if ((0, validate_js_1.validatenull)(list)) {
+                list = [];
+            }
+            else {
+                if (dataType == 'json') {
+                    list = JSON.parse(list);
+                }
+                else {
+                    list = (list + '').split(separator) || [];
+                }
+            }
+        }
+        list.forEach((ele, index) => {
+            list[index] = (0, util_js_1.detailDataType)(ele, dataType);
+        });
+        if (variable_js_1.ARRAY_LIST.includes(type) && (0, validate_js_1.validatenull)(list) && alone)
+            list = [''];
+    }
+    else {
+        list = (0, util_js_1.detailDataType)(list, dataType);
+    }
+    return list;
+};
+exports.initVal = initVal;
+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 (variable_js_1.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;
+};
+exports.getSearchType = getSearchType;
+const getComponent = (type, component) => {
+    let result = type || 'input';
+    if (!(0, validate_js_1.validatenull)(component)) {
+        return component;
+    }
+    else if (variable_js_1.ARRAY_LIST.includes(type || '')) {
+        result = 'array';
+    }
+    else if (['time', 'timerange'].includes(type || '')) {
+        result = 'time';
+    }
+    else if (variable_js_1.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 (variable_js_1.INPUT_LIST.includes(type || '')) {
+        result = 'input-' + type;
+    }
+    return variable_js_1.KEY_COMPONENT_NAME + result;
+};
+exports.getComponent = getComponent;
+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 ((variable_js_1.ARRAY_VALUE_LIST.includes(ele.type) &&
+            ele.emitPath !== false &&
+            ele.dataType != 'json') ||
+            (variable_js_1.MULTIPLE_LIST.includes(ele.type) && ele.multiple) ||
+            ele.dataType === 'array') {
+            tableForm[ele.prop] = [];
+        }
+        else if (variable_js_1.RANGE_LIST.includes(ele.type) && ele.range == true) {
+            tableForm[ele.prop] = [0, 0];
+        }
+        else {
+            tableForm[ele.prop] = '';
+        }
+        if (ele.bind) {
+            tableForm = (0, util_js_1.createObj)(tableForm, ele.bind);
+        }
+        if (!(0, validate_js_1.validatenull)(ele.value)) {
+            tableForm[ele.prop] = ele.value;
+        }
+    });
+    return tableForm;
+};
+exports.formInitVal = formInitVal;
+const getPlaceholder = function (column, type) {
+    const placeholder = column.placeholder;
+    const label = column.label;
+    if (type === 'search') {
+        const searchPlaceholder = column.searchPlaceholder;
+        if (!(0, validate_js_1.validatenull)(searchPlaceholder)) {
+            return searchPlaceholder;
+        }
+        else {
+            return label;
+        }
+    }
+    else if ((0, validate_js_1.validatenull)(placeholder)) {
+        if (variable_js_1.SELECT_LIST.includes(column.type)) {
+            return `${(0, index_js_1.t)('tip.select')} ${label}`;
+        }
+        else {
+            return `${(0, index_js_1.t)('tip.input')} ${label}`;
+        }
+    }
+    return placeholder;
+};
+exports.getPlaceholder = getPlaceholder;

package/lib/core/dataformat.ts

@@ -0,0 +1,190 @@
+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/lib/core/detail.js

@@ -0,0 +1,81 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detail = void 0;
+const validate_js_1 = require("../utils/validate.js");
+const util_js_1 = require("../utils/util.js");
+const variable_js_1 = require("../global/variable.js");
+const dayjs_1 = __importDefault(require("dayjs"));
+const detail = (row = {}, column = {}, option = {}, dic = []) => {
+    let result = row[column.prop];
+    const type = column.type;
+    const separator = column.separator;
+    if (column.bind)
+        result = (0, util_js_1.getAsVal)(row, column.bind);
+    if (!(0, validate_js_1.validatenull)(result)) {
+        const selectFlag = variable_js_1.MULTIPLE_LIST.includes(column.type) && column.multiple;
+        const arrayFlag = variable_js_1.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 || variable_js_1.DIC_SPLIT);
+                    }
+                }
+                result.forEach((ele, index) => {
+                    result[index] = (0, util_js_1.detailDataType)(ele, column.dataType);
+                });
+            }
+            else {
+                result = (0, util_js_1.detailDataType)(result, column.dataType);
+            }
+        }
+        if (type === 'password') {
+            result = (0, util_js_1.getPasswordChar)(result, '*');
+        }
+        else if (variable_js_1.DATE_LIST.includes(type) && column.format) {
+            const format = column.format;
+            const formatValue = (0, dayjs_1.default)().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) => (0, dayjs_1.default)(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 = [(0, dayjs_1.default)(date1).format(format), (0, dayjs_1.default)(date2).format(format)].join(column.separator || '~');
+            }
+            else {
+                if (type === 'time') {
+                    result = `${formatValue} ${result}`;
+                }
+                result = (0, dayjs_1.default)(result).format(format);
+            }
+        }
+    }
+    if (!(0, validate_js_1.validatenull)(dic)) {
+        result = (0, util_js_1.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) && !(0, validate_js_1.validatenull)(dic)) {
+        result = result.join(separator || variable_js_1.DIC_SHOW_SPLIT);
+    }
+    return result;
+};
+exports.detail = detail;

package/lib/core/detail.ts

@@ -0,0 +1,81 @@
+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;
+};