@fecp/mobile-designer 1.0.9 → 1.0.11

package/es/node_modules/vant/es/tab/Tab.mjs

@@ -0,0 +1,153 @@
+import { defineComponent, ref, getCurrentInstance, computed, watchEffect, watch, provide, createVNode, withDirectives, vShow, nextTick, mergeProps } from "vue";
+import { normalizeClass, stringifyStyle, normalizeStyle } from "../../../@vue/shared/dist/shared.esm-bundler.mjs";
+import { TABS_KEY } from "../tabs/Tabs.mjs";
+import { useParent, doubleRaf } from "../../../@vant/use/dist/index.esm.mjs";
+import { useId } from "../composables/use-id.mjs";
+import { useExpose } from "../composables/use-expose.mjs";
+import { routeProps } from "../composables/use-route.mjs";
+import { TAB_STATUS_KEY } from "../composables/use-tab-status.mjs";
+import { TabTitle } from "./TabTitle.mjs";
+import { SwipeItem } from "../swipe-item/index.mjs";
+import { extend, pick } from "../utils/basic.mjs";
+import { createNamespace } from "../utils/create.mjs";
+import { truthProp, unknownProp, numericProp } from "../utils/props.mjs";
+const [name, bem] = createNamespace("tab");
+const tabProps = extend({}, routeProps, {
+  dot: Boolean,
+  name: numericProp,
+  badge: numericProp,
+  title: String,
+  disabled: Boolean,
+  titleClass: unknownProp,
+  titleStyle: [String, Object],
+  showZeroBadge: truthProp
+});
+var stdin_default = defineComponent({
+  name,
+  props: tabProps,
+  setup(props, {
+    slots
+  }) {
+    const id = useId();
+    const inited = ref(false);
+    const instance = getCurrentInstance();
+    const {
+      parent,
+      index
+    } = useParent(TABS_KEY);
+    if (!parent) {
+      return;
+    }
+    const getName = () => {
+      var _a;
+      return (_a = props.name) != null ? _a : index.value;
+    };
+    const init = () => {
+      inited.value = true;
+      if (parent.props.lazyRender) {
+        nextTick(() => {
+          parent.onRendered(getName(), props.title);
+        });
+      }
+    };
+    const active = computed(() => {
+      const isActive = getName() === parent.currentName.value;
+      if (isActive && !inited.value) {
+        init();
+      }
+      return isActive;
+    });
+    const parsedClass = ref("");
+    const parsedStyle = ref("");
+    watchEffect(() => {
+      const {
+        titleClass,
+        titleStyle
+      } = props;
+      parsedClass.value = titleClass ? normalizeClass(titleClass) : "";
+      parsedStyle.value = titleStyle && typeof titleStyle !== "string" ? stringifyStyle(normalizeStyle(titleStyle)) : titleStyle;
+    });
+    const renderTitle = (onClickTab) => createVNode(TabTitle, mergeProps({
+      "key": id,
+      "id": `${parent.id}-${index.value}`,
+      "ref": parent.setTitleRefs(index.value),
+      "style": parsedStyle.value,
+      "class": parsedClass.value,
+      "isActive": active.value,
+      "controls": id,
+      "scrollable": parent.scrollable.value,
+      "activeColor": parent.props.titleActiveColor,
+      "inactiveColor": parent.props.titleInactiveColor,
+      "onClick": (event) => onClickTab(instance.proxy, index.value, event)
+    }, pick(parent.props, ["type", "color", "shrink"]), pick(props, ["dot", "badge", "title", "disabled", "showZeroBadge"])), {
+      title: slots.title
+    });
+    const hasInactiveClass = ref(!active.value);
+    watch(active, (val) => {
+      if (val) {
+        hasInactiveClass.value = false;
+      } else {
+        doubleRaf(() => {
+          hasInactiveClass.value = true;
+        });
+      }
+    });
+    watch(() => props.title, () => {
+      parent.setLine();
+      parent.scrollIntoView();
+    });
+    provide(TAB_STATUS_KEY, active);
+    useExpose({
+      id,
+      renderTitle
+    });
+    return () => {
+      var _a;
+      const label = `${parent.id}-${index.value}`;
+      const {
+        animated,
+        swipeable,
+        scrollspy,
+        lazyRender
+      } = parent.props;
+      if (!slots.default && !animated) {
+        return;
+      }
+      const show = scrollspy || active.value;
+      if (animated || swipeable) {
+        return createVNode(SwipeItem, {
+          "id": id,
+          "role": "tabpanel",
+          "class": bem("panel-wrapper", {
+            inactive: hasInactiveClass.value
+          }),
+          "tabindex": active.value ? 0 : -1,
+          "aria-hidden": !active.value,
+          "aria-labelledby": label,
+          "data-allow-mismatch": "attribute"
+        }, {
+          default: () => {
+            var _a2;
+            return [createVNode("div", {
+              "class": bem("panel")
+            }, [(_a2 = slots.default) == null ? void 0 : _a2.call(slots)])];
+          }
+        });
+      }
+      const shouldRender = inited.value || scrollspy || !lazyRender;
+      const Content = shouldRender ? (_a = slots.default) == null ? void 0 : _a.call(slots) : null;
+      return withDirectives(createVNode("div", {
+        "id": id,
+        "role": "tabpanel",
+        "class": bem("panel"),
+        "tabindex": show ? 0 : -1,
+        "aria-labelledby": label,
+        "data-allow-mismatch": "attribute"
+      }, [Content]), [[vShow, show]]);
+    };
+  }
+});
+export {
+  stdin_default as default,
+  tabProps
+};

package/es/node_modules/vant/es/tab/TabTitle.mjs

@@ -0,0 +1,92 @@
+import { defineComponent, computed, createVNode } from "vue";
+import { Badge } from "../badge/index.mjs";
+import { truthProp, numericProp } from "../utils/props.mjs";
+import { createNamespace } from "../utils/create.mjs";
+import { isDef } from "../utils/basic.mjs";
+const [name, bem] = createNamespace("tab");
+const TabTitle = defineComponent({
+  name,
+  props: {
+    id: String,
+    dot: Boolean,
+    type: String,
+    color: String,
+    title: String,
+    badge: numericProp,
+    shrink: Boolean,
+    isActive: Boolean,
+    disabled: Boolean,
+    controls: String,
+    scrollable: Boolean,
+    activeColor: String,
+    inactiveColor: String,
+    showZeroBadge: truthProp
+  },
+  setup(props, {
+    slots
+  }) {
+    const style = computed(() => {
+      const style2 = {};
+      const {
+        type,
+        color,
+        disabled,
+        isActive,
+        activeColor,
+        inactiveColor
+      } = props;
+      const isCard = type === "card";
+      if (color && isCard) {
+        style2.borderColor = color;
+        if (!disabled) {
+          if (isActive) {
+            style2.backgroundColor = color;
+          } else {
+            style2.color = color;
+          }
+        }
+      }
+      const titleColor = isActive ? activeColor : inactiveColor;
+      if (titleColor) {
+        style2.color = titleColor;
+      }
+      return style2;
+    });
+    const renderText = () => {
+      const Text = createVNode("span", {
+        "class": bem("text", {
+          ellipsis: !props.scrollable
+        })
+      }, [slots.title ? slots.title() : props.title]);
+      if (props.dot || isDef(props.badge) && props.badge !== "") {
+        return createVNode(Badge, {
+          "dot": props.dot,
+          "content": props.badge,
+          "showZero": props.showZeroBadge
+        }, {
+          default: () => [Text]
+        });
+      }
+      return Text;
+    };
+    return () => createVNode("div", {
+      "id": props.id,
+      "role": "tab",
+      "class": [bem([props.type, {
+        grow: props.scrollable && !props.shrink,
+        shrink: props.shrink,
+        active: props.isActive,
+        disabled: props.disabled
+      }])],
+      "style": style.value,
+      "tabindex": props.disabled ? void 0 : props.isActive ? 0 : -1,
+      "aria-selected": props.isActive,
+      "aria-disabled": props.disabled || void 0,
+      "aria-controls": props.controls,
+      "data-allow-mismatch": "attribute"
+    }, [renderText()]);
+  }
+});
+export {
+  TabTitle
+};

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

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

package/es/node_modules/vant/es/tabbar/Tabbar.mjs

@@ -0,0 +1,88 @@
+import { defineComponent, ref, createVNode } from "vue";
+import { useChildren } from "../../../@vant/use/dist/index.esm.mjs";
+import { usePlaceholder } from "../composables/use-placeholder.mjs";
+import { makeNumericProp, numericProp, truthProp } from "../utils/props.mjs";
+import { createNamespace } from "../utils/create.mjs";
+import { callInterceptor } from "../utils/interceptor.mjs";
+import { getZIndexStyle } from "../utils/format.mjs";
+import { BORDER_TOP_BOTTOM } from "../utils/constant.mjs";
+const [name, bem] = createNamespace("tabbar");
+const tabbarProps = {
+  route: Boolean,
+  fixed: truthProp,
+  border: truthProp,
+  zIndex: numericProp,
+  placeholder: Boolean,
+  activeColor: String,
+  beforeChange: Function,
+  inactiveColor: String,
+  modelValue: makeNumericProp(0),
+  safeAreaInsetBottom: {
+    type: Boolean,
+    default: null
+  }
+};
+const TABBAR_KEY = Symbol(name);
+var stdin_default = defineComponent({
+  name,
+  props: tabbarProps,
+  emits: ["change", "update:modelValue"],
+  setup(props, {
+    emit,
+    slots
+  }) {
+    const root = ref();
+    const {
+      linkChildren
+    } = useChildren(TABBAR_KEY);
+    const renderPlaceholder = usePlaceholder(root, bem);
+    const enableSafeArea = () => {
+      var _a;
+      return (_a = props.safeAreaInsetBottom) != null ? _a : props.fixed;
+    };
+    const renderTabbar = () => {
+      var _a;
+      const {
+        fixed,
+        zIndex,
+        border
+      } = props;
+      return createVNode("div", {
+        "ref": root,
+        "role": "tablist",
+        "style": getZIndexStyle(zIndex),
+        "class": [bem({
+          fixed
+        }), {
+          [BORDER_TOP_BOTTOM]: border,
+          "van-safe-area-bottom": enableSafeArea()
+        }]
+      }, [(_a = slots.default) == null ? void 0 : _a.call(slots)]);
+    };
+    const setActive = (active, afterChange) => {
+      callInterceptor(props.beforeChange, {
+        args: [active],
+        done() {
+          emit("update:modelValue", active);
+          emit("change", active);
+          afterChange();
+        }
+      });
+    };
+    linkChildren({
+      props,
+      setActive
+    });
+    return () => {
+      if (props.fixed && props.placeholder) {
+        return renderPlaceholder(renderTabbar);
+      }
+      return renderTabbar();
+    };
+  }
+});
+export {
+  TABBAR_KEY,
+  stdin_default as default,
+  tabbarProps
+};

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

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

package/es/node_modules/vant/es/tabbar-item/TabbarItem.mjs

@@ -0,0 +1,119 @@
+import { defineComponent, getCurrentInstance, computed, createVNode, mergeProps } from "vue";
+import { TABBAR_KEY } from "../tabbar/Tabbar.mjs";
+import { useParent } from "../../../@vant/use/dist/index.esm.mjs";
+import { useRoute, routeProps } from "../composables/use-route.mjs";
+import { Icon } from "../icon/index.mjs";
+import { Badge } from "../badge/index.mjs";
+import { extend, isObject } from "../utils/basic.mjs";
+import { createNamespace } from "../utils/create.mjs";
+import { numericProp } from "../utils/props.mjs";
+const [name, bem] = createNamespace("tabbar-item");
+const tabbarItemProps = extend({}, routeProps, {
+  dot: Boolean,
+  icon: String,
+  name: numericProp,
+  badge: numericProp,
+  badgeProps: Object,
+  iconPrefix: String
+});
+var stdin_default = defineComponent({
+  name,
+  props: tabbarItemProps,
+  emits: ["click"],
+  setup(props, {
+    emit,
+    slots
+  }) {
+    const route = useRoute();
+    const vm = getCurrentInstance().proxy;
+    const {
+      parent,
+      index
+    } = useParent(TABBAR_KEY);
+    if (!parent) {
+      return;
+    }
+    const active = computed(() => {
+      var _a;
+      const {
+        route: route2,
+        modelValue
+      } = parent.props;
+      if (route2 && "$route" in vm) {
+        const {
+          $route
+        } = vm;
+        const {
+          to
+        } = props;
+        const config = isObject(to) ? to : {
+          path: to
+        };
+        return !!$route.matched.find((val) => {
+          const pathMatched = "path" in config && config.path === val.path;
+          const nameMatched = "name" in config && config.name === val.name;
+          return pathMatched || nameMatched;
+        });
+      }
+      return ((_a = props.name) != null ? _a : index.value) === modelValue;
+    });
+    const onClick = (event) => {
+      var _a;
+      if (!active.value) {
+        parent.setActive((_a = props.name) != null ? _a : index.value, route);
+      }
+      emit("click", event);
+    };
+    const renderIcon = () => {
+      if (slots.icon) {
+        return slots.icon({
+          active: active.value
+        });
+      }
+      if (props.icon) {
+        return createVNode(Icon, {
+          "name": props.icon,
+          "classPrefix": props.iconPrefix
+        }, null);
+      }
+    };
+    return () => {
+      var _a;
+      const {
+        dot,
+        badge
+      } = props;
+      const {
+        activeColor,
+        inactiveColor
+      } = parent.props;
+      const color = active.value ? activeColor : inactiveColor;
+      return createVNode("div", {
+        "role": "tab",
+        "class": bem({
+          active: active.value
+        }),
+        "style": {
+          color
+        },
+        "tabindex": 0,
+        "aria-selected": active.value,
+        "onClick": onClick
+      }, [createVNode(Badge, mergeProps({
+        "dot": dot,
+        "class": bem("icon"),
+        "content": badge
+      }, props.badgeProps), {
+        default: renderIcon
+      }), createVNode("div", {
+        "class": bem("text")
+      }, [(_a = slots.default) == null ? void 0 : _a.call(slots, {
+        active: active.value
+      })])]);
+    };
+  }
+});
+export {
+  stdin_default as default,
+  tabbarItemProps
+};

package/es/node_modules/vant/es/tabbar-item/index.mjs

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