@fecp/designer 5.5.113 → 5.5.115

package/lib/node_modules/vant/es/nav-bar/NavBar.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const Vue = require("vue");
+const usePlaceholder = require("../composables/use-placeholder.js");
+const index = require("../icon/index.js");
+const props = require("../utils/props.js");
+const create = require("../utils/create.js");
+const format = require("../utils/format.js");
+const constant = require("../utils/constant.js");
+const [name, bem] = create.createNamespace("nav-bar");
+const navBarProps = {
+  title: String,
+  fixed: Boolean,
+  zIndex: props.numericProp,
+  border: props.truthProp,
+  leftText: String,
+  rightText: String,
+  leftDisabled: Boolean,
+  rightDisabled: Boolean,
+  leftArrow: Boolean,
+  placeholder: Boolean,
+  safeAreaInsetTop: Boolean,
+  clickable: props.truthProp
+};
+var stdin_default = Vue.defineComponent({
+  name,
+  props: navBarProps,
+  emits: ["clickLeft", "clickRight"],
+  setup(props2, {
+    emit,
+    slots
+  }) {
+    const navBarRef = Vue.ref();
+    const renderPlaceholder = usePlaceholder.usePlaceholder(navBarRef, bem);
+    const onClickLeft = (event) => {
+      if (!props2.leftDisabled) {
+        emit("clickLeft", event);
+      }
+    };
+    const onClickRight = (event) => {
+      if (!props2.rightDisabled) {
+        emit("clickRight", event);
+      }
+    };
+    const renderLeft = () => {
+      if (slots.left) {
+        return slots.left();
+      }
+      return [props2.leftArrow && Vue.createVNode(index.Icon, {
+        "class": bem("arrow"),
+        "name": "arrow-left"
+      }, null), props2.leftText && Vue.createVNode("span", {
+        "class": bem("text")
+      }, [props2.leftText])];
+    };
+    const renderRight = () => {
+      if (slots.right) {
+        return slots.right();
+      }
+      return Vue.createVNode("span", {
+        "class": bem("text")
+      }, [props2.rightText]);
+    };
+    const renderNavBar = () => {
+      const {
+        title,
+        fixed,
+        border,
+        zIndex
+      } = props2;
+      const style = format.getZIndexStyle(zIndex);
+      const hasLeft = props2.leftArrow || props2.leftText || slots.left;
+      const hasRight = props2.rightText || slots.right;
+      return Vue.createVNode("div", {
+        "ref": navBarRef,
+        "style": style,
+        "class": [bem({
+          fixed
+        }), {
+          [constant.BORDER_BOTTOM]: border,
+          "van-safe-area-top": props2.safeAreaInsetTop
+        }]
+      }, [Vue.createVNode("div", {
+        "class": bem("content")
+      }, [hasLeft && Vue.createVNode("div", {
+        "class": [bem("left", {
+          disabled: props2.leftDisabled
+        }), props2.clickable && !props2.leftDisabled ? constant.HAPTICS_FEEDBACK : ""],
+        "onClick": onClickLeft
+      }, [renderLeft()]), Vue.createVNode("div", {
+        "class": [bem("title"), "van-ellipsis"]
+      }, [slots.title ? slots.title() : title]), hasRight && Vue.createVNode("div", {
+        "class": [bem("right", {
+          disabled: props2.rightDisabled
+        }), props2.clickable && !props2.rightDisabled ? constant.HAPTICS_FEEDBACK : ""],
+        "onClick": onClickRight
+      }, [renderRight()])])]);
+    };
+    return () => {
+      if (props2.fixed && props2.placeholder) {
+        return renderPlaceholder(renderNavBar);
+      }
+      return renderNavBar();
+    };
+  }
+});
+exports.default = stdin_default;
+exports.navBarProps = navBarProps;

package/lib/node_modules/vant/es/nav-bar/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const NavBar$1 = require("./NavBar.js");
+const withInstall = require("../utils/with-install.js");
+const NavBar = withInstall.withInstall(NavBar$1.default);
+exports.navBarProps = NavBar$1.navBarProps;
+exports.NavBar = NavBar;

package/lib/node_modules/vant/es/notice-bar/NoticeBar.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const Vue = require("vue");
+const index_esm = require("../../../@vant/use/dist/index.esm.js");
+const useExpose = require("../composables/use-expose.js");
+const onPopupReopen = require("../composables/on-popup-reopen.js");
+const index = require("../icon/index.js");
+const props = require("../utils/props.js");
+const create = require("../utils/create.js");
+const basic = require("../utils/basic.js");
+const [name, bem] = create.createNamespace("notice-bar");
+const noticeBarProps = {
+  text: String,
+  mode: String,
+  color: String,
+  delay: props.makeNumericProp(1),
+  speed: props.makeNumericProp(60),
+  leftIcon: String,
+  wrapable: Boolean,
+  background: String,
+  scrollable: {
+    type: Boolean,
+    default: null
+  }
+};
+var stdin_default = Vue.defineComponent({
+  name,
+  props: noticeBarProps,
+  emits: ["close", "replay"],
+  setup(props2, {
+    emit,
+    slots
+  }) {
+    let wrapWidth = 0;
+    let contentWidth = 0;
+    let startTimer;
+    const wrapRef = Vue.ref();
+    const contentRef = Vue.ref();
+    const state = Vue.reactive({
+      show: true,
+      offset: 0,
+      duration: 0
+    });
+    const renderLeftIcon = () => {
+      if (slots["left-icon"]) {
+        return slots["left-icon"]();
+      }
+      if (props2.leftIcon) {
+        return Vue.createVNode(index.Icon, {
+          "class": bem("left-icon"),
+          "name": props2.leftIcon
+        }, null);
+      }
+    };
+    const getRightIconName = () => {
+      if (props2.mode === "closeable") {
+        return "cross";
+      }
+      if (props2.mode === "link") {
+        return "arrow";
+      }
+    };
+    const onClickRightIcon = (event) => {
+      if (props2.mode === "closeable") {
+        state.show = false;
+        emit("close", event);
+      }
+    };
+    const renderRightIcon = () => {
+      if (slots["right-icon"]) {
+        return slots["right-icon"]();
+      }
+      const name2 = getRightIconName();
+      if (name2) {
+        return Vue.createVNode(index.Icon, {
+          "name": name2,
+          "class": bem("right-icon"),
+          "onClick": onClickRightIcon
+        }, null);
+      }
+    };
+    const onTransitionEnd = () => {
+      state.offset = wrapWidth;
+      state.duration = 0;
+      index_esm.raf(() => {
+        index_esm.doubleRaf(() => {
+          state.offset = -contentWidth;
+          state.duration = (contentWidth + wrapWidth) / +props2.speed;
+          emit("replay");
+        });
+      });
+    };
+    const renderMarquee = () => {
+      const ellipsis = props2.scrollable === false && !props2.wrapable;
+      const style = {
+        transform: state.offset ? `translateX(${state.offset}px)` : "",
+        transitionDuration: `${state.duration}s`
+      };
+      return Vue.createVNode("div", {
+        "ref": wrapRef,
+        "role": "marquee",
+        "class": bem("wrap")
+      }, [Vue.createVNode("div", {
+        "ref": contentRef,
+        "style": style,
+        "class": [bem("content"), {
+          "van-ellipsis": ellipsis
+        }],
+        "onTransitionend": onTransitionEnd
+      }, [slots.default ? slots.default() : props2.text])]);
+    };
+    const reset = () => {
+      const {
+        delay,
+        speed,
+        scrollable
+      } = props2;
+      const ms = basic.isDef(delay) ? +delay * 1e3 : 0;
+      wrapWidth = 0;
+      contentWidth = 0;
+      state.offset = 0;
+      state.duration = 0;
+      clearTimeout(startTimer);
+      startTimer = setTimeout(() => {
+        if (!wrapRef.value || !contentRef.value || scrollable === false) {
+          return;
+        }
+        const wrapRefWidth = index_esm.useRect(wrapRef).width;
+        const contentRefWidth = index_esm.useRect(contentRef).width;
+        if (scrollable || contentRefWidth > wrapRefWidth) {
+          index_esm.doubleRaf(() => {
+            wrapWidth = wrapRefWidth;
+            contentWidth = contentRefWidth;
+            state.offset = -contentWidth;
+            state.duration = contentWidth / +speed;
+          });
+        }
+      }, ms);
+    };
+    onPopupReopen.onPopupReopen(reset);
+    index_esm.onMountedOrActivated(reset);
+    index_esm.useEventListener("pageshow", reset);
+    useExpose.useExpose({
+      reset
+    });
+    Vue.watch(() => [props2.text, props2.scrollable], reset);
+    return () => {
+      const {
+        color,
+        wrapable,
+        background
+      } = props2;
+      return Vue.withDirectives(Vue.createVNode("div", {
+        "role": "alert",
+        "class": bem({
+          wrapable
+        }),
+        "style": {
+          color,
+          background
+        }
+      }, [renderLeftIcon(), renderMarquee(), renderRightIcon()]), [[Vue.vShow, state.show]]);
+    };
+  }
+});
+exports.default = stdin_default;
+exports.noticeBarProps = noticeBarProps;

package/lib/node_modules/vant/es/notice-bar/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const NoticeBar$1 = require("./NoticeBar.js");
+const withInstall = require("../utils/with-install.js");
+const NoticeBar = withInstall.withInstall(NoticeBar$1.default);
+exports.noticeBarProps = NoticeBar$1.noticeBarProps;
+exports.NoticeBar = NoticeBar;

package/lib/node_modules/vant/es/notify/Notify.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const Vue = require("vue");
+const index = require("../popup/index.js");
+const shared = require("../popup/shared.js");
+const basic = require("../utils/basic.js");
+const props = require("../utils/props.js");
+const create = require("../utils/create.js");
+const [name, bem] = create.createNamespace("notify");
+const popupInheritProps = ["lockScroll", "position", "show", "teleport", "zIndex"];
+const notifyProps = basic.extend({}, shared.popupSharedProps, {
+  type: props.makeStringProp("danger"),
+  color: String,
+  message: props.numericProp,
+  position: props.makeStringProp("top"),
+  className: props.unknownProp,
+  background: String,
+  lockScroll: Boolean
+});
+var stdin_default = Vue.defineComponent({
+  name,
+  props: notifyProps,
+  emits: ["update:show"],
+  setup(props2, {
+    emit,
+    slots
+  }) {
+    const updateShow = (show) => emit("update:show", show);
+    return () => Vue.createVNode(index.Popup, Vue.mergeProps({
+      "class": [bem([props2.type]), props2.className],
+      "style": {
+        color: props2.color,
+        background: props2.background
+      },
+      "overlay": false,
+      "duration": 0.2,
+      "onUpdate:show": updateShow
+    }, basic.pick(props2, popupInheritProps)), {
+      default: () => [slots.default ? slots.default() : props2.message]
+    });
+  }
+});
+exports.default = stdin_default;
+exports.notifyProps = notifyProps;

package/lib/node_modules/vant/es/notify/function-call.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const Vue = require("vue");
+const mountComponent = require("../utils/mount-component.js");
+const Notify = require("./Notify.js");
+const basic = require("../utils/basic.js");
+let timer;
+let instance;
+const parseOptions = (message) => basic.isObject(message) ? message : {
+  message
+};
+function initInstance() {
+  ({
+    instance
+  } = mountComponent.mountComponent({
+    setup() {
+      const {
+        state,
+        toggle
+      } = mountComponent.usePopupState();
+      return () => Vue.createVNode(Notify.default, Vue.mergeProps(state, {
+        "onUpdate:show": toggle
+      }), null);
+    }
+  }));
+}
+const getDefaultOptions = () => ({
+  type: "danger",
+  color: void 0,
+  message: "",
+  onClose: void 0,
+  onClick: void 0,
+  onOpened: void 0,
+  duration: 3e3,
+  position: void 0,
+  className: "",
+  lockScroll: false,
+  background: void 0
+});
+let currentOptions = getDefaultOptions();
+const closeNotify = () => {
+  if (instance) {
+    instance.toggle(false);
+  }
+};
+function showNotify(options) {
+  if (!basic.inBrowser) {
+    return;
+  }
+  if (!instance) {
+    initInstance();
+  }
+  options = basic.extend({}, currentOptions, parseOptions(options));
+  instance.open(options);
+  clearTimeout(timer);
+  if (options.duration > 0) {
+    timer = setTimeout(closeNotify, options.duration);
+  }
+  return instance;
+}
+const setNotifyDefaultOptions = (options) => basic.extend(currentOptions, options);
+const resetNotifyDefaultOptions = () => {
+  currentOptions = getDefaultOptions();
+};
+exports.closeNotify = closeNotify;
+exports.resetNotifyDefaultOptions = resetNotifyDefaultOptions;
+exports.setNotifyDefaultOptions = setNotifyDefaultOptions;
+exports.showNotify = showNotify;

package/lib/node_modules/vant/es/notify/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const Notify$1 = require("./Notify.js");
+const withInstall = require("../utils/with-install.js");
+const Notify = withInstall.withInstall(Notify$1.default);
+exports.notifyProps = Notify$1.notifyProps;
+exports.Notify = Notify;

package/lib/node_modules/vant/es/number-keyboard/NumberKeyboard.js

@@ -0,0 +1,239 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const Vue = require("vue");
+const index_esm = require("../../../@vant/use/dist/index.esm.js");
+const NumberKeyboardKey = require("./NumberKeyboardKey.js");
+const dom = require("../utils/dom.js");
+const props = require("../utils/props.js");
+const create = require("../utils/create.js");
+const format = require("../utils/format.js");
+const constant = require("../utils/constant.js");
+const [name, bem] = create.createNamespace("number-keyboard");
+const numberKeyboardProps = {
+  show: Boolean,
+  title: String,
+  theme: props.makeStringProp("default"),
+  zIndex: props.numericProp,
+  teleport: [String, Object],
+  maxlength: props.makeNumericProp(Infinity),
+  modelValue: props.makeStringProp(""),
+  transition: props.truthProp,
+  blurOnClose: props.truthProp,
+  showDeleteKey: props.truthProp,
+  randomKeyOrder: Boolean,
+  closeButtonText: String,
+  deleteButtonText: String,
+  closeButtonLoading: Boolean,
+  hideOnClickOutside: props.truthProp,
+  safeAreaInsetBottom: props.truthProp,
+  extraKey: {
+    type: [String, Array],
+    default: ""
+  }
+};
+function shuffle(array) {
+  for (let i = array.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    const temp = array[i];
+    array[i] = array[j];
+    array[j] = temp;
+  }
+  return array;
+}
+var stdin_default = Vue.defineComponent({
+  name,
+  inheritAttrs: false,
+  props: numberKeyboardProps,
+  emits: ["show", "hide", "blur", "input", "close", "delete", "update:modelValue"],
+  setup(props2, {
+    emit,
+    slots,
+    attrs
+  }) {
+    const root = Vue.ref();
+    const genBasicKeys = () => {
+      const keys2 = Array(9).fill("").map((_, i) => ({
+        text: i + 1
+      }));
+      if (props2.randomKeyOrder) {
+        shuffle(keys2);
+      }
+      return keys2;
+    };
+    const genDefaultKeys = () => [...genBasicKeys(), {
+      text: props2.extraKey,
+      type: "extra"
+    }, {
+      text: 0
+    }, {
+      text: props2.showDeleteKey ? props2.deleteButtonText : "",
+      type: props2.showDeleteKey ? "delete" : ""
+    }];
+    const genCustomKeys = () => {
+      const keys2 = genBasicKeys();
+      const {
+        extraKey
+      } = props2;
+      const extraKeys = Array.isArray(extraKey) ? extraKey : [extraKey];
+      if (extraKeys.length === 0) {
+        keys2.push({
+          text: 0,
+          wider: true
+        });
+      } else if (extraKeys.length === 1) {
+        keys2.push({
+          text: 0,
+          wider: true
+        }, {
+          text: extraKeys[0],
+          type: "extra"
+        });
+      } else if (extraKeys.length === 2) {
+        keys2.push({
+          text: extraKeys[0],
+          type: "extra"
+        }, {
+          text: 0
+        }, {
+          text: extraKeys[1],
+          type: "extra"
+        });
+      }
+      return keys2;
+    };
+    const keys = Vue.computed(() => props2.theme === "custom" ? genCustomKeys() : genDefaultKeys());
+    const onBlur = () => {
+      if (props2.show) {
+        emit("blur");
+      }
+    };
+    const onClose = () => {
+      emit("close");
+      if (props2.blurOnClose) {
+        onBlur();
+      }
+    };
+    const onAnimationEnd = () => emit(props2.show ? "show" : "hide");
+    const onPress = (text, type) => {
+      if (text === "") {
+        if (type === "extra") {
+          onBlur();
+        }
+        return;
+      }
+      const value = props2.modelValue;
+      if (type === "delete") {
+        emit("delete");
+        emit("update:modelValue", value.slice(0, value.length - 1));
+      } else if (type === "close") {
+        onClose();
+      } else if (value.length < +props2.maxlength) {
+        emit("input", text);
+        emit("update:modelValue", value + text);
+      }
+    };
+    const renderTitle = () => {
+      const {
+        title,
+        theme,
+        closeButtonText
+      } = props2;
+      const leftSlot = slots["title-left"];
+      const showClose = closeButtonText && theme === "default";
+      const showTitle = title || showClose || leftSlot;
+      if (!showTitle) {
+        return;
+      }
+      return Vue.createVNode("div", {
+        "class": bem("header")
+      }, [leftSlot && Vue.createVNode("span", {
+        "class": bem("title-left")
+      }, [leftSlot()]), title && Vue.createVNode("h2", {
+        "class": bem("title")
+      }, [title]), showClose && Vue.createVNode("button", {
+        "type": "button",
+        "class": [bem("close"), constant.HAPTICS_FEEDBACK],
+        "onClick": onClose
+      }, [closeButtonText])]);
+    };
+    const renderKeys = () => keys.value.map((key) => {
+      const keySlots = {};
+      if (key.type === "delete") {
+        keySlots.default = slots.delete;
+      }
+      if (key.type === "extra") {
+        keySlots.default = slots["extra-key"];
+      }
+      return Vue.createVNode(NumberKeyboardKey.default, {
+        "key": key.text,
+        "text": key.text,
+        "type": key.type,
+        "wider": key.wider,
+        "color": key.color,
+        "onPress": onPress
+      }, keySlots);
+    });
+    const renderSidebar = () => {
+      if (props2.theme === "custom") {
+        return Vue.createVNode("div", {
+          "class": bem("sidebar")
+        }, [props2.showDeleteKey && Vue.createVNode(NumberKeyboardKey.default, {
+          "large": true,
+          "text": props2.deleteButtonText,
+          "type": "delete",
+          "onPress": onPress
+        }, {
+          default: slots.delete
+        }), Vue.createVNode(NumberKeyboardKey.default, {
+          "large": true,
+          "text": props2.closeButtonText,
+          "type": "close",
+          "color": "blue",
+          "loading": props2.closeButtonLoading,
+          "onPress": onPress
+        }, null)]);
+      }
+    };
+    Vue.watch(() => props2.show, (value) => {
+      if (!props2.transition) {
+        emit(value ? "show" : "hide");
+      }
+    });
+    if (props2.hideOnClickOutside) {
+      index_esm.useClickAway(root, onBlur, {
+        eventName: "touchstart"
+      });
+    }
+    return () => {
+      const Title = renderTitle();
+      const Content = Vue.createVNode(Vue.Transition, {
+        "name": props2.transition ? "van-slide-up" : ""
+      }, {
+        default: () => [Vue.withDirectives(Vue.createVNode("div", Vue.mergeProps({
+          "ref": root,
+          "style": format.getZIndexStyle(props2.zIndex),
+          "class": bem({
+            unfit: !props2.safeAreaInsetBottom,
+            "with-title": !!Title
+          }),
+          "onAnimationend": onAnimationEnd,
+          "onTouchstartPassive": dom.stopPropagation
+        }, attrs), [Title, Vue.createVNode("div", {
+          "class": bem("body")
+        }, [Vue.createVNode("div", {
+          "class": bem("keys")
+        }, [renderKeys()]), renderSidebar()])]), [[Vue.vShow, props2.show]])]
+      });
+      if (props2.teleport) {
+        return Vue.createVNode(Vue.Teleport, {
+          "to": props2.teleport
+        }, {
+          default: () => [Content]
+        });
+      }
+      return Content;
+    };
+  }
+});
+exports.default = stdin_default;
+exports.numberKeyboardProps = numberKeyboardProps;