@fecp/designer 5.4.100 → 5.4.104

package/es/packages/mobile/node_modules/vant/es/nav-bar/NavBar.mjs

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

package/es/packages/mobile/node_modules/vant/es/nav-bar/index.mjs

@@ -0,0 +1,8 @@
+import stdin_default from "./NavBar.mjs";
+import { navBarProps } from "./NavBar.mjs";
+import { withInstall } from "../utils/with-install.mjs";
+const NavBar = withInstall(stdin_default);
+export {
+  NavBar,
+  navBarProps
+};

package/es/packages/mobile/node_modules/vant/es/notice-bar/NoticeBar.mjs

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

package/es/packages/mobile/node_modules/vant/es/notice-bar/index.mjs

@@ -0,0 +1,8 @@
+import stdin_default from "./NoticeBar.mjs";
+import { noticeBarProps } from "./NoticeBar.mjs";
+import { withInstall } from "../utils/with-install.mjs";
+const NoticeBar = withInstall(stdin_default);
+export {
+  NoticeBar,
+  noticeBarProps
+};

package/es/packages/mobile/node_modules/vant/es/notify/Notify.mjs

@@ -0,0 +1,44 @@
+import { defineComponent, createVNode, mergeProps } from "vue";
+import { Popup } from "../popup/index.mjs";
+import { popupSharedProps } from "../popup/shared.mjs";
+import { extend, pick } from "../utils/basic.mjs";
+import { createNamespace } from "../utils/create.mjs";
+import { unknownProp, makeStringProp, numericProp } from "../utils/props.mjs";
+const [name, bem] = createNamespace("notify");
+const popupInheritProps = ["lockScroll", "position", "show", "teleport", "zIndex"];
+const notifyProps = extend({}, popupSharedProps, {
+  type: makeStringProp("danger"),
+  color: String,
+  message: numericProp,
+  position: makeStringProp("top"),
+  className: unknownProp,
+  background: String,
+  lockScroll: Boolean
+});
+var stdin_default = defineComponent({
+  name,
+  props: notifyProps,
+  emits: ["update:show"],
+  setup(props, {
+    emit,
+    slots
+  }) {
+    const updateShow = (show) => emit("update:show", show);
+    return () => createVNode(Popup, mergeProps({
+      "class": [bem([props.type]), props.className],
+      "style": {
+        color: props.color,
+        background: props.background
+      },
+      "overlay": false,
+      "duration": 0.2,
+      "onUpdate:show": updateShow
+    }, pick(props, popupInheritProps)), {
+      default: () => [slots.default ? slots.default() : props.message]
+    });
+  }
+});
+export {
+  stdin_default as default,
+  notifyProps
+};

package/es/packages/mobile/node_modules/vant/es/notify/function-call.mjs

@@ -0,0 +1,62 @@
+import { createVNode, mergeProps } from "vue";
+import { mountComponent, usePopupState } from "../utils/mount-component.mjs";
+import stdin_default from "./Notify.mjs";
+import { inBrowser, extend, isObject } from "../utils/basic.mjs";
+let timer;
+let instance;
+const parseOptions = (message) => isObject(message) ? message : {
+  message
+};
+function initInstance() {
+  ({
+    instance
+  } = mountComponent({
+    setup() {
+      const {
+        state,
+        toggle
+      } = usePopupState();
+      return () => createVNode(stdin_default, 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 (!inBrowser) {
+    return;
+  }
+  if (!instance) {
+    initInstance();
+  }
+  options = extend({}, currentOptions, parseOptions(options));
+  instance.open(options);
+  clearTimeout(timer);
+  if (options.duration > 0) {
+    timer = setTimeout(closeNotify, options.duration);
+  }
+  return instance;
+}
+export {
+  closeNotify,
+  showNotify
+};

package/es/packages/mobile/node_modules/vant/es/overlay/Overlay.mjs

@@ -0,0 +1,71 @@
+import { defineComponent, ref, createVNode, Transition, Teleport, withDirectives, mergeProps, vShow } from "vue";
+import { useEventListener } from "../../../@vant/use/dist/index.esm.mjs";
+import { useLazyRender } from "../composables/use-lazy-render.mjs";
+import { getZIndexStyle } from "../utils/format.mjs";
+import { truthProp, unknownProp, numericProp } from "../utils/props.mjs";
+import { createNamespace } from "../utils/create.mjs";
+import { preventDefault } from "../utils/dom.mjs";
+import { extend, isDef } from "../utils/basic.mjs";
+const [name, bem] = createNamespace("overlay");
+const overlayProps = {
+  show: Boolean,
+  zIndex: numericProp,
+  duration: numericProp,
+  className: unknownProp,
+  lockScroll: truthProp,
+  lazyRender: truthProp,
+  customStyle: Object,
+  teleport: [String, Object]
+};
+var stdin_default = defineComponent({
+  name,
+  inheritAttrs: false,
+  props: overlayProps,
+  setup(props, {
+    attrs,
+    slots
+  }) {
+    const root = ref();
+    const lazyRender = useLazyRender(() => props.show || !props.lazyRender);
+    const onTouchMove = (event) => {
+      if (props.lockScroll) {
+        preventDefault(event, true);
+      }
+    };
+    const renderOverlay = lazyRender(() => {
+      var _a;
+      const style = extend(getZIndexStyle(props.zIndex), props.customStyle);
+      if (isDef(props.duration)) {
+        style.animationDuration = `${props.duration}s`;
+      }
+      return withDirectives(createVNode("div", mergeProps({
+        "ref": root,
+        "style": style,
+        "class": [bem(), props.className]
+      }, attrs), [(_a = slots.default) == null ? void 0 : _a.call(slots)]), [[vShow, props.show]]);
+    });
+    useEventListener("touchmove", onTouchMove, {
+      target: root
+    });
+    return () => {
+      const Content = createVNode(Transition, {
+        "name": "van-fade",
+        "appear": true
+      }, {
+        default: renderOverlay
+      });
+      if (props.teleport) {
+        return createVNode(Teleport, {
+          "to": props.teleport
+        }, {
+          default: () => [Content]
+        });
+      }
+      return Content;
+    };
+  }
+});
+export {
+  stdin_default as default,
+  overlayProps
+};

package/es/packages/mobile/node_modules/vant/es/overlay/index.mjs

@@ -0,0 +1,8 @@
+import stdin_default from "./Overlay.mjs";
+import { overlayProps } from "./Overlay.mjs";
+import { withInstall } from "../utils/with-install.mjs";
+const Overlay = withInstall(stdin_default);
+export {
+  Overlay,
+  overlayProps
+};

package/es/packages/mobile/node_modules/vant/es/pagination/Pagination.mjs

@@ -0,0 +1,157 @@
+import { defineComponent, computed, watchEffect, createVNode } from "vue";
+import { truthProp, makeNumericProp, makeNumberProp, makeStringProp } from "../utils/props.mjs";
+import { createNamespace } from "../utils/create.mjs";
+import { clamp } from "../utils/format.mjs";
+import { BORDER_SURROUND } from "../utils/constant.mjs";
+const [name, bem, t] = createNamespace("pagination");
+const makePage = (number, text, active) => ({
+  number,
+  text,
+  active
+});
+const paginationProps = {
+  mode: makeStringProp("multi"),
+  prevText: String,
+  nextText: String,
+  pageCount: makeNumericProp(0),
+  modelValue: makeNumberProp(0),
+  totalItems: makeNumericProp(0),
+  showPageSize: makeNumericProp(5),
+  itemsPerPage: makeNumericProp(10),
+  forceEllipses: Boolean,
+  showPrevButton: truthProp,
+  showNextButton: truthProp
+};
+var stdin_default = defineComponent({
+  name,
+  props: paginationProps,
+  emits: ["change", "update:modelValue"],
+  setup(props, {
+    emit,
+    slots
+  }) {
+    const count = computed(() => {
+      const {
+        pageCount,
+        totalItems,
+        itemsPerPage
+      } = props;
+      const count2 = +pageCount || Math.ceil(+totalItems / +itemsPerPage);
+      return Math.max(1, count2);
+    });
+    const pages = computed(() => {
+      const items = [];
+      const pageCount = count.value;
+      const showPageSize = +props.showPageSize;
+      const {
+        modelValue,
+        forceEllipses
+      } = props;
+      let startPage = 1;
+      let endPage = pageCount;
+      const isMaxSized = showPageSize < pageCount;
+      if (isMaxSized) {
+        startPage = Math.max(modelValue - Math.floor(showPageSize / 2), 1);
+        endPage = startPage + showPageSize - 1;
+        if (endPage > pageCount) {
+          endPage = pageCount;
+          startPage = endPage - showPageSize + 1;
+        }
+      }
+      for (let number = startPage; number <= endPage; number++) {
+        const page = makePage(number, number, number === modelValue);
+        items.push(page);
+      }
+      if (isMaxSized && showPageSize > 0 && forceEllipses) {
+        if (startPage > 1) {
+          const prevPages = makePage(startPage - 1, "...");
+          items.unshift(prevPages);
+        }
+        if (endPage < pageCount) {
+          const nextPages = makePage(endPage + 1, "...");
+          items.push(nextPages);
+        }
+      }
+      return items;
+    });
+    const updateModelValue = (value, emitChange) => {
+      value = clamp(value, 1, count.value);
+      if (props.modelValue !== value) {
+        emit("update:modelValue", value);
+        if (emitChange) {
+          emit("change", value);
+        }
+      }
+    };
+    watchEffect(() => updateModelValue(props.modelValue));
+    const renderDesc = () => createVNode("li", {
+      "class": bem("page-desc")
+    }, [slots.pageDesc ? slots.pageDesc() : `${props.modelValue}/${count.value}`]);
+    const renderPrevButton = () => {
+      const {
+        mode,
+        modelValue,
+        showPrevButton
+      } = props;
+      if (!showPrevButton) {
+        return;
+      }
+      const slot = slots["prev-text"];
+      const disabled = modelValue === 1;
+      return createVNode("li", {
+        "class": [bem("item", {
+          disabled,
+          border: mode === "simple",
+          prev: true
+        }), BORDER_SURROUND]
+      }, [createVNode("button", {
+        "type": "button",
+        "disabled": disabled,
+        "onClick": () => updateModelValue(modelValue - 1, true)
+      }, [slot ? slot() : props.prevText || t("prev")])]);
+    };
+    const renderNextButton = () => {
+      const {
+        mode,
+        modelValue,
+        showNextButton
+      } = props;
+      if (!showNextButton) {
+        return;
+      }
+      const slot = slots["next-text"];
+      const disabled = modelValue === count.value;
+      return createVNode("li", {
+        "class": [bem("item", {
+          disabled,
+          border: mode === "simple",
+          next: true
+        }), BORDER_SURROUND]
+      }, [createVNode("button", {
+        "type": "button",
+        "disabled": disabled,
+        "onClick": () => updateModelValue(modelValue + 1, true)
+      }, [slot ? slot() : props.nextText || t("next")])]);
+    };
+    const renderPages = () => pages.value.map((page) => createVNode("li", {
+      "class": [bem("item", {
+        active: page.active,
+        page: true
+      }), BORDER_SURROUND]
+    }, [createVNode("button", {
+      "type": "button",
+      "aria-current": page.active || void 0,
+      "onClick": () => updateModelValue(page.number, true)
+    }, [slots.page ? slots.page(page) : page.text])]));
+    return () => createVNode("nav", {
+      "role": "navigation",
+      "class": bem()
+    }, [createVNode("ul", {
+      "class": bem("items")
+    }, [renderPrevButton(), props.mode === "simple" ? renderDesc() : renderPages(), renderNextButton()])]);
+  }
+});
+export {
+  stdin_default as default,
+  paginationProps
+};

package/es/packages/mobile/node_modules/vant/es/pagination/index.mjs

@@ -0,0 +1,8 @@
+import stdin_default from "./Pagination.mjs";
+import { paginationProps } from "./Pagination.mjs";
+import { withInstall } from "../utils/with-install.mjs";
+const Pagination = withInstall(stdin_default);
+export {
+  Pagination,
+  paginationProps
+};