@fecp/designer 5.4.101 → 5.4.104

package/lib/packages/mobile/node_modules/@vxe-ui/core/es/src/permission.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const configStore = require("./configStore.js");
+require("../../node_modules/xe-utils/es/index.esm.js");
+const ctor = require("../../node_modules/xe-utils/es/ctor.js");
+function handleCheckInfo(permissionCode, permissionMethod) {
+  let checkVisible = true;
+  let checkDisabled = false;
+  const checkMethod = permissionMethod || configStore.globalConfigStore.permissionMethod;
+  if (permissionCode && checkMethod) {
+    checkVisible = false;
+    checkDisabled = true;
+    let vDone = false;
+    let dDone = false;
+    const codeList = String(permissionCode).split("|");
+    for (let i = 0; i < codeList.length; i++) {
+      const code = codeList[i];
+      let visible = true;
+      let disabled = false;
+      const rest = checkMethod({ code });
+      if (ctor.default.isBoolean(rest)) {
+        visible = rest;
+      } else if (rest) {
+        visible = !!rest.visible;
+        disabled = !!rest.disabled;
+      }
+      if (!disabled && !dDone) {
+        dDone = true;
+        checkDisabled = disabled;
+      }
+      if (visible && !vDone) {
+        vDone = true;
+        checkVisible = visible;
+      }
+      if (vDone && dDone) {
+        break;
+      }
+    }
+  }
+  const info = {
+    code: permissionCode,
+    visible: checkVisible,
+    disabled: checkDisabled
+  };
+  return info;
+}
+const permission = {
+  getCheckInfo(code) {
+    return handleCheckInfo(code);
+  },
+  checkVisible(code) {
+    const permissionInfo = handleCheckInfo(code);
+    return permissionInfo.visible;
+  },
+  checkDisable(code) {
+    const permissionInfo = handleCheckInfo(code);
+    return permissionInfo.disabled;
+  }
+};
+exports.handleCheckInfo = handleCheckInfo;
+exports.permission = permission;

package/lib/packages/mobile/node_modules/@vxe-ui/core/es/src/renderer.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("../../node_modules/xe-utils/es/index.esm.js");
+const log = require("./log.js");
+const ctor = require("../../node_modules/xe-utils/es/ctor.js");
+const renderMap = {};
+const renderer = {
+  mixin(opts) {
+    ctor.default.each(opts, (options, name) => renderer.add(name, options));
+    return renderer;
+  },
+  get(name) {
+    return renderMap[name] || null;
+  },
+  add(name, options) {
+    if (name && options) {
+      const renders = renderMap[name];
+      if (renders) {
+        ctor.default.each(options, (val, key) => {
+          if (!ctor.default.eqNull(renders[key]) && renders[key] !== val) {
+            log.log.warn("vxe.error.coverProp", [`Renderer.${name}`, key]);
+          }
+        });
+        Object.assign(renders, options);
+      } else {
+        renderMap[name] = options;
+      }
+    }
+    return renderer;
+  },
+  forEach(callback) {
+    ctor.default.objectEach(renderMap, callback);
+    return renderer;
+  },
+  delete(name) {
+    delete renderMap[name];
+    return renderer;
+  }
+};
+exports.renderer = renderer;

package/lib/packages/mobile/node_modules/@vxe-ui/core/es/src/resize.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("../../node_modules/xe-utils/es/index.esm.js");
+const configStore = require("./configStore.js");
+const ctor = require("../../node_modules/xe-utils/es/ctor.js");
+let resizeTimeout;
+const eventStore = [];
+const defaultInterval = 500;
+function eventHandle() {
+  if (eventStore.length) {
+    eventStore.forEach((item) => {
+      item.tarList.forEach((observer) => {
+        const { target, width, heighe } = observer;
+        const clientWidth = target.clientWidth;
+        const clientHeight = target.clientHeight;
+        const rWidth = clientWidth && width !== clientWidth;
+        const rHeight = clientHeight && heighe !== clientHeight;
+        if (rWidth || rHeight) {
+          observer.width = clientWidth;
+          observer.heighe = clientHeight;
+          setTimeout(item.callback);
+        }
+      });
+    });
+    eventListener();
+  }
+}
+function eventListener() {
+  clearTimeout(resizeTimeout);
+  resizeTimeout = setTimeout(eventHandle, configStore.globalConfigStore.resizeInterval || defaultInterval);
+}
+class XEResizeObserver {
+  constructor(callback) {
+    Object.defineProperty(this, "tarList", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: []
+    });
+    Object.defineProperty(this, "callback", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    this.callback = callback;
+  }
+  observe(target) {
+    if (target) {
+      const { tarList } = this;
+      if (!tarList.some((observer) => observer.target === target)) {
+        tarList.push({
+          target,
+          width: target.clientWidth,
+          heighe: target.clientHeight
+        });
+      }
+      if (!eventStore.length) {
+        eventListener();
+      }
+      if (!eventStore.some((item) => item === this)) {
+        eventStore.push(this);
+      }
+    }
+  }
+  unobserve(target) {
+    ctor.default.remove(eventStore, (item) => item.tarList.some((observer) => observer.target === target));
+  }
+  disconnect() {
+    ctor.default.remove(eventStore, (item) => item === this);
+  }
+}
+const globalResize = {
+  create(callback) {
+    if (window.ResizeObserver) {
+      return new window.ResizeObserver(callback);
+    }
+    return new XEResizeObserver(callback);
+  }
+};
+exports.globalResize = globalResize;

package/lib/packages/mobile/node_modules/@vxe-ui/core/es/src/store.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const log = require("./log.js");
+require("../../node_modules/xe-utils/es/index.esm.js");
+const ctor = require("../../node_modules/xe-utils/es/ctor.js");
+class Store {
+  constructor() {
+    Object.defineProperty(this, "store", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: {}
+    });
+  }
+  mixin(options) {
+    ctor.default.each(options, (item, key) => {
+      this.add(key, item);
+    });
+    return this;
+  }
+  has(name) {
+    return !!this.get(name);
+  }
+  get(name) {
+    return this.store[name];
+  }
+  add(name, options) {
+    const conf = this.store[name];
+    const confKeys = ctor.default.keys(conf);
+    ctor.default.each(options, (item, key) => {
+      if (confKeys.includes(key)) {
+        log.log.warn("vxe.error.coverProp", [name, key]);
+      }
+    });
+    this.store[name] = conf ? ctor.default.merge(conf, options) : options;
+    return this;
+  }
+  delete(name) {
+    delete this.store[name];
+  }
+  forEach(callback) {
+    ctor.default.objectEach(this.store, callback);
+  }
+}
+exports.Store = Store;
+exports.default = Store;

package/lib/packages/mobile/node_modules/@vxe-ui/core/es/src/theme.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const core = require("./core.js");
+const themeStore = require("./themeStore.js");
+function setTheme(name) {
+  const theme = !name || name === "default" ? "light" : name;
+  themeStore.themeConfigStore.theme = theme;
+  if (typeof document !== "undefined") {
+    const documentElement = document.documentElement;
+    if (documentElement) {
+      documentElement.setAttribute("data-vxe-ui-theme", theme);
+    }
+  }
+  return core.VxeCore;
+}
+function getTheme() {
+  return themeStore.themeConfigStore.theme;
+}
+exports.getTheme = getTheme;
+exports.setTheme = setTheme;

package/lib/packages/mobile/node_modules/@vxe-ui/core/es/src/themeStore.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const themeConfigStore = {
+  theme: ""
+};
+exports.themeConfigStore = themeConfigStore;

package/lib/packages/mobile/node_modules/@vxe-ui/core/es/src/useFns.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const vue = require("vue");
+const permission = require("./permission.js");
+function useSize(props) {
+  const xeSizeInfo = vue.inject("xeSizeInfo", null);
+  const computeSize = vue.computed(() => {
+    return props.size || (xeSizeInfo ? xeSizeInfo.value : null);
+  });
+  vue.provide("xeSizeInfo", computeSize);
+  return { computeSize };
+}
+function usePermission(props) {
+  const computePermissionInfo = vue.computed(() => {
+    return permission.handleCheckInfo(props.permissionCode, props.permissionMethod);
+  });
+  return {
+    computePermissionInfo
+  };
+}
+const useFns = {
+  useSize,
+  usePermission
+};
+exports.useFns = useFns;
+exports.usePermission = usePermission;
+exports.useSize = useSize;

package/lib/packages/mobile/node_modules/@vxe-ui/core/es/src/validators.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const store = require("./store.js");
+const validators = new store.Store();
+Object.assign(validators, { _name: "Validators" });
+exports.validators = validators;

package/lib/packages/mobile/node_modules/@vxe-ui/core/es/src/vm.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("../../node_modules/xe-utils/es/index.esm.js");
+const ctor = require("../../node_modules/xe-utils/es/ctor.js");
+function getSlotVNs(vns) {
+  if (ctor.default.isArray(vns)) {
+    return vns;
+  }
+  return vns ? [vns] : [];
+}
+exports.getSlotVNs = getSlotVNs;

package/lib/packages/mobile/node_modules/@vxe-ui/core/node_modules/xe-utils/es/add.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const helperNumberAdd = require("./helperNumberAdd.js");
+const toNumber = require("./toNumber.js");
+function add(num1, num2) {
+  return helperNumberAdd.default(toNumber.default(num1), toNumber.default(num2));
+}
+exports.default = add;

package/lib/packages/mobile/node_modules/@vxe-ui/core/node_modules/xe-utils/es/after.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const slice = require("./slice.js");
+function after(count, callback, context) {
+  var runCount = 0;
+  var rests = [];
+  return function() {
+    var args = arguments;
+    runCount++;
+    if (runCount <= count) {
+      rests.push(args[0]);
+    }
+    if (runCount >= count) {
+      callback.apply(context, [rests].concat(slice.default(args)));
+    }
+  };
+}
+exports.default = after;

package/lib/packages/mobile/node_modules/@vxe-ui/core/node_modules/xe-utils/es/arrayEach.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+function arrayEach(list, iterate, context) {
+  if (list) {
+    if (list.forEach) {
+      list.forEach(iterate, context);
+    } else {
+      for (var index = 0, len = list.length; index < len; index++) {
+        iterate.call(context, list[index], index, list);
+      }
+    }
+  }
+}
+exports.default = arrayEach;

package/lib/packages/mobile/node_modules/@vxe-ui/core/node_modules/xe-utils/es/arrayIndexOf.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+function arrayIndexOf(list, val) {
+  if (list.indexOf) {
+    return list.indexOf(val);
+  }
+  for (var index = 0, len = list.length; index < len; index++) {
+    if (val === list[index]) {
+      return index;
+    }
+  }
+}
+exports.default = arrayIndexOf;

package/lib/packages/mobile/node_modules/@vxe-ui/core/node_modules/xe-utils/es/arrayLastIndexOf.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+function arrayLastIndexOf(list, val) {
+  if (list.lastIndexOf) {
+    return list.lastIndexOf(val);
+  }
+  for (var len = list.length - 1; len >= 0; len--) {
+    if (val === list[len]) {
+      return len;
+    }
+  }
+  return -1;
+}
+exports.default = arrayLastIndexOf;

package/lib/packages/mobile/node_modules/@vxe-ui/core/node_modules/xe-utils/es/assign.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const arrayEach = require("./arrayEach.js");
+const keys = require("./keys.js");
+const isArray = require("./isArray.js");
+const clone = require("./clone.js");
+var objectAssignFns = Object.assign;
+function handleAssign(destination, args, isClone) {
+  var len = args.length;
+  for (var source, index = 1; index < len; index++) {
+    source = args[index];
+    arrayEach.default(keys.default(args[index]), isClone ? function(key) {
+      destination[key] = clone.default(source[key], isClone);
+    } : function(key) {
+      destination[key] = source[key];
+    });
+  }
+  return destination;
+}
+var assign = function(target) {
+  if (target) {
+    var args = arguments;
+    if (target === true) {
+      if (args.length > 1) {
+        target = isArray.default(target[1]) ? [] : {};
+        return handleAssign(target, args, true);
+      }
+    } else {
+      return objectAssignFns ? objectAssignFns.apply(Object, args) : handleAssign(target, args);
+    }
+  }
+  return target;
+};
+exports.default = assign;

package/lib/packages/mobile/node_modules/@vxe-ui/core/node_modules/xe-utils/es/before.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const slice = require("./slice.js");
+function before(count, callback, context) {
+  var runCount = 0;
+  var rests = [];
+  context = context || this;
+  return function() {
+    var args = arguments;
+    runCount++;
+    if (runCount < count) {
+      rests.push(args[0]);
+      callback.apply(context, [rests].concat(slice.default(args)));
+    }
+  };
+}
+exports.default = before;

package/lib/packages/mobile/node_modules/@vxe-ui/core/node_modules/xe-utils/es/bind.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const slice = require("./slice.js");
+function bind(callback, context) {
+  var args = slice.default(arguments, 2);
+  return function() {
+    return callback.apply(context, slice.default(arguments).concat(args));
+  };
+}
+exports.default = bind;

package/lib/packages/mobile/node_modules/@vxe-ui/core/node_modules/xe-utils/es/browse.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const staticStrUndefined = require("./staticStrUndefined.js");
+const staticDocument = require("./staticDocument.js");
+const staticWindow = require("./staticWindow.js");
+const assign = require("./assign.js");
+const arrayEach = require("./arrayEach.js");
+function isBrowseStorage(storage) {
+  try {
+    var testKey = "__xe_t";
+    storage.setItem(testKey, 1);
+    storage.removeItem(testKey);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+function isBrowseType(type) {
+  return navigator.userAgent.indexOf(type) > -1;
+}
+function browse() {
+  var $body, isChrome, isEdge;
+  var isMobile = false;
+  var isLocalStorage = false;
+  var isSessionStorage = false;
+  var result = {
+    isNode: false,
+    isMobile,
+    isPC: false,
+    isDoc: !!staticDocument.default
+  };
+  if (!staticWindow.default && typeof process !== staticStrUndefined.default) {
+    result.isNode = true;
+  } else {
+    isEdge = isBrowseType("Edge");
+    isChrome = isBrowseType("Chrome");
+    isMobile = /(Android|webOS|iPhone|iPad|iPod|SymbianOS|BlackBerry|Windows Phone)/.test(navigator.userAgent);
+    if (result.isDoc) {
+      $body = staticDocument.default.body || staticDocument.default.documentElement;
+      arrayEach.default(["webkit", "khtml", "moz", "ms", "o"], function(core) {
+        result["-" + core] = !!$body[core + "MatchesSelector"];
+      });
+    }
+    try {
+      isLocalStorage = isBrowseStorage(staticWindow.default.localStorage);
+    } catch (e) {
+    }
+    try {
+      isSessionStorage = isBrowseStorage(staticWindow.default.sessionStorage);
+    } catch (e) {
+    }
+    assign.default(result, {
+      edge: isEdge,
+      firefox: isBrowseType("Firefox"),
+      msie: !isEdge && result["-ms"],
+      safari: !isChrome && !isEdge && isBrowseType("Safari"),
+      isMobile,
+      isPC: !isMobile,
+      isLocalStorage,
+      isSessionStorage
+    });
+  }
+  return result;
+}
+exports.default = browse;

package/lib/packages/mobile/node_modules/@vxe-ui/core/node_modules/xe-utils/es/camelCase.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const toValueString = require("./toValueString.js");
+const helperStringSubstring = require("./helperStringSubstring.js");
+const helperStringUpperCase = require("./helperStringUpperCase.js");
+const helperStringLowerCase = require("./helperStringLowerCase.js");
+var camelCacheMaps = {};
+function camelCase(str) {
+  str = toValueString.default(str);
+  if (camelCacheMaps[str]) {
+    return camelCacheMaps[str];
+  }
+  var strLen = str.length;
+  var rest = str.replace(/([-]+)/g, function(text, flag, index) {
+    return index && index + flag.length < strLen ? "-" : "";
+  });
+  strLen = rest.length;
+  rest = rest.replace(/([A-Z]+)/g, function(text, upper, index) {
+    var upperLen = upper.length;
+    upper = helperStringLowerCase.default(upper);
+    if (index) {
+      if (upperLen > 2 && index + upperLen < strLen) {
+        return helperStringUpperCase.default(helperStringSubstring.default(upper, 0, 1)) + helperStringSubstring.default(upper, 1, upperLen - 1) + helperStringUpperCase.default(helperStringSubstring.default(upper, upperLen - 1, upperLen));
+      }
+      return helperStringUpperCase.default(helperStringSubstring.default(upper, 0, 1)) + helperStringSubstring.default(upper, 1, upperLen);
+    } else {
+      if (upperLen > 1 && index + upperLen < strLen) {
+        return helperStringSubstring.default(upper, 0, upperLen - 1) + helperStringUpperCase.default(helperStringSubstring.default(upper, upperLen - 1, upperLen));
+      }
+    }
+    return upper;
+  }).replace(/(-[a-zA-Z])/g, function(text, upper) {
+    return helperStringUpperCase.default(helperStringSubstring.default(upper, 1, upper.length));
+  });
+  camelCacheMaps[str] = rest;
+  return rest;
+}
+exports.default = camelCase;

package/lib/packages/mobile/node_modules/@vxe-ui/core/node_modules/xe-utils/es/ceil.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const helperCreateMathNumber = require("./helperCreateMathNumber.js");
+var ceil = helperCreateMathNumber.default("ceil");
+exports.default = ceil;

package/lib/packages/mobile/node_modules/@vxe-ui/core/node_modules/xe-utils/es/chunk.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const isArray = require("./isArray.js");
+function chunk(array, size) {
+  var index;
+  var result = [];
+  var arrLen = size >> 0 || 1;
+  if (isArray.default(array)) {
+    if (arrLen >= 0 && array.length > arrLen) {
+      index = 0;
+      while (index < array.length) {
+        result.push(array.slice(index, index + arrLen));
+        index += arrLen;
+      }
+    } else {
+      result = array.length ? [array] : array;
+    }
+  }
+  return result;
+}
+exports.default = chunk;

package/lib/packages/mobile/node_modules/@vxe-ui/core/node_modules/xe-utils/es/clear.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const helperDeleteProperty = require("./helperDeleteProperty.js");
+const isPlainObject = require("./isPlainObject.js");
+const isObject = require("./isObject.js");
+const isArray = require("./isArray.js");
+const isNull = require("./isNull.js");
+const assign = require("./assign.js");
+const objectEach = require("./objectEach.js");
+function clear(obj, defs, assigns) {
+  if (obj) {
+    var len;
+    var isDefs = arguments.length > 1 && (isNull.default(defs) || !isObject.default(defs));
+    var extds = isDefs ? assigns : defs;
+    if (isPlainObject.default(obj)) {
+      objectEach.default(obj, isDefs ? function(val, key) {
+        obj[key] = defs;
+      } : function(val, key) {
+        helperDeleteProperty.default(obj, key);
+      });
+      if (extds) {
+        assign.default(obj, extds);
+      }
+    } else if (isArray.default(obj)) {
+      if (isDefs) {
+        len = obj.length;
+        while (len > 0) {
+          len--;
+          obj[len] = defs;
+        }
+      } else {
+        obj.length = 0;
+      }
+      if (extds) {
+        obj.push.apply(obj, extds);
+      }
+    }
+  }
+  return obj;
+}
+exports.default = clear;