@ibiz-template/vue3-components 0.7.40-alpha.9 → 0.7.41-alpha.0

package/es/editor/data-picker/ibiz-transfer-picker/components/transfer/interface.d.ts

@@ -0,0 +1,99 @@
+import type { ExtractPropTypes, h as H, PropType, VNode } from 'vue';
+export declare const UPDATE_MODEL_EVENT = "update:modelValue";
+export declare const CHANGE_EVENT = "change";
+export declare const INPUT_EVENT = "input";
+export declare const LEFT_CHECK_CHANGE_EVENT = "leftCheckChange";
+export declare const RIGHT_CHECK_CHANGE_EVENT = "rightCheckChange";
+export declare const LEFT_AC_SEARCH = "leftAcSearch";
+export type TransferKey = string | number;
+export type TransferDirection = 'left' | 'right';
+export type renderContent = (h: typeof H, option: IData) => VNode | VNode[];
+export interface TransferFormat {
+    noChecked?: string;
+    hasChecked?: string;
+}
+export interface TransferPropsAlias {
+    label?: string;
+    key?: string;
+    disabled?: string;
+}
+export interface TransferCheckedState {
+    leftChecked: TransferKey[];
+    rightChecked: TransferKey[];
+}
+export declare const transferCheckedChangeFn: (value: TransferKey[], movedKeys?: TransferKey[]) => boolean;
+export declare const transferProps: {
+    data: {
+        type: PropType<import("@ibiz-template/core").IApiData>;
+        default: () => IData;
+    };
+    titles: {
+        type: PropType<string[]>;
+        default: () => Array<string>;
+    };
+    buttonTexts: {
+        type: PropType<string[]>;
+        default: () => Array<string>;
+    };
+    filterPlaceholder: StringConstructor;
+    filterMethod: {
+        type: PropType<(query: string, item: IData) => boolean>;
+    };
+    rightSearchMethod: {
+        type: PropType<(query: string) => IData[]>;
+    };
+    leftDefaultChecked: {
+        type: PropType<TransferKey[]>;
+        default: () => Array<TransferKey>;
+    };
+    rightDefaultChecked: {
+        type: PropType<TransferKey[]>;
+        default: () => Array<TransferKey>;
+    };
+    renderContent: {
+        type: PropType<renderContent>;
+    };
+    modelValue: {
+        type: PropType<TransferKey[]>;
+        default: () => Array<TransferKey>;
+    };
+    format: {
+        type: PropType<TransferFormat>;
+        default: () => TransferFormat;
+    };
+    filterable: BooleanConstructor;
+    props: {
+        type: PropType<TransferPropsAlias>;
+        default: () => TransferPropsAlias;
+    };
+    targetOrder: {
+        type: StringConstructor;
+        values: string[];
+        default: string;
+    };
+    enableRemoteSearch: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    validateEvent: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    loading: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    readonly: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+};
+export type TransferProps = ExtractPropTypes<typeof transferProps>;
+export declare const transferEmits: {
+    change: (value: TransferKey[], direction: TransferDirection, movedKeys: TransferKey[]) => boolean;
+    "update:modelValue": (value: TransferKey[]) => boolean;
+    leftCheckChange: (value: TransferKey[], movedKeys?: TransferKey[]) => boolean;
+    rightCheckChange: (value: TransferKey[], movedKeys?: TransferKey[]) => boolean;
+    leftAcSearch: (query: string) => string;
+};
+export type TransferEmits = typeof transferEmits;

package/es/editor/data-picker/ibiz-transfer-picker/components/transfer/interface.mjs

@@ -0,0 +1,89 @@
+import { isArray, isNil } from 'lodash-es';
+
+"use strict";
+const UPDATE_MODEL_EVENT = "update:modelValue";
+const CHANGE_EVENT = "change";
+const INPUT_EVENT = "input";
+const LEFT_CHECK_CHANGE_EVENT = "leftCheckChange";
+const RIGHT_CHECK_CHANGE_EVENT = "rightCheckChange";
+const LEFT_AC_SEARCH = "leftAcSearch";
+const transferCheckedChangeFn = (value, movedKeys) => [value, movedKeys].every(isArray) || isArray(value) && isNil(movedKeys);
+const transferProps = {
+  data: {
+    type: Array,
+    default: () => []
+  },
+  titles: {
+    type: Array,
+    default: () => []
+  },
+  buttonTexts: {
+    type: Array,
+    default: () => []
+  },
+  filterPlaceholder: String,
+  filterMethod: {
+    type: Function
+  },
+  rightSearchMethod: {
+    type: Function
+  },
+  leftDefaultChecked: {
+    type: Array,
+    default: () => []
+  },
+  rightDefaultChecked: {
+    type: Array,
+    default: () => []
+  },
+  renderContent: {
+    type: Function
+  },
+  modelValue: {
+    type: Array,
+    default: () => []
+  },
+  format: {
+    type: Object,
+    default: () => ({})
+  },
+  filterable: Boolean,
+  props: {
+    type: Object,
+    default: () => ({
+      label: "label",
+      key: "key",
+      disabled: "disabled"
+    })
+  },
+  targetOrder: {
+    type: String,
+    values: ["original", "push", "unshift"],
+    default: "original"
+  },
+  enableRemoteSearch: {
+    type: Boolean,
+    default: false
+  },
+  validateEvent: {
+    type: Boolean,
+    default: true
+  },
+  loading: {
+    type: Boolean,
+    default: false
+  },
+  readonly: {
+    type: Boolean,
+    default: false
+  }
+};
+const transferEmits = {
+  [CHANGE_EVENT]: (value, direction, movedKeys) => [value, movedKeys].every(isArray) && ["left", "right"].includes(direction),
+  [UPDATE_MODEL_EVENT]: (value) => isArray(value),
+  [LEFT_CHECK_CHANGE_EVENT]: transferCheckedChangeFn,
+  [RIGHT_CHECK_CHANGE_EVENT]: transferCheckedChangeFn,
+  [LEFT_AC_SEARCH]: (query) => query
+};
+
+export { CHANGE_EVENT, INPUT_EVENT, LEFT_AC_SEARCH, LEFT_CHECK_CHANGE_EVENT, RIGHT_CHECK_CHANGE_EVENT, UPDATE_MODEL_EVENT, transferCheckedChangeFn, transferEmits, transferProps };

package/es/editor/data-picker/ibiz-transfer-picker/components/transfer/transfer-util.d.ts

@@ -0,0 +1,17 @@
+import type { ComputedRef, SetupContext } from 'vue';
+import type { TransferCheckedState, TransferEmits, TransferKey, TransferProps, TransferPropsAlias } from './interface';
+export declare const usePropsAlias: (props: {
+    props: TransferPropsAlias;
+}) => ComputedRef;
+export declare const useComputedData: (props: TransferProps) => {
+    sourceData: ComputedRef;
+    targetData: ComputedRef;
+};
+export declare const useCheckedChange: (checkedState: TransferCheckedState, emit: SetupContext<TransferEmits>['emit']) => {
+    onSourceCheckedChange: (val: TransferKey[], movedKeys?: TransferKey[]) => void;
+    onTargetCheckedChange: (val: TransferKey[], movedKeys?: TransferKey[]) => void;
+};
+export declare const useMove: (props: TransferProps, checkedState: TransferCheckedState, emit: SetupContext<TransferEmits>['emit']) => {
+    addToLeft: () => void;
+    addToRight: () => void;
+};

package/es/editor/data-picker/ibiz-transfer-picker/components/transfer/transfer-util.mjs

@@ -0,0 +1,103 @@
+import { computed } from 'vue';
+import { LEFT_CHECK_CHANGE_EVENT, RIGHT_CHECK_CHANGE_EVENT, UPDATE_MODEL_EVENT, CHANGE_EVENT } from './interface.mjs';
+
+"use strict";
+const usePropsAlias = (props) => {
+  const initProps = {
+    label: "label",
+    key: "key",
+    disabled: "disabled"
+  };
+  return computed(() => ({
+    ...initProps,
+    ...props.props
+  }));
+};
+const useComputedData = (props) => {
+  const propsAlias = usePropsAlias(props);
+  const dataObj = computed(
+    () => props.data.reduce(
+      // eslint-disable-next-line no-return-assign, no-param-reassign
+      (o, cur) => (o[cur[propsAlias.value.key]] = cur) && o,
+      {}
+    )
+  );
+  const sourceData = computed(
+    () => props.data.filter(
+      (item) => !props.modelValue.includes(item[propsAlias.value.key])
+    )
+  );
+  const targetData = computed(() => {
+    if (props.targetOrder === "original") {
+      return props.data.filter(
+        (item) => props.modelValue.includes(item[propsAlias.value.key])
+      );
+    }
+    return props.modelValue.reduce((arr, cur) => {
+      const val = dataObj.value[cur];
+      if (val) {
+        arr.push(val);
+      }
+      return arr;
+    }, []);
+  });
+  return {
+    sourceData,
+    targetData
+  };
+};
+const useCheckedChange = (checkedState, emit) => {
+  const onSourceCheckedChange = (val, movedKeys) => {
+    checkedState.leftChecked = val;
+    if (!movedKeys)
+      return;
+    emit(LEFT_CHECK_CHANGE_EVENT, val, movedKeys);
+  };
+  const onTargetCheckedChange = (val, movedKeys) => {
+    checkedState.rightChecked = val;
+    if (!movedKeys)
+      return;
+    emit(RIGHT_CHECK_CHANGE_EVENT, val, movedKeys);
+  };
+  return {
+    onSourceCheckedChange,
+    onTargetCheckedChange
+  };
+};
+const useMove = (props, checkedState, emit) => {
+  const propsAlias = usePropsAlias(props);
+  const _emit = (value, direction, movedKeys) => {
+    emit(UPDATE_MODEL_EVENT, value);
+    emit(CHANGE_EVENT, value, direction, movedKeys);
+  };
+  const addToLeft = () => {
+    const currentValue = props.modelValue.slice();
+    checkedState.rightChecked.forEach((item) => {
+      const index = currentValue.indexOf(item);
+      if (index > -1) {
+        currentValue.splice(index, 1);
+      }
+    });
+    _emit(currentValue, "left", checkedState.rightChecked);
+  };
+  const addToRight = () => {
+    let currentValue = props.modelValue.slice();
+    const itemsToBeMoved = props.data.filter((item) => {
+      const itemKey = item[propsAlias.value.key];
+      return checkedState.leftChecked.includes(itemKey) && !props.modelValue.includes(itemKey);
+    }).map((item) => item[propsAlias.value.key]);
+    currentValue = props.targetOrder === "unshift" ? itemsToBeMoved.concat(currentValue) : currentValue.concat(itemsToBeMoved);
+    if (props.targetOrder === "original") {
+      currentValue = props.data.filter(
+        (item) => currentValue.includes(item[propsAlias.value.key])
+      ).map((item) => item[propsAlias.value.key]);
+    }
+    _emit(currentValue, "right", checkedState.leftChecked);
+  };
+  return {
+    addToLeft,
+    addToRight
+  };
+};
+
+export { useCheckedChange, useComputedData, useMove, usePropsAlias };

package/es/editor/data-picker/ibiz-transfer-picker/components/transfer/transfer.css

@@ -0,0 +1 @@
+.ibiz-transfer__buttons{display:inline-block;padding:0 1.875rem;vertical-align:middle}.ibiz-transfer__button{vertical-align:top}.ibiz-transfer__button:nth-child(2){margin:0 0 0 10px}.ibiz-transfer__button i,.ibiz-transfer__button span{font-size:var(--ibiz-font-size-header-6)}.ibiz-transfer__button .el-icon{font-size:var(--ibiz-font-size-regular)}

package/es/editor/data-picker/ibiz-transfer-picker/components/transfer/transfer.d.ts

@@ -0,0 +1,182 @@
+import { VNode } from 'vue';
+import type { TransferDirection } from './interface';
+import './transfer.scss';
+export declare const TransferSelect: import("vue").DefineComponent<{
+    data: {
+        type: import("vue").PropType<import("@ibiz-template/core").IApiData>;
+        default: () => import("@ibiz-template/core").IApiData;
+    };
+    titles: {
+        type: import("vue").PropType<string[]>;
+        default: () => string[];
+    };
+    buttonTexts: {
+        type: import("vue").PropType<string[]>;
+        default: () => string[];
+    };
+    filterPlaceholder: StringConstructor;
+    filterMethod: {
+        type: import("vue").PropType<(query: string, item: import("@ibiz-template/core").IApiData) => boolean>;
+    };
+    rightSearchMethod: {
+        type: import("vue").PropType<(query: string) => import("@ibiz-template/core").IApiData[]>;
+    };
+    leftDefaultChecked: {
+        type: import("vue").PropType<import("./interface").TransferKey[]>;
+        default: () => import("./interface").TransferKey[];
+    };
+    rightDefaultChecked: {
+        type: import("vue").PropType<import("./interface").TransferKey[]>;
+        default: () => import("./interface").TransferKey[];
+    };
+    renderContent: {
+        type: import("vue").PropType<import("./interface").renderContent>;
+    };
+    modelValue: {
+        type: import("vue").PropType<import("./interface").TransferKey[]>;
+        default: () => import("./interface").TransferKey[];
+    };
+    format: {
+        type: import("vue").PropType<import("./interface").TransferFormat>;
+        default: () => import("./interface").TransferFormat;
+    };
+    filterable: BooleanConstructor;
+    props: {
+        type: import("vue").PropType<import("./interface").TransferPropsAlias>;
+        default: () => import("./interface").TransferPropsAlias;
+    };
+    targetOrder: {
+        type: StringConstructor;
+        values: string[];
+        default: string;
+    };
+    enableRemoteSearch: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    validateEvent: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    loading: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    readonly: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}, {
+    ns: import("@ibiz-template/core").Namespace;
+    targetData: import("vue").ComputedRef<any>;
+    rightPanelTitle: import("vue").ComputedRef<string>;
+    optionRender: import("vue").ComputedRef<(option: IData) => VNode | VNode[]>;
+    panelFilterPlaceholder: import("vue").ComputedRef<string>;
+    leftPanelTitle: import("vue").ComputedRef<string>;
+    sourceData: import("vue").ComputedRef<any>;
+    leftPanel: import("vue").Ref<any>;
+    rightPanel: import("vue").Ref<any>;
+    hasButtonTexts: import("vue").ComputedRef<boolean>;
+    checkedState: {
+        leftChecked: import("./interface").TransferKey[];
+        rightChecked: import("./interface").TransferKey[];
+    };
+    addToLeft: () => void;
+    addToRight: () => void;
+    clearQuery: (which: TransferDirection) => void;
+    onLeftAcSearch: (query: string) => void;
+    onSourceCheckedChange: (val: import("./interface").TransferKey[], movedKeys?: import("./interface").TransferKey[] | undefined) => void;
+    onTargetCheckedChange: (val: import("./interface").TransferKey[], movedKeys?: import("./interface").TransferKey[] | undefined) => void;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    change: (value: import("./interface").TransferKey[], direction: TransferDirection, movedKeys: import("./interface").TransferKey[]) => boolean;
+    "update:modelValue": (value: import("./interface").TransferKey[]) => boolean;
+    leftCheckChange: (value: import("./interface").TransferKey[], movedKeys?: import("./interface").TransferKey[] | undefined) => boolean;
+    rightCheckChange: (value: import("./interface").TransferKey[], movedKeys?: import("./interface").TransferKey[] | undefined) => boolean;
+    leftAcSearch: (query: string) => string;
+}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    data: {
+        type: import("vue").PropType<import("@ibiz-template/core").IApiData>;
+        default: () => import("@ibiz-template/core").IApiData;
+    };
+    titles: {
+        type: import("vue").PropType<string[]>;
+        default: () => string[];
+    };
+    buttonTexts: {
+        type: import("vue").PropType<string[]>;
+        default: () => string[];
+    };
+    filterPlaceholder: StringConstructor;
+    filterMethod: {
+        type: import("vue").PropType<(query: string, item: import("@ibiz-template/core").IApiData) => boolean>;
+    };
+    rightSearchMethod: {
+        type: import("vue").PropType<(query: string) => import("@ibiz-template/core").IApiData[]>;
+    };
+    leftDefaultChecked: {
+        type: import("vue").PropType<import("./interface").TransferKey[]>;
+        default: () => import("./interface").TransferKey[];
+    };
+    rightDefaultChecked: {
+        type: import("vue").PropType<import("./interface").TransferKey[]>;
+        default: () => import("./interface").TransferKey[];
+    };
+    renderContent: {
+        type: import("vue").PropType<import("./interface").renderContent>;
+    };
+    modelValue: {
+        type: import("vue").PropType<import("./interface").TransferKey[]>;
+        default: () => import("./interface").TransferKey[];
+    };
+    format: {
+        type: import("vue").PropType<import("./interface").TransferFormat>;
+        default: () => import("./interface").TransferFormat;
+    };
+    filterable: BooleanConstructor;
+    props: {
+        type: import("vue").PropType<import("./interface").TransferPropsAlias>;
+        default: () => import("./interface").TransferPropsAlias;
+    };
+    targetOrder: {
+        type: StringConstructor;
+        values: string[];
+        default: string;
+    };
+    enableRemoteSearch: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    validateEvent: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    loading: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    readonly: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & {
+    onChange?: ((value: import("./interface").TransferKey[], direction: TransferDirection, movedKeys: import("./interface").TransferKey[]) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: import("./interface").TransferKey[]) => any) | undefined;
+    onLeftCheckChange?: ((value: import("./interface").TransferKey[], movedKeys?: import("./interface").TransferKey[] | undefined) => any) | undefined;
+    onRightCheckChange?: ((value: import("./interface").TransferKey[], movedKeys?: import("./interface").TransferKey[] | undefined) => any) | undefined;
+    onLeftAcSearch?: ((query: string) => any) | undefined;
+}, {
+    props: import("./interface").TransferPropsAlias;
+    data: import("@ibiz-template/core").IApiData;
+    loading: boolean;
+    modelValue: import("./interface").TransferKey[];
+    readonly: boolean;
+    format: import("./interface").TransferFormat;
+    titles: string[];
+    buttonTexts: string[];
+    leftDefaultChecked: import("./interface").TransferKey[];
+    rightDefaultChecked: import("./interface").TransferKey[];
+    filterable: boolean;
+    targetOrder: string;
+    enableRemoteSearch: boolean;
+    validateEvent: boolean;
+}, {}>;

package/es/editor/data-picker/ibiz-transfer-picker/components/transfer/transfer.mjs

@@ -0,0 +1,146 @@
+import { reactive, ref, computed, h, createVNode, resolveComponent, defineComponent } from 'vue';
+import { isEmpty } from 'ramda';
+import { useNamespace } from '@ibiz-template/vue3-util';
+import { usePropsAlias, useComputedData, useCheckedChange, useMove } from './transfer-util.mjs';
+import { transferProps, transferEmits } from './interface.mjs';
+import { TransferPanel } from '../transfer-panel/transfer-panel.mjs';
+import { arrowLeft, arrowRight } from './icon.mjs';
+import './transfer.css';
+
+"use strict";
+const TransferSelect = /* @__PURE__ */ defineComponent({
+  name: "IBizTransfer",
+  props: transferProps,
+  emits: transferEmits,
+  setup(props, {
+    emit,
+    slots
+  }) {
+    const ns = useNamespace("transfer");
+    const checkedState = reactive({
+      leftChecked: [],
+      rightChecked: []
+    });
+    const propsAlias = usePropsAlias(props);
+    const {
+      sourceData,
+      targetData
+    } = useComputedData(props);
+    const {
+      onSourceCheckedChange,
+      onTargetCheckedChange
+    } = useCheckedChange(checkedState, emit);
+    const {
+      addToLeft,
+      addToRight
+    } = useMove(props, checkedState, emit);
+    const leftPanel = ref();
+    const rightPanel = ref();
+    const clearQuery = (which) => {
+      switch (which) {
+        case "left":
+          leftPanel.value.query = "";
+          break;
+        case "right":
+          rightPanel.value.query = "";
+          break;
+        default:
+          break;
+      }
+    };
+    const onLeftAcSearch = (query) => {
+      emit("leftAcSearch", query);
+    };
+    const hasButtonTexts = computed(() => props.buttonTexts.length === 2);
+    const leftPanelTitle = computed(() => props.titles[0] || "\u53EF\u9009\u5217\u8868");
+    const rightPanelTitle = computed(() => props.titles[1] || "\u5DF2\u9009\u5217\u8868");
+    const panelFilterPlaceholder = computed(() => props.filterPlaceholder || "\u8BF7\u8F93\u5165");
+    const optionRender = computed(() => (option) => {
+      var _a;
+      if (props.renderContent)
+        return props.renderContent(h, option);
+      const defaultSlotVNodes = (((_a = slots.default) == null ? void 0 : _a.call(slots, {
+        option
+      })) || []).filter((node) => node.type !== Comment);
+      if (defaultSlotVNodes.length) {
+        return defaultSlotVNodes;
+      }
+      return h("span", option[propsAlias.value.label] || option[propsAlias.value.key]);
+    });
+    return {
+      ns,
+      targetData,
+      rightPanelTitle,
+      optionRender,
+      panelFilterPlaceholder,
+      leftPanelTitle,
+      sourceData,
+      leftPanel,
+      rightPanel,
+      hasButtonTexts,
+      checkedState,
+      addToLeft,
+      addToRight,
+      clearQuery,
+      onLeftAcSearch,
+      onSourceCheckedChange,
+      onTargetCheckedChange
+    };
+  },
+  render() {
+    return createVNode("div", {
+      "class": this.ns.b()
+    }, [createVNode(TransferPanel, {
+      "ref": "leftPanel",
+      "data": this.sourceData,
+      "readonly": this.readonly,
+      "optionRender": this.optionRender,
+      "placeholder": this.panelFilterPlaceholder,
+      "title": this.leftPanelTitle,
+      "filterable": this.filterable,
+      "format": this.format,
+      "enableAcSearch": this.enableRemoteSearch,
+      "loading": this.loading,
+      "filterMethod": this.filterMethod,
+      "defaultChecked": this.leftDefaultChecked,
+      "onAcSearch": this.onLeftAcSearch,
+      "props": this.props,
+      "onCheckedChange": this.onSourceCheckedChange
+    }, null), createVNode("div", {
+      "class": this.ns.e("buttons")
+    }, [createVNode(resolveComponent("el-button"), {
+      "class": [this.ns.e("button"), this.ns.is("with-texts", this.hasButtonTexts)],
+      "type": "primary",
+      "disabled": !!isEmpty(this.checkedState.rightChecked) || this.readonly,
+      "onClick": this.addToLeft
+    }, {
+      default: () => [createVNode(resolveComponent("el-icon"), null, {
+        default: () => arrowLeft()
+      }), this.buttonTexts[0] !== void 0 ? createVNode("span", null, [this.buttonTexts[0]]) : null]
+    }), createVNode(resolveComponent("el-button"), {
+      "class": [this.ns.e("button"), this.ns.is("with-texts", this.hasButtonTexts)],
+      "type": "primary",
+      "disabled": !!isEmpty(this.checkedState.leftChecked) || this.readonly,
+      "onClick": this.addToRight
+    }, {
+      default: () => [this.buttonTexts[1] !== void 0 ? createVNode("span", null, [this.buttonTexts[1]]) : null, createVNode(resolveComponent("el-icon"), null, {
+        default: () => arrowRight()
+      })]
+    })]), createVNode(TransferPanel, {
+      "ref": "rightPanel",
+      "data": this.targetData,
+      "readonly": this.readonly,
+      "optionRender": this.optionRender,
+      "placeholder": this.panelFilterPlaceholder,
+      "filterable": this.filterable,
+      "format": this.format,
+      "filterMethod": this.filterMethod,
+      "title": this.rightPanelTitle,
+      "defaultChecked": this.rightDefaultChecked,
+      "props": this.props,
+      "onCheckedChange": this.onTargetCheckedChange
+    }, null)]);
+  }
+});
+
+export { TransferSelect };

package/es/editor/data-picker/ibiz-transfer-picker/components/transfer-panel/icon.d.ts

@@ -0,0 +1 @@
+export declare const Search: () => JSX.Element;

package/es/editor/data-picker/ibiz-transfer-picker/components/transfer-panel/icon.mjs

@@ -0,0 +1,12 @@
+import { createVNode } from 'vue';
+
+"use strict";
+const Search = () => createVNode("svg", {
+  "xmlns": "http://www.w3.org/2000/svg",
+  "viewBox": "0 0 1024 1024"
+}, [createVNode("path", {
+  "fill": "currentColor",
+  "d": "m795.904 750.72 124.992 124.928a32 32 0 0 1-45.248 45.248L750.656 795.904a416 416 0 1 1 45.248-45.248zM480 832a352 352 0 1 0 0-704 352 352 0 0 0 0 704"
+}, null)]);
+
+export { Search };