sard-uniapp 1.23.4 → 1.24.0

package/components/segmented/index.scss

@@ -0,0 +1,60 @@
+@use '../style/base' as *;
+
+@include bem(segmented) {
+  @include b() {
+    @include universal;
+    flex-direction: row;
+    align-items: stretch;
+    min-height: var(--sar-segmented-min-height);
+    padding: var(--sar-segmented-padding);
+    border-radius: var(--sar-segmented-border-radius);
+    background-color: var(--sar-segmented-bg);
+    font-size: var(--sar-segmented-font-size);
+
+    @include m(vertical) {
+      display: inline-flex;
+
+      @include e(group) {
+        flex-direction: column;
+      }
+
+      @include e(pointer) {
+        width: 100%;
+      }
+    }
+
+    @include m(small) {
+      min-height: var(--sar-segmented-small-min-height);
+    }
+
+    @include m(large) {
+      min-height: var(--sar-segmented-large-min-height);
+    }
+
+    @include m(round) {
+      border-radius: var(--sar-rounded-full);
+
+      @include e(pointer) {
+        border-radius: var(--sar-rounded-full);
+      }
+    }
+  }
+
+  @include e(pointer) {
+    position: absolute;
+    top: 0;
+    left: 0;
+    height: 100%;
+    border-radius: calc(var(--sar-segmented-border-radius) - 4rpx);
+    background-color: var(--sar-segmented-pointer-bg);
+    box-shadow: var(--sar-segmented-pointer-box-shadow);
+    transition: transform var(--sar-segmented-pointer-duration);
+  }
+
+  @include e(group) {
+    @include universal;
+    flex-direction: row;
+    align-items: stretch;
+    width: 100%;
+  }
+}

package/components/segmented/segmented.d.ts

@@ -0,0 +1,21 @@
+import { type SegmentedProps, type SegmentedSlots } from './common';
+declare function __VLS_template(): Readonly<SegmentedSlots> & SegmentedSlots;
+declare const __VLS_component: import("vue").DefineComponent<SegmentedProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    "update:model-value": (value: any) => any;
+    change: (value: any) => any;
+}, string, import("vue").PublicProps, Readonly<SegmentedProps> & Readonly<{
+    "onUpdate:model-value"?: ((value: any) => any) | undefined;
+    onChange?: ((value: any) => any) | undefined;
+}>, {
+    size: import("./common").SegmentedSize;
+    shape: "square" | "round";
+    direction: "horizontal" | "vertical";
+    validateEvent: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/components/segmented/segmented.vue

@@ -0,0 +1,163 @@
+<template>
+  <view :class="segmentedClass" :style="segmentedStyle">
+    <view :class="groupClass">
+      <view :class="pointerClass" :style="pointerStyle"></view>
+      <slot>
+        <sar-segmented-item
+          v-for="(option, i) in convertedOptions"
+          :key="i"
+          :value="option.value"
+          :label="option.label"
+          :disabled="option.disabled"
+          :icon="option.icon"
+          :icon-family="option.iconFamily"
+          :icon-size="option.iconSize"
+        />
+      </slot>
+    </view>
+  </view>
+</template>
+
+<script>
+import { mergeDefaults as _mergeDefaults, defineComponent as _defineComponent } from "vue";
+import { computed, provide, reactive, ref, toRef, watch } from "vue";
+import { classNames, stringifyStyle, createBem, isPrimitive } from "../../utils";
+import {
+  defaultSegmentedProps,
+  defaultOptionKeys,
+  segmentedContextSymbol
+} from "./common";
+import SarSegmentedItem from "../segmented-item/segmented-item.vue";
+import { useFormItemContext } from "../form";
+/**
+ * @property {string} rootClass 组件根元素类名，默认值：-。
+ * @property {StyleValue} rootStyle 组件根元素样式，默认值：-。
+ * @property {any} modelValue 绑定值，默认值：-。
+ * @property {boolean} disabled 是否禁用，默认值：false。
+ * @property {boolean} readonly 是否只读，默认值：false。
+ * @property {'small' | 'middle' | 'large'} size 组件大小，默认值：'middle'。
+ * @property {'horizontal' | 'vertical'} direction 展示的方向，默认值：'horizontal'。
+ * @property {'square' | 'round'} shape 形状，默认值：'square'。
+ * @property {SegmentedOption[]} options 选项的数据，默认值：-。
+ * @property {SegmentedOptionKeys} optionKeys 自定义 options 的 label、value 的字段，默认值：{label: 'label', value: 'value'}。
+ * @property {boolean} validateEvent 是否触发表单验证，默认值：true。
+ * @event {(value: any) => void} update 当所选值更改时触发
+ * @event {(value: any) => void} change 当所选值更改时触发
+ */
+export default  _defineComponent({
+  components: {
+    SarSegmentedItem,
+  },
+  ...{
+    options: {
+      virtualHost: true,
+      styleIsolation: "shared"
+    }
+  },
+  __name: "segmented",
+  props:  _mergeDefaults({
+    rootStyle: { type: [Boolean, null, String, Object, Array], required: false, skipCheck: true },
+    rootClass: { type: String, required: false },
+    modelValue: { type: null, required: false },
+    disabled: { type: Boolean, required: false },
+    readonly: { type: Boolean, required: false },
+    size: { type: String, required: false },
+    direction: { type: String, required: false },
+    shape: { type: String, required: false },
+    options: { type: Array, required: false },
+    optionKeys: { type: Object, required: false },
+    validateEvent: { type: Boolean, required: false }
+  }, defaultSegmentedProps),
+  emits: ["update:model-value", "change"],
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const bem = createBem("segmented");
+    const formItemContext = useFormItemContext();
+    const innerValue = ref(props.modelValue);
+    watch(
+      () => props.modelValue,
+      () => {
+        innerValue.value = props.modelValue;
+        if (props.validateEvent) {
+          formItemContext?.onChange();
+        }
+      }
+    );
+    const fieldKeys = computed(() => {
+      return Object.assign({}, defaultOptionKeys, props.optionKeys);
+    });
+    const convertedOptions = computed(() => {
+      return (props.options || []).map((option) => {
+        return isPrimitive(option) ? {
+          label: option,
+          value: option
+        } : {
+          label: option[fieldKeys.value.label],
+          value: option[fieldKeys.value.value],
+          disabled: option[fieldKeys.value.disabled],
+          icon: option.icon,
+          iconFamily: option.iconFamily,
+          iconSize: option.iconSize
+        };
+      });
+    });
+    const currentIndex = computed(() => {
+      return convertedOptions.value.findIndex(
+        (option) => option.value === innerValue.value
+      );
+    });
+    const optionsCount = computed(() => convertedOptions.value.length);
+    const toggle = (value) => {
+      if (value !== innerValue.value) {
+        innerValue.value = value;
+        emit("update:model-value", value);
+        emit("change", value);
+      }
+    };
+    provide(
+      segmentedContextSymbol,
+      reactive({
+        disabled: toRef(() => props.disabled),
+        readonly: toRef(() => props.readonly),
+        size: toRef(() => props.size),
+        shape: toRef(() => props.shape),
+        value: innerValue,
+        toggle
+      })
+    );
+    __expose({});
+    const segmentedClass = computed(() => {
+      return classNames(
+        bem.b(),
+        bem.m(props.size),
+        bem.m(props.direction),
+        bem.m(props.shape),
+        props.rootClass
+      );
+    });
+    const segmentedStyle = computed(() => {
+      return stringifyStyle(props.rootStyle);
+    });
+    const groupClass = computed(() => {
+      return classNames(bem.e("group"));
+    });
+    const pointerClass = computed(() => {
+      return classNames(bem.e("pointer"));
+    });
+    const pointerStyle = computed(() => {
+      const isHorizontal = props.direction === "horizontal";
+      return {
+        [isHorizontal ? "width" : "height"]: 1 / optionsCount.value * 100 + "%",
+        transform: `translate${isHorizontal ? "X" : "Y"}(${currentIndex.value * 100}%)`
+      };
+    });
+    const __returned__ = { props, emit, bem, formItemContext, innerValue, fieldKeys, convertedOptions, currentIndex, optionsCount, toggle, segmentedClass, segmentedStyle, groupClass, pointerClass, pointerStyle, SarSegmentedItem };
+    return __returned__;
+  }
+});
+</script>
+
+<style lang="scss">
+@import './index.scss';
+</style>

package/components/segmented/variables.scss

@@ -0,0 +1,21 @@
+// #variables
+page,
+.sar-portal {
+  --sar-segmented-min-height: 64rpx;
+  --sar-segmented-large-min-height: 80rpx;
+  --sar-segmented-small-min-height: 48rpx;
+  --sar-segmented-padding: 2px;
+  --sar-segmented-font-size: var(--sar-text-base);
+  --sar-segmented-bg: var(--sar-secondary-bg);
+  --sar-segmented-border-radius: var(--sar-rounded);
+  --sar-segmented-pointer-bg: var(--sar-emphasis-bg);
+  --sar-segmented-pointer-duration: var(--sar-duration);
+  --sar-segmented-pointer-box-shadow: var(--sar-shadow-sm);
+  --sar-segmented-item-padding: 24rpx;
+  --sar-segmented-item-small-padding: 16rpx;
+  --sar-segmented-item-color: var(--sar-secondary-color);
+  --sar-segmented-item-active-bg: var(--sar-active-deep-bg);
+  --sar-segmented-item-active-color: var(--sar-emphasis-color);
+  --sar-segmented-item-label-margin-left: 12rpx;
+}
+// #endvariables

package/components/segmented-item/common.d.ts

@@ -0,0 +1,21 @@
+import { type StyleValue } from 'vue';
+export interface SegmentedItemProps {
+    rootStyle?: StyleValue;
+    rootClass?: string;
+    label?: string | number;
+    value?: string | number | boolean;
+    icon?: string;
+    iconFamily?: string;
+    iconSize?: string;
+    disabled?: boolean;
+    readonly?: boolean;
+}
+export declare const defaultSegmentedItemProps: {};
+export interface SegmentedItemSlots {
+    default?(props: Record<string, never>): any;
+}
+export interface SegmentedItemEmits {
+    (e: 'click', event: any): void;
+}
+export interface SegmentedItemExpose {
+}

package/components/segmented-item/common.js

@@ -0,0 +1 @@
+export const defaultSegmentedItemProps = {};

package/components/segmented-item/index.d.ts

@@ -0,0 +1 @@
+export type { SegmentedItemProps, SegmentedItemSlots, SegmentedItemEmits, SegmentedItemExpose, } from './common';

package/components/segmented-item/index.js

@@ -0,0 +1 @@
+export {};

package/components/segmented-item/index.scss

@@ -0,0 +1,60 @@
+@use '../style/base' as *;
+
+@include bem(segmented-item) {
+  @include b() {
+    @include universal;
+    flex-direction: row;
+    flex: 1;
+    justify-content: center;
+    align-items: center;
+    min-width: 0;
+    min-height: calc(
+      var(--sar-segmented-min-height) - var(--sar-segmented-padding) * 2
+    );
+    padding: 0 var(--sar-segmented-item-padding);
+    border-radius: calc(var(--sar-segmented-border-radius) - 4rpx);
+    color: var(--sar-segmented-item-color);
+
+    @include m(small) {
+      min-height: calc(
+        var(--sar-segmented-small-min-height) - var(--sar-segmented-padding) * 2
+      );
+    }
+
+    @include m(large) {
+      min-height: calc(
+        var(--sar-segmented-large-min-height) - var(--sar-segmented-padding) * 2
+      );
+    }
+
+    @include m(round) {
+      border-radius: var(--sar-rounded-full);
+    }
+
+    @include m(with-icon) {
+      @include e(label) {
+        margin-left: var(--sar-segmented-item-label-margin-left);
+      }
+    }
+
+    @include m-not(disabled, readonly, selected) {
+      cursor: pointer;
+
+      &:active {
+        background-color: var(--sar-segmented-item-active-bg);
+      }
+    }
+
+    @include m(selected) {
+      color: var(--sar-segmented-item-active-color);
+    }
+
+    @include m(disabled) {
+      @include disabled-text;
+    }
+  }
+
+  @include e(label) {
+    @include ellipsis;
+  }
+}

package/components/segmented-item/segmented-item.d.ts

@@ -0,0 +1,14 @@
+import { type SegmentedItemProps, type SegmentedItemSlots } from './common';
+declare function __VLS_template(): Readonly<SegmentedItemSlots> & SegmentedItemSlots;
+declare const __VLS_component: import("vue").DefineComponent<SegmentedItemProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    click: (event: any) => any;
+}, string, import("vue").PublicProps, Readonly<SegmentedItemProps> & Readonly<{
+    onClick?: ((event: any) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/components/segmented-item/segmented-item.vue

@@ -0,0 +1,99 @@
+<template>
+  <view
+    :class="segmentedItemClass"
+    :style="segmentedItemStyle"
+    @click="onClick"
+  >
+    <slot>
+      <view :class="bem.e('icon')">
+        <sar-icon :name="icon" :family="iconFamily" :size="iconSize" />
+      </view>
+      <view v-if="label" :class="bem.e('label')">{{ label }}</view>
+    </slot>
+  </view>
+</template>
+
+<script>
+import { mergeDefaults as _mergeDefaults, defineComponent as _defineComponent } from "vue";
+import { computed, inject } from "vue";
+import { classNames, stringifyStyle, createBem } from "../../utils";
+import {
+  defaultSegmentedItemProps
+} from "./common";
+import {
+  segmentedContextSymbol
+} from "../segmented/common";
+import SarIcon from "../icon/icon.vue";
+import { useFormContext } from "../form";
+export default  _defineComponent({
+  components: {
+    SarIcon,
+  },
+  ...{
+    options: {
+      virtualHost: true,
+      styleIsolation: "shared"
+    }
+  },
+  __name: "segmented-item",
+  props:  _mergeDefaults({
+    rootStyle: { type: [Boolean, null, String, Object, Array], required: false, skipCheck: true },
+    rootClass: { type: String, required: false },
+    label: { type: [String, Number], required: false },
+    value: { type: [String, Number, Boolean], required: false },
+    icon: { type: String, required: false },
+    iconFamily: { type: String, required: false },
+    iconSize: { type: String, required: false },
+    disabled: { type: Boolean, required: false },
+    readonly: { type: Boolean, required: false }
+  }, defaultSegmentedItemProps),
+  emits: ["click"],
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const bem = createBem("segmented-item");
+    const context = inject(segmentedContextSymbol, null);
+    if (!context) {
+      throw new Error("SegmentedItem must be included in Segmented.");
+    }
+    const formContext = useFormContext();
+    const isSelected = computed(() => {
+      return context.value === props.value;
+    });
+    const isDisabled = computed(() => {
+      return formContext?.disabled || context?.disabled || props.disabled;
+    });
+    const isReadonly = computed(() => {
+      return formContext?.readonly || context?.readonly || props.readonly;
+    });
+    const onClick = (event) => {
+      if (!isDisabled.value && !isReadonly.value) {
+        context.toggle(props.value);
+      }
+      emit("click", event);
+    };
+    __expose({});
+    const segmentedItemClass = computed(() => {
+      return classNames(
+        bem.b(),
+        bem.m("selected", isSelected.value),
+        bem.m("disabled", isDisabled.value),
+        bem.m("readonly", isReadonly.value),
+        bem.m("with-icon", !!props.icon),
+        bem.m(context.size),
+        bem.m(context.shape),
+        props.rootClass
+      );
+    });
+    const segmentedItemStyle = computed(() => {
+      return stringifyStyle(props.rootStyle);
+    });
+    const __returned__ = { props, emit, bem, context, formContext, isSelected, isDisabled, isReadonly, onClick, segmentedItemClass, segmentedItemStyle, SarIcon };
+    return __returned__;
+  }
+});
+</script>
+
+<style lang="scss">
+@import './index.scss';
+</style>

package/components/sticky/README.md

@@ -39,6 +39,10 @@ import StickyBox from 'sard-uniapp/components/sticky-box/sticky-box.vue'
 
 @code('${DEMO_PATH}/sticky/demo/OffsetTop.vue')
 
+`@/utils`
+
+@code('${ROOT_PATH}/utils/index.ts')
+
 ### 动态插入
 
 即使是动态插入的数据，`Sticky` 组件也能重新计算其位置。

package/components/tree/README.md

@@ -121,10 +121,11 @@ import Tree from 'sard-uniapp/components/tree/tree.vue'
 
 ### TreeEmits
 
-| 事件                            | 描述                   | 类型                                                 |
-| ------------------------------- | ---------------------- | ---------------------------------------------------- |
-| update:current <sup>1.17+</sup> | 选择节点后触发（单选） | (key: string \| number, node: TreeStateNode) => void |
-| select <sup>1.17+</sup>         | 选择节点后触发（单选） | (key: string \| number, node: TreeStateNode) => void |
+| 事件                            | 描述                   | 类型                                                     |
+| ------------------------------- | ---------------------- | -------------------------------------------------------- |
+| update:current <sup>1.17+</sup> | 选择节点后触发（单选） | (key: string \| number, node: TreeStateNode) => void     |
+| select <sup>1.17+</sup>         | 选择节点后触发（单选） | (key: string \| number, node: TreeStateNode) => void     |
+| check <sup>1.24+</sup>          | 点击树节点复选框时触发 | (event: {checked: boolean; node: TreeStateNode}) => void |
 
 ### TreeExpose
 

package/components/tree/common.d.ts

@@ -63,6 +63,10 @@ export declare const defaultTreeProps: () => {
 export interface TreeEmits {
     (e: 'update:current', key: string | number, node: TreeStateNode): void;
     (e: 'select', key: string | number, node: TreeStateNode): void;
+    (e: 'check', event: {
+        checked: boolean;
+        node: TreeStateNode;
+    }): void;
 }
 export interface TreeExpose {
     setExpanded: (key: string | number, expanded: boolean) => void;
@@ -93,7 +97,7 @@ export interface TreeContext {
     treeData: TreeStateNode[];
     setExpandedByNode: (node: TreeStateNode, expanded: boolean) => void;
     toggleExpandedByNode: (node: TreeStateNode) => void;
-    setCheckedByNode: (node: TreeStateNode, checked: boolean) => void;
+    toggleCheck: (node: TreeStateNode, checked: boolean) => void;
     levelup: (node: TreeStateNode) => void;
     leveldown: (node: TreeStateNode) => void;
     edit: (node: TreeStateNode, getEditRect: () => Promise<NodeRect>) => void;

package/components/tree/tree.d.ts

@@ -14,9 +14,17 @@ declare const _default: import("vue").DefineComponent<TreeProps, {
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
     select: (key: string | number, node: TreeStateNode) => any;
     "update:current": (key: string | number, node: TreeStateNode) => any;
+    check: (event: {
+        checked: boolean;
+        node: TreeStateNode;
+    }) => any;
 }, string, import("vue").PublicProps, Readonly<TreeProps> & Readonly<{
     onSelect?: ((key: string | number, node: TreeStateNode) => any) | undefined;
     "onUpdate:current"?: ((key: string | number, node: TreeStateNode) => any) | undefined;
+    onCheck?: ((event: {
+        checked: boolean;
+        node: TreeStateNode;
+    }) => any) | undefined;
 }>, {
     data: TreeNode[];
     accordion: boolean;

package/components/tree/tree.vue

@@ -75,6 +75,7 @@ import { recurAncestor, recurDescendant, recurNodes } from "./utils";
  * @property {(value: string, node: TreeStateNode) => boolean} filterMethod 自定义过滤方法，默认值：-。
  * @event {(key: string | number, node: TreeStateNode) => void} update 选择节点后触发（单选）
  * @event {(key: string | number, node: TreeStateNode) => void} select 选择节点后触发（单选）
+ * @event {(event: {checked: boolean; node: TreeStateNode}) => void} check 点击树节点复选框时触发
  */
 export default  _defineComponent({
   components: {
@@ -110,7 +111,7 @@ export default  _defineComponent({
     filterMode: { type: String, required: false },
     filterMethod: { type: Function, required: false }
   }, defaultTreeProps()),
-  emits: ["update:current", "select"],
+  emits: ["update:current", "select", "check"],
   setup(__props, { expose: __expose, emit: __emit }) {
     const props = __props;
     const emit = __emit;
@@ -399,6 +400,13 @@ export default  _defineComponent({
       recur(treeData.value);
       totalLevel.value = count;
     };
+    const toggleCheck = (node, checked) => {
+      setCheckedByNode(node, checked);
+      emit("check", {
+        checked,
+        node
+      });
+    };
     watch(
       () => props.data,
       () => {
@@ -559,6 +567,7 @@ export default  _defineComponent({
       levelup,
       leveldown,
       drop,
+      toggleCheck,
       edit,
       currentKey,
       singleSelect
@@ -592,7 +601,7 @@ export default  _defineComponent({
       return treeMap;
     }, set treeMap(v) {
       treeMap = v;
-    }, totalLevel, recurRawNode, setExpandedByNode, toggleExpandedByNode, setExpanded, toggleExpanded, setExpandedKeys, getExpandedKeys, setCheckedByNode, updateAncestorChecked, setCheckedKeys, setChecked, getCheckedKeys, getHalfCheckedKeys, prepend, append, appendRoot, before, after, remove, levelup, leveldown, drop, addRootNode, getCleanTreeData, setRenderPosition, popoverOptions, popover, get currentEditNode() {
+    }, totalLevel, recurRawNode, setExpandedByNode, toggleExpandedByNode, setExpanded, toggleExpanded, setExpandedKeys, getExpandedKeys, setCheckedByNode, updateAncestorChecked, setCheckedKeys, setChecked, getCheckedKeys, getHalfCheckedKeys, prepend, append, appendRoot, before, after, remove, levelup, leveldown, drop, addRootNode, getCleanTreeData, setRenderPosition, toggleCheck, popoverOptions, popover, get currentEditNode() {
       return currentEditNode;
     }, set currentEditNode(v) {
       currentEditNode = v;

package/components/tree-node/tree-node.vue

@@ -299,7 +299,7 @@ export default  _defineComponent({
     const [onSelectionTouchStart, onSelectionTouchEnd] = useSimulatedClick(() => {
       if (!props.node.disabled) {
         if (treeContext.selectable) {
-          treeContext.setCheckedByNode(props.node, !props.node.checked);
+          treeContext.toggleCheck(props.node, !props.node.checked);
         }
         if (canSingleSelectable.value) {
           treeContext.singleSelect(props.node);

package/components/upload/README.md

@@ -29,6 +29,20 @@ import Upload from 'sard-uniapp/components/upload/upload.vue'
 
 @code('${DEMO_PATH}/upload/demo/Video.vue')
 
+### 同时上传图片和视频 <sup>1.23.5+</sup>
+
+@info
+
+仅 app 和微信支持。
+
+不支持的端，默认回退为选择图片。
+
+@endinfo
+
+设置 `:accept="['image', 'video']"` 允许同时选择图片和视频。
+
+@code('${DEMO_PATH}/upload/demo/Mix.vue')
+
 ### 限定上传数量
 
 通过 `maxCount` 属性可以限制上传文件的数量，上传数量达到限制后，会自动隐藏选择区域。
@@ -99,7 +113,7 @@ import Upload from 'sard-uniapp/components/upload/upload.vue'
 | -------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------- | -------------------------- |
 | root-class                       | 组件根元素类名                                                                                                                                    | string                                                                                        | -                          |
 | root-style                       | 组件根元素样式                                                                                                                                    | StyleValue                                                                                    | -                          |
-| accept                           | 允许上传的文件类型                                                                                                                                | 'image' \| 'video'                                                                            | 'image'                    |
+| accept                           | 允许上传的文件类型                                                                                                                                | 'image' \| 'video' \| ('image' \| 'video' )[]                                                 | 'image'                    |
 | multiple                         | 是否开启图片多选                                                                                                                                  | boolean                                                                                       | false                      |
 | source-type                      | 文件选择来源                                                                                                                                      | ('album' \| 'camera')[]                                                                       | ['album', 'camera']        |
 | size-type                        | 所选的图片的尺寸                                                                                                                                  | ('original' \| 'compressed')[]                                                                | ['original', 'compressed'] |

package/components/upload/common.d.ts

@@ -26,7 +26,7 @@ export interface UploadSelectOptions {
 export interface UploadProps {
     rootStyle?: StyleValue;
     rootClass?: string;
-    accept?: 'image' | 'video';
+    accept?: 'image' | 'video' | ('image' | 'video')[];
     multiple?: boolean;
     sourceType?: ('album' | 'camera')[];
     sizeType?: ('original' | 'compressed')[];
@@ -45,7 +45,7 @@ export interface UploadProps {
     beforeRemove?: (index: number, fileItem: UploadFileItem) => boolean | Promise<void>;
     validateEvent?: boolean;
 }
-export declare const defaultUploadProps: Omit<typeof defaultConfig.upload, "sourceType" | "sizeType">;
+export declare const defaultUploadProps: Omit<typeof defaultConfig.upload, "sourceType" | "sizeType" | "accept">;
 export interface UploadSlots {
     default?(props: {
         list: UploadFileItem[];

package/components/upload/upload.d.ts

@@ -11,7 +11,6 @@ declare const __VLS_component: import("vue").DefineComponent<UploadProps, {}, {}
     onRemove?: ((index: number, item: UploadFileItem) => any) | undefined;
     "onItem-click"?: ((item: UploadFileItem, index: number) => any) | undefined;
 }>, {
-    accept: "image" | "video";
     validateEvent: boolean;
     maxDuration: number;
     maxCount: number;