@fecp/mobile-designer 1.0.9 → 1.0.11

package/es/node_modules/vant/es/index-bar/IndexBar.mjs

@@ -0,0 +1,237 @@
+import { defineComponent, ref, computed, onMounted, watch, createVNode, Teleport, nextTick } from "vue";
+import { useScrollParent, useChildren, useEventListener, useRect } from "../../../@vant/use/dist/index.esm.mjs";
+import { useTouch } from "../composables/use-touch.mjs";
+import { useExpose } from "../composables/use-expose.mjs";
+import { makeNumberProp, numericProp, truthProp } from "../utils/props.mjs";
+import { createNamespace } from "../utils/create.mjs";
+import { isDef } from "../utils/basic.mjs";
+import { isHidden, getScrollTop, getRootScrollTop, setRootScrollTop, preventDefault } from "../utils/dom.mjs";
+function genAlphabet() {
+  const charCodeOfA = "A".charCodeAt(0);
+  const indexList = Array(26).fill("").map((_, i) => String.fromCharCode(charCodeOfA + i));
+  return indexList;
+}
+const [name, bem] = createNamespace("index-bar");
+const indexBarProps = {
+  sticky: truthProp,
+  zIndex: numericProp,
+  teleport: [String, Object],
+  highlightColor: String,
+  stickyOffsetTop: makeNumberProp(0),
+  indexList: {
+    type: Array,
+    default: genAlphabet
+  }
+};
+const INDEX_BAR_KEY = Symbol(name);
+var stdin_default = defineComponent({
+  name,
+  props: indexBarProps,
+  emits: ["select", "change"],
+  setup(props, {
+    emit,
+    slots
+  }) {
+    const root = ref();
+    const sidebar = ref();
+    const activeAnchor = ref("");
+    const touch = useTouch();
+    const scrollParent = useScrollParent(root);
+    const {
+      children,
+      linkChildren
+    } = useChildren(INDEX_BAR_KEY);
+    let selectActiveIndex;
+    linkChildren({
+      props
+    });
+    const sidebarStyle = computed(() => {
+      if (isDef(props.zIndex)) {
+        return {
+          zIndex: +props.zIndex + 1
+        };
+      }
+    });
+    const highlightStyle = computed(() => {
+      if (props.highlightColor) {
+        return {
+          color: props.highlightColor
+        };
+      }
+    });
+    const getActiveAnchor = (scrollTop, rects) => {
+      for (let i = children.length - 1; i >= 0; i--) {
+        const prevHeight = i > 0 ? rects[i - 1].height : 0;
+        const reachTop = props.sticky ? prevHeight + props.stickyOffsetTop : 0;
+        if (scrollTop + reachTop >= rects[i].top) {
+          return i;
+        }
+      }
+      return -1;
+    };
+    const getMatchAnchor = (index) => children.find((item) => String(item.index) === index);
+    const onScroll = () => {
+      if (isHidden(root)) {
+        return;
+      }
+      const {
+        sticky,
+        indexList
+      } = props;
+      const scrollTop = getScrollTop(scrollParent.value);
+      const scrollParentRect = useRect(scrollParent);
+      const rects = children.map((item) => item.getRect(scrollParent.value, scrollParentRect));
+      let active = -1;
+      if (selectActiveIndex) {
+        const match = getMatchAnchor(selectActiveIndex);
+        if (match) {
+          const rect = match.getRect(scrollParent.value, scrollParentRect);
+          if (props.sticky && props.stickyOffsetTop) {
+            active = getActiveAnchor(rect.top - props.stickyOffsetTop, rects);
+          } else {
+            active = getActiveAnchor(rect.top, rects);
+          }
+        }
+      } else {
+        active = getActiveAnchor(scrollTop, rects);
+      }
+      activeAnchor.value = indexList[active];
+      if (sticky) {
+        children.forEach((item, index) => {
+          const {
+            state,
+            $el
+          } = item;
+          if (index === active || index === active - 1) {
+            const rect = $el.getBoundingClientRect();
+            state.left = rect.left;
+            state.width = rect.width;
+          } else {
+            state.left = null;
+            state.width = null;
+          }
+          if (index === active) {
+            state.active = true;
+            state.top = Math.max(props.stickyOffsetTop, rects[index].top - scrollTop) + scrollParentRect.top;
+          } else if (index === active - 1 && selectActiveIndex === "") {
+            const activeItemTop = rects[active].top - scrollTop;
+            state.active = activeItemTop > 0;
+            state.top = activeItemTop + scrollParentRect.top - rects[index].height;
+          } else {
+            state.active = false;
+          }
+        });
+      }
+      selectActiveIndex = "";
+    };
+    const init = () => {
+      nextTick(onScroll);
+    };
+    useEventListener("scroll", onScroll, {
+      target: scrollParent,
+      passive: true
+    });
+    onMounted(init);
+    watch(() => props.indexList, init);
+    watch(activeAnchor, (value) => {
+      if (value) {
+        emit("change", value);
+      }
+    });
+    const renderIndexes = () => props.indexList.map((index) => {
+      const active = index === activeAnchor.value;
+      return createVNode("span", {
+        "class": bem("index", {
+          active
+        }),
+        "style": active ? highlightStyle.value : void 0,
+        "data-index": index
+      }, [index]);
+    });
+    const scrollTo = (index) => {
+      selectActiveIndex = String(index);
+      const match = getMatchAnchor(selectActiveIndex);
+      if (match) {
+        const scrollTop = getScrollTop(scrollParent.value);
+        const scrollParentRect = useRect(scrollParent);
+        const {
+          offsetHeight
+        } = document.documentElement;
+        match.$el.scrollIntoView();
+        if (scrollTop === offsetHeight - scrollParentRect.height) {
+          onScroll();
+          return;
+        }
+        if (props.sticky && props.stickyOffsetTop) {
+          if (getRootScrollTop() === offsetHeight - scrollParentRect.height) {
+            setRootScrollTop(getRootScrollTop());
+          } else {
+            setRootScrollTop(getRootScrollTop() - props.stickyOffsetTop);
+          }
+        }
+        emit("select", match.index);
+      }
+    };
+    const scrollToElement = (element) => {
+      const {
+        index
+      } = element.dataset;
+      if (index) {
+        scrollTo(index);
+      }
+    };
+    const onClickSidebar = (event) => {
+      scrollToElement(event.target);
+    };
+    let touchActiveIndex;
+    const onTouchMove = (event) => {
+      touch.move(event);
+      if (touch.isVertical()) {
+        preventDefault(event);
+        const {
+          clientX,
+          clientY
+        } = event.touches[0];
+        const target = document.elementFromPoint(clientX, clientY);
+        if (target) {
+          const {
+            index
+          } = target.dataset;
+          if (index && touchActiveIndex !== index) {
+            touchActiveIndex = index;
+            scrollToElement(target);
+          }
+        }
+      }
+    };
+    const renderSidebar = () => createVNode("div", {
+      "ref": sidebar,
+      "class": bem("sidebar"),
+      "style": sidebarStyle.value,
+      "onClick": onClickSidebar,
+      "onTouchstartPassive": touch.start
+    }, [renderIndexes()]);
+    useExpose({
+      scrollTo
+    });
+    useEventListener("touchmove", onTouchMove, {
+      target: sidebar
+    });
+    return () => {
+      var _a;
+      return createVNode("div", {
+        "ref": root,
+        "class": bem()
+      }, [props.teleport ? createVNode(Teleport, {
+        "to": props.teleport
+      }, {
+        default: () => [renderSidebar()]
+      }) : renderSidebar(), (_a = slots.default) == null ? void 0 : _a.call(slots)]);
+    };
+  }
+});
+export {
+  INDEX_BAR_KEY,
+  stdin_default as default,
+  indexBarProps
+};

package/es/node_modules/vant/es/index-bar/index.mjs

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

package/es/node_modules/vant/es/lazyload/vue-lazyload/util.mjs

@@ -0,0 +1,23 @@
+function throttle(action, delay) {
+  let timeout = null;
+  let lastRun = 0;
+  return function(...args) {
+    if (timeout) {
+      return;
+    }
+    const elapsed = Date.now() - lastRun;
+    const runCallback = () => {
+      lastRun = Date.now();
+      timeout = false;
+      action.apply(this, args);
+    };
+    if (elapsed >= delay) {
+      runCallback();
+    } else {
+      timeout = setTimeout(runCallback, delay);
+    }
+  };
+}
+export {
+  throttle
+};

package/es/node_modules/vant/es/list/List.mjs

@@ -0,0 +1,145 @@
+import { defineComponent, ref, computed, watch, onUpdated, onMounted, createVNode, nextTick } from "vue";
+import { useScrollParent, useEventListener, useRect } from "../../../@vant/use/dist/index.esm.mjs";
+import { useExpose } from "../composables/use-expose.mjs";
+import { useTabStatus } from "../composables/use-tab-status.mjs";
+import { Loading } from "../loading/index.mjs";
+import { truthProp, makeStringProp, makeNumericProp } from "../utils/props.mjs";
+import { createNamespace } from "../utils/create.mjs";
+import { isHidden } from "../utils/dom.mjs";
+const [name, bem, t] = createNamespace("list");
+const listProps = {
+  error: Boolean,
+  offset: makeNumericProp(300),
+  loading: Boolean,
+  disabled: Boolean,
+  finished: Boolean,
+  scroller: Object,
+  errorText: String,
+  direction: makeStringProp("down"),
+  loadingText: String,
+  finishedText: String,
+  immediateCheck: truthProp
+};
+var stdin_default = defineComponent({
+  name,
+  props: listProps,
+  emits: ["load", "update:error", "update:loading"],
+  setup(props, {
+    emit,
+    slots
+  }) {
+    const loading = ref(props.loading);
+    const root = ref();
+    const placeholder = ref();
+    const tabStatus = useTabStatus();
+    const scrollParent = useScrollParent(root);
+    const scroller = computed(() => props.scroller || scrollParent.value);
+    const check = () => {
+      nextTick(() => {
+        if (loading.value || props.finished || props.disabled || props.error || // skip check when inside an inactive tab
+        (tabStatus == null ? void 0 : tabStatus.value) === false) {
+          return;
+        }
+        const {
+          direction
+        } = props;
+        const offset = +props.offset;
+        const scrollParentRect = useRect(scroller);
+        if (!scrollParentRect.height || isHidden(root)) {
+          return;
+        }
+        let isReachEdge = false;
+        const placeholderRect = useRect(placeholder);
+        if (direction === "up") {
+          isReachEdge = scrollParentRect.top - placeholderRect.top <= offset;
+        } else {
+          isReachEdge = placeholderRect.bottom - scrollParentRect.bottom <= offset;
+        }
+        if (isReachEdge) {
+          loading.value = true;
+          emit("update:loading", true);
+          emit("load");
+        }
+      });
+    };
+    const renderFinishedText = () => {
+      if (props.finished) {
+        const text = slots.finished ? slots.finished() : props.finishedText;
+        if (text) {
+          return createVNode("div", {
+            "class": bem("finished-text")
+          }, [text]);
+        }
+      }
+    };
+    const clickErrorText = () => {
+      emit("update:error", false);
+      check();
+    };
+    const renderErrorText = () => {
+      if (props.error) {
+        const text = slots.error ? slots.error() : props.errorText;
+        if (text) {
+          return createVNode("div", {
+            "role": "button",
+            "class": bem("error-text"),
+            "tabindex": 0,
+            "onClick": clickErrorText
+          }, [text]);
+        }
+      }
+    };
+    const renderLoading = () => {
+      if (loading.value && !props.finished && !props.disabled) {
+        return createVNode("div", {
+          "class": bem("loading")
+        }, [slots.loading ? slots.loading() : createVNode(Loading, {
+          "class": bem("loading-icon")
+        }, {
+          default: () => [props.loadingText || t("loading")]
+        })]);
+      }
+    };
+    watch(() => [props.loading, props.finished, props.error], check);
+    if (tabStatus) {
+      watch(tabStatus, (tabActive) => {
+        if (tabActive) {
+          check();
+        }
+      });
+    }
+    onUpdated(() => {
+      loading.value = props.loading;
+    });
+    onMounted(() => {
+      if (props.immediateCheck) {
+        check();
+      }
+    });
+    useExpose({
+      check
+    });
+    useEventListener("scroll", check, {
+      target: scroller,
+      passive: true
+    });
+    return () => {
+      var _a;
+      const Content = (_a = slots.default) == null ? void 0 : _a.call(slots);
+      const Placeholder = createVNode("div", {
+        "ref": placeholder,
+        "class": bem("placeholder")
+      }, null);
+      return createVNode("div", {
+        "ref": root,
+        "role": "feed",
+        "class": bem(),
+        "aria-busy": loading.value
+      }, [props.direction === "down" ? Content : Placeholder, renderLoading(), renderFinishedText(), renderErrorText(), props.direction === "up" ? Content : Placeholder]);
+    };
+  }
+});
+export {
+  stdin_default as default,
+  listProps
+};

package/es/node_modules/vant/es/list/index.mjs

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

package/es/node_modules/vant/es/loading/Loading.mjs

@@ -0,0 +1,73 @@
+import { defineComponent, computed, createVNode } from "vue";
+import { getSizeStyle, addUnit } from "../utils/format.mjs";
+import { numericProp, makeStringProp } from "../utils/props.mjs";
+import { createNamespace } from "../utils/create.mjs";
+import { extend } from "../utils/basic.mjs";
+const [name, bem] = createNamespace("loading");
+const SpinIcon = Array(12).fill(null).map((_, index) => createVNode("i", {
+  "class": bem("line", String(index + 1))
+}, null));
+const CircularIcon = createVNode("svg", {
+  "class": bem("circular"),
+  "viewBox": "25 25 50 50"
+}, [createVNode("circle", {
+  "cx": "50",
+  "cy": "50",
+  "r": "20",
+  "fill": "none"
+}, null)]);
+const loadingProps = {
+  size: numericProp,
+  type: makeStringProp("circular"),
+  color: String,
+  vertical: Boolean,
+  textSize: numericProp,
+  textColor: String
+};
+var stdin_default = defineComponent({
+  name,
+  props: loadingProps,
+  setup(props, {
+    slots
+  }) {
+    const spinnerStyle = computed(() => extend({
+      color: props.color
+    }, getSizeStyle(props.size)));
+    const renderIcon = () => {
+      const DefaultIcon = props.type === "spinner" ? SpinIcon : CircularIcon;
+      return createVNode("span", {
+        "class": bem("spinner", props.type),
+        "style": spinnerStyle.value
+      }, [slots.icon ? slots.icon() : DefaultIcon]);
+    };
+    const renderText = () => {
+      var _a;
+      if (slots.default) {
+        return createVNode("span", {
+          "class": bem("text"),
+          "style": {
+            fontSize: addUnit(props.textSize),
+            color: (_a = props.textColor) != null ? _a : props.color
+          }
+        }, [slots.default()]);
+      }
+    };
+    return () => {
+      const {
+        type,
+        vertical
+      } = props;
+      return createVNode("div", {
+        "class": bem([type, {
+          vertical
+        }]),
+        "aria-live": "polite",
+        "aria-busy": true
+      }, [renderIcon(), renderText()]);
+    };
+  }
+});
+export {
+  stdin_default as default,
+  loadingProps
+};

package/es/node_modules/vant/es/loading/index.mjs

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

package/es/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/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
+};