vant 4.0.0-alpha.3 → 4.0.0-beta.1

package/es/address-edit/AddressEditDetail.mjs

@@ -0,0 +1,76 @@
+import { Fragment as _Fragment, createVNode as _createVNode } from "vue";
+import { ref, defineComponent } from "vue";
+import { createNamespace, numericProp } from "../utils/index.mjs";
+import { Cell } from "../cell/index.mjs";
+import { Field } from "../field/index.mjs";
+const [name, bem] = createNamespace("address-edit-detail");
+const t = createNamespace("address-edit")[2];
+var stdin_default = defineComponent({
+  name,
+  props: {
+    show: Boolean,
+    rows: numericProp,
+    value: String,
+    rules: Array,
+    focused: Boolean,
+    maxlength: numericProp,
+    searchResult: Array,
+    showSearchResult: Boolean
+  },
+  emits: ["blur", "focus", "input", "selectSearch"],
+  setup(props, {
+    emit
+  }) {
+    const field = ref();
+    const showSearchResult = () => props.focused && props.searchResult && props.showSearchResult;
+    const onSelect = (express) => {
+      emit("selectSearch", express);
+      emit("input", `${express.address || ""} ${express.name || ""}`.trim());
+    };
+    const renderSearchResult = () => {
+      if (!showSearchResult()) {
+        return;
+      }
+      const {
+        searchResult
+      } = props;
+      return searchResult.map((express) => _createVNode(Cell, {
+        "clickable": true,
+        "key": (express.name || "") + (express.address || ""),
+        "icon": "location-o",
+        "title": express.name,
+        "label": express.address,
+        "class": bem("search-item"),
+        "border": false,
+        "onClick": () => onSelect(express)
+      }, null));
+    };
+    const onBlur = (event) => emit("blur", event);
+    const onFocus = (event) => emit("focus", event);
+    const onInput = (value) => emit("input", value);
+    return () => {
+      if (props.show) {
+        return _createVNode(_Fragment, null, [_createVNode(Field, {
+          "autosize": true,
+          "clearable": true,
+          "ref": field,
+          "class": bem(),
+          "rows": props.rows,
+          "type": "textarea",
+          "rules": props.rules,
+          "label": t("addressDetail"),
+          "border": !showSearchResult(),
+          "maxlength": props.maxlength,
+          "modelValue": props.value,
+          "placeholder": t("addressDetail"),
+          "onBlur": onBlur,
+          "onFocus": onFocus,
+          "onUpdate:modelValue": onInput
+        }, null), renderSearchResult()]);
+      }
+    };
+  }
+});
+export {
+  stdin_default as default
+};

package/es/address-edit/index.mjs

@@ -0,0 +1,8 @@
+import { withInstall } from "../utils/index.mjs";
+import _AddressEdit from "./AddressEdit.mjs";
+const AddressEdit = withInstall(_AddressEdit);
+var stdin_default = AddressEdit;
+export {
+  AddressEdit,
+  stdin_default as default
+};

package/es/address-list/AddressList.mjs

@@ -0,0 +1,82 @@
+import { createVNode as _createVNode } from "vue";
+import { defineComponent } from "vue";
+import { truthProp, numericProp, makeArrayProp, createNamespace } from "../utils/index.mjs";
+import { Button } from "../button/index.mjs";
+import { RadioGroup } from "../radio-group/index.mjs";
+import AddressListItem from "./AddressListItem.mjs";
+const [name, bem, t] = createNamespace("address-list");
+const addressListProps = {
+  list: makeArrayProp(),
+  modelValue: numericProp,
+  switchable: truthProp,
+  disabledText: String,
+  disabledList: makeArrayProp(),
+  addButtonText: String,
+  defaultTagText: String
+};
+var stdin_default = defineComponent({
+  name,
+  props: addressListProps,
+  emits: ["add", "edit", "select", "clickItem", "editDisabled", "selectDisabled", "update:modelValue"],
+  setup(props, {
+    slots,
+    emit
+  }) {
+    const renderItem = (item, index, disabled) => {
+      const onEdit = () => emit(disabled ? "editDisabled" : "edit", item, index);
+      const onClick = () => emit("clickItem", item, index);
+      const onSelect = () => {
+        emit(disabled ? "selectDisabled" : "select", item, index);
+        if (!disabled) {
+          emit("update:modelValue", item.id);
+        }
+      };
+      return _createVNode(AddressListItem, {
+        "key": item.id,
+        "address": item,
+        "disabled": disabled,
+        "switchable": props.switchable,
+        "defaultTagText": props.defaultTagText,
+        "onEdit": onEdit,
+        "onClick": onClick,
+        "onSelect": onSelect
+      }, {
+        bottom: slots["item-bottom"],
+        tag: slots.tag
+      });
+    };
+    const renderList = (list, disabled) => {
+      if (list) {
+        return list.map((item, index) => renderItem(item, index, disabled));
+      }
+    };
+    const renderBottom = () => _createVNode("div", {
+      "class": [bem("bottom"), "van-safe-area-bottom"]
+    }, [_createVNode(Button, {
+      "round": true,
+      "block": true,
+      "type": "primary",
+      "text": props.addButtonText || t("add"),
+      "class": bem("add"),
+      "onClick": () => emit("add")
+    }, null)]);
+    return () => {
+      var _a, _b;
+      const List = renderList(props.list);
+      const DisabledList = renderList(props.disabledList, true);
+      const DisabledText = props.disabledText && _createVNode("div", {
+        "class": bem("disabled-text")
+      }, [props.disabledText]);
+      return _createVNode("div", {
+        "class": bem()
+      }, [(_a = slots.top) == null ? void 0 : _a.call(slots), _createVNode(RadioGroup, {
+        "modelValue": props.modelValue
+      }, {
+        default: () => [List]
+      }), DisabledText, DisabledList, (_b = slots.default) == null ? void 0 : _b.call(slots), renderBottom()]);
+    };
+  }
+});
+export {
+  stdin_default as default
+};

package/es/address-list/AddressListItem.mjs

@@ -0,0 +1,96 @@
+import { createVNode as _createVNode } from "vue";
+import { defineComponent } from "vue";
+import { extend, createNamespace, makeRequiredProp } from "../utils/index.mjs";
+import { Tag } from "../tag/index.mjs";
+import { Icon } from "../icon/index.mjs";
+import { Cell } from "../cell/index.mjs";
+import { Radio } from "../radio/index.mjs";
+const [name, bem] = createNamespace("address-item");
+var stdin_default = defineComponent({
+  name,
+  props: {
+    address: makeRequiredProp(Object),
+    disabled: Boolean,
+    switchable: Boolean,
+    defaultTagText: String
+  },
+  emits: ["edit", "click", "select"],
+  setup(props, {
+    slots,
+    emit
+  }) {
+    const onClick = () => {
+      if (props.switchable) {
+        emit("select");
+      }
+      emit("click");
+    };
+    const renderRightIcon = () => _createVNode(Icon, {
+      "name": "edit",
+      "class": bem("edit"),
+      "onClick": (event) => {
+        event.stopPropagation();
+        emit("edit");
+        emit("click");
+      }
+    }, null);
+    const renderTag = () => {
+      if (slots.tag) {
+        return slots.tag(props.address);
+      }
+      if (props.address.isDefault && props.defaultTagText) {
+        return _createVNode(Tag, {
+          "type": "primary",
+          "round": true,
+          "class": bem("tag")
+        }, {
+          default: () => [props.defaultTagText]
+        });
+      }
+    };
+    const renderContent = () => {
+      const {
+        address,
+        disabled,
+        switchable
+      } = props;
+      const Info = [_createVNode("div", {
+        "class": bem("name")
+      }, [`${address.name} ${address.tel}`, renderTag()]), _createVNode("div", {
+        "class": bem("address")
+      }, [address.address])];
+      if (switchable && !disabled) {
+        return _createVNode(Radio, {
+          "name": address.id,
+          "iconSize": 18
+        }, {
+          default: () => [Info]
+        });
+      }
+      return Info;
+    };
+    return () => {
+      var _a;
+      const {
+        disabled
+      } = props;
+      return _createVNode("div", {
+        "class": bem({
+          disabled
+        }),
+        "onClick": onClick
+      }, [_createVNode(Cell, {
+        "border": false,
+        "titleClass": bem("title")
+      }, {
+        title: renderContent,
+        "right-icon": renderRightIcon
+      }), (_a = slots.bottom) == null ? void 0 : _a.call(slots, extend({}, props.address, {
+        disabled
+      }))]);
+    };
+  }
+});
+export {
+  stdin_default as default
+};

package/es/address-list/index.mjs

@@ -0,0 +1,8 @@
+import { withInstall } from "../utils/index.mjs";
+import _AddressList from "./AddressList.mjs";
+const AddressList = withInstall(_AddressList);
+var stdin_default = AddressList;
+export {
+  AddressList,
+  stdin_default as default
+};

package/es/area/Area.mjs

@@ -0,0 +1,76 @@
+import { createVNode as _createVNode, mergeProps as _mergeProps } from "vue";
+import { ref, watch, computed, defineComponent } from "vue";
+import { pick, extend, makeArrayProp, makeNumericProp, createNamespace } from "../utils/index.mjs";
+import { pickerSharedProps } from "../picker/Picker.mjs";
+import { INHERIT_PROPS, INHERIT_SLOTS, formatDataForCascade } from "./utils.mjs";
+import { useExpose } from "../composables/use-expose.mjs";
+import { Picker } from "../picker/index.mjs";
+const [name, bem] = createNamespace("area");
+const areaProps = extend({}, pickerSharedProps, {
+  modelValue: String,
+  columnsNum: makeNumericProp(3),
+  columnsPlaceholder: makeArrayProp(),
+  areaList: {
+    type: Object,
+    default: () => ({})
+  }
+});
+var stdin_default = defineComponent({
+  name,
+  props: areaProps,
+  emits: ["change", "confirm", "cancel", "update:modelValue"],
+  setup(props, {
+    emit,
+    slots
+  }) {
+    const codes = ref([]);
+    const picker = ref();
+    const columns = computed(() => formatDataForCascade(props));
+    const onChange = (...args) => emit("change", ...args);
+    const onCancel = (...args) => emit("cancel", ...args);
+    const onConfirm = (...args) => emit("confirm", ...args);
+    watch(codes, (newCodes) => {
+      const lastCode = newCodes.length ? newCodes[newCodes.length - 1] : "";
+      if (lastCode && lastCode !== props.modelValue) {
+        emit("update:modelValue", lastCode);
+      }
+    }, {
+      deep: true
+    });
+    watch(() => props.modelValue, (newCode) => {
+      if (newCode) {
+        const lastCode = codes.value.length ? codes.value[codes.value.length - 1] : "";
+        if (newCode !== lastCode) {
+          codes.value = [`${newCode.slice(0, 2)}0000`, `${newCode.slice(0, 4)}00`, newCode].slice(0, +props.columnsNum);
+        }
+      } else {
+        codes.value = [];
+      }
+    }, {
+      immediate: true
+    });
+    useExpose({
+      confirm: () => {
+        var _a;
+        return (_a = picker.value) == null ? void 0 : _a.confirm();
+      },
+      getSelectedOptions: () => {
+        var _a;
+        return ((_a = picker.value) == null ? void 0 : _a.getSelectedOptions()) || [];
+      }
+    });
+    return () => _createVNode(Picker, _mergeProps({
+      "ref": picker,
+      "modelValue": codes.value,
+      "onUpdate:modelValue": ($event) => codes.value = $event,
+      "class": bem(),
+      "columns": columns.value,
+      "onChange": onChange,
+      "onCancel": onCancel,
+      "onConfirm": onConfirm
+    }, pick(props, INHERIT_PROPS)), pick(slots, INHERIT_SLOTS));
+  }
+});
+export {
+  stdin_default as default
+};

package/es/area/index.mjs

@@ -0,0 +1,8 @@
+import { withInstall } from "../utils/index.mjs";
+import _Area from "./Area.mjs";
+const Area = withInstall(_Area);
+var stdin_default = Area;
+export {
+  Area,
+  stdin_default as default
+};

package/es/badge/Badge.mjs

@@ -0,0 +1,95 @@
+import { createVNode as _createVNode } from "vue";
+import { computed, defineComponent } from "vue";
+import { isDef, addUnit, isNumeric, truthProp, numericProp, makeStringProp, createNamespace } from "../utils/index.mjs";
+const [name, bem] = createNamespace("badge");
+const badgeProps = {
+  dot: Boolean,
+  max: numericProp,
+  tag: makeStringProp("div"),
+  color: String,
+  offset: Array,
+  content: numericProp,
+  showZero: truthProp,
+  position: makeStringProp("top-right")
+};
+var stdin_default = defineComponent({
+  name,
+  props: badgeProps,
+  setup(props, {
+    slots
+  }) {
+    const hasContent = () => {
+      if (slots.content) {
+        return true;
+      }
+      const {
+        content,
+        showZero
+      } = props;
+      return isDef(content) && content !== "" && (showZero || content !== 0 && content !== "0");
+    };
+    const renderContent = () => {
+      const {
+        dot,
+        max,
+        content
+      } = props;
+      if (!dot && hasContent()) {
+        if (slots.content) {
+          return slots.content();
+        }
+        if (isDef(max) && isNumeric(content) && +content > max) {
+          return `${max}+`;
+        }
+        return content;
+      }
+    };
+    const style = computed(() => {
+      const style2 = {
+        background: props.color
+      };
+      if (props.offset) {
+        const [x, y] = props.offset;
+        if (slots.default) {
+          style2.top = addUnit(y);
+          if (typeof x === "number") {
+            style2.right = addUnit(-x);
+          } else {
+            style2.right = x.startsWith("-") ? x.replace("-", "") : `-${x}`;
+          }
+        } else {
+          style2.marginTop = addUnit(y);
+          style2.marginLeft = addUnit(x);
+        }
+      }
+      return style2;
+    });
+    const renderBadge = () => {
+      if (hasContent() || props.dot) {
+        return _createVNode("div", {
+          "class": bem([props.position, {
+            dot: props.dot,
+            fixed: !!slots.default
+          }]),
+          "style": style.value
+        }, [renderContent()]);
+      }
+    };
+    return () => {
+      if (slots.default) {
+        const {
+          tag
+        } = props;
+        return _createVNode(tag, {
+          "class": bem("wrapper")
+        }, {
+          default: () => [slots.default(), renderBadge()]
+        });
+      }
+      return renderBadge();
+    };
+  }
+});
+export {
+  stdin_default as default
+};

package/es/badge/index.mjs

@@ -0,0 +1,8 @@
+import { withInstall } from "../utils/index.mjs";
+import _Badge from "./Badge.mjs";
+const Badge = withInstall(_Badge);
+var stdin_default = Badge;
+export {
+  Badge,
+  stdin_default as default
+};

package/es/button/Button.mjs

@@ -0,0 +1,148 @@
+import { createVNode as _createVNode } from "vue";
+import { defineComponent } from "vue";
+import { extend, numericProp, preventDefault, makeStringProp, createNamespace, BORDER_SURROUND } from "../utils/index.mjs";
+import { useRoute, routeProps } from "../composables/use-route.mjs";
+import { Icon } from "../icon/index.mjs";
+import { Loading } from "../loading/index.mjs";
+const [name, bem] = createNamespace("button");
+const buttonProps = extend({}, routeProps, {
+  tag: makeStringProp("button"),
+  text: String,
+  icon: String,
+  type: makeStringProp("default"),
+  size: makeStringProp("normal"),
+  color: String,
+  block: Boolean,
+  plain: Boolean,
+  round: Boolean,
+  square: Boolean,
+  loading: Boolean,
+  hairline: Boolean,
+  disabled: Boolean,
+  iconPrefix: String,
+  nativeType: makeStringProp("button"),
+  loadingSize: numericProp,
+  loadingText: String,
+  loadingType: String,
+  iconPosition: makeStringProp("left")
+});
+var stdin_default = defineComponent({
+  name,
+  props: buttonProps,
+  emits: ["click"],
+  setup(props, {
+    emit,
+    slots
+  }) {
+    const route = useRoute();
+    const renderLoadingIcon = () => {
+      if (slots.loading) {
+        return slots.loading();
+      }
+      return _createVNode(Loading, {
+        "size": props.loadingSize,
+        "type": props.loadingType,
+        "class": bem("loading")
+      }, null);
+    };
+    const renderIcon = () => {
+      if (props.loading) {
+        return renderLoadingIcon();
+      }
+      if (slots.icon) {
+        return _createVNode("div", {
+          "class": bem("icon")
+        }, [slots.icon()]);
+      }
+      if (props.icon) {
+        return _createVNode(Icon, {
+          "name": props.icon,
+          "class": bem("icon"),
+          "classPrefix": props.iconPrefix
+        }, null);
+      }
+    };
+    const renderText = () => {
+      let text;
+      if (props.loading) {
+        text = props.loadingText;
+      } else {
+        text = slots.default ? slots.default() : props.text;
+      }
+      if (text) {
+        return _createVNode("span", {
+          "class": bem("text")
+        }, [text]);
+      }
+    };
+    const getStyle = () => {
+      const {
+        color,
+        plain
+      } = props;
+      if (color) {
+        const style = {
+          color: plain ? color : "white"
+        };
+        if (!plain) {
+          style.background = color;
+        }
+        if (color.includes("gradient")) {
+          style.border = 0;
+        } else {
+          style.borderColor = color;
+        }
+        return style;
+      }
+    };
+    const onClick = (event) => {
+      if (props.loading) {
+        preventDefault(event);
+      } else if (!props.disabled) {
+        emit("click", event);
+        route();
+      }
+    };
+    return () => {
+      const {
+        tag,
+        type,
+        size,
+        block,
+        round,
+        plain,
+        square,
+        loading,
+        disabled,
+        hairline,
+        nativeType,
+        iconPosition
+      } = props;
+      const classes = [bem([type, size, {
+        plain,
+        block,
+        round,
+        square,
+        loading,
+        disabled,
+        hairline
+      }]), {
+        [BORDER_SURROUND]: hairline
+      }];
+      return _createVNode(tag, {
+        "type": nativeType,
+        "class": classes,
+        "style": getStyle(),
+        "disabled": disabled,
+        "onClick": onClick
+      }, {
+        default: () => [_createVNode("div", {
+          "class": bem("content")
+        }, [iconPosition === "left" && renderIcon(), renderText(), iconPosition === "right" && renderIcon()])]
+      });
+    };
+  }
+});
+export {
+  stdin_default as default
+};

package/es/button/index.mjs

@@ -0,0 +1,8 @@
+import { withInstall } from "../utils/index.mjs";
+import _Button from "./Button.mjs";
+const Button = withInstall(_Button);
+var stdin_default = Button;
+export {
+  Button,
+  stdin_default as default
+};