@fecp/designer 5.5.114 → 5.5.115

package/lib/node_modules/vant/es/slider/Slider.js

@@ -0,0 +1,290 @@
+"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 useTouch = require("../composables/use-touch.js");
+const format = require("../utils/format.js");
+const props = require("../utils/props.js");
+const create = require("../utils/create.js");
+const basic = require("../utils/basic.js");
+const dom = require("../utils/dom.js");
+const [name, bem] = create.createNamespace("slider");
+const sliderProps = {
+  min: props.makeNumericProp(0),
+  max: props.makeNumericProp(100),
+  step: props.makeNumericProp(1),
+  range: Boolean,
+  reverse: Boolean,
+  disabled: Boolean,
+  readonly: Boolean,
+  vertical: Boolean,
+  barHeight: props.numericProp,
+  buttonSize: props.numericProp,
+  activeColor: String,
+  inactiveColor: String,
+  modelValue: {
+    type: [Number, Array],
+    default: 0
+  }
+};
+var stdin_default = Vue.defineComponent({
+  name,
+  props: sliderProps,
+  emits: ["change", "dragEnd", "dragStart", "update:modelValue"],
+  setup(props2, {
+    emit,
+    slots
+  }) {
+    let buttonIndex;
+    let current;
+    let startValue;
+    const root = Vue.ref();
+    const slider = [Vue.ref(), Vue.ref()];
+    const dragStatus = Vue.ref();
+    const touch = useTouch.useTouch();
+    const scope = Vue.computed(() => Number(props2.max) - Number(props2.min));
+    const wrapperStyle = Vue.computed(() => {
+      const crossAxis = props2.vertical ? "width" : "height";
+      return {
+        background: props2.inactiveColor,
+        [crossAxis]: format.addUnit(props2.barHeight)
+      };
+    });
+    const isRange = (val) => props2.range && Array.isArray(val);
+    const calcMainAxis = () => {
+      const {
+        modelValue,
+        min
+      } = props2;
+      if (isRange(modelValue)) {
+        return `${(modelValue[1] - modelValue[0]) * 100 / scope.value}%`;
+      }
+      return `${(modelValue - Number(min)) * 100 / scope.value}%`;
+    };
+    const calcOffset = () => {
+      const {
+        modelValue,
+        min
+      } = props2;
+      if (isRange(modelValue)) {
+        return `${(modelValue[0] - Number(min)) * 100 / scope.value}%`;
+      }
+      return "0%";
+    };
+    const barStyle = Vue.computed(() => {
+      const mainAxis = props2.vertical ? "height" : "width";
+      const style = {
+        [mainAxis]: calcMainAxis(),
+        background: props2.activeColor
+      };
+      if (dragStatus.value) {
+        style.transition = "none";
+      }
+      const getPositionKey = () => {
+        if (props2.vertical) {
+          return props2.reverse ? "bottom" : "top";
+        }
+        return props2.reverse ? "right" : "left";
+      };
+      style[getPositionKey()] = calcOffset();
+      return style;
+    });
+    const format$1 = (value) => {
+      const min = +props2.min;
+      const max = +props2.max;
+      const step = +props2.step;
+      value = format.clamp(value, min, max);
+      const diff = Math.round((value - min) / step) * step;
+      return format.addNumber(min, diff);
+    };
+    const updateStartValue = () => {
+      const current2 = props2.modelValue;
+      if (isRange(current2)) {
+        startValue = current2.map(format$1);
+      } else {
+        startValue = format$1(current2);
+      }
+    };
+    const handleRangeValue = (value) => {
+      var _a, _b;
+      const left = (_a = value[0]) != null ? _a : Number(props2.min);
+      const right = (_b = value[1]) != null ? _b : Number(props2.max);
+      return left > right ? [right, left] : [left, right];
+    };
+    const updateValue = (value, end) => {
+      if (isRange(value)) {
+        value = handleRangeValue(value).map(format$1);
+      } else {
+        value = format$1(value);
+      }
+      if (!basic.isSameValue(value, props2.modelValue)) {
+        emit("update:modelValue", value);
+      }
+      if (end && !basic.isSameValue(value, startValue)) {
+        emit("change", value);
+      }
+    };
+    const onClick = (event) => {
+      event.stopPropagation();
+      if (props2.disabled || props2.readonly) {
+        return;
+      }
+      updateStartValue();
+      const {
+        min,
+        reverse,
+        vertical,
+        modelValue
+      } = props2;
+      const rect = index_esm.useRect(root);
+      const getDelta = () => {
+        if (vertical) {
+          if (reverse) {
+            return rect.bottom - event.clientY;
+          }
+          return event.clientY - rect.top;
+        }
+        if (reverse) {
+          return rect.right - event.clientX;
+        }
+        return event.clientX - rect.left;
+      };
+      const total = vertical ? rect.height : rect.width;
+      const value = Number(min) + getDelta() / total * scope.value;
+      if (isRange(modelValue)) {
+        const [left, right] = modelValue;
+        const middle = (left + right) / 2;
+        if (value <= middle) {
+          updateValue([value, right], true);
+        } else {
+          updateValue([left, value], true);
+        }
+      } else {
+        updateValue(value, true);
+      }
+    };
+    const onTouchStart = (event) => {
+      if (props2.disabled || props2.readonly) {
+        return;
+      }
+      touch.start(event);
+      current = props2.modelValue;
+      updateStartValue();
+      dragStatus.value = "start";
+    };
+    const onTouchMove = (event) => {
+      if (props2.disabled || props2.readonly) {
+        return;
+      }
+      if (dragStatus.value === "start") {
+        emit("dragStart", event);
+      }
+      dom.preventDefault(event, true);
+      touch.move(event);
+      dragStatus.value = "dragging";
+      const rect = index_esm.useRect(root);
+      const delta = props2.vertical ? touch.deltaY.value : touch.deltaX.value;
+      const total = props2.vertical ? rect.height : rect.width;
+      let diff = delta / total * scope.value;
+      if (props2.reverse) {
+        diff = -diff;
+      }
+      if (isRange(startValue)) {
+        const index = props2.reverse ? 1 - buttonIndex : buttonIndex;
+        current[index] = startValue[index] + diff;
+      } else {
+        current = startValue + diff;
+      }
+      updateValue(current);
+    };
+    const onTouchEnd = (event) => {
+      if (props2.disabled || props2.readonly) {
+        return;
+      }
+      if (dragStatus.value === "dragging") {
+        updateValue(current, true);
+        emit("dragEnd", event);
+      }
+      dragStatus.value = "";
+    };
+    const getButtonClassName = (index) => {
+      if (typeof index === "number") {
+        const position = ["left", "right"];
+        return bem(`button-wrapper`, position[index]);
+      }
+      return bem("button-wrapper", props2.reverse ? "left" : "right");
+    };
+    const renderButtonContent = (value, index) => {
+      const dragging = dragStatus.value === "dragging";
+      if (typeof index === "number") {
+        const slot = slots[index === 0 ? "left-button" : "right-button"];
+        let dragIndex;
+        if (dragging && Array.isArray(current)) {
+          dragIndex = current[0] > current[1] ? buttonIndex ^ 1 : buttonIndex;
+        }
+        if (slot) {
+          return slot({
+            value,
+            dragging,
+            dragIndex
+          });
+        }
+      }
+      if (slots.button) {
+        return slots.button({
+          value,
+          dragging
+        });
+      }
+      return Vue.createVNode("div", {
+        "class": bem("button"),
+        "style": format.getSizeStyle(props2.buttonSize)
+      }, null);
+    };
+    const renderButton = (index) => {
+      const current2 = typeof index === "number" ? props2.modelValue[index] : props2.modelValue;
+      return Vue.createVNode("div", {
+        "ref": slider[index != null ? index : 0],
+        "role": "slider",
+        "class": getButtonClassName(index),
+        "tabindex": props2.disabled ? void 0 : 0,
+        "aria-valuemin": props2.min,
+        "aria-valuenow": current2,
+        "aria-valuemax": props2.max,
+        "aria-disabled": props2.disabled || void 0,
+        "aria-readonly": props2.readonly || void 0,
+        "aria-orientation": props2.vertical ? "vertical" : "horizontal",
+        "onTouchstartPassive": (event) => {
+          if (typeof index === "number") {
+            buttonIndex = index;
+          }
+          onTouchStart(event);
+        },
+        "onTouchend": onTouchEnd,
+        "onTouchcancel": onTouchEnd,
+        "onClick": dom.stopPropagation
+      }, [renderButtonContent(current2, index)]);
+    };
+    updateValue(props2.modelValue);
+    index_esm.useCustomFieldValue(() => props2.modelValue);
+    slider.forEach((item) => {
+      index_esm.useEventListener("touchmove", onTouchMove, {
+        target: item
+      });
+    });
+    return () => Vue.createVNode("div", {
+      "ref": root,
+      "style": wrapperStyle.value,
+      "class": bem({
+        vertical: props2.vertical,
+        disabled: props2.disabled
+      }),
+      "onClick": onClick
+    }, [Vue.createVNode("div", {
+      "class": bem("bar"),
+      "style": barStyle.value
+    }, [props2.range ? [renderButton(0), renderButton(1)] : renderButton()])]);
+  }
+});
+exports.default = stdin_default;
+exports.sliderProps = sliderProps;

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

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

package/lib/node_modules/vant/es/space/Space.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const Vue = require("vue");
+const create = require("../utils/create.js");
+const [name, bem] = create.createNamespace("space");
+const spaceProps = {
+  align: String,
+  direction: {
+    type: String,
+    default: "horizontal"
+  },
+  size: {
+    type: [Number, String, Array],
+    default: 8
+  },
+  wrap: Boolean,
+  fill: Boolean
+};
+function filterEmpty(children = []) {
+  const nodes = [];
+  children.forEach((child) => {
+    if (Array.isArray(child)) {
+      nodes.push(...child);
+    } else if (child.type === Vue.Fragment) {
+      nodes.push(...filterEmpty(child.children));
+    } else {
+      nodes.push(child);
+    }
+  });
+  return nodes.filter((c) => {
+    var _a;
+    return !(c && (c.type === Vue.Comment || c.type === Vue.Fragment && ((_a = c.children) == null ? void 0 : _a.length) === 0 || c.type === Vue.Text && c.children.trim() === ""));
+  });
+}
+var stdin_default = Vue.defineComponent({
+  name,
+  props: spaceProps,
+  setup(props, {
+    slots
+  }) {
+    const mergedAlign = Vue.computed(() => {
+      var _a;
+      return (_a = props.align) != null ? _a : props.direction === "horizontal" ? "center" : "";
+    });
+    const getMargin = (size) => {
+      if (typeof size === "number") {
+        return size + "px";
+      }
+      return size;
+    };
+    const getMarginStyle = (isLast) => {
+      const style = {};
+      const marginRight = `${getMargin(Array.isArray(props.size) ? props.size[0] : props.size)}`;
+      const marginBottom = `${getMargin(Array.isArray(props.size) ? props.size[1] : props.size)}`;
+      if (isLast) {
+        return props.wrap ? {
+          marginBottom
+        } : {};
+      }
+      if (props.direction === "horizontal") {
+        style.marginRight = marginRight;
+      }
+      if (props.direction === "vertical" || props.wrap) {
+        style.marginBottom = marginBottom;
+      }
+      return style;
+    };
+    return () => {
+      var _a;
+      const children = filterEmpty((_a = slots.default) == null ? void 0 : _a.call(slots));
+      return Vue.createVNode("div", {
+        "class": [bem({
+          [props.direction]: props.direction,
+          [`align-${mergedAlign.value}`]: mergedAlign.value,
+          wrap: props.wrap,
+          fill: props.fill
+        })]
+      }, [children.map((c, i) => Vue.createVNode("div", {
+        "key": `item-${i}`,
+        "class": `${name}-item`,
+        "style": getMarginStyle(i === children.length - 1)
+      }, [c]))]);
+    };
+  }
+});
+exports.default = stdin_default;
+exports.spaceProps = spaceProps;

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

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

package/lib/node_modules/vant/es/stepper/Stepper.js

@@ -0,0 +1,254 @@
+"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 props = require("../utils/props.js");
+const create = require("../utils/create.js");
+const format = require("../utils/format.js");
+const constant = require("../utils/constant.js");
+const basic = require("../utils/basic.js");
+const dom = require("../utils/dom.js");
+const interceptor = require("../utils/interceptor.js");
+const [name, bem] = create.createNamespace("stepper");
+const LONG_PRESS_INTERVAL = 200;
+const isEqual = (value1, value2) => String(value1) === String(value2);
+const stepperProps = {
+  min: props.makeNumericProp(1),
+  max: props.makeNumericProp(Infinity),
+  name: props.makeNumericProp(""),
+  step: props.makeNumericProp(1),
+  theme: String,
+  integer: Boolean,
+  disabled: Boolean,
+  showPlus: props.truthProp,
+  showMinus: props.truthProp,
+  showInput: props.truthProp,
+  longPress: props.truthProp,
+  autoFixed: props.truthProp,
+  allowEmpty: Boolean,
+  modelValue: props.numericProp,
+  inputWidth: props.numericProp,
+  buttonSize: props.numericProp,
+  placeholder: String,
+  disablePlus: Boolean,
+  disableMinus: Boolean,
+  disableInput: Boolean,
+  beforeChange: Function,
+  defaultValue: props.makeNumericProp(1),
+  decimalLength: props.numericProp
+};
+var stdin_default = Vue.defineComponent({
+  name,
+  props: stepperProps,
+  emits: ["plus", "blur", "minus", "focus", "change", "overlimit", "update:modelValue"],
+  setup(props2, {
+    emit
+  }) {
+    const format$1 = (value, autoFixed = true) => {
+      const {
+        min,
+        max,
+        allowEmpty,
+        decimalLength
+      } = props2;
+      if (allowEmpty && value === "") {
+        return value;
+      }
+      value = format.formatNumber(String(value), !props2.integer);
+      value = value === "" ? 0 : +value;
+      value = Number.isNaN(value) ? +min : value;
+      value = autoFixed ? Math.max(Math.min(+max, value), +min) : value;
+      if (basic.isDef(decimalLength)) {
+        value = value.toFixed(+decimalLength);
+      }
+      return value;
+    };
+    const getInitialValue = () => {
+      var _a;
+      const defaultValue = (_a = props2.modelValue) != null ? _a : props2.defaultValue;
+      const value = format$1(defaultValue);
+      if (!isEqual(value, props2.modelValue)) {
+        emit("update:modelValue", value);
+      }
+      return value;
+    };
+    let actionType;
+    const inputRef = Vue.ref();
+    const current = Vue.ref(getInitialValue());
+    const minusDisabled = Vue.computed(() => props2.disabled || props2.disableMinus || +current.value <= +props2.min);
+    const plusDisabled = Vue.computed(() => props2.disabled || props2.disablePlus || +current.value >= +props2.max);
+    const inputStyle = Vue.computed(() => ({
+      width: format.addUnit(props2.inputWidth),
+      height: format.addUnit(props2.buttonSize)
+    }));
+    const buttonStyle = Vue.computed(() => format.getSizeStyle(props2.buttonSize));
+    const check = () => {
+      const value = format$1(current.value);
+      if (!isEqual(value, current.value)) {
+        current.value = value;
+      }
+    };
+    const setValue = (value) => {
+      if (props2.beforeChange) {
+        interceptor.callInterceptor(props2.beforeChange, {
+          args: [value],
+          done() {
+            current.value = value;
+          }
+        });
+      } else {
+        current.value = value;
+      }
+    };
+    const onChange = () => {
+      if (actionType === "plus" && plusDisabled.value || actionType === "minus" && minusDisabled.value) {
+        emit("overlimit", actionType);
+        return;
+      }
+      const diff = actionType === "minus" ? -props2.step : +props2.step;
+      const value = format$1(format.addNumber(+current.value, diff));
+      setValue(value);
+      emit(actionType);
+    };
+    const onInput = (event) => {
+      const input = event.target;
+      const {
+        value
+      } = input;
+      const {
+        decimalLength
+      } = props2;
+      let formatted = format.formatNumber(String(value), !props2.integer);
+      if (basic.isDef(decimalLength) && formatted.includes(".")) {
+        const pair = formatted.split(".");
+        formatted = `${pair[0]}.${pair[1].slice(0, +decimalLength)}`;
+      }
+      if (props2.beforeChange) {
+        input.value = String(current.value);
+      } else if (!isEqual(value, formatted)) {
+        input.value = formatted;
+      }
+      const isNumeric = formatted === String(+formatted);
+      setValue(isNumeric ? +formatted : formatted);
+    };
+    const onFocus = (event) => {
+      var _a;
+      if (props2.disableInput) {
+        (_a = inputRef.value) == null ? void 0 : _a.blur();
+      } else {
+        emit("focus", event);
+      }
+    };
+    const onBlur = (event) => {
+      const input = event.target;
+      const value = format$1(input.value, props2.autoFixed);
+      input.value = String(value);
+      current.value = value;
+      Vue.nextTick(() => {
+        emit("blur", event);
+        dom.resetScroll();
+      });
+    };
+    let isLongPress;
+    let longPressTimer;
+    const longPressStep = () => {
+      longPressTimer = setTimeout(() => {
+        onChange();
+        longPressStep();
+      }, LONG_PRESS_INTERVAL);
+    };
+    const onTouchStart = () => {
+      if (props2.longPress) {
+        isLongPress = false;
+        clearTimeout(longPressTimer);
+        longPressTimer = setTimeout(() => {
+          isLongPress = true;
+          onChange();
+          longPressStep();
+        }, constant.LONG_PRESS_START_TIME);
+      }
+    };
+    const onTouchEnd = (event) => {
+      if (props2.longPress) {
+        clearTimeout(longPressTimer);
+        if (isLongPress) {
+          dom.preventDefault(event);
+        }
+      }
+    };
+    const onMousedown = (event) => {
+      if (props2.disableInput) {
+        dom.preventDefault(event);
+      }
+    };
+    const createListeners = (type) => ({
+      onClick: (event) => {
+        dom.preventDefault(event);
+        actionType = type;
+        onChange();
+      },
+      onTouchstartPassive: () => {
+        actionType = type;
+        onTouchStart();
+      },
+      onTouchend: onTouchEnd,
+      onTouchcancel: onTouchEnd
+    });
+    Vue.watch(() => [props2.max, props2.min, props2.integer, props2.decimalLength], check);
+    Vue.watch(() => props2.modelValue, (value) => {
+      if (!isEqual(value, current.value)) {
+        current.value = format$1(value);
+      }
+    });
+    Vue.watch(current, (value) => {
+      emit("update:modelValue", value);
+      emit("change", value, {
+        name: props2.name
+      });
+    });
+    index_esm.useCustomFieldValue(() => props2.modelValue);
+    return () => Vue.createVNode("div", {
+      "role": "group",
+      "class": bem([props2.theme])
+    }, [Vue.withDirectives(Vue.createVNode("button", Vue.mergeProps({
+      "type": "button",
+      "style": buttonStyle.value,
+      "class": [bem("minus", {
+        disabled: minusDisabled.value
+      }), {
+        [constant.HAPTICS_FEEDBACK]: !minusDisabled.value
+      }],
+      "aria-disabled": minusDisabled.value || void 0
+    }, createListeners("minus")), null), [[Vue.vShow, props2.showMinus]]), Vue.withDirectives(Vue.createVNode("input", {
+      "ref": inputRef,
+      "type": props2.integer ? "tel" : "text",
+      "role": "spinbutton",
+      "class": bem("input"),
+      "value": current.value,
+      "style": inputStyle.value,
+      "disabled": props2.disabled,
+      "readonly": props2.disableInput,
+      "inputmode": props2.integer ? "numeric" : "decimal",
+      "placeholder": props2.placeholder,
+      "autocomplete": "off",
+      "aria-valuemax": props2.max,
+      "aria-valuemin": props2.min,
+      "aria-valuenow": current.value,
+      "onBlur": onBlur,
+      "onInput": onInput,
+      "onFocus": onFocus,
+      "onMousedown": onMousedown
+    }, null), [[Vue.vShow, props2.showInput]]), Vue.withDirectives(Vue.createVNode("button", Vue.mergeProps({
+      "type": "button",
+      "style": buttonStyle.value,
+      "class": [bem("plus", {
+        disabled: plusDisabled.value
+      }), {
+        [constant.HAPTICS_FEEDBACK]: !plusDisabled.value
+      }],
+      "aria-disabled": plusDisabled.value || void 0
+    }, createListeners("plus")), null), [[Vue.vShow, props2.showPlus]])]);
+  }
+});
+exports.default = stdin_default;
+exports.stepperProps = stepperProps;

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

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