@fecp/designer 5.5.113 → 5.5.115

package/lib/node_modules/vant/es/grid-item/GridItem.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const Vue = require("vue");
+const Grid = require("../grid/Grid.js");
+const index_esm = require("../../../@vant/use/dist/index.esm.js");
+const useRoute = require("../composables/use-route.js");
+const index$1 = require("../icon/index.js");
+const index = require("../badge/index.js");
+const constant = require("../utils/constant.js");
+const basic = require("../utils/basic.js");
+const props = require("../utils/props.js");
+const create = require("../utils/create.js");
+const format = require("../utils/format.js");
+const [name, bem] = create.createNamespace("grid-item");
+const gridItemProps = basic.extend({}, useRoute.routeProps, {
+  dot: Boolean,
+  text: String,
+  icon: String,
+  badge: props.numericProp,
+  iconColor: String,
+  iconPrefix: String,
+  badgeProps: Object
+});
+var stdin_default = Vue.defineComponent({
+  name,
+  props: gridItemProps,
+  setup(props2, {
+    slots
+  }) {
+    const {
+      parent,
+      index: index$2
+    } = index_esm.useParent(Grid.GRID_KEY);
+    const route = useRoute.useRoute();
+    if (!parent) {
+      return;
+    }
+    const rootStyle = Vue.computed(() => {
+      const {
+        square,
+        gutter,
+        columnNum
+      } = parent.props;
+      const percent = `${100 / +columnNum}%`;
+      const style = {
+        flexBasis: percent
+      };
+      if (square) {
+        style.paddingTop = percent;
+      } else if (gutter) {
+        const gutterValue = format.addUnit(gutter);
+        style.paddingRight = gutterValue;
+        if (index$2.value >= +columnNum) {
+          style.marginTop = gutterValue;
+        }
+      }
+      return style;
+    });
+    const contentStyle = Vue.computed(() => {
+      const {
+        square,
+        gutter
+      } = parent.props;
+      if (square && gutter) {
+        const gutterValue = format.addUnit(gutter);
+        return {
+          right: gutterValue,
+          bottom: gutterValue,
+          height: "auto"
+        };
+      }
+    });
+    const renderIcon = () => {
+      if (slots.icon) {
+        return Vue.createVNode(index.Badge, Vue.mergeProps({
+          "dot": props2.dot,
+          "content": props2.badge
+        }, props2.badgeProps), {
+          default: slots.icon
+        });
+      }
+      if (props2.icon) {
+        return Vue.createVNode(index$1.Icon, {
+          "dot": props2.dot,
+          "name": props2.icon,
+          "size": parent.props.iconSize,
+          "badge": props2.badge,
+          "class": bem("icon"),
+          "color": props2.iconColor,
+          "badgeProps": props2.badgeProps,
+          "classPrefix": props2.iconPrefix
+        }, null);
+      }
+    };
+    const renderText = () => {
+      if (slots.text) {
+        return slots.text();
+      }
+      if (props2.text) {
+        return Vue.createVNode("span", {
+          "class": bem("text")
+        }, [props2.text]);
+      }
+    };
+    const renderContent = () => {
+      if (slots.default) {
+        return slots.default();
+      }
+      return [renderIcon(), renderText()];
+    };
+    return () => {
+      const {
+        center,
+        border,
+        square,
+        gutter,
+        reverse,
+        direction,
+        clickable
+      } = parent.props;
+      const classes = [bem("content", [direction, {
+        center,
+        square,
+        reverse,
+        clickable,
+        surround: border && gutter
+      }]), {
+        [constant.BORDER]: border
+      }];
+      return Vue.createVNode("div", {
+        "class": [bem({
+          square
+        })],
+        "style": rootStyle.value
+      }, [Vue.createVNode("div", {
+        "role": clickable ? "button" : void 0,
+        "class": classes,
+        "style": contentStyle.value,
+        "tabindex": clickable ? 0 : void 0,
+        "onClick": route
+      }, [renderContent()])]);
+    };
+  }
+});
+exports.default = stdin_default;
+exports.gridItemProps = gridItemProps;

package/lib/node_modules/vant/es/grid-item/index.js

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

package/lib/node_modules/vant/es/highlight/Highlight.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const Vue = require("vue");
+const props = require("../utils/props.js");
+const create = require("../utils/create.js");
+const [name, bem] = create.createNamespace("highlight");
+const highlightProps = {
+  autoEscape: props.truthProp,
+  caseSensitive: Boolean,
+  highlightClass: String,
+  highlightTag: props.makeStringProp("span"),
+  keywords: props.makeRequiredProp([String, Array]),
+  sourceString: props.makeStringProp(""),
+  tag: props.makeStringProp("div"),
+  unhighlightClass: String,
+  unhighlightTag: props.makeStringProp("span")
+};
+var stdin_default = Vue.defineComponent({
+  name,
+  props: highlightProps,
+  setup(props2) {
+    const highlightChunks = Vue.computed(() => {
+      const {
+        autoEscape,
+        caseSensitive,
+        keywords,
+        sourceString
+      } = props2;
+      const flags = caseSensitive ? "g" : "gi";
+      const _keywords = Array.isArray(keywords) ? keywords : [keywords];
+      let chunks = _keywords.filter((keyword) => keyword).reduce((chunks2, keyword) => {
+        if (autoEscape) {
+          keyword = keyword.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        }
+        const regex = new RegExp(keyword, flags);
+        let match;
+        while (match = regex.exec(sourceString)) {
+          const start = match.index;
+          const end = regex.lastIndex;
+          if (start >= end) {
+            regex.lastIndex++;
+            continue;
+          }
+          chunks2.push({
+            start,
+            end,
+            highlight: true
+          });
+        }
+        return chunks2;
+      }, []);
+      chunks = chunks.sort((a, b) => a.start - b.start).reduce((chunks2, currentChunk) => {
+        const prevChunk = chunks2[chunks2.length - 1];
+        if (!prevChunk || currentChunk.start > prevChunk.end) {
+          const unhighlightStart = prevChunk ? prevChunk.end : 0;
+          const unhighlightEnd = currentChunk.start;
+          if (unhighlightStart !== unhighlightEnd) {
+            chunks2.push({
+              start: unhighlightStart,
+              end: unhighlightEnd,
+              highlight: false
+            });
+          }
+          chunks2.push(currentChunk);
+        } else {
+          prevChunk.end = Math.max(prevChunk.end, currentChunk.end);
+        }
+        return chunks2;
+      }, []);
+      const lastChunk = chunks[chunks.length - 1];
+      if (!lastChunk) {
+        chunks.push({
+          start: 0,
+          end: sourceString.length,
+          highlight: false
+        });
+      }
+      if (lastChunk && lastChunk.end < sourceString.length) {
+        chunks.push({
+          start: lastChunk.end,
+          end: sourceString.length,
+          highlight: false
+        });
+      }
+      return chunks;
+    });
+    const renderContent = () => {
+      const {
+        sourceString,
+        highlightClass,
+        unhighlightClass,
+        highlightTag,
+        unhighlightTag
+      } = props2;
+      return highlightChunks.value.map((chunk) => {
+        const {
+          start,
+          end,
+          highlight
+        } = chunk;
+        const text = sourceString.slice(start, end);
+        if (highlight) {
+          return Vue.createVNode(highlightTag, {
+            "class": [bem("tag"), highlightClass]
+          }, {
+            default: () => [text]
+          });
+        }
+        return Vue.createVNode(unhighlightTag, {
+          "class": unhighlightClass
+        }, {
+          default: () => [text]
+        });
+      });
+    };
+    return () => {
+      const {
+        tag
+      } = props2;
+      return Vue.createVNode(tag, {
+        "class": bem()
+      }, {
+        default: () => [renderContent()]
+      });
+    };
+  }
+});
+exports.default = stdin_default;
+exports.highlightProps = highlightProps;

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

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

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;