@smallwei/avue 3.8.2 → 3.8.4

package/lib/core/dic.js

@@ -0,0 +1,220 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendDic = exports.loadLocalDic = exports.loadDic = exports.loadCascaderDic = void 0;
+const util_js_1 = require("../utils/util.js");
+const validate_js_1 = require("../utils/validate.js");
+const variable_js_1 = require("../global/variable.js");
+const key = 'key';
+function getDataType(list = [], props = {}, type) {
+    const valueKey = props.value || variable_js_1.DIC_PROPS.value;
+    const childrenKey = props.children || variable_js_1.DIC_PROPS.children;
+    list.forEach((ele) => {
+        ele[valueKey] = (0, util_js_1.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 = (0, util_js_1.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]) {
+                            (0, exports.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);
+        });
+    });
+};
+exports.loadCascaderDic = loadCascaderDic;
+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) => {
+                    (0, exports.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);
+        });
+    });
+};
+exports.loadDic = loadDic;
+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;
+};
+exports.loadLocalDic = loadLocalDic;
+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 ((0, validate_js_1.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);
+        });
+    });
+};
+exports.sendDic = sendDic;

package/lib/core/dic.ts

@@ -0,0 +1,235 @@
+import { detailDataType, getAsVal } from '../utils/util';
+import { validatenull } from '../utils/validate';
+import { DIC_PROPS } from '../global/variable';
+
+const key = 'key';
+
+function getDataType(list: Record<string, any>[] = [], props: Record<string, any> = {}, type: any) {
+  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: any, props: Record<string, any>, dataType: any) {
+  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: Record<string, any>[], safe: any) => {
+  return new Promise<Record<string, any>>((resolve) => {
+    const list: Promise<any>[] = [];
+    const result: Record<string, any> = {};
+    const columnList = columnOption.filter((ele) => ele.parentProp);
+    safe.data.forEach((ele: any, index: number) => {
+      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: any[]) => {
+      data.forEach((ele) => {
+        if (!result[ele.index]) result[ele.index] = {};
+        result[ele.index][ele.prop] = ele.data;
+      });
+      resolve(result);
+    });
+  });
+};
+
+export const loadDic = (option: Record<string, any>, safe: any) => {
+  return new Promise<Record<string, any>>((resolve) => {
+    const list: Promise<any>[] = [];
+    const result: Record<string, any> = {};
+    let notList: string[] = [];
+    const nameList: string[] = [];
+    const column = option.column || [];
+    column.forEach((ele: any) => {
+      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: any[]) => {
+      nameList.forEach((ele, index) => {
+        result[ele] = res[index];
+      });
+      resolve(result);
+    });
+  });
+};
+
+export const loadLocalDic = (option: Record<string, any>, safe: any) => {
+  const columnData: Record<string, any> = {};
+  const optionData = option.dicData || {};
+  option.column.forEach((ele: any) => {
+    const dic = ele.dicData;
+    const prop = ele.prop;
+    if (dic instanceof Function) {
+      const dicResult = dic(ele);
+      if (dicResult instanceof Promise) {
+        dicResult.then((res: any[]) => {
+          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: Record<string, any>, safe: any) => {
+  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: string) => {
+    let result = ele === key ? value : form[ele];
+    if (validatenull(result)) result = '';
+    url = url.replace(`{{${ele}}}`, result);
+  });
+
+  const getKey = (data: Record<string, any>) => {
+    const result: Record<string, any> = {};
+    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<any[]>((resolve, reject) => {
+    if (!url) resolve([]);
+    const callback = (res: any) => {
+      let currentList: any[] = [];
+      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: any) {
+        callback(res);
+      })
+      .catch((err: any) => {
+        reject(err);
+      });
+  });
+};

package/lib/core/locale.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_js_1 = require("../locale/index.js");
+exports.default = {
+    methods: {
+        t(...args) {
+            return index_js_1.t.apply(this, args);
+        },
+    },
+};

package/lib/core/locale.ts

@@ -0,0 +1,9 @@
+import { t } from '../locale/index';
+
+export default {
+  methods: {
+    t(...args: any[]) {
+      return t.apply(this, args);
+    },
+  },
+};

package/lib/core/packages.js

@@ -0,0 +1,66 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_js_1 = __importDefault(require("../plugin/logs/index.js"));
+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',
+    },
+};
+exports.default = (() => {
+    return {
+        logs(name) {
+            const obj = list[name];
+            if (!obj)
+                return;
+            index_js_1.default.capsule(name, obj.title, 'warning');
+            index_js_1.default.warning('CDN:' + (obj.url || '-'));
+            index_js_1.default.warning('GITHUB:' + (obj.github || '-'));
+        },
+    };
+})();

package/lib/core/packages.ts

@@ -0,0 +1,62 @@
+import $Log from '../plugin/logs/index';
+
+const list: Record<string, { url: string; title: string; github?: string }> = {
+  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',
+  },
+};
+
+export default (() => {
+  return {
+    logs(name: string) {
+      const obj = list[name];
+      if (!obj) return;
+      $Log.capsule(name, obj.title, 'warning');
+      $Log.warning('CDN:' + (obj.url || '-'));
+      $Log.warning('GITHUB:' + (obj.github || '-'));
+    },
+  };
+})();

package/lib/core/slot.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    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;
+            });
+        },
+    },
+};

package/lib/core/slot.ts

@@ -0,0 +1,30 @@
+export default {
+  methods: {
+    getSlotName(item: Record<string, any> = {}, type = 'D', slot?: Record<string, any>) {
+      const result: Record<string, string> = {
+        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: string[] = [], slot: Record<string, any>, propList: Array<Record<string, any>>) {
+      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;
+      });
+    },
+  },
+};