@fecp/mobile-designer 1.0.9 → 1.0.11

package/es/node_modules/vant/es/action-bar/ActionBar.mjs

@@ -0,0 +1,45 @@
+import { defineComponent, ref, createVNode } from "vue";
+import { useChildren } from "../../../@vant/use/dist/index.esm.mjs";
+import { usePlaceholder } from "../composables/use-placeholder.mjs";
+import { truthProp } from "../utils/props.mjs";
+import { createNamespace } from "../utils/create.mjs";
+const [name, bem] = createNamespace("action-bar");
+const ACTION_BAR_KEY = Symbol(name);
+const actionBarProps = {
+  placeholder: Boolean,
+  safeAreaInsetBottom: truthProp
+};
+var stdin_default = defineComponent({
+  name,
+  props: actionBarProps,
+  setup(props, {
+    slots
+  }) {
+    const root = ref();
+    const renderPlaceholder = usePlaceholder(root, bem);
+    const {
+      linkChildren
+    } = useChildren(ACTION_BAR_KEY);
+    linkChildren();
+    const renderActionBar = () => {
+      var _a;
+      return createVNode("div", {
+        "ref": root,
+        "class": [bem(), {
+          "van-safe-area-bottom": props.safeAreaInsetBottom
+        }]
+      }, [(_a = slots.default) == null ? void 0 : _a.call(slots)]);
+    };
+    return () => {
+      if (props.placeholder) {
+        return renderPlaceholder(renderActionBar);
+      }
+      return renderActionBar();
+    };
+  }
+});
+export {
+  ACTION_BAR_KEY,
+  actionBarProps,
+  stdin_default as default
+};

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

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

package/es/node_modules/vant/es/action-bar-button/ActionBarButton.mjs

@@ -0,0 +1,74 @@
+import { defineComponent, computed, createVNode } from "vue";
+import { ACTION_BAR_KEY } from "../action-bar/ActionBar.mjs";
+import { useParent } from "../../../@vant/use/dist/index.esm.mjs";
+import { useExpose } from "../composables/use-expose.mjs";
+import { useRoute, routeProps } from "../composables/use-route.mjs";
+import { Button } from "../button/index.mjs";
+import { extend } from "../utils/basic.mjs";
+import { createNamespace } from "../utils/create.mjs";
+const [name, bem] = createNamespace("action-bar-button");
+const actionBarButtonProps = extend({}, routeProps, {
+  type: String,
+  text: String,
+  icon: String,
+  color: String,
+  loading: Boolean,
+  disabled: Boolean
+});
+var stdin_default = defineComponent({
+  name,
+  props: actionBarButtonProps,
+  setup(props, {
+    slots
+  }) {
+    const route = useRoute();
+    const {
+      parent,
+      index
+    } = useParent(ACTION_BAR_KEY);
+    const isFirst = computed(() => {
+      if (parent) {
+        const prev = parent.children[index.value - 1];
+        return !(prev && "isButton" in prev);
+      }
+    });
+    const isLast = computed(() => {
+      if (parent) {
+        const next = parent.children[index.value + 1];
+        return !(next && "isButton" in next);
+      }
+    });
+    useExpose({
+      isButton: true
+    });
+    return () => {
+      const {
+        type,
+        icon,
+        text,
+        color,
+        loading,
+        disabled
+      } = props;
+      return createVNode(Button, {
+        "class": bem([type, {
+          last: isLast.value,
+          first: isFirst.value
+        }]),
+        "size": "large",
+        "type": type,
+        "icon": icon,
+        "color": color,
+        "loading": loading,
+        "disabled": disabled,
+        "onClick": route
+      }, {
+        default: () => [slots.default ? slots.default() : text]
+      });
+    };
+  }
+});
+export {
+  actionBarButtonProps,
+  stdin_default as default
+};

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

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

package/es/node_modules/vant/es/action-sheet/ActionSheet.mjs

@@ -0,0 +1,142 @@
+import { defineComponent, createVNode, mergeProps, nextTick } from "vue";
+import { Icon } from "../icon/index.mjs";
+import { Popup } from "../popup/index.mjs";
+import { Loading } from "../loading/index.mjs";
+import { popupSharedPropKeys, popupSharedProps } from "../popup/shared.mjs";
+import { extend, pick } from "../utils/basic.mjs";
+import { truthProp, makeStringProp, makeArrayProp } from "../utils/props.mjs";
+import { createNamespace } from "../utils/create.mjs";
+import { HAPTICS_FEEDBACK } from "../utils/constant.mjs";
+const [name, bem] = createNamespace("action-sheet");
+const actionSheetProps = extend({}, popupSharedProps, {
+  title: String,
+  round: truthProp,
+  actions: makeArrayProp(),
+  closeIcon: makeStringProp("cross"),
+  closeable: truthProp,
+  cancelText: String,
+  description: String,
+  closeOnPopstate: truthProp,
+  closeOnClickAction: Boolean,
+  safeAreaInsetBottom: truthProp
+});
+const popupInheritKeys = [...popupSharedPropKeys, "round", "closeOnPopstate", "safeAreaInsetBottom"];
+var stdin_default = defineComponent({
+  name,
+  props: actionSheetProps,
+  emits: ["select", "cancel", "update:show"],
+  setup(props, {
+    slots,
+    emit
+  }) {
+    const updateShow = (show) => emit("update:show", show);
+    const onCancel = () => {
+      updateShow(false);
+      emit("cancel");
+    };
+    const renderHeader = () => {
+      if (props.title) {
+        return createVNode("div", {
+          "class": bem("header")
+        }, [props.title, props.closeable && createVNode(Icon, {
+          "name": props.closeIcon,
+          "class": [bem("close"), HAPTICS_FEEDBACK],
+          "onClick": onCancel
+        }, null)]);
+      }
+    };
+    const renderCancel = () => {
+      if (slots.cancel || props.cancelText) {
+        return [createVNode("div", {
+          "class": bem("gap")
+        }, null), createVNode("button", {
+          "type": "button",
+          "class": bem("cancel"),
+          "onClick": onCancel
+        }, [slots.cancel ? slots.cancel() : props.cancelText])];
+      }
+    };
+    const renderIcon = (action) => {
+      if (action.icon) {
+        return createVNode(Icon, {
+          "class": bem("item-icon"),
+          "name": action.icon
+        }, null);
+      }
+    };
+    const renderActionContent = (action, index) => {
+      if (action.loading) {
+        return createVNode(Loading, {
+          "class": bem("loading-icon")
+        }, null);
+      }
+      if (slots.action) {
+        return slots.action({
+          action,
+          index
+        });
+      }
+      return [createVNode("span", {
+        "class": bem("name")
+      }, [action.name]), action.subname && createVNode("div", {
+        "class": bem("subname")
+      }, [action.subname])];
+    };
+    const renderAction = (action, index) => {
+      const {
+        color,
+        loading,
+        callback,
+        disabled,
+        className
+      } = action;
+      const onClick = () => {
+        if (disabled || loading) {
+          return;
+        }
+        if (callback) {
+          callback(action);
+        }
+        if (props.closeOnClickAction) {
+          updateShow(false);
+        }
+        nextTick(() => emit("select", action, index));
+      };
+      return createVNode("button", {
+        "type": "button",
+        "style": {
+          color
+        },
+        "class": [bem("item", {
+          loading,
+          disabled
+        }), className],
+        "onClick": onClick
+      }, [renderIcon(action), renderActionContent(action, index)]);
+    };
+    const renderDescription = () => {
+      if (props.description || slots.description) {
+        const content = slots.description ? slots.description() : props.description;
+        return createVNode("div", {
+          "class": bem("description")
+        }, [content]);
+      }
+    };
+    return () => createVNode(Popup, mergeProps({
+      "class": bem(),
+      "position": "bottom",
+      "onUpdate:show": updateShow
+    }, pick(props, popupInheritKeys)), {
+      default: () => {
+        var _a;
+        return [renderHeader(), renderDescription(), createVNode("div", {
+          "class": bem("content")
+        }, [props.actions.map(renderAction), (_a = slots.default) == null ? void 0 : _a.call(slots)]), renderCancel()];
+      }
+    });
+  }
+});
+export {
+  actionSheetProps,
+  stdin_default as default
+};

package/es/node_modules/vant/es/action-sheet/index.mjs

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

package/es/node_modules/vant/es/back-top/BackTop.mjs

@@ -0,0 +1,119 @@
+import { defineComponent, ref, computed, onMounted, onActivated, onDeactivated, watch, createVNode, mergeProps, Teleport, nextTick } from "vue";
+import { throttle } from "../lazyload/vue-lazyload/util.mjs";
+import { useEventListener, getScrollParent } from "../../../@vant/use/dist/index.esm.mjs";
+import { Icon } from "../icon/index.mjs";
+import { makeNumericProp, numericProp } from "../utils/props.mjs";
+import { createNamespace } from "../utils/create.mjs";
+import { extend, inBrowser } from "../utils/basic.mjs";
+import { getZIndexStyle, addUnit } from "../utils/format.mjs";
+import { getScrollTop } from "../utils/dom.mjs";
+const [name, bem] = createNamespace("back-top");
+const backTopProps = {
+  right: numericProp,
+  bottom: numericProp,
+  zIndex: numericProp,
+  target: [String, Object],
+  offset: makeNumericProp(200),
+  immediate: Boolean,
+  teleport: {
+    type: [String, Object],
+    default: "body"
+  }
+};
+var stdin_default = defineComponent({
+  name,
+  inheritAttrs: false,
+  props: backTopProps,
+  emits: ["click"],
+  setup(props, {
+    emit,
+    slots,
+    attrs
+  }) {
+    let shouldReshow = false;
+    const show = ref(false);
+    const root = ref();
+    const scrollParent = ref();
+    const style = computed(() => extend(getZIndexStyle(props.zIndex), {
+      right: addUnit(props.right),
+      bottom: addUnit(props.bottom)
+    }));
+    const onClick = (event) => {
+      var _a;
+      emit("click", event);
+      (_a = scrollParent.value) == null ? void 0 : _a.scrollTo({
+        top: 0,
+        behavior: props.immediate ? "auto" : "smooth"
+      });
+    };
+    const scroll = () => {
+      show.value = scrollParent.value ? getScrollTop(scrollParent.value) >= +props.offset : false;
+    };
+    const getTarget = () => {
+      const {
+        target
+      } = props;
+      if (typeof target === "string") {
+        const el = document.querySelector(target);
+        if (el) {
+          return el;
+        }
+      } else {
+        return target;
+      }
+    };
+    const updateTarget = () => {
+      if (inBrowser) {
+        nextTick(() => {
+          scrollParent.value = props.target ? getTarget() : getScrollParent(root.value);
+          scroll();
+        });
+      }
+    };
+    useEventListener("scroll", throttle(scroll, 100), {
+      target: scrollParent
+    });
+    onMounted(updateTarget);
+    onActivated(() => {
+      if (shouldReshow) {
+        show.value = true;
+        shouldReshow = false;
+      }
+    });
+    onDeactivated(() => {
+      if (show.value && props.teleport) {
+        show.value = false;
+        shouldReshow = true;
+      }
+    });
+    watch(() => props.target, updateTarget);
+    return () => {
+      const Content = createVNode("div", mergeProps({
+        "ref": !props.teleport ? root : void 0,
+        "class": bem({
+          active: show.value
+        }),
+        "style": style.value,
+        "onClick": onClick
+      }, attrs), [slots.default ? slots.default() : createVNode(Icon, {
+        "name": "back-top",
+        "class": bem("icon")
+      }, null)]);
+      if (props.teleport) {
+        return [createVNode("div", {
+          "ref": root,
+          "class": bem("placeholder")
+        }, null), createVNode(Teleport, {
+          "to": props.teleport
+        }, {
+          default: () => [Content]
+        })];
+      }
+      return Content;
+    };
+  }
+});
+export {
+  backTopProps,
+  stdin_default as default
+};

package/es/node_modules/vant/es/back-top/index.mjs

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

package/es/node_modules/vant/es/button/Button.mjs

@@ -0,0 +1,152 @@
+import { defineComponent, createVNode } from "vue";
+import { routeProps, useRoute } from "../composables/use-route.mjs";
+import { Icon } from "../icon/index.mjs";
+import { Loading } from "../loading/index.mjs";
+import { BORDER_SURROUND } from "../utils/constant.mjs";
+import { preventDefault } from "../utils/dom.mjs";
+import { createNamespace } from "../utils/create.mjs";
+import { extend } from "../utils/basic.mjs";
+import { makeStringProp, numericProp } from "../utils/props.mjs";
+const [name, bem] = createNamespace("button");
+const buttonProps = extend({}, routeProps, {
+  tag: makeStringProp("button"),
+  text: String,
+  icon: String,
+  type: makeStringProp("default"),
+  size: makeStringProp("normal"),
+  color: String,
+  block: Boolean,
+  plain: Boolean,
+  round: Boolean,
+  square: Boolean,
+  loading: Boolean,
+  hairline: Boolean,
+  disabled: Boolean,
+  iconPrefix: String,
+  nativeType: makeStringProp("button"),
+  loadingSize: numericProp,
+  loadingText: String,
+  loadingType: String,
+  iconPosition: makeStringProp("left")
+});
+var stdin_default = defineComponent({
+  name,
+  props: buttonProps,
+  emits: ["click"],
+  setup(props, {
+    emit,
+    slots
+  }) {
+    const route = useRoute();
+    const renderLoadingIcon = () => {
+      if (slots.loading) {
+        return slots.loading();
+      }
+      return createVNode(Loading, {
+        "size": props.loadingSize,
+        "type": props.loadingType,
+        "class": bem("loading")
+      }, null);
+    };
+    const renderIcon = () => {
+      if (props.loading) {
+        return renderLoadingIcon();
+      }
+      if (slots.icon) {
+        return createVNode("div", {
+          "class": bem("icon")
+        }, [slots.icon()]);
+      }
+      if (props.icon) {
+        return createVNode(Icon, {
+          "name": props.icon,
+          "class": bem("icon"),
+          "classPrefix": props.iconPrefix
+        }, null);
+      }
+    };
+    const renderText = () => {
+      let text;
+      if (props.loading) {
+        text = props.loadingText;
+      } else {
+        text = slots.default ? slots.default() : props.text;
+      }
+      if (text) {
+        return createVNode("span", {
+          "class": bem("text")
+        }, [text]);
+      }
+    };
+    const getStyle = () => {
+      const {
+        color,
+        plain
+      } = props;
+      if (color) {
+        const style = {
+          color: plain ? color : "white"
+        };
+        if (!plain) {
+          style.background = color;
+        }
+        if (color.includes("gradient")) {
+          style.border = 0;
+        } else {
+          style.borderColor = color;
+        }
+        return style;
+      }
+    };
+    const onClick = (event) => {
+      if (props.loading) {
+        preventDefault(event);
+      } else if (!props.disabled) {
+        emit("click", event);
+        route();
+      }
+    };
+    return () => {
+      const {
+        tag,
+        type,
+        size,
+        block,
+        round,
+        plain,
+        square,
+        loading,
+        disabled,
+        hairline,
+        nativeType,
+        iconPosition
+      } = props;
+      const classes = [bem([type, size, {
+        plain,
+        block,
+        round,
+        square,
+        loading,
+        disabled,
+        hairline
+      }]), {
+        [BORDER_SURROUND]: hairline
+      }];
+      return createVNode(tag, {
+        "type": nativeType,
+        "class": classes,
+        "style": getStyle(),
+        "disabled": disabled,
+        "onClick": onClick
+      }, {
+        default: () => [createVNode("div", {
+          "class": bem("content")
+        }, [iconPosition === "left" && renderIcon(), renderText(), iconPosition === "right" && renderIcon()])]
+      });
+    };
+  }
+});
+export {
+  buttonProps,
+  stdin_default as default
+};

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

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