@fecp/designer 5.4.100 → 5.4.104

package/lib/packages/mobile/node_modules/vant/es/floating-panel/FloatingPanel.js

@@ -0,0 +1,162 @@
+"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 useLockScroll = require("../composables/use-lock-scroll.js");
+const useTouch = require("../composables/use-touch.js");
+const useSyncPropRef = require("../composables/use-sync-prop-ref.js");
+const props = require("../utils/props.js");
+const create = require("../utils/create.js");
+const dom = require("../utils/dom.js");
+const format = require("../utils/format.js");
+const closest = require("../utils/closest.js");
+const floatingPanelProps = {
+  height: props.makeNumericProp(0),
+  anchors: props.makeArrayProp(),
+  duration: props.makeNumericProp(0.3),
+  magnetic: props.truthProp,
+  draggable: props.truthProp,
+  contentDraggable: props.truthProp,
+  lockScroll: Boolean,
+  safeAreaInsetBottom: props.truthProp
+};
+const [name, bem] = create.createNamespace("floating-panel");
+var stdin_default = vue.defineComponent({
+  name,
+  props: floatingPanelProps,
+  emits: ["heightChange", "update:height"],
+  setup(props2, {
+    emit,
+    slots
+  }) {
+    const DAMP = 0.2;
+    const rootRef = vue.ref();
+    const contentRef = vue.ref();
+    const height = useSyncPropRef.useSyncPropRef(() => +props2.height, (value) => emit("update:height", value));
+    const boundary = vue.computed(() => {
+      var _a, _b;
+      return {
+        min: (_a = props2.anchors[0]) != null ? _a : 100,
+        max: (_b = props2.anchors[props2.anchors.length - 1]) != null ? _b : Math.round(dom.windowHeight.value * 0.6)
+      };
+    });
+    const anchors = vue.computed(() => props2.anchors.length >= 2 ? props2.anchors : [boundary.value.min, boundary.value.max]);
+    const dragging = vue.ref(false);
+    const rootStyle = vue.computed(() => ({
+      height: format.addUnit(boundary.value.max),
+      transform: `translateY(calc(100% + ${format.addUnit(-height.value)}))`,
+      transition: !dragging.value ? `transform ${props2.duration}s cubic-bezier(0.18, 0.89, 0.32, 1.28)` : "none"
+    }));
+    const ease = (moveY) => {
+      const absDistance = Math.abs(moveY);
+      const {
+        min,
+        max
+      } = boundary.value;
+      if (absDistance > max) {
+        return -(max + (absDistance - max) * DAMP);
+      }
+      if (absDistance < min) {
+        return -(min - (min - absDistance) * DAMP);
+      }
+      return moveY;
+    };
+    let startY;
+    let maxScroll = -1;
+    const touch = useTouch.useTouch();
+    const onTouchstart = (e) => {
+      if (!props2.draggable) return;
+      touch.start(e);
+      dragging.value = true;
+      startY = -height.value;
+      maxScroll = -1;
+    };
+    const onTouchmove = (e) => {
+      var _a;
+      if (!props2.draggable) return;
+      touch.move(e);
+      const target = e.target;
+      if (contentRef.value === target || ((_a = contentRef.value) == null ? void 0 : _a.contains(target))) {
+        const {
+          scrollTop
+        } = contentRef.value;
+        maxScroll = Math.max(maxScroll, scrollTop);
+        if (!props2.contentDraggable) return;
+        if (-startY < boundary.value.max) {
+          dom.preventDefault(e, true);
+        } else if (!(scrollTop <= 0 && touch.deltaY.value > 0) || maxScroll > 0) {
+          return;
+        }
+      }
+      const moveY = touch.deltaY.value + startY;
+      height.value = -ease(moveY);
+    };
+    const onTouchend = () => {
+      maxScroll = -1;
+      if (!dragging.value) {
+        return;
+      }
+      dragging.value = false;
+      if (!props2.draggable) {
+        return;
+      }
+      if (props2.magnetic) {
+        height.value = closest.closest(anchors.value, height.value);
+      } else {
+        const {
+          min,
+          max
+        } = boundary.value;
+        height.value = Math.max(min, Math.min(max, height.value));
+      }
+      if (height.value !== -startY) {
+        emit("heightChange", {
+          height: height.value
+        });
+      }
+    };
+    vue.watch(boundary, () => {
+      height.value = closest.closest(anchors.value, height.value);
+    }, {
+      immediate: true
+    });
+    useLockScroll.useLockScroll(rootRef, () => props2.lockScroll || dragging.value);
+    index_esm.useEventListener("touchmove", onTouchmove, {
+      target: rootRef
+    });
+    const renderHeader = () => {
+      if (slots.header) {
+        return slots.header();
+      }
+      if (!props2.draggable) {
+        return null;
+      }
+      return vue.createVNode("div", {
+        "class": bem("header")
+      }, [vue.createVNode("div", {
+        "class": bem("header-bar")
+      }, null)]);
+    };
+    return () => {
+      var _a;
+      return vue.createVNode("div", {
+        "class": [bem(), {
+          "van-safe-area-bottom": props2.safeAreaInsetBottom
+        }],
+        "ref": rootRef,
+        "style": rootStyle.value,
+        "onTouchstartPassive": onTouchstart,
+        "onTouchend": onTouchend,
+        "onTouchcancel": onTouchend
+      }, [renderHeader(), vue.createVNode("div", {
+        "class": bem("content"),
+        "ref": contentRef,
+        "style": {
+          paddingBottom: format.addUnit(boundary.value.max - height.value)
+        }
+      }, [(_a = slots.default) == null ? void 0 : _a.call(slots)])]);
+    };
+  }
+});
+exports.default = stdin_default;
+exports.floatingPanelProps = floatingPanelProps;

package/lib/packages/mobile/node_modules/vant/es/floating-panel/index.js

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

package/lib/packages/mobile/node_modules/vant/es/form/Form.js

@@ -0,0 +1,171 @@
+"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 constant = require("../utils/constant.js");
+const props = require("../utils/props.js");
+const create = require("../utils/create.js");
+const dom = require("../utils/dom.js");
+const [name, bem] = create.createNamespace("form");
+const formProps = {
+  colon: Boolean,
+  disabled: Boolean,
+  readonly: Boolean,
+  required: [Boolean, String],
+  showError: Boolean,
+  labelWidth: props.numericProp,
+  labelAlign: String,
+  inputAlign: String,
+  scrollToError: Boolean,
+  scrollToErrorPosition: String,
+  validateFirst: Boolean,
+  submitOnEnter: props.truthProp,
+  showErrorMessage: props.truthProp,
+  errorMessageAlign: String,
+  validateTrigger: {
+    type: [String, Array],
+    default: "onBlur"
+  }
+};
+var stdin_default = vue.defineComponent({
+  name,
+  props: formProps,
+  emits: ["submit", "failed"],
+  setup(props2, {
+    emit,
+    slots
+  }) {
+    const {
+      children,
+      linkChildren
+    } = index_esm.useChildren(constant.FORM_KEY);
+    const getFieldsByNames = (names) => {
+      if (names) {
+        return children.filter((field) => names.includes(field.name));
+      }
+      return children;
+    };
+    const validateSeq = (names) => new Promise((resolve, reject) => {
+      const errors = [];
+      const fields = getFieldsByNames(names);
+      fields.reduce((promise, field) => promise.then(() => {
+        if (!errors.length) {
+          return field.validate().then((error) => {
+            if (error) {
+              errors.push(error);
+            }
+          });
+        }
+      }), Promise.resolve()).then(() => {
+        if (errors.length) {
+          reject(errors);
+        } else {
+          resolve();
+        }
+      });
+    });
+    const validateAll = (names) => new Promise((resolve, reject) => {
+      const fields = getFieldsByNames(names);
+      Promise.all(fields.map((item) => item.validate())).then((errors) => {
+        errors = errors.filter(Boolean);
+        if (errors.length) {
+          reject(errors);
+        } else {
+          resolve();
+        }
+      });
+    });
+    const validateField = (name2) => {
+      const matched = children.find((item) => item.name === name2);
+      if (matched) {
+        return new Promise((resolve, reject) => {
+          matched.validate().then((error) => {
+            if (error) {
+              reject(error);
+            } else {
+              resolve();
+            }
+          });
+        });
+      }
+      return Promise.reject();
+    };
+    const validate = (name2) => {
+      if (typeof name2 === "string") {
+        return validateField(name2);
+      }
+      return props2.validateFirst ? validateSeq(name2) : validateAll(name2);
+    };
+    const resetValidation = (name2) => {
+      if (typeof name2 === "string") {
+        name2 = [name2];
+      }
+      const fields = getFieldsByNames(name2);
+      fields.forEach((item) => {
+        item.resetValidation();
+      });
+    };
+    const getValidationStatus = () => children.reduce((form, field) => {
+      form[field.name] = field.getValidationStatus();
+      return form;
+    }, {});
+    const scrollToField = (name2, options) => {
+      children.some((item) => {
+        if (item.name === name2) {
+          item.$el.scrollIntoView(options);
+          return true;
+        }
+        return false;
+      });
+    };
+    const getValues = () => children.reduce((form, field) => {
+      if (field.name !== void 0) {
+        form[field.name] = field.formValue.value;
+      }
+      return form;
+    }, {});
+    const submit = () => {
+      const values = getValues();
+      validate().then(() => emit("submit", values)).catch((errors) => {
+        emit("failed", {
+          values,
+          errors
+        });
+        const {
+          scrollToError,
+          scrollToErrorPosition
+        } = props2;
+        if (scrollToError && errors[0].name) {
+          scrollToField(errors[0].name, scrollToErrorPosition ? {
+            block: scrollToErrorPosition
+          } : void 0);
+        }
+      });
+    };
+    const onSubmit = (event) => {
+      dom.preventDefault(event);
+      submit();
+    };
+    linkChildren({
+      props: props2
+    });
+    useExpose.useExpose({
+      submit,
+      validate,
+      getValues,
+      scrollToField,
+      resetValidation,
+      getValidationStatus
+    });
+    return () => {
+      var _a;
+      return vue.createVNode("form", {
+        "class": bem(),
+        "onSubmit": onSubmit
+      }, [(_a = slots.default) == null ? void 0 : _a.call(slots)]);
+    };
+  }
+});
+exports.default = stdin_default;
+exports.formProps = formProps;

package/lib/packages/mobile/node_modules/vant/es/form/index.js

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

package/lib/packages/mobile/node_modules/vant/es/grid/Grid.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const vue = require("vue");
+const constant = require("../utils/constant.js");
+const index_esm = require("../../../@vant/use/dist/index.esm.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");
+const gridProps = {
+  square: Boolean,
+  center: props.truthProp,
+  border: props.truthProp,
+  gutter: props.numericProp,
+  reverse: Boolean,
+  iconSize: props.numericProp,
+  direction: String,
+  clickable: Boolean,
+  columnNum: props.makeNumericProp(4)
+};
+const GRID_KEY = Symbol(name);
+var stdin_default = vue.defineComponent({
+  name,
+  props: gridProps,
+  setup(props2, {
+    slots
+  }) {
+    const {
+      linkChildren
+    } = index_esm.useChildren(GRID_KEY);
+    linkChildren({
+      props: props2
+    });
+    return () => {
+      var _a;
+      return vue.createVNode("div", {
+        "style": {
+          paddingLeft: format.addUnit(props2.gutter)
+        },
+        "class": [bem(), {
+          [constant.BORDER_TOP]: props2.border && !props2.gutter
+        }]
+      }, [(_a = slots.default) == null ? void 0 : _a.call(slots)]);
+    };
+  }
+});
+exports.GRID_KEY = GRID_KEY;
+exports.default = stdin_default;
+exports.gridProps = gridProps;

package/lib/packages/mobile/node_modules/vant/es/grid/index.js

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

package/lib/packages/mobile/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 create = require("../utils/create.js");
+const format = require("../utils/format.js");
+const props = require("../utils/props.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/packages/mobile/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/packages/mobile/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/packages/mobile/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;