ep-craft 0.1.34 → 0.1.35

package/dist/components/transfer/EpTransferPanel.vue.d.ts

@@ -0,0 +1,24 @@
+import type { TransferDataItem } from './transfer';
+import type { TransferPanelProps } from './transfer-panel';
+declare const _default: <T extends TransferDataItem = TransferDataItem>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly "onChecked-change"?: ((value: import("./transfer").TransferKey[], movedKeys?: import("./transfer").TransferKey[] | undefined) => any) | undefined;
+    } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, "onChecked-change"> & TransferPanelProps<T> & Partial<{}>> & import("vue").PublicProps;
+    expose(exposed: import("vue").ShallowUnwrapRef<{
+        /** @description filter keyword */
+        query: import("vue").Ref<string, string>;
+    }>): void;
+    attrs: any;
+    slots: {
+        empty?: (props: {}) => any;
+    } & {
+        default?: (props: {}) => any;
+    };
+    emit: (event: "checked-change", value: import("./transfer").TransferKey[], movedKeys?: import("./transfer").TransferKey[] | undefined) => void;
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/components/transfer/EpTransferPanel.vue.js

@@ -0,0 +1,191 @@
+import { defineComponent as J, useSlots as K, reactive as Q, computed as N, toRefs as W, openBlock as r, createElementBlock as v, normalizeClass as o, unref as e, createElementVNode as d, createVNode as m, isRef as S, withCtx as u, toDisplayString as V, createBlock as g, createCommentVNode as w, withDirectives as D, Fragment as X, renderList as Y, normalizeStyle as Z, vShow as P, renderSlot as U, createTextVNode as _ } from "vue";
+import { isEmpty as f } from "../../utils/types.js";
+import "lodash-unified";
+import "@vueuse/core";
+import "@vue/shared";
+import { mutable as ee } from "../../utils/typescript.js";
+import { Search as te } from "@element-plus/icons-vue";
+import { useNamespace as le } from "../../hooks/use-namespace/index.js";
+import { useLocale as ae } from "../../hooks/use-locale/index.js";
+import "../../hooks/use-size/index.js";
+import "@popperjs/core";
+import "../../hooks/use-z-index/index.js";
+import "../../hooks/use-delayed-toggle/index.js";
+import "../../hooks/use-aria/index.js";
+import "../../hooks/use-model-toggle/index.js";
+import "../../hooks/use-empty-values/index.js";
+import { EpCheckbox as E } from "../checkbox/index.js";
+import { EpCheckboxGroup as oe } from "../checkbox-group/index.js";
+import { ElInput as ie } from "../input/index.js";
+import re from "../virtual-list/src/components/fixed-size-list.js";
+import "../virtual-list/src/components/dynamic-size-list.js";
+import "../virtual-list/src/props.js";
+import { transferPanelEmits as ne } from "./transfer-panel.js";
+import { useCheck as se } from "./composables/use-check.js";
+import "./transfer.js";
+import { usePropsAlias as de } from "./composables/use-props-alias.js";
+const Ae = /* @__PURE__ */ J({
+  name: "EpTransferPanel",
+  __name: "EpTransferPanel",
+  props: {
+    data: { default: () => [] },
+    optionRender: {},
+    placeholder: {},
+    title: {},
+    filterable: { type: Boolean },
+    format: { default: () => ({}) },
+    filterMethod: {},
+    defaultChecked: { default: () => [] },
+    props: { default: () => ee({
+      label: "label",
+      key: "key",
+      disabled: "disabled"
+    }) },
+    virtualScroll: { type: Boolean, default: !1 },
+    itemSize: { default: 30 }
+  },
+  emits: ne,
+  setup(t, { expose: q, emit: A }) {
+    const R = t, F = A, G = K(), z = ({ option: h }) => h, { t: x } = ae(), a = le("transfer"), b = Q({
+      checked: [],
+      allChecked: !1,
+      query: "",
+      checkChangeByUser: !0
+    }), n = de(R), {
+      filteredData: c,
+      checkedSummary: M,
+      virtualListRef: T,
+      isIndeterminate: I,
+      checkboxGroupRef: $,
+      virtualListHeight: H,
+      handleAllCheckedChange: O
+    } = se(R, b, F), k = N(
+      () => !f(b.query) && f(c.value)
+    ), B = N(() => !f(G.default()[0].children)), { checked: y, allChecked: C, query: p } = W(b);
+    return q({
+      /** @description filter keyword */
+      query: p
+    }), (h, s) => (r(), v("div", {
+      class: o(e(a).b("panel"))
+    }, [
+      d("p", {
+        class: o(e(a).be("panel", "header"))
+      }, [
+        m(e(E), {
+          modelValue: e(C),
+          "onUpdate:modelValue": s[0] || (s[0] = (l) => S(C) ? C.value = l : null),
+          indeterminate: e(I),
+          "validate-event": !1,
+          onChange: e(O)
+        }, {
+          default: u(() => [
+            d("span", {
+              class: o(e(a).be("panel", "header-title"))
+            }, V(t.title), 3),
+            d("span", {
+              class: o(e(a).be("panel", "header-count"))
+            }, V(e(M)), 3)
+          ]),
+          _: 1
+        }, 8, ["modelValue", "indeterminate", "onChange"])
+      ], 2),
+      d("div", {
+        class: o([e(a).be("panel", "body"), e(a).is("with-footer", B.value)])
+      }, [
+        t.filterable ? (r(), g(e(ie), {
+          key: 0,
+          modelValue: e(p),
+          "onUpdate:modelValue": s[1] || (s[1] = (l) => S(p) ? p.value = l : null),
+          class: o(e(a).be("panel", "filter")),
+          size: "default",
+          placeholder: t.placeholder,
+          "prefix-icon": e(te),
+          clearable: "",
+          "validate-event": !1
+        }, null, 8, ["modelValue", "class", "placeholder", "prefix-icon"])) : w("", !0),
+        D(m(e(oe), {
+          ref_key: "checkboxGroupRef",
+          ref: $,
+          modelValue: e(y),
+          "onUpdate:modelValue": s[2] || (s[2] = (l) => S(y) ? y.value = l : null),
+          "validate-event": !1,
+          class: o([e(a).is("filterable", t.filterable), e(a).be("panel", "list")])
+        }, {
+          default: u(() => [
+            t.virtualScroll ? (r(), g(e(re), {
+              key: 1,
+              ref_key: "virtualListRef",
+              ref: T,
+              data: e(c),
+              total: e(c).length,
+              "item-size": t.itemSize,
+              height: e(H)
+            }, {
+              default: u(({ data: l, index: i, style: j }) => [
+                (r(), v("div", {
+                  key: l[i][e(n).key],
+                  style: Z(j)
+                }, [
+                  m(e(E), {
+                    class: o(e(a).be("panel", "item")),
+                    value: l[i][e(n).key],
+                    disabled: l[i][e(n).disabled],
+                    "validate-event": !1
+                  }, {
+                    default: u(() => {
+                      var L;
+                      return [
+                        m(z, {
+                          option: (L = t.optionRender) == null ? void 0 : L.call(t, l[i])
+                        }, null, 8, ["option"])
+                      ];
+                    }),
+                    _: 2
+                  }, 1032, ["class", "value", "disabled"])
+                ], 4))
+              ]),
+              _: 1
+            }, 8, ["data", "total", "item-size", "height"])) : (r(!0), v(X, { key: 0 }, Y(e(c), (l) => (r(), g(e(E), {
+              key: l[e(n).key],
+              class: o(e(a).be("panel", "item")),
+              value: l[e(n).key],
+              disabled: l[e(n).disabled],
+              "validate-event": !1
+            }, {
+              default: u(() => {
+                var i;
+                return [
+                  m(z, {
+                    option: (i = t.optionRender) == null ? void 0 : i.call(t, l)
+                  }, null, 8, ["option"])
+                ];
+              }),
+              _: 2
+            }, 1032, ["class", "value", "disabled"]))), 128))
+          ]),
+          _: 1
+        }, 8, ["modelValue", "class"]), [
+          [P, !k.value && !e(f)(t.data)]
+        ]),
+        D(d("div", {
+          class: o(e(a).be("panel", "empty"))
+        }, [
+          U(h.$slots, "empty", {}, () => [
+            _(V(k.value ? e(x)("el.transfer.noMatch") : e(x)("el.transfer.noData")), 1)
+          ])
+        ], 2), [
+          [P, k.value || e(f)(t.data)]
+        ])
+      ], 2),
+      B.value ? (r(), v("p", {
+        key: 0,
+        class: o(e(a).be("panel", "footer"))
+      }, [
+        U(h.$slots, "default")
+      ], 2)) : w("", !0)
+    ], 2));
+  }
+});
+export {
+  Ae as default
+};

package/dist/components/transfer/EpTransferPanel2.vue.js

@@ -0,0 +1,4 @@
+import f from "./EpTransferPanel.vue.js";
+export {
+  f as default
+};

package/dist/components/transfer/composables/index.d.ts

@@ -0,0 +1,5 @@
+export { useCheck } from './use-check';
+export { useCheckedChange } from './use-checked-change';
+export { useComputedData } from './use-computed-data';
+export { useMove } from './use-move';
+export { usePropsAlias } from './use-props-alias';

package/dist/components/transfer/composables/use-check.d.ts

@@ -0,0 +1,286 @@
+import type { SetupContext } from 'vue';
+import type { CheckboxValueType } from '@element-plus/components/checkbox';
+import type { TransferDataItem } from '../transfer';
+import type { TransferPanelEmits, TransferPanelProps, TransferPanelState } from '../transfer-panel';
+import type { FixedSizeListInstance } from '@element-plus/components/virtual-list';
+export declare const useCheck: <T extends TransferDataItem = TransferDataItem>(props: Required<Pick<TransferPanelProps<T>, "data" | "format" | "defaultChecked" | "props" | "virtualScroll">> & {
+    filterMethod: TransferPanelProps<T>["filterMethod"];
+}, panelState: TransferPanelState, emit: SetupContext<TransferPanelEmits>["emit"]) => {
+    filteredData: import("vue").ComputedRef<T[]>;
+    checkableData: import("vue").ComputedRef<T[]>;
+    checkedSummary: import("vue").ComputedRef<string>;
+    virtualListRef: import("vue").Ref<FixedSizeListInstance | undefined, FixedSizeListInstance | undefined>;
+    isIndeterminate: import("vue").ComputedRef<boolean>;
+    checkboxGroupRef: import("vue").Ref<({
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{
+            props: import("@element-plus/components/checkbox-group").CheckboxOptionProps;
+            disabled: import("@element-plus/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            type: string;
+            tag: string;
+            modelValue: import("@element-plus/components/checkbox-group").CheckboxGroupValueType;
+            validateEvent: import("@element-plus/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        }> & Omit<{
+            readonly props: import("@element-plus/components/checkbox-group").CheckboxOptionProps;
+            readonly type: string;
+            readonly tag: string;
+            readonly modelValue: import("@element-plus/components/checkbox-group").CheckboxGroupValueType;
+            readonly validateEvent: import("@element-plus/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            readonly size?: import("@element-plus/utils").EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never> | undefined;
+            readonly fill?: string | undefined;
+            readonly disabled?: import("@element-plus/utils").EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
+            readonly options?: import("@element-plus/components/checkbox-group").CheckboxOption[] | undefined;
+            readonly ariaLabel?: string | undefined;
+            readonly min?: number | undefined;
+            readonly max?: number | undefined;
+            readonly textColor?: string | undefined;
+            readonly "onUpdate:modelValue"?: ((val: import("@element-plus/components/checkbox-group").CheckboxGroupValueType) => any) | undefined;
+            readonly onChange?: ((val: CheckboxValueType[]) => any) | undefined;
+        } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "props" | "disabled" | "type" | "tag" | "modelValue" | "validateEvent">;
+        $attrs: import("vue").Attrs;
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import("vue").Slot<any> | undefined;
+        }>;
+        $root: import("vue").ComponentPublicInstance | null;
+        $parent: import("vue").ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: ((event: "update:modelValue", val: import("@element-plus/components/checkbox-group").CheckboxGroupValueType) => void) & ((event: "change", val: CheckboxValueType[]) => void);
+        $el: any;
+        $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+            ariaLabel: StringConstructor;
+            modelValue: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => import("@element-plus/components/checkbox-group").CheckboxGroupValueType) | (() => import("@element-plus/components/checkbox-group").CheckboxGroupValueType) | (((new (...args: any[]) => import("@element-plus/components/checkbox-group").CheckboxGroupValueType) | (() => import("@element-plus/components/checkbox-group").CheckboxGroupValueType)) | null)[], unknown, unknown, () => never[], boolean>;
+            disabled: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+            min: NumberConstructor;
+            max: NumberConstructor;
+            size: {
+                readonly type: import("vue").PropType<import("@element-plus/utils").EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            fill: StringConstructor;
+            textColor: StringConstructor;
+            tag: import("@element-plus/utils").EpPropFinalized<StringConstructor, unknown, unknown, string, boolean>;
+            validateEvent: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+            options: {
+                readonly type: import("vue").PropType<import("@element-plus/components/checkbox-group").CheckboxOption[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            props: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => import("@element-plus/components/checkbox-group").CheckboxOptionProps) | (() => import("@element-plus/components/checkbox-group").CheckboxOptionProps) | (((new (...args: any[]) => import("@element-plus/components/checkbox-group").CheckboxOptionProps) | (() => import("@element-plus/components/checkbox-group").CheckboxOptionProps)) | null)[], unknown, unknown, () => Required<import("@element-plus/components/checkbox-group").CheckboxOptionProps>, boolean>;
+            type: import("@element-plus/utils").EpPropFinalized<StringConstructor, string, unknown, string, boolean>;
+        }>> & Readonly<{
+            "onUpdate:modelValue"?: ((val: import("@element-plus/components/checkbox-group").CheckboxGroupValueType) => any) | undefined;
+            onChange?: ((val: CheckboxValueType[]) => any) | undefined;
+        }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            "update:modelValue": (val: import("@element-plus/components/checkbox-group").CheckboxGroupValueType) => void;
+            change: (val: CheckboxValueType[]) => void;
+        }, string, {
+            props: import("@element-plus/components/checkbox-group").CheckboxOptionProps;
+            disabled: import("@element-plus/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            type: string;
+            tag: string;
+            modelValue: import("@element-plus/components/checkbox-group").CheckboxGroupValueType;
+            validateEvent: import("@element-plus/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import("vue").nextTick;
+        $watch<T_1 extends string | ((...args: any) => any)>(source: T_1, cb: T_1 extends (...args: any) => infer R ? (...args: [R, R, import("@vue/reactivity").OnCleanup]) => any : (...args: [any, any, import("@vue/reactivity").OnCleanup]) => any, options?: import("vue").WatchOptions): import("vue").WatchStopHandle;
+    } & Readonly<{
+        props: import("@element-plus/components/checkbox-group").CheckboxOptionProps;
+        disabled: import("@element-plus/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        type: string;
+        tag: string;
+        modelValue: import("@element-plus/components/checkbox-group").CheckboxGroupValueType;
+        validateEvent: import("@element-plus/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    }> & Omit<Readonly<import("vue").ExtractPropTypes<{
+        ariaLabel: StringConstructor;
+        modelValue: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => import("@element-plus/components/checkbox-group").CheckboxGroupValueType) | (() => import("@element-plus/components/checkbox-group").CheckboxGroupValueType) | (((new (...args: any[]) => import("@element-plus/components/checkbox-group").CheckboxGroupValueType) | (() => import("@element-plus/components/checkbox-group").CheckboxGroupValueType)) | null)[], unknown, unknown, () => never[], boolean>;
+        disabled: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+        min: NumberConstructor;
+        max: NumberConstructor;
+        size: {
+            readonly type: import("vue").PropType<import("@element-plus/utils").EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        fill: StringConstructor;
+        textColor: StringConstructor;
+        tag: import("@element-plus/utils").EpPropFinalized<StringConstructor, unknown, unknown, string, boolean>;
+        validateEvent: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+        options: {
+            readonly type: import("vue").PropType<import("@element-plus/components/checkbox-group").CheckboxOption[]>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        props: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => import("@element-plus/components/checkbox-group").CheckboxOptionProps) | (() => import("@element-plus/components/checkbox-group").CheckboxOptionProps) | (((new (...args: any[]) => import("@element-plus/components/checkbox-group").CheckboxOptionProps) | (() => import("@element-plus/components/checkbox-group").CheckboxOptionProps)) | null)[], unknown, unknown, () => Required<import("@element-plus/components/checkbox-group").CheckboxOptionProps>, boolean>;
+        type: import("@element-plus/utils").EpPropFinalized<StringConstructor, string, unknown, string, boolean>;
+    }>> & Readonly<{
+        "onUpdate:modelValue"?: ((val: import("@element-plus/components/checkbox-group").CheckboxGroupValueType) => any) | undefined;
+        onChange?: ((val: CheckboxValueType[]) => any) | undefined;
+    }>, "props" | "disabled" | "type" | "tag" | "modelValue" | "validateEvent"> & {} & import("vue").ComponentCustomProperties & {} & {
+        $slots: {
+            default?: (props: {}) => any;
+        };
+    }) | undefined, ({
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{
+            props: import("@element-plus/components/checkbox-group").CheckboxOptionProps;
+            disabled: import("@element-plus/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            type: string;
+            tag: string;
+            modelValue: import("@element-plus/components/checkbox-group").CheckboxGroupValueType;
+            validateEvent: import("@element-plus/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        }> & Omit<{
+            readonly props: import("@element-plus/components/checkbox-group").CheckboxOptionProps;
+            readonly type: string;
+            readonly tag: string;
+            readonly modelValue: import("@element-plus/components/checkbox-group").CheckboxGroupValueType;
+            readonly validateEvent: import("@element-plus/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            readonly size?: import("@element-plus/utils").EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never> | undefined;
+            readonly fill?: string | undefined;
+            readonly disabled?: import("@element-plus/utils").EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
+            readonly options?: import("@element-plus/components/checkbox-group").CheckboxOption[] | undefined;
+            readonly ariaLabel?: string | undefined;
+            readonly min?: number | undefined;
+            readonly max?: number | undefined;
+            readonly textColor?: string | undefined;
+            readonly "onUpdate:modelValue"?: ((val: import("@element-plus/components/checkbox-group").CheckboxGroupValueType) => any) | undefined;
+            readonly onChange?: ((val: CheckboxValueType[]) => any) | undefined;
+        } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "props" | "disabled" | "type" | "tag" | "modelValue" | "validateEvent">;
+        $attrs: import("vue").Attrs;
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import("vue").Slot<any> | undefined;
+        }>;
+        $root: import("vue").ComponentPublicInstance | null;
+        $parent: import("vue").ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: ((event: "update:modelValue", val: import("@element-plus/components/checkbox-group").CheckboxGroupValueType) => void) & ((event: "change", val: CheckboxValueType[]) => void);
+        $el: any;
+        $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+            ariaLabel: StringConstructor;
+            modelValue: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => import("@element-plus/components/checkbox-group").CheckboxGroupValueType) | (() => import("@element-plus/components/checkbox-group").CheckboxGroupValueType) | (((new (...args: any[]) => import("@element-plus/components/checkbox-group").CheckboxGroupValueType) | (() => import("@element-plus/components/checkbox-group").CheckboxGroupValueType)) | null)[], unknown, unknown, () => never[], boolean>;
+            disabled: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+            min: NumberConstructor;
+            max: NumberConstructor;
+            size: {
+                readonly type: import("vue").PropType<import("@element-plus/utils").EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            fill: StringConstructor;
+            textColor: StringConstructor;
+            tag: import("@element-plus/utils").EpPropFinalized<StringConstructor, unknown, unknown, string, boolean>;
+            validateEvent: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+            options: {
+                readonly type: import("vue").PropType<import("@element-plus/components/checkbox-group").CheckboxOption[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            props: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => import("@element-plus/components/checkbox-group").CheckboxOptionProps) | (() => import("@element-plus/components/checkbox-group").CheckboxOptionProps) | (((new (...args: any[]) => import("@element-plus/components/checkbox-group").CheckboxOptionProps) | (() => import("@element-plus/components/checkbox-group").CheckboxOptionProps)) | null)[], unknown, unknown, () => Required<import("@element-plus/components/checkbox-group").CheckboxOptionProps>, boolean>;
+            type: import("@element-plus/utils").EpPropFinalized<StringConstructor, string, unknown, string, boolean>;
+        }>> & Readonly<{
+            "onUpdate:modelValue"?: ((val: import("@element-plus/components/checkbox-group").CheckboxGroupValueType) => any) | undefined;
+            onChange?: ((val: CheckboxValueType[]) => any) | undefined;
+        }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            "update:modelValue": (val: import("@element-plus/components/checkbox-group").CheckboxGroupValueType) => void;
+            change: (val: CheckboxValueType[]) => void;
+        }, string, {
+            props: import("@element-plus/components/checkbox-group").CheckboxOptionProps;
+            disabled: import("@element-plus/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            type: string;
+            tag: string;
+            modelValue: import("@element-plus/components/checkbox-group").CheckboxGroupValueType;
+            validateEvent: import("@element-plus/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import("vue").nextTick;
+        $watch<T_1 extends string | ((...args: any) => any)>(source: T_1, cb: T_1 extends (...args: any) => infer R ? (...args: [R, R, import("@vue/reactivity").OnCleanup]) => any : (...args: [any, any, import("@vue/reactivity").OnCleanup]) => any, options?: import("vue").WatchOptions): import("vue").WatchStopHandle;
+    } & Readonly<{
+        props: import("@element-plus/components/checkbox-group").CheckboxOptionProps;
+        disabled: import("@element-plus/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        type: string;
+        tag: string;
+        modelValue: import("@element-plus/components/checkbox-group").CheckboxGroupValueType;
+        validateEvent: import("@element-plus/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    }> & Omit<Readonly<import("vue").ExtractPropTypes<{
+        ariaLabel: StringConstructor;
+        modelValue: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => import("@element-plus/components/checkbox-group").CheckboxGroupValueType) | (() => import("@element-plus/components/checkbox-group").CheckboxGroupValueType) | (((new (...args: any[]) => import("@element-plus/components/checkbox-group").CheckboxGroupValueType) | (() => import("@element-plus/components/checkbox-group").CheckboxGroupValueType)) | null)[], unknown, unknown, () => never[], boolean>;
+        disabled: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+        min: NumberConstructor;
+        max: NumberConstructor;
+        size: {
+            readonly type: import("vue").PropType<import("@element-plus/utils").EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        fill: StringConstructor;
+        textColor: StringConstructor;
+        tag: import("@element-plus/utils").EpPropFinalized<StringConstructor, unknown, unknown, string, boolean>;
+        validateEvent: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+        options: {
+            readonly type: import("vue").PropType<import("@element-plus/components/checkbox-group").CheckboxOption[]>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        props: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => import("@element-plus/components/checkbox-group").CheckboxOptionProps) | (() => import("@element-plus/components/checkbox-group").CheckboxOptionProps) | (((new (...args: any[]) => import("@element-plus/components/checkbox-group").CheckboxOptionProps) | (() => import("@element-plus/components/checkbox-group").CheckboxOptionProps)) | null)[], unknown, unknown, () => Required<import("@element-plus/components/checkbox-group").CheckboxOptionProps>, boolean>;
+        type: import("@element-plus/utils").EpPropFinalized<StringConstructor, string, unknown, string, boolean>;
+    }>> & Readonly<{
+        "onUpdate:modelValue"?: ((val: import("@element-plus/components/checkbox-group").CheckboxGroupValueType) => any) | undefined;
+        onChange?: ((val: CheckboxValueType[]) => any) | undefined;
+    }>, "props" | "disabled" | "type" | "tag" | "modelValue" | "validateEvent"> & {} & import("vue").ComponentCustomProperties & {} & {
+        $slots: {
+            default?: (props: {}) => any;
+        };
+    }) | undefined>;
+    virtualListHeight: import("vue").ShallowRef<number>;
+    updateAllChecked: () => void;
+    handleAllCheckedChange: (value: CheckboxValueType) => void;
+};

package/dist/components/transfer/composables/use-check.js

@@ -0,0 +1,89 @@
+import { computed as n, ref as m, watch as i } from "vue";
+import { isFunction as L } from "@vue/shared";
+import "lodash-unified";
+import { useElementSize as D } from "@vueuse/core";
+import "@element-plus/icons-vue";
+import { CHECKED_CHANGE_EVENT as y } from "../transfer-panel.js";
+import { usePropsAlias as $ } from "./use-props-alias.js";
+const x = (h, t, k) => {
+  const s = $(h), d = n(() => h.data.filter((e) => L(h.filterMethod) ? h.filterMethod(t.query, e) : String(
+    e[s.value.label] || e[s.value.key]
+  ).toLowerCase().includes(t.query.toLowerCase()))), u = n(
+    () => d.value.filter((e) => !e[s.value.disabled])
+  ), C = n(() => {
+    const e = t.checked.length, c = h.data.length, { noChecked: r, hasChecked: o } = h.format;
+    return r && o ? e > 0 ? o.replace(/\${checked}/g, e.toString()).replace(/\${total}/g, c.toString()) : r.replace(/\${total}/g, c.toString()) : `${e}/${c}`;
+  }), v = n(() => {
+    const e = t.checked.length;
+    return e > 0 && e < u.value.length;
+  }), a = () => {
+    const e = u.value.map(
+      (c) => c[s.value.key]
+    );
+    t.allChecked = e.length > 0 && e.every((c) => t.checked.includes(c));
+  }, b = (e) => {
+    t.checked = e ? u.value.map((c) => c[s.value.key]) : [];
+  }, f = m(), { height: E } = D(
+    n(() => {
+      var e;
+      return (e = f.value) == null ? void 0 : e.$el;
+    })
+  ), g = m();
+  return i(
+    () => t.checked,
+    (e, c) => {
+      if (a(), t.checkChangeByUser) {
+        const r = e.concat(c).filter((o) => !e.includes(o) || !c.includes(o));
+        k(y, e, r);
+      } else
+        k(y, e), t.checkChangeByUser = !0;
+    }
+  ), i(u, () => {
+    a();
+  }), i(
+    () => h.data,
+    () => {
+      const e = [], c = d.value.map(
+        (r) => r[s.value.key]
+      );
+      t.checked.forEach((r) => {
+        c.includes(r) && e.push(r);
+      }), t.checkChangeByUser = !1, t.checked = e;
+    }
+  ), i(
+    () => h.defaultChecked,
+    (e, c) => {
+      if (c && e.length === c.length && e.every((l) => c.includes(l)))
+        return;
+      const r = [], o = u.value.map(
+        (l) => l[s.value.key]
+      );
+      e.forEach((l) => {
+        o.includes(l) && r.push(l);
+      }), t.checkChangeByUser = !1, t.checked = r;
+    },
+    {
+      immediate: !0
+    }
+  ), i(
+    () => t.query,
+    () => {
+      var e;
+      h.virtualScroll && ((e = g.value) == null || e.scrollToItem(0));
+    },
+    { flush: "post" }
+  ), {
+    filteredData: d,
+    checkableData: u,
+    checkedSummary: C,
+    virtualListRef: g,
+    isIndeterminate: v,
+    checkboxGroupRef: f,
+    virtualListHeight: E,
+    updateAllChecked: a,
+    handleAllCheckedChange: b
+  };
+};
+export {
+  x as useCheck
+};

package/dist/components/transfer/composables/use-checked-change.d.ts

@@ -0,0 +1,6 @@
+import type { SetupContext } from 'vue';
+import type { TransferCheckedState, TransferEmits, TransferKey } from '../transfer';
+export declare const useCheckedChange: (checkedState: TransferCheckedState, emit: SetupContext<TransferEmits>["emit"]) => {
+    onSourceCheckedChange: (val: TransferKey[], movedKeys?: TransferKey[]) => void;
+    onTargetCheckedChange: (val: TransferKey[], movedKeys?: TransferKey[]) => void;
+};

package/dist/components/transfer/composables/use-checked-change.js

@@ -0,0 +1,12 @@
+import { RIGHT_CHECK_CHANGE_EVENT as h, LEFT_CHECK_CHANGE_EVENT as c } from "../transfer.js";
+const g = (n, r) => ({
+  onSourceCheckedChange: (e, C) => {
+    n.leftChecked = e, C && r(c, e, C);
+  },
+  onTargetCheckedChange: (e, C) => {
+    n.rightChecked = e, C && r(h, e, C);
+  }
+});
+export {
+  g as useCheckedChange
+};

package/dist/components/transfer/composables/use-computed-data.d.ts

@@ -0,0 +1,5 @@
+import type { TransferDataItem, TransferProps } from '../transfer';
+export declare const useComputedData: <T extends TransferDataItem = TransferDataItem>(props: Required<Omit<TransferProps<T>, "filterPlaceholder" | "filterMethod" | "renderContent">>) => {
+    sourceData: import("vue").ComputedRef<T[]>;
+    targetData: import("vue").ComputedRef<T[]>;
+};