@fecp/designer 5.5.112 → 5.5.114

package/lib/node_modules/vant/es/icon/Icon.js

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

package/lib/node_modules/vant/es/icon/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const Icon$1 = require("./Icon.js");
+const withInstall = require("../utils/with-install.js");
+const Icon = withInstall.withInstall(Icon$1.default);
+var stdin_default = Icon;
+exports.iconProps = Icon$1.iconProps;
+exports.Icon = Icon;
+exports.default = stdin_default;

package/lib/node_modules/vant/es/image/Image.js

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

package/lib/node_modules/vant/es/image/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const Image$1 = require("./Image.js");
+const withInstall = require("../utils/with-install.js");
+const Image = withInstall.withInstall(Image$1.default);
+exports.imageProps = Image$1.imageProps;
+exports.Image = Image;

package/lib/node_modules/vant/es/image-preview/ImagePreview.js

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