@fecp/designer 5.5.113 → 5.5.115

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

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

package/lib/node_modules/vant/es/cascader/Cascader.js

@@ -0,0 +1,243 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const Vue = require("vue");
+const useRefs = require("../composables/use-refs.js");
+const index$2 = require("../tab/index.js");
+const index$1 = require("../tabs/index.js");
+const index = require("../icon/index.js");
+const props = require("../utils/props.js");
+const create = require("../utils/create.js");
+const basic = require("../utils/basic.js");
+const constant = require("../utils/constant.js");
+const [name, bem, t] = create.createNamespace("cascader");
+const cascaderProps = {
+  title: String,
+  options: props.makeArrayProp(),
+  closeable: props.truthProp,
+  swipeable: props.truthProp,
+  closeIcon: props.makeStringProp("cross"),
+  showHeader: props.truthProp,
+  modelValue: props.numericProp,
+  fieldNames: Object,
+  placeholder: String,
+  activeColor: String
+};
+var stdin_default = Vue.defineComponent({
+  name,
+  props: cascaderProps,
+  emits: ["close", "change", "finish", "clickTab", "update:modelValue"],
+  setup(props2, {
+    slots,
+    emit
+  }) {
+    const tabs = Vue.ref([]);
+    const activeTab = Vue.ref(0);
+    const [selectedElementRefs, setSelectedElementRefs] = useRefs.useRefs();
+    const {
+      text: textKey,
+      value: valueKey,
+      children: childrenKey
+    } = basic.extend({
+      text: "text",
+      value: "value",
+      children: "children"
+    }, props2.fieldNames);
+    const getSelectedOptionsByValue = (options, value) => {
+      for (const option of options) {
+        if (option[valueKey] === value) {
+          return [option];
+        }
+        if (option[childrenKey]) {
+          const selectedOptions = getSelectedOptionsByValue(option[childrenKey], value);
+          if (selectedOptions) {
+            return [option, ...selectedOptions];
+          }
+        }
+      }
+    };
+    const updateTabs = () => {
+      const {
+        options,
+        modelValue
+      } = props2;
+      if (modelValue !== void 0) {
+        const selectedOptions = getSelectedOptionsByValue(options, modelValue);
+        if (selectedOptions) {
+          let optionsCursor = options;
+          tabs.value = selectedOptions.map((option) => {
+            const tab = {
+              options: optionsCursor,
+              selected: option
+            };
+            const next = optionsCursor.find((item) => item[valueKey] === option[valueKey]);
+            if (next) {
+              optionsCursor = next[childrenKey];
+            }
+            return tab;
+          });
+          if (optionsCursor) {
+            tabs.value.push({
+              options: optionsCursor,
+              selected: null
+            });
+          }
+          Vue.nextTick(() => {
+            activeTab.value = tabs.value.length - 1;
+          });
+          return;
+        }
+      }
+      tabs.value = [{
+        options,
+        selected: null
+      }];
+    };
+    const onSelect = (option, tabIndex) => {
+      if (option.disabled) {
+        return;
+      }
+      tabs.value[tabIndex].selected = option;
+      if (tabs.value.length > tabIndex + 1) {
+        tabs.value = tabs.value.slice(0, tabIndex + 1);
+      }
+      if (option[childrenKey]) {
+        const nextTab = {
+          options: option[childrenKey],
+          selected: null
+        };
+        if (tabs.value[tabIndex + 1]) {
+          tabs.value[tabIndex + 1] = nextTab;
+        } else {
+          tabs.value.push(nextTab);
+        }
+        Vue.nextTick(() => {
+          activeTab.value++;
+        });
+      }
+      const selectedOptions = tabs.value.map((tab) => tab.selected).filter(Boolean);
+      emit("update:modelValue", option[valueKey]);
+      const params = {
+        value: option[valueKey],
+        tabIndex,
+        selectedOptions
+      };
+      emit("change", params);
+      if (!option[childrenKey]) {
+        emit("finish", params);
+      }
+    };
+    const onClose = () => emit("close");
+    const onClickTab = ({
+      name: name2,
+      title
+    }) => emit("clickTab", name2, title);
+    const renderHeader = () => props2.showHeader ? Vue.createVNode("div", {
+      "class": bem("header")
+    }, [Vue.createVNode("h2", {
+      "class": bem("title")
+    }, [slots.title ? slots.title() : props2.title]), props2.closeable ? Vue.createVNode(index.Icon, {
+      "name": props2.closeIcon,
+      "class": [bem("close-icon"), constant.HAPTICS_FEEDBACK],
+      "onClick": onClose
+    }, null) : null]) : null;
+    const renderOption = (option, selectedOption, tabIndex) => {
+      const {
+        disabled
+      } = option;
+      const selected = !!(selectedOption && option[valueKey] === selectedOption[valueKey]);
+      const color = option.color || (selected ? props2.activeColor : void 0);
+      const Text = slots.option ? slots.option({
+        option,
+        selected
+      }) : Vue.createVNode("span", null, [option[textKey]]);
+      return Vue.createVNode("li", {
+        "ref": selected ? setSelectedElementRefs(tabIndex) : void 0,
+        "role": "menuitemradio",
+        "class": [bem("option", {
+          selected,
+          disabled
+        }), option.className],
+        "style": {
+          color
+        },
+        "tabindex": disabled ? void 0 : selected ? 0 : -1,
+        "aria-checked": selected,
+        "aria-disabled": disabled || void 0,
+        "onClick": () => onSelect(option, tabIndex)
+      }, [Text, selected ? Vue.createVNode(index.Icon, {
+        "name": "success",
+        "class": bem("selected-icon")
+      }, null) : null]);
+    };
+    const renderOptions = (options, selectedOption, tabIndex) => Vue.createVNode("ul", {
+      "role": "menu",
+      "class": bem("options")
+    }, [options.map((option) => renderOption(option, selectedOption, tabIndex))]);
+    const renderTab = (tab, tabIndex) => {
+      const {
+        options,
+        selected
+      } = tab;
+      const placeholder = props2.placeholder || t("select");
+      const title = selected ? selected[textKey] : placeholder;
+      return Vue.createVNode(index$2.Tab, {
+        "title": title,
+        "titleClass": bem("tab", {
+          unselected: !selected
+        })
+      }, {
+        default: () => {
+          var _a, _b;
+          return [(_a = slots["options-top"]) == null ? void 0 : _a.call(slots, {
+            tabIndex
+          }), renderOptions(options, selected, tabIndex), (_b = slots["options-bottom"]) == null ? void 0 : _b.call(slots, {
+            tabIndex
+          })];
+        }
+      });
+    };
+    const renderTabs = () => Vue.createVNode(index$1.Tabs, {
+      "active": activeTab.value,
+      "onUpdate:active": ($event) => activeTab.value = $event,
+      "shrink": true,
+      "animated": true,
+      "class": bem("tabs"),
+      "color": props2.activeColor,
+      "swipeable": props2.swipeable,
+      "onClickTab": onClickTab
+    }, {
+      default: () => [tabs.value.map(renderTab)]
+    });
+    const scrollIntoView = (el) => {
+      const scrollParent = el.parentElement;
+      if (scrollParent) {
+        scrollParent.scrollTop = el.offsetTop - (scrollParent.offsetHeight - el.offsetHeight) / 2;
+      }
+    };
+    updateTabs();
+    Vue.watch(activeTab, (value) => {
+      const el = selectedElementRefs.value[value];
+      if (el) scrollIntoView(el);
+    });
+    Vue.watch(() => props2.options, updateTabs, {
+      deep: true
+    });
+    Vue.watch(() => props2.modelValue, (value) => {
+      if (value !== void 0) {
+        const values = tabs.value.map((tab) => {
+          var _a;
+          return (_a = tab.selected) == null ? void 0 : _a[valueKey];
+        });
+        if (values.includes(value)) {
+          return;
+        }
+      }
+      updateTabs();
+    });
+    return () => Vue.createVNode("div", {
+      "class": bem()
+    }, [renderHeader(), renderTabs()]);
+  }
+});
+exports.cascaderProps = cascaderProps;
+exports.default = stdin_default;

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

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

package/lib/node_modules/vant/es/cell/Cell.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const Vue = require("vue");
+const useRoute = require("../composables/use-route.js");
+const index = require("../icon/index.js");
+const basic = require("../utils/basic.js");
+const create = require("../utils/create.js");
+const props = require("../utils/props.js");
+const [name, bem] = create.createNamespace("cell");
+const cellSharedProps = {
+  tag: props.makeStringProp("div"),
+  icon: String,
+  size: String,
+  title: props.numericProp,
+  value: props.numericProp,
+  label: props.numericProp,
+  center: Boolean,
+  isLink: Boolean,
+  border: props.truthProp,
+  iconPrefix: String,
+  valueClass: props.unknownProp,
+  labelClass: props.unknownProp,
+  titleClass: props.unknownProp,
+  titleStyle: null,
+  arrowDirection: String,
+  required: {
+    type: [Boolean, String],
+    default: null
+  },
+  clickable: {
+    type: Boolean,
+    default: null
+  }
+};
+const cellProps = basic.extend({}, cellSharedProps, useRoute.routeProps);
+var stdin_default = Vue.defineComponent({
+  name,
+  props: cellProps,
+  setup(props2, {
+    slots
+  }) {
+    const route = useRoute.useRoute();
+    const renderLabel = () => {
+      const showLabel = slots.label || basic.isDef(props2.label);
+      if (showLabel) {
+        return Vue.createVNode("div", {
+          "class": [bem("label"), props2.labelClass]
+        }, [slots.label ? slots.label() : props2.label]);
+      }
+    };
+    const renderTitle = () => {
+      var _a;
+      if (slots.title || basic.isDef(props2.title)) {
+        const titleSlot = (_a = slots.title) == null ? void 0 : _a.call(slots);
+        if (Array.isArray(titleSlot) && titleSlot.length === 0) {
+          return;
+        }
+        return Vue.createVNode("div", {
+          "class": [bem("title"), props2.titleClass],
+          "style": props2.titleStyle
+        }, [titleSlot || Vue.createVNode("span", null, [props2.title]), renderLabel()]);
+      }
+    };
+    const renderValue = () => {
+      const slot = slots.value || slots.default;
+      const hasValue = slot || basic.isDef(props2.value);
+      if (hasValue) {
+        return Vue.createVNode("div", {
+          "class": [bem("value"), props2.valueClass]
+        }, [slot ? slot() : Vue.createVNode("span", null, [props2.value])]);
+      }
+    };
+    const renderLeftIcon = () => {
+      if (slots.icon) {
+        return slots.icon();
+      }
+      if (props2.icon) {
+        return Vue.createVNode(index.Icon, {
+          "name": props2.icon,
+          "class": bem("left-icon"),
+          "classPrefix": props2.iconPrefix
+        }, null);
+      }
+    };
+    const renderRightIcon = () => {
+      if (slots["right-icon"]) {
+        return slots["right-icon"]();
+      }
+      if (props2.isLink) {
+        const name2 = props2.arrowDirection && props2.arrowDirection !== "right" ? `arrow-${props2.arrowDirection}` : "arrow";
+        return Vue.createVNode(index.Icon, {
+          "name": name2,
+          "class": bem("right-icon")
+        }, null);
+      }
+    };
+    return () => {
+      var _a;
+      const {
+        tag,
+        size,
+        center,
+        border,
+        isLink,
+        required
+      } = props2;
+      const clickable = (_a = props2.clickable) != null ? _a : isLink;
+      const classes = {
+        center,
+        required: !!required,
+        clickable,
+        borderless: !border
+      };
+      if (size) {
+        classes[size] = !!size;
+      }
+      return Vue.createVNode(tag, {
+        "class": bem(classes),
+        "role": clickable ? "button" : void 0,
+        "tabindex": clickable ? 0 : void 0,
+        "onClick": route
+      }, {
+        default: () => {
+          var _a2;
+          return [renderLeftIcon(), renderTitle(), renderValue(), renderRightIcon(), (_a2 = slots.extra) == null ? void 0 : _a2.call(slots)];
+        }
+      });
+    };
+  }
+});
+exports.cellProps = cellProps;
+exports.cellSharedProps = cellSharedProps;
+exports.default = stdin_default;

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

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

package/lib/node_modules/vant/es/cell-group/CellGroup.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const Vue = require("vue");
+const useScopeId = require("../composables/use-scope-id.js");
+const props = require("../utils/props.js");
+const create = require("../utils/create.js");
+const constant = require("../utils/constant.js");
+const [name, bem] = create.createNamespace("cell-group");
+const cellGroupProps = {
+  title: String,
+  inset: Boolean,
+  border: props.truthProp
+};
+var stdin_default = Vue.defineComponent({
+  name,
+  inheritAttrs: false,
+  props: cellGroupProps,
+  setup(props2, {
+    slots,
+    attrs
+  }) {
+    const renderGroup = () => {
+      var _a;
+      return Vue.createVNode("div", Vue.mergeProps({
+        "class": [bem({
+          inset: props2.inset
+        }), {
+          [constant.BORDER_TOP_BOTTOM]: props2.border && !props2.inset
+        }]
+      }, attrs, useScopeId.useScopeId()), [(_a = slots.default) == null ? void 0 : _a.call(slots)]);
+    };
+    const renderTitle = () => Vue.createVNode("div", {
+      "class": bem("title", {
+        inset: props2.inset
+      })
+    }, [slots.title ? slots.title() : props2.title]);
+    return () => {
+      if (props2.title || slots.title) {
+        return Vue.createVNode(Vue.Fragment, null, [renderTitle(), renderGroup()]);
+      }
+      return renderGroup();
+    };
+  }
+});
+exports.cellGroupProps = cellGroupProps;
+exports.default = stdin_default;

package/lib/node_modules/vant/es/cell-group/index.js

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

package/lib/node_modules/vant/es/checkbox/Checkbox.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const Vue = require("vue");
+const CheckboxGroup = require("../checkbox-group/CheckboxGroup.js");
+const index_esm = require("../../../@vant/use/dist/index.esm.js");
+const useExpose = require("../composables/use-expose.js");
+const Checker = require("./Checker.js");
+const basic = require("../utils/basic.js");
+const props = require("../utils/props.js");
+const create = require("../utils/create.js");
+const [name, bem] = create.createNamespace("checkbox");
+const checkboxProps = basic.extend({}, Checker.checkerProps, {
+  shape: String,
+  bindGroup: props.truthProp,
+  indeterminate: {
+    type: Boolean,
+    default: null
+  }
+});
+var stdin_default = Vue.defineComponent({
+  name,
+  props: checkboxProps,
+  emits: ["change", "update:modelValue"],
+  setup(props2, {
+    emit,
+    slots
+  }) {
+    const {
+      parent
+    } = index_esm.useParent(CheckboxGroup.CHECKBOX_GROUP_KEY);
+    const setParentValue = (checked2) => {
+      const {
+        name: name2
+      } = props2;
+      const {
+        max,
+        modelValue
+      } = parent.props;
+      const value = modelValue.slice();
+      if (checked2) {
+        const overlimit = max && value.length >= +max;
+        if (!overlimit && !value.includes(name2)) {
+          value.push(name2);
+          if (props2.bindGroup) {
+            parent.updateValue(value);
+          }
+        }
+      } else {
+        const index = value.indexOf(name2);
+        if (index !== -1) {
+          value.splice(index, 1);
+          if (props2.bindGroup) {
+            parent.updateValue(value);
+          }
+        }
+      }
+    };
+    const checked = Vue.computed(() => {
+      if (parent && props2.bindGroup) {
+        return parent.props.modelValue.indexOf(props2.name) !== -1;
+      }
+      return !!props2.modelValue;
+    });
+    const toggle = (newValue = !checked.value) => {
+      if (parent && props2.bindGroup) {
+        setParentValue(newValue);
+      } else {
+        emit("update:modelValue", newValue);
+      }
+      if (props2.indeterminate !== null) emit("change", newValue);
+    };
+    Vue.watch(() => props2.modelValue, (value) => {
+      if (props2.indeterminate === null) emit("change", value);
+    });
+    useExpose.useExpose({
+      toggle,
+      props: props2,
+      checked
+    });
+    index_esm.useCustomFieldValue(() => props2.modelValue);
+    return () => Vue.createVNode(Checker.default, Vue.mergeProps({
+      "bem": bem,
+      "role": "checkbox",
+      "parent": parent,
+      "checked": checked.value,
+      "onToggle": toggle
+    }, props2), basic.pick(slots, ["default", "icon"]));
+  }
+});
+exports.checkboxProps = checkboxProps;
+exports.default = stdin_default;

package/lib/node_modules/vant/es/checkbox/Checker.js

@@ -0,0 +1,144 @@
+"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 basic = require("../utils/basic.js");
+const format = require("../utils/format.js");
+const checkerProps = {
+  name: props.unknownProp,
+  disabled: Boolean,
+  iconSize: props.numericProp,
+  modelValue: props.unknownProp,
+  checkedColor: String,
+  labelPosition: String,
+  labelDisabled: Boolean
+};
+var stdin_default = Vue.defineComponent({
+  props: basic.extend({}, checkerProps, {
+    bem: props.makeRequiredProp(Function),
+    role: String,
+    shape: String,
+    parent: Object,
+    checked: Boolean,
+    bindGroup: props.truthProp,
+    indeterminate: {
+      type: Boolean,
+      default: null
+    }
+  }),
+  emits: ["click", "toggle"],
+  setup(props2, {
+    emit,
+    slots
+  }) {
+    const iconRef = Vue.ref();
+    const getParentProp = (name) => {
+      if (props2.parent && props2.bindGroup) {
+        return props2.parent.props[name];
+      }
+    };
+    const disabled = Vue.computed(() => {
+      if (props2.parent && props2.bindGroup) {
+        const disabled2 = getParentProp("disabled") || props2.disabled;
+        if (props2.role === "checkbox") {
+          const checkedCount = getParentProp("modelValue").length;
+          const max = getParentProp("max");
+          const overlimit = max && checkedCount >= +max;
+          return disabled2 || overlimit && !props2.checked;
+        }
+        return disabled2;
+      }
+      return props2.disabled;
+    });
+    const direction = Vue.computed(() => getParentProp("direction"));
+    const iconStyle = Vue.computed(() => {
+      const checkedColor = props2.checkedColor || getParentProp("checkedColor");
+      if (checkedColor && props2.checked && !disabled.value) {
+        return {
+          borderColor: checkedColor,
+          backgroundColor: checkedColor
+        };
+      }
+    });
+    const shape = Vue.computed(() => {
+      return props2.shape || getParentProp("shape") || "round";
+    });
+    const onClick = (event) => {
+      const {
+        target
+      } = event;
+      const icon = iconRef.value;
+      const iconClicked = icon === target || (icon == null ? void 0 : icon.contains(target));
+      if (!disabled.value && (iconClicked || !props2.labelDisabled)) {
+        emit("toggle");
+      }
+      emit("click", event);
+    };
+    const renderIcon = () => {
+      var _a, _b;
+      const {
+        bem,
+        checked,
+        indeterminate
+      } = props2;
+      const iconSize = props2.iconSize || getParentProp("iconSize");
+      return Vue.createVNode("div", {
+        "ref": iconRef,
+        "class": bem("icon", [shape.value, {
+          disabled: disabled.value,
+          checked,
+          indeterminate
+        }]),
+        "style": shape.value !== "dot" ? {
+          fontSize: format.addUnit(iconSize)
+        } : {
+          width: format.addUnit(iconSize),
+          height: format.addUnit(iconSize),
+          borderColor: (_a = iconStyle.value) == null ? void 0 : _a.borderColor
+        }
+      }, [slots.icon ? slots.icon({
+        checked,
+        disabled: disabled.value
+      }) : shape.value !== "dot" ? Vue.createVNode(index.Icon, {
+        "name": indeterminate ? "minus" : "success",
+        "style": iconStyle.value
+      }, null) : Vue.createVNode("div", {
+        "class": bem("icon--dot__icon"),
+        "style": {
+          backgroundColor: (_b = iconStyle.value) == null ? void 0 : _b.backgroundColor
+        }
+      }, null)]);
+    };
+    const renderLabel = () => {
+      const {
+        checked
+      } = props2;
+      if (slots.default) {
+        return Vue.createVNode("span", {
+          "class": props2.bem("label", [props2.labelPosition, {
+            disabled: disabled.value
+          }])
+        }, [slots.default({
+          checked,
+          disabled: disabled.value
+        })]);
+      }
+    };
+    return () => {
+      const nodes = props2.labelPosition === "left" ? [renderLabel(), renderIcon()] : [renderIcon(), renderLabel()];
+      return Vue.createVNode("div", {
+        "role": props2.role,
+        "class": props2.bem([{
+          disabled: disabled.value,
+          "label-disabled": props2.labelDisabled
+        }, direction.value]),
+        "tabindex": disabled.value ? void 0 : 0,
+        "aria-checked": props2.checked,
+        "onClick": onClick
+      }, [nodes]);
+    };
+  }
+});
+exports.checkerProps = checkerProps;
+exports.default = stdin_default;