@fecp/designer 5.5.113 → 5.5.115

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;

package/lib/node_modules/vant/es/steps/Steps.js

@@ -0,0 +1,47 @@
+"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 [name, bem] = create.createNamespace("steps");
+const stepsProps = {
+  active: props.makeNumericProp(0),
+  direction: props.makeStringProp("horizontal"),
+  activeIcon: props.makeStringProp("checked"),
+  iconPrefix: String,
+  finishIcon: String,
+  activeColor: String,
+  inactiveIcon: String,
+  inactiveColor: String
+};
+const STEPS_KEY = Symbol(name);
+var stdin_default = Vue.defineComponent({
+  name,
+  props: stepsProps,
+  emits: ["clickStep"],
+  setup(props2, {
+    emit,
+    slots
+  }) {
+    const {
+      linkChildren
+    } = index_esm.useChildren(STEPS_KEY);
+    const onClickStep = (index) => emit("clickStep", index);
+    linkChildren({
+      props: props2,
+      onClickStep
+    });
+    return () => {
+      var _a;
+      return Vue.createVNode("div", {
+        "class": bem([props2.direction])
+      }, [Vue.createVNode("div", {
+        "class": bem("items")
+      }, [(_a = slots.default) == null ? void 0 : _a.call(slots)])]);
+    };
+  }
+});
+exports.STEPS_KEY = STEPS_KEY;
+exports.default = stdin_default;
+exports.stepsProps = stepsProps;

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

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

package/lib/node_modules/vant/es/sticky/Sticky.js

@@ -0,0 +1,142 @@
+"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 useVisibilityChange = require("../composables/use-visibility-change.js");
+const props = require("../utils/props.js");
+const format = require("../utils/format.js");
+const dom = require("../utils/dom.js");
+const create = require("../utils/create.js");
+const basic = require("../utils/basic.js");
+const [name, bem] = create.createNamespace("sticky");
+const stickyProps = {
+  zIndex: props.numericProp,
+  position: props.makeStringProp("top"),
+  container: Object,
+  offsetTop: props.makeNumericProp(0),
+  offsetBottom: props.makeNumericProp(0)
+};
+var stdin_default = Vue.defineComponent({
+  name,
+  props: stickyProps,
+  emits: ["scroll", "change"],
+  setup(props2, {
+    emit,
+    slots
+  }) {
+    const root = Vue.ref();
+    const scrollParent = index_esm.useScrollParent(root);
+    const state = Vue.reactive({
+      fixed: false,
+      width: 0,
+      // root width
+      height: 0,
+      // root height
+      transform: 0
+    });
+    const isReset = Vue.ref(false);
+    const offset = Vue.computed(() => format.unitToPx(props2.position === "top" ? props2.offsetTop : props2.offsetBottom));
+    const rootStyle = Vue.computed(() => {
+      if (isReset.value) {
+        return;
+      }
+      const {
+        fixed,
+        height,
+        width
+      } = state;
+      if (fixed) {
+        return {
+          width: `${width}px`,
+          height: `${height}px`
+        };
+      }
+    });
+    const stickyStyle = Vue.computed(() => {
+      if (!state.fixed || isReset.value) {
+        return;
+      }
+      const style = basic.extend(format.getZIndexStyle(props2.zIndex), {
+        width: `${state.width}px`,
+        height: `${state.height}px`,
+        [props2.position]: `${offset.value}px`
+      });
+      if (state.transform) {
+        style.transform = `translate3d(0, ${state.transform}px, 0)`;
+      }
+      return style;
+    });
+    const emitScroll = (scrollTop) => emit("scroll", {
+      scrollTop,
+      isFixed: state.fixed
+    });
+    const onScroll = () => {
+      if (!root.value || dom.isHidden(root)) {
+        return;
+      }
+      const {
+        container,
+        position
+      } = props2;
+      const rootRect = index_esm.useRect(root);
+      const scrollTop = dom.getScrollTop(window);
+      state.width = rootRect.width;
+      state.height = rootRect.height;
+      if (position === "top") {
+        if (container) {
+          const containerRect = index_esm.useRect(container);
+          const difference = containerRect.bottom - offset.value - state.height;
+          state.fixed = offset.value > rootRect.top && containerRect.bottom > 0;
+          state.transform = difference < 0 ? difference : 0;
+        } else {
+          state.fixed = offset.value > rootRect.top;
+        }
+      } else {
+        const {
+          clientHeight
+        } = document.documentElement;
+        if (container) {
+          const containerRect = index_esm.useRect(container);
+          const difference = clientHeight - containerRect.top - offset.value - state.height;
+          state.fixed = clientHeight - offset.value < rootRect.bottom && clientHeight > containerRect.top;
+          state.transform = difference < 0 ? -difference : 0;
+        } else {
+          state.fixed = clientHeight - offset.value < rootRect.bottom;
+        }
+      }
+      emitScroll(scrollTop);
+    };
+    Vue.watch(() => state.fixed, (value) => emit("change", value));
+    index_esm.useEventListener("scroll", onScroll, {
+      target: scrollParent,
+      passive: true
+    });
+    useVisibilityChange.useVisibilityChange(root, onScroll);
+    Vue.watch([dom.windowWidth, dom.windowHeight], () => {
+      if (!root.value || dom.isHidden(root) || !state.fixed) {
+        return;
+      }
+      isReset.value = true;
+      Vue.nextTick(() => {
+        const rootRect = index_esm.useRect(root);
+        state.width = rootRect.width;
+        state.height = rootRect.height;
+        isReset.value = false;
+      });
+    });
+    return () => {
+      var _a;
+      return Vue.createVNode("div", {
+        "ref": root,
+        "style": rootStyle.value
+      }, [Vue.createVNode("div", {
+        "class": bem({
+          fixed: state.fixed && !isReset.value
+        }),
+        "style": stickyStyle.value
+      }, [(_a = slots.default) == null ? void 0 : _a.call(slots)])]);
+    };
+  }
+});
+exports.default = stdin_default;
+exports.stickyProps = stickyProps;

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

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

package/lib/node_modules/vant/es/submit-bar/SubmitBar.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const Vue = require("vue");
+const index = require("../icon/index.js");
+const index$1 = require("../button/index.js");
+const usePlaceholder = require("../composables/use-placeholder.js");
+const props = require("../utils/props.js");
+const create = require("../utils/create.js");
+const [name, bem, t] = create.createNamespace("submit-bar");
+const submitBarProps = {
+  tip: String,
+  label: String,
+  price: Number,
+  tipIcon: String,
+  loading: Boolean,
+  currency: props.makeStringProp("¥"),
+  disabled: Boolean,
+  textAlign: String,
+  buttonText: String,
+  buttonType: props.makeStringProp("danger"),
+  buttonColor: String,
+  suffixLabel: String,
+  placeholder: Boolean,
+  decimalLength: props.makeNumericProp(2),
+  safeAreaInsetBottom: props.truthProp
+};
+var stdin_default = Vue.defineComponent({
+  name,
+  props: submitBarProps,
+  emits: ["submit"],
+  setup(props2, {
+    emit,
+    slots
+  }) {
+    const root = Vue.ref();
+    const renderPlaceholder = usePlaceholder.usePlaceholder(root, bem);
+    const renderText = () => {
+      const {
+        price,
+        label,
+        currency,
+        textAlign,
+        suffixLabel,
+        decimalLength
+      } = props2;
+      if (typeof price === "number") {
+        const pricePair = (price / 100).toFixed(+decimalLength).split(".");
+        const decimal = decimalLength ? `.${pricePair[1]}` : "";
+        return Vue.createVNode("div", {
+          "class": bem("text"),
+          "style": {
+            textAlign
+          }
+        }, [Vue.createVNode("span", null, [label || t("label")]), Vue.createVNode("span", {
+          "class": bem("price")
+        }, [currency, Vue.createVNode("span", {
+          "class": bem("price-integer")
+        }, [pricePair[0]]), decimal]), suffixLabel && Vue.createVNode("span", {
+          "class": bem("suffix-label")
+        }, [suffixLabel])]);
+      }
+    };
+    const renderTip = () => {
+      var _a;
+      const {
+        tip,
+        tipIcon
+      } = props2;
+      if (slots.tip || tip) {
+        return Vue.createVNode("div", {
+          "class": bem("tip")
+        }, [tipIcon && Vue.createVNode(index.Icon, {
+          "class": bem("tip-icon"),
+          "name": tipIcon
+        }, null), tip && Vue.createVNode("span", {
+          "class": bem("tip-text")
+        }, [tip]), (_a = slots.tip) == null ? void 0 : _a.call(slots)]);
+      }
+    };
+    const onClickButton = () => emit("submit");
+    const renderButton = () => {
+      if (slots.button) {
+        return slots.button();
+      }
+      return Vue.createVNode(index$1.Button, {
+        "round": true,
+        "type": props2.buttonType,
+        "text": props2.buttonText,
+        "class": bem("button", props2.buttonType),
+        "color": props2.buttonColor,
+        "loading": props2.loading,
+        "disabled": props2.disabled,
+        "onClick": onClickButton
+      }, null);
+    };
+    const renderSubmitBar = () => {
+      var _a, _b;
+      return Vue.createVNode("div", {
+        "ref": root,
+        "class": [bem(), {
+          "van-safe-area-bottom": props2.safeAreaInsetBottom
+        }]
+      }, [(_a = slots.top) == null ? void 0 : _a.call(slots), renderTip(), Vue.createVNode("div", {
+        "class": bem("bar")
+      }, [(_b = slots.default) == null ? void 0 : _b.call(slots), renderText(), renderButton()])]);
+    };
+    return () => {
+      if (props2.placeholder) {
+        return renderPlaceholder(renderSubmitBar);
+      }
+      return renderSubmitBar();
+    };
+  }
+});
+exports.default = stdin_default;
+exports.submitBarProps = submitBarProps;

package/lib/node_modules/vant/es/submit-bar/index.js

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