@fecp/designer 5.4.101 → 5.4.104

package/es/packages/mobile/node_modules/vant/es/icon/Icon.mjs

@@ -0,0 +1,61 @@
+import { defineComponent, inject, computed, createVNode, mergeProps } from "vue";
+import { Badge } from "../badge/index.mjs";
+import { CONFIG_PROVIDER_KEY } from "../config-provider/ConfigProvider.mjs";
+import { numericProp, makeStringProp } from "../utils/props.mjs";
+import { createNamespace } from "../utils/create.mjs";
+import { addUnit } from "../utils/format.mjs";
+const [name, bem] = createNamespace("icon");
+const isImage = (name2) => name2 == null ? void 0 : name2.includes("/");
+const iconProps = {
+  dot: Boolean,
+  tag: makeStringProp("i"),
+  name: String,
+  size: numericProp,
+  badge: numericProp,
+  color: String,
+  badgeProps: Object,
+  classPrefix: String
+};
+var stdin_default = defineComponent({
+  name,
+  props: iconProps,
+  setup(props, {
+    slots
+  }) {
+    const config = inject(CONFIG_PROVIDER_KEY, null);
+    const classPrefix = computed(() => props.classPrefix || (config == null ? void 0 : config.iconPrefix) || bem());
+    return () => {
+      const {
+        tag,
+        dot,
+        name: name2,
+        size,
+        badge,
+        color
+      } = props;
+      const isImageIcon = isImage(name2);
+      return createVNode(Badge, mergeProps({
+        "dot": dot,
+        "tag": tag,
+        "class": [classPrefix.value, isImageIcon ? "" : `${classPrefix.value}-${name2}`],
+        "style": {
+          color,
+          fontSize: addUnit(size)
+        },
+        "content": badge
+      }, props.badgeProps), {
+        default: () => {
+          var _a;
+          return [(_a = slots.default) == null ? void 0 : _a.call(slots), isImageIcon && createVNode("img", {
+            "class": bem("image"),
+            "src": name2
+          }, null)];
+        }
+      });
+    };
+  }
+});
+export {
+  stdin_default as default,
+  iconProps
+};

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

@@ -0,0 +1,10 @@
+import stdin_default$1 from "./Icon.mjs";
+import { iconProps } from "./Icon.mjs";
+import { withInstall } from "../utils/with-install.mjs";
+const Icon = withInstall(stdin_default$1);
+var stdin_default = Icon;
+export {
+  Icon,
+  stdin_default as default,
+  iconProps
+};

package/es/packages/mobile/node_modules/vant/es/image/Image.mjs

@@ -0,0 +1,179 @@
+import { defineComponent, ref, getCurrentInstance, computed, watch, onBeforeUnmount, onMounted, nextTick, createVNode, withDirectives, mergeProps, resolveDirective } from "vue";
+import { Icon } from "../icon/index.mjs";
+import { makeStringProp, truthProp, numericProp } from "../utils/props.mjs";
+import { createNamespace } from "../utils/create.mjs";
+import { addUnit } from "../utils/format.mjs";
+import { isDef, inBrowser } from "../utils/basic.mjs";
+const [name, bem] = createNamespace("image");
+const imageProps = {
+  src: String,
+  alt: String,
+  fit: String,
+  position: String,
+  round: Boolean,
+  block: Boolean,
+  width: numericProp,
+  height: numericProp,
+  radius: numericProp,
+  lazyLoad: Boolean,
+  iconSize: numericProp,
+  showError: truthProp,
+  errorIcon: makeStringProp("photo-fail"),
+  iconPrefix: String,
+  showLoading: truthProp,
+  loadingIcon: makeStringProp("photo"),
+  crossorigin: String,
+  referrerpolicy: String,
+  decoding: String
+};
+var stdin_default = defineComponent({
+  name,
+  props: imageProps,
+  emits: ["load", "error"],
+  setup(props, {
+    emit,
+    slots
+  }) {
+    const error = ref(false);
+    const loading = ref(true);
+    const imageRef = ref();
+    const {
+      $Lazyload
+    } = getCurrentInstance().proxy;
+    const style = computed(() => {
+      const style2 = {
+        width: addUnit(props.width),
+        height: addUnit(props.height)
+      };
+      if (isDef(props.radius)) {
+        style2.overflow = "hidden";
+        style2.borderRadius = addUnit(props.radius);
+      }
+      return style2;
+    });
+    watch(() => props.src, () => {
+      error.value = false;
+      loading.value = true;
+    });
+    const onLoad = (event) => {
+      if (loading.value) {
+        loading.value = false;
+        emit("load", event);
+      }
+    };
+    const triggerLoad = () => {
+      const loadEvent = new Event("load");
+      Object.defineProperty(loadEvent, "target", {
+        value: imageRef.value,
+        enumerable: true
+      });
+      onLoad(loadEvent);
+    };
+    const onError = (event) => {
+      error.value = true;
+      loading.value = false;
+      emit("error", event);
+    };
+    const renderIcon = (name2, className, slot) => {
+      if (slot) {
+        return slot();
+      }
+      return createVNode(Icon, {
+        "name": name2,
+        "size": props.iconSize,
+        "class": className,
+        "classPrefix": props.iconPrefix
+      }, null);
+    };
+    const renderPlaceholder = () => {
+      if (loading.value && props.showLoading) {
+        return createVNode("div", {
+          "class": bem("loading")
+        }, [renderIcon(props.loadingIcon, bem("loading-icon"), slots.loading)]);
+      }
+      if (error.value && props.showError) {
+        return createVNode("div", {
+          "class": bem("error")
+        }, [renderIcon(props.errorIcon, bem("error-icon"), slots.error)]);
+      }
+    };
+    const renderImage = () => {
+      if (error.value || !props.src) {
+        return;
+      }
+      const attrs = {
+        alt: props.alt,
+        class: bem("img"),
+        decoding: props.decoding,
+        style: {
+          objectFit: props.fit,
+          objectPosition: props.position
+        },
+        crossorigin: props.crossorigin,
+        referrerpolicy: props.referrerpolicy
+      };
+      if (props.lazyLoad) {
+        return withDirectives(createVNode("img", mergeProps({
+          "ref": imageRef
+        }, attrs), null), [[resolveDirective("lazy"), props.src]]);
+      }
+      return createVNode("img", mergeProps({
+        "ref": imageRef,
+        "src": props.src,
+        "onLoad": onLoad,
+        "onError": onError
+      }, attrs), null);
+    };
+    const onLazyLoaded = ({
+      el
+    }) => {
+      const check = () => {
+        if (el === imageRef.value && loading.value) {
+          triggerLoad();
+        }
+      };
+      if (imageRef.value) {
+        check();
+      } else {
+        nextTick(check);
+      }
+    };
+    const onLazyLoadError = ({
+      el
+    }) => {
+      if (el === imageRef.value && !error.value) {
+        onError();
+      }
+    };
+    if ($Lazyload && inBrowser) {
+      $Lazyload.$on("loaded", onLazyLoaded);
+      $Lazyload.$on("error", onLazyLoadError);
+      onBeforeUnmount(() => {
+        $Lazyload.$off("loaded", onLazyLoaded);
+        $Lazyload.$off("error", onLazyLoadError);
+      });
+    }
+    onMounted(() => {
+      nextTick(() => {
+        var _a;
+        if (((_a = imageRef.value) == null ? void 0 : _a.complete) && !props.lazyLoad) {
+          triggerLoad();
+        }
+      });
+    });
+    return () => {
+      var _a;
+      return createVNode("div", {
+        "class": bem({
+          round: props.round,
+          block: props.block
+        }),
+        "style": style.value
+      }, [renderImage(), renderPlaceholder(), (_a = slots.default) == null ? void 0 : _a.call(slots)]);
+    };
+  }
+});
+export {
+  stdin_default as default,
+  imageProps
+};

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

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

package/es/packages/mobile/node_modules/vant/es/image-preview/ImagePreview.mjs

@@ -0,0 +1,201 @@
+import { defineComponent, ref, reactive, onMounted, watch, nextTick, createVNode, mergeProps } from "vue";
+import { useRect } from "../../../@vant/use/dist/index.esm.mjs";
+import { useExpose } from "../composables/use-expose.mjs";
+import { Icon } from "../icon/index.mjs";
+import { Swipe } from "../swipe/index.mjs";
+import { Popup } from "../popup/index.mjs";
+import stdin_default$1 from "./ImagePreviewItem.mjs";
+import { makeStringProp, truthProp, makeNumericProp, unknownProp, makeArrayProp } from "../utils/props.mjs";
+import { createNamespace } from "../utils/create.mjs";
+import { windowWidth, windowHeight } from "../utils/dom.mjs";
+import { pick } from "../utils/basic.mjs";
+import { HAPTICS_FEEDBACK } from "../utils/constant.mjs";
+import { callInterceptor } from "../utils/interceptor.mjs";
+const [name, bem] = createNamespace("image-preview");
+const popupProps = ["show", "teleport", "transition", "overlayStyle", "closeOnPopstate"];
+const imagePreviewProps = {
+  show: Boolean,
+  loop: truthProp,
+  images: makeArrayProp(),
+  minZoom: makeNumericProp(1 / 3),
+  maxZoom: makeNumericProp(3),
+  overlay: truthProp,
+  vertical: Boolean,
+  closeable: Boolean,
+  showIndex: truthProp,
+  className: unknownProp,
+  closeIcon: makeStringProp("clear"),
+  transition: String,
+  beforeClose: Function,
+  doubleScale: truthProp,
+  overlayClass: unknownProp,
+  overlayStyle: Object,
+  swipeDuration: makeNumericProp(300),
+  startPosition: makeNumericProp(0),
+  showIndicators: Boolean,
+  closeOnPopstate: truthProp,
+  closeOnClickImage: truthProp,
+  closeOnClickOverlay: truthProp,
+  closeIconPosition: makeStringProp("top-right"),
+  teleport: [String, Object]
+};
+var stdin_default = defineComponent({
+  name,
+  props: imagePreviewProps,
+  emits: ["scale", "close", "closed", "change", "longPress", "update:show"],
+  setup(props, {
+    emit,
+    slots
+  }) {
+    const swipeRef = ref();
+    const activedPreviewItemRef = ref();
+    const state = reactive({
+      active: 0,
+      rootWidth: 0,
+      rootHeight: 0,
+      disableZoom: false
+    });
+    const resize = () => {
+      if (swipeRef.value) {
+        const rect = useRect(swipeRef.value.$el);
+        state.rootWidth = rect.width;
+        state.rootHeight = rect.height;
+        swipeRef.value.resize();
+      }
+    };
+    const emitScale = (args) => emit("scale", args);
+    const updateShow = (show) => emit("update:show", show);
+    const emitClose = () => {
+      callInterceptor(props.beforeClose, {
+        args: [state.active],
+        done: () => updateShow(false)
+      });
+    };
+    const setActive = (active) => {
+      if (active !== state.active) {
+        state.active = active;
+        emit("change", active);
+      }
+    };
+    const renderIndex = () => {
+      if (props.showIndex) {
+        return createVNode("div", {
+          "class": bem("index")
+        }, [slots.index ? slots.index({
+          index: state.active
+        }) : `${state.active + 1} / ${props.images.length}`]);
+      }
+    };
+    const renderCover = () => {
+      if (slots.cover) {
+        return createVNode("div", {
+          "class": bem("cover")
+        }, [slots.cover()]);
+      }
+    };
+    const onDragStart = () => {
+      state.disableZoom = true;
+    };
+    const onDragEnd = () => {
+      state.disableZoom = false;
+    };
+    const renderImages = () => createVNode(Swipe, {
+      "ref": swipeRef,
+      "lazyRender": true,
+      "loop": props.loop,
+      "class": bem("swipe"),
+      "vertical": props.vertical,
+      "duration": props.swipeDuration,
+      "initialSwipe": props.startPosition,
+      "showIndicators": props.showIndicators,
+      "indicatorColor": "white",
+      "onChange": setActive,
+      "onDragEnd": onDragEnd,
+      "onDragStart": onDragStart
+    }, {
+      default: () => [props.images.map((image, index) => createVNode(stdin_default$1, {
+        "ref": (item) => {
+          if (index === state.active) {
+            activedPreviewItemRef.value = item;
+          }
+        },
+        "src": image,
+        "show": props.show,
+        "active": state.active,
+        "maxZoom": props.maxZoom,
+        "minZoom": props.minZoom,
+        "rootWidth": state.rootWidth,
+        "rootHeight": state.rootHeight,
+        "disableZoom": state.disableZoom,
+        "doubleScale": props.doubleScale,
+        "closeOnClickImage": props.closeOnClickImage,
+        "closeOnClickOverlay": props.closeOnClickOverlay,
+        "vertical": props.vertical,
+        "onScale": emitScale,
+        "onClose": emitClose,
+        "onLongPress": () => emit("longPress", {
+          index
+        })
+      }, {
+        image: slots.image
+      }))]
+    });
+    const renderClose = () => {
+      if (props.closeable) {
+        return createVNode(Icon, {
+          "role": "button",
+          "name": props.closeIcon,
+          "class": [bem("close-icon", props.closeIconPosition), HAPTICS_FEEDBACK],
+          "onClick": emitClose
+        }, null);
+      }
+    };
+    const onClosed = () => emit("closed");
+    const swipeTo = (index, options) => {
+      var _a;
+      return (_a = swipeRef.value) == null ? void 0 : _a.swipeTo(index, options);
+    };
+    useExpose({
+      resetScale: () => {
+        var _a;
+        (_a = activedPreviewItemRef.value) == null ? void 0 : _a.resetScale();
+      },
+      swipeTo
+    });
+    onMounted(resize);
+    watch([windowWidth, windowHeight], resize);
+    watch(() => props.startPosition, (value) => setActive(+value));
+    watch(() => props.show, (value) => {
+      const {
+        images,
+        startPosition
+      } = props;
+      if (value) {
+        setActive(+startPosition);
+        nextTick(() => {
+          resize();
+          swipeTo(+startPosition, {
+            immediate: true
+          });
+        });
+      } else {
+        emit("close", {
+          index: state.active,
+          url: images[state.active]
+        });
+      }
+    });
+    return () => createVNode(Popup, mergeProps({
+      "class": [bem(), props.className],
+      "overlayClass": [bem("overlay"), props.overlayClass],
+      "onClosed": onClosed,
+      "onUpdate:show": updateShow
+    }, pick(props, popupProps)), {
+      default: () => [renderClose(), renderImages(), renderIndex(), renderCover()]
+    });
+  }
+});
+export {
+  stdin_default as default,
+  imagePreviewProps
+};