@opentiny/vue-renderless 3.13.1 → 3.14.0

package/tabbar-item/vue.js

@@ -2,7 +2,7 @@ import "../chunk-G2ADBYYC.js";
 import { getRouteActive, onClick, bindChildren, routeTab, getTabbarItemsWidth } from "./index";
 import { xss } from "../common";
 const api = ["state", "onClick", "getTabbarItemsWidth"];
-const renderless = (props, { computed, onMounted, reactive }, { parent, emit, nextTick, route, router, dispatch, vm }) => {
+const renderless = (props, { computed, onMounted, reactive, inject }, { parent, emit, nextTick, route, router, dispatch, vm }) => {
   const api2 = {};
   const state = reactive({
     index: -1,
@@ -14,7 +14,8 @@ const renderless = (props, { computed, onMounted, reactive }, { parent, emit, ne
     renderColor: computed(() => parent.$parent[state.active ? "activeColor" : "inactiveColor"]),
     showVm: true,
     itemWidth: null,
-    childrenNumber: 0
+    childrenNumber: 0,
+    customIcon: inject("customIcon", null) || props.customIcon
   });
   Object.assign(api2, {
     state,

package/tabs/index.js

@@ -77,13 +77,25 @@ const handleTabClick = ({ api, emit, props, refs }) => (pane, tabName, event) =>
     refs.nav && refs.nav.expandTabHide();
   }
 };
-const handleTabRemove = (emit) => (pane, event) => {
+const handleTabRemove = ({ emit, props }) => (pane, event) => {
   if (pane.disabled) {
     return;
   }
   event.stopPropagation();
-  emit("edit", pane.name, "remove");
-  emit("close", pane.name);
+  const emitEvent = () => {
+    emit("edit", pane.name, "remove");
+    emit("close", pane.name);
+  };
+  if (typeof props.beforeClose === "function") {
+    const beforeCloseResult = props.beforeClose(pane.name);
+    if (beforeCloseResult && beforeCloseResult.then) {
+      beforeCloseResult.then((res) => res && emitEvent());
+    } else {
+      beforeCloseResult && emitEvent();
+    }
+  } else {
+    emitEvent();
+  }
 };
 const handleTabAdd = (emit) => () => {
   emit("edit", null, "add");
@@ -97,7 +109,7 @@ const setCurrentName = ({ api, props, refs, state }) => (value) => {
       before.then(() => {
         api.changeCurrentName(value);
         refs.nav && refs.nav.removeFocus(value);
-      });
+      }).catch(() => null);
     } else if (before !== false) {
       api.changeCurrentName(value);
     }

package/tabs/vue.js

@@ -39,6 +39,7 @@ const initState = ({ reactive, props }) => reactive({
   offsetY: 0,
   direction: "",
   expandPanesWidth: "",
+  activeIndex: 1,
   separator: props.separator
 });
 const initWatcher = ({
@@ -77,7 +78,7 @@ const renderless = (props, { onMounted, onUpdated, provide, reactive, watch }, {
   Object.assign(api2, {
     state,
     handleTabAdd: handleTabAdd(emit),
-    handleTabRemove: handleTabRemove(emit),
+    handleTabRemove: handleTabRemove({ emit, props }),
     changeDirection: changeDirection({ props, state }),
     changeCurrentName: changeCurrentName({ emit, state }),
     calcMorePanes: calcMorePanes({ parent, props, state, refs }),

package/tabs-mf/index.js

@@ -2,11 +2,22 @@ import "../chunk-G2ADBYYC.js";
 import { random } from "../common/string";
 import debounce from "../common/deps/debounce";
 import { fastdom } from "../common/deps/fastdom";
-const setActive = ({ emit, state, props }) => (name) => {
+const setActive = ({ state, props, api }) => (name) => {
   const current = state.currentItem ? state.currentItem.name : "";
-  if (current && current !== name && props.beforeLeave && !props.beforeLeave(name, current)) {
-    return;
+  if (current && current !== name && props.beforeLeave) {
+    const before = props.beforeLeave(name, current);
+    if (before && before.then) {
+      before.then(() => {
+        api.changeCurrentName(name);
+      }).catch(() => null);
+    } else if (before !== false) {
+      api.changeCurrentName(name);
+    }
+  } else {
+    api.changeCurrentName(name);
   }
+};
+const changeCurrentName = ({ emit, state }) => (name) => {
   state.items.forEach((item) => item.selected = item.name === name);
   emit("update:activeName", name);
   emit("update:modelValue", name);
@@ -41,7 +52,7 @@ const clickMore = (api) => (name) => {
   api.setActive(name);
   api.scrollTo(name);
 };
-const removeItem = ({ state, emit }) => (name) => {
+const removeItem = ({ state, emit }) => (name, silent = false) => {
   const itemIndex = state.items.findIndex((item) => item.name === name);
   const navIndex = state.navs.findIndex((item) => item.name === name);
   if (~itemIndex) {
@@ -49,8 +60,10 @@ const removeItem = ({ state, emit }) => (name) => {
     state.items = [...state.items];
     state.navs.splice(navIndex, 1);
     state.navs = [...state.navs];
-    emit("edit", name, "remove");
-    emit("close", name);
+    if (!silent) {
+      emit("edit", name, "remove");
+      emit("close", name);
+    }
   }
 };
 const wheelListener = ({ vm, api, tabs, state }) => debounce(10, (e) => {
@@ -99,6 +112,7 @@ const handleNavItemClose = ({ tabs, props }) => (e) => {
 export {
   addItem,
   addNav,
+  changeCurrentName,
   clickMore,
   emitAdd,
   getBoundRect,

package/tabs-mf/vue-nav.js

@@ -1,26 +1,41 @@
 import "../chunk-G2ADBYYC.js";
 const api = ["state"];
-const renderless = (props, { reactive, inject, computed, nextTick, watch }) => {
+const renderless = (props, { reactive, inject, computed, onMounted, onBeforeUnmount }, { vm }) => {
   const tabs = inject("tabs", null);
   const state = reactive({
     navItems: computed(() => tabs.state.items),
-    currentNav: null,
+    currentNav: computed(() => tabs.state.navs[state.currentIndex]),
     currentIndex: computed(
       () => tabs.state.navs.findIndex((item) => tabs.state.currentItem && tabs.state.currentItem.name === item.name)
     ),
     currentWidth: 0,
     currentPosition: 0
   });
-  watch(
-    () => state.currentIndex,
-    () => {
-      nextTick(() => {
-        const nav = state.currentNav = tabs.state.navs[state.currentIndex];
-        state.currentWidth = nav && nav.$el.offsetWidth || 0;
-        state.currentPosition = nav && nav.$el.offsetLeft || 0;
-      });
+  let rafId, observer;
+  onMounted(() => {
+    observer = new MutationObserver((mutationsList) => {
+      for (let mutation of mutationsList) {
+        if (mutation.type === "attributes") {
+          if (rafId) {
+            cancelAnimationFrame(rafId);
+          }
+          rafId = requestAnimationFrame(() => {
+            const nav = state.currentNav;
+            state.currentWidth = nav && nav.$el.offsetWidth || 0;
+            state.currentPosition = nav && nav.$el.offsetLeft || 0;
+          });
+        }
+      }
+    });
+    observer.observe(vm.$el, { attributes: true, subtree: true });
+  });
+  onBeforeUnmount(() => {
+    if (rafId) {
+      cancelAnimationFrame(rafId);
     }
-  );
+    observer.disconnect();
+    observer = null;
+  });
   return { state };
 };
 export {

package/tabs-mf/vue.js

@@ -1,6 +1,6 @@
 import "../chunk-G2ADBYYC.js";
 import { random } from "../common/string";
-import { setActive, addItem, addNav, scrollTo, clickMore, removeItem } from "./index";
+import { setActive, addItem, addNav, scrollTo, clickMore, removeItem, changeCurrentName } from "./index";
 const api = ["state", "setActive", "addItem", "addNav", "scrollTo", "clickMore", "removeItem"];
 const renderless = (props, { onMounted, onBeforeUnmount, provide, reactive, watch, computed }, { vm, emit }) => {
   const state = reactive({
@@ -10,15 +10,15 @@ const renderless = (props, { onMounted, onBeforeUnmount, provide, reactive, watc
     key: computed(() => state.currentItem ? state.currentItem.name : random()),
     separator: props.separator
   });
-  const api2 = {
-    setActive: setActive({ emit, state, props }),
+  const api2 = {};
+  Object.assign(api2, {
+    state,
+    setActive: setActive({ api: api2, state, props }),
     addItem: addItem(state),
     addNav: addNav(state),
     scrollTo: scrollTo({ vm, state }),
-    removeItem: removeItem({ state, emit })
-  };
-  Object.assign(api2, {
-    state,
+    removeItem: removeItem({ state, emit }),
+    changeCurrentName: changeCurrentName({ state, emit }),
     clickMore: clickMore(api2)
   });
   provide("tabs", vm);

package/tabs-mf/wheel.js

@@ -64,6 +64,7 @@ const getWheelListener = ({ addApiName, removeApiName, prefix, support, window }
   remove: (elem, eventName, callback, useCapture) => {
     const cb = elemCbMap.get(elem);
     elem[removeApiName](prefix + eventName, cb, useCapture || false);
+    elemCbMap.delete(elem);
   }
 });
 export {

package/tag/index.js

@@ -8,7 +8,7 @@ const handleClose = ({ emit, props, state }) => (event) => {
   props.beforeDelete ? props.beforeDelete(close) : close();
 };
 const handleClick = ({ emit, props, parent, state }) => (event) => {
-  if (props.selectable === false || props.disabled)
+  if (props.selectable || props.disabled)
     return;
   parent.$parent && parent.$parent.tagSelectable && event.stopPropagation();
   state.selected = !state.selected;

package/tag-group/index.js

@@ -25,7 +25,8 @@ const getHiddenTags = ({ props, vm, state }) => () => {
   state.hiddenTags = [];
   Array.from(tags).forEach((el, index) => {
     const item = props.data[index];
-    if (el.offsetTop >= el.offsetHeight && item) {
+    const element = el;
+    if (element.offsetTop >= element.offsetHeight && item) {
       state.hiddenTags.push(__spreadValues({}, item));
     }
   });

package/time/index.js

@@ -13,10 +13,13 @@ const watchValue = ({ api, nextTick, state }) => (value) => {
     state.needInitAdjust = false;
   }
 };
-const watchVisible = ({ nextTick, vm, state }) => (value) => {
+const watchVisible = ({ nextTick, vm, state, api }) => (value) => {
   if (value) {
     state.oldValue = state.value;
-    nextTick(() => vm.$refs.spinner.emitSelectRange("hours"));
+    nextTick(() => {
+      vm.$refs.spinner.emitSelectRange("hours");
+      api.adjustSpinners();
+    });
   } else {
     state.needInitAdjust = true;
   }

package/time/vue.js

@@ -45,7 +45,7 @@ const renderless = (props, { computed, onMounted, reactive, watch, nextTick }, {
     adjustSpinners: adjustSpinners(vm),
     handleCancel: handleCancel({ state, emit }),
     setSelectionRange: setSelectionRange({ state, emit }),
-    watchVisible: watchVisible({ nextTick, vm, state }),
+    watchVisible: watchVisible({ nextTick, vm, state, api: api2 }),
     isValidValue: isValidValue({ state }),
     changeSelectionRange: changeSelectionRange({ vm, state }),
     handleConfirm: handleConfirm({ state, emit }),

package/time-line/index.js

@@ -46,10 +46,10 @@ const computedData = ({ props, state }) => () => {
 };
 const computedCurrent = ({ props, state }) => () => state.isReverse ? state.nodes.length - props.active - 1 : props.active;
 const computedIsReverse = (props) => () => props.reverse && props.vertical;
-const computedStackNodes = ({ state, constants }) => () => {
-  if (state.nodes.length >= constants.STACK_NODES_MAX) {
+const computedStackNodes = ({ state, props }) => () => {
+  if (state.nodes.length >= props.nodeMax && !props.foldDisabled) {
     state.showData = true;
-    return state.nodes.slice(0, constants.LIMITED_STACK_NODES);
+    return state.nodes.slice(0, props.limitedNodes);
   }
   return state.nodes;
 };

package/time-line/vue.js

@@ -14,7 +14,7 @@ import {
   toggleFold
 } from "./index";
 const api = ["state", "handleClick", "getStatusCls", "getStatus", "getDate", "changeStatus", "toggleFold"];
-const renderless = (props, { computed, reactive, provide, watch }, { t, emit, constants }) => {
+const renderless = (props, { computed, reactive, provide, watch }, { t, emit, constants, designConfig }) => {
   const api2 = {};
   const state = reactive({
     nodes: computed(() => api2.computedData()),
@@ -37,7 +37,7 @@ const renderless = (props, { computed, reactive, provide, watch }, { t, emit, co
     getStatus: getStatus({ state, t }),
     handleClick: handleClick({ emit, state }),
     getStatusCls: getStatusCls({ constants, state }),
-    computedStackNodes: computedStackNodes({ state, constants }),
+    computedStackNodes: computedStackNodes({ state, props }),
     changeStatus: changeStatus({ state }),
     computedWrapperClass: computedWrapperClass({ props }),
     toggleFold: toggleFold({ props })

package/time-picker-mobile/index.js

@@ -1,11 +1,15 @@
 import "../chunk-G2ADBYYC.js";
 const optionMethod = (value) => {
   const val = ("0" + value).slice(-2);
-  return { id: val, label: val };
+  return { id: +val, label: val };
 };
 const watchModelValue = ({ props, state }) => () => {
-  const { modelValue } = props;
-  state.dateArr = modelValue ? modelValue.slice() : [];
+  const { modelValue, showSeconds } = props;
+  const num = showSeconds ? 3 : 2;
+  if (!showSeconds && modelValue.length === 3) {
+    state.seconds = modelValue[2];
+  }
+  state.dateArr = modelValue ? modelValue.slice(0, num) : [];
 };
 const watchVisible = ({ api, state }) => (value) => {
   state.visible = value;
@@ -18,11 +22,26 @@ const updateVisible = ({ state, emit }) => (value) => {
 const confirm = ({ emit, state }) => (value) => {
   const dateArr = value.map((item) => ("0" + item).slice(-2));
   state.dateArr = dateArr;
-  emit("update:modelValue", dateArr);
-  emit("confirm", dateArr);
+  emit("update:modelValue", state.value);
+  emit("confirm", state.value);
+};
+const getTimePeriod = ({ state, props }) => (unit, length) => {
+  const step = props.step || {};
+  const value = step[unit] || 1;
+  return Array.from({ length }).map((v, key) => key).filter((v) => v % value === 0).map((v) => optionMethod(v));
+};
+const computedOptions = ({ state, api, props }) => () => {
+  const { showSeconds } = props;
+  const options = [];
+  options.push(api.getTimePeriod("hour", 24));
+  options.push(api.getTimePeriod("minute", 60));
+  showSeconds && options.push(api.getTimePeriod("second", 60));
+  return options;
 };
 export {
+  computedOptions,
   confirm,
+  getTimePeriod,
   optionMethod,
   updateVisible,
   watchModelValue,

package/time-picker-mobile/vue.js

@@ -1,16 +1,24 @@
 import "../chunk-G2ADBYYC.js";
-import { optionMethod, watchModelValue, watchVisible, confirm, updateVisible } from "./index";
+import {
+  optionMethod,
+  watchModelValue,
+  watchVisible,
+  confirm,
+  updateVisible,
+  getTimePeriod,
+  computedOptions
+} from "./index";
 const api = ["state", "confirm", "updateVisible"];
-const renderless = (props, { reactive, watch }, { emit }) => {
+const renderless = (props, { reactive, watch, computed }, { emit }) => {
   const api2 = {};
   const state = reactive({
     visible: false,
     dateArr: [],
-    optionList: [
-      { range: [0, 23], optionMethod },
-      { range: [0, 59], optionMethod },
-      { range: [0, 59], optionMethod }
-    ]
+    seconds: null,
+    options: computed(() => api2.computedOptions()),
+    value: computed(
+      () => !props.showSeconds && state.seconds !== null ? [...state.dateArr, state.seconds] : state.dateArr
+    )
   });
   Object.assign(api2, {
     state,
@@ -18,6 +26,8 @@ const renderless = (props, { reactive, watch }, { emit }) => {
     watchVisible: watchVisible({ api: api2, state }),
     confirm: confirm({ emit, state }),
     updateVisible: updateVisible({ emit, state }),
+    getTimePeriod: getTimePeriod({ state, props }),
+    computedOptions: computedOptions({ state, api: api2, props }),
     optionMethod
   });
   watch(() => props.visible, api2.watchVisible);

package/time-range/index.js

@@ -74,6 +74,8 @@ const handleMaxChange = ({ api, state }) => (date) => {
   api.handleChange();
 };
 const handleChange = ({ api, emit, vm, state }) => () => {
+  if (!vm.$refs.minSpinner || !vm.$refs.maxSpinner || !state.visible)
+    return;
   if (api.isValidValue([state.minDate, state.maxDate])) {
     vm.$refs.minSpinner.state.selectableRange = [[api.minTimeOfDay(state.minDate), state.maxDate]];
     vm.$refs.maxSpinner.state.selectableRange = [[state.minDate, api.maxTimeOfDay(state.maxDate)]];

package/timeline-item/vue.js

@@ -11,7 +11,7 @@ import {
   computedItemStyle
 } from "./index";
 const api = ["state", "handleClick", "getStatusCls", "getStatus", "getDate", "rootProps"];
-const renderless = (props, { computed, reactive, inject }, { t, emit, constants }) => {
+const renderless = (props, { computed, reactive, inject }, { t, emit, constants, designConfig }) => {
   const api2 = {};
   const { timelineItems, nodes, props: rootProps } = inject("nodesInject");
   timelineItems.push(props.node);

package/tooltip/index.js

@@ -75,7 +75,7 @@ const setExpectedState = ({ state }) => (value) => {
   }
   state.expectedState = value;
 };
-const destroyed = ({ state, api }) => () => {
+const destroyed = ({ state, api, vm }) => () => {
   const reference = state.referenceElm;
   state.showPopper = false;
   if (reference && reference.nodeType === 1) {
@@ -86,6 +86,10 @@ const destroyed = ({ state, api }) => () => {
     off(reference, "blur", api.handleBlur);
     off(reference, "click", api.removeFocusing);
   }
+  if (vm.popperVM) {
+    typeof vm.popperVM.$destroy === "function" && vm.popperVM.$destroy();
+    vm.popperVM = null;
+  }
 };
 const debounceClose = ({ api, props }) => debounce(props.closeDelay, () => {
   api.handleClosePopper();
@@ -137,7 +141,7 @@ const observeCallback = ({ state, popperVmRef }) => (mutationsList) => {
     }
   }
 };
-const bindPopper = ({ vm, refs, nextTick, popperVmRef }) => (el) => {
+const bindPopper = ({ vm, nextTick, popperVmRef }) => (el) => {
   nextTick(() => vm.bindEvent(el));
   let popperVM = vm.popperVM;
   if (!vm.$refs.popper) {
@@ -145,7 +149,6 @@ const bindPopper = ({ vm, refs, nextTick, popperVmRef }) => (el) => {
   } else {
     popperVmRef.popper = vm.$refs.popper;
   }
-  refs.popper || (refs.popper = popperVM.$el);
   nextTick(() => {
     if (vm.modelValue) {
       vm.updatePopper();

package/tooltip/vue.js

@@ -55,10 +55,10 @@ const renderless = (props, {
   onMounted,
   onUnmounted,
   inject
-}, { vm, emit, refs, slots, nextTick, parent }) => {
+}, { vm, emit, slots, nextTick, parent }) => {
   const api2 = {};
-  const popperParam = { emit, props, nextTick, toRefs, reactive, parent: parent.$parent, refs };
   const popperVmRef = {};
+  const popperParam = { emit, props, nextTick, toRefs, reactive, parent: parent.$parent, vm, popperVmRef };
   Object.assign(popperParam, { slots, onBeforeUnmount, onDeactivated, watch });
   const { showPopper, updatePopper, popperElm, referenceElm, doDestroy } = userPopper(popperParam);
   const state = initState({ reactive, showPopper, popperElm, referenceElm, props, inject });
@@ -68,8 +68,8 @@ const renderless = (props, {
     updatePopper,
     show: show({ api: api2, state, props }),
     hide: hide(api2),
-    destroyed: destroyed({ state, api: api2 }),
-    bindPopper: bindPopper({ vm, refs, nextTick, popperVmRef }),
+    destroyed: destroyed({ state, api: api2, vm }),
+    bindPopper: bindPopper({ vm, nextTick, popperVmRef }),
     watchFocusing: watchFocusing(state),
     removeFocusing: removeFocusing({ api: api2, state }),
     handleBlur: handleBlur({ api: api2, state }),

package/transfer/index.js

@@ -27,7 +27,12 @@ const getFlatData = (data, hasChildren) => {
   }
   return nodes;
 };
-const getTargetData = ({ props, state, Tree, Table }) => () => {
+const getTargetData = ({
+  props,
+  state,
+  Tree,
+  Table
+}) => () => {
   if (props.render && props.render.plugin.name === Tree) {
     const nodes = getFlatData(copyArray(props.data), true);
     const rightData = nodes.filter((item) => props.modelValue.includes(item[props.props.key]));
@@ -87,7 +92,13 @@ const addToLeft = ({ emit, props, state }) => (value) => {
   };
   props.beforeTransfer ? props.beforeTransfer(change) : change();
 };
-const addToRight = ({ emit, refs, props, state, Tree }) => (value) => {
+const addToRight = ({
+  emit,
+  refs,
+  props,
+  state,
+  Tree
+}) => (value) => {
   const change = () => {
     state.isToLeft = false;
     let currentValue = props.modelValue.slice();
@@ -154,7 +165,13 @@ const logicFun = ({ props, emit, state }) => ({ event, isAdd, pullMode }) => {
   emit("update:modelValue", currentValue);
   emit("change", currentValue, "left", movedKeys);
 };
-const sortableEvent = ({ api, droppanel, props, queryDom, refs }) => () => {
+const sortableEvent = ({
+  api,
+  droppanel,
+  props,
+  queryDom,
+  refs
+}) => () => {
   if (props.dropConfig) {
     const leftPanel = refs.leftPanel.$el.querySelector(droppanel);
     const Sortable = props.dropConfig.plugin;
@@ -187,24 +204,6 @@ const sortableEvent = ({ api, droppanel, props, queryDom, refs }) => () => {
 };
 const getLeftCheckedData = ({ props, state }) => () => state.sourceData.filter((item) => !item[props.props.disabled]);
 const getRightCheckedData = ({ props, state }) => () => state.targetData.filter((item) => !item[props.props.disabled]);
-const recursiveData = ({ api, props, state }) => (data, isCasader, sign) => {
-  const propChildren = props.treeOp && props.treeOp.props && props.treeOp.props.children || "children";
-  const values = props.modelValue.slice();
-  const key = props.props.key;
-  data.forEach((obj) => {
-    const isChecked = ~values.indexOf(obj[key]);
-    if (sign && !isCasader) {
-      state.treeData.push(obj);
-    } else {
-      if (isChecked) {
-        state.treeData.push(obj);
-      }
-    }
-    if (obj[propChildren] && obj[propChildren].length > 0) {
-      api.recursiveData(obj[propChildren], isCasader, !!isChecked);
-    }
-  });
-};
 export {
   addToLeft,
   addToRight,
@@ -218,6 +217,5 @@ export {
   logicFun,
   onSourceCheckedChange,
   onTargetCheckedChange,
-  recursiveData,
   sortableEvent
 };

package/transfer/vue.js

@@ -2,7 +2,6 @@ import "../chunk-G2ADBYYC.js";
 import {
   getObj,
   getSourceData,
-  recursiveData,
   getLeftCheckedData,
   getRightCheckedData,
   getTargetData,
@@ -24,8 +23,6 @@ const initState = ({ reactive, computed, api: api2, props, h, slots }) => reacti
   sourceData: computed(() => api2.getSourceData()),
   targetData: computed(() => api2.getTargetData()),
   hasButtonTexts: computed(() => props.buttonTexts.length === 2),
-  treeData: [],
-  sourceTreeData: [],
   isToLeft: false,
   optionRender: computed(() => (option) => {
     if (props.renderContent) {
@@ -45,7 +42,6 @@ const renderless = (props, { computed, onMounted, reactive, h }, { $prefix, emit
   const { DROPPANEL, TRANSFERPANEL } = parent.$constants;
   Object.assign(api2, {
     state,
-    $slots: parent.$slots,
     getObj: getObj(props),
     clearQuery: clearQuery(refs),
     getSourceData: getSourceData({ props, Tree }),
@@ -57,8 +53,7 @@ const renderless = (props, { computed, onMounted, reactive, h }, { $prefix, emit
     onSourceCheckedChange: onSourceCheckedChange({ emit, state }),
     logicFun: logicFun({ props, emit, state }),
     getTargetData: getTargetData({ props, state, Tree, Table }),
-    recursiveData: recursiveData({ api: api2, props, state }),
-    sortableEvent: sortableEvent({ api: api2, droppanel: DROPPANEL, props, queryDom: TRANSFERPANEL, refs, state })
+    sortableEvent: sortableEvent({ api: api2, droppanel: DROPPANEL, props, queryDom: TRANSFERPANEL, refs })
   });
   onMounted(api2.sortableEvent);
   return api2;

package/transfer-panel/vue.js

@@ -113,16 +113,14 @@ const initWatcher = ({ watch, state, api: api2, props, Table }) => {
     }
   );
 };
-const renderless = (props, { computed, reactive, watch, toRaw, markRaw }, { $prefix, t, emit, parent, nextTick, refs, vm, slots }) => {
+const renderless = (props, { computed, reactive, watch, toRaw }, { $prefix, emit, parent, vm, slots }) => {
   const api2 = {};
   const Table = $prefix + "Table";
   const Tree = $prefix + "Tree";
   const state = initState({ reactive, props, parent, computed, api: api2, slots });
   Object.assign(api2, {
-    t,
     state,
     toRaw,
-    markRaw,
     sizesChange: sizesChange(state),
     setPosition: setPosition({ parent, state }),
     selectChange: selectChange(state),
@@ -131,14 +129,14 @@ const renderless = (props, { computed, reactive, watch, toRaw, markRaw }, { $pre
     checkedEvent: checkedEvent(state),
     getDeteminate: getDeteminate(state),
     updateAllChecked: updateAllChecked({ state, Table, Tree }),
-    handleAllCheckedChange: handleAllCheckedChange({ nextTick, props, state, Table, Tree, vm }),
+    handleAllCheckedChange: handleAllCheckedChange({ state, Table, Tree, vm }),
     getCheckedSummary: getCheckedSummary({ props, state, Tree }),
     getFilterTreeData: getFilterTreeData({ props, state }),
     getTreeCheckableData: getTreeCheckableData(state),
     getStrictData: getStrictData({ props, state }),
     setExpandCache: setExpandCache(state),
     getCheckableData: getCheckableData({ api: api2, state, Tree }),
-    getFilterData: getFilterData({ api: api2, parent, props, refs, state, Table, Tree }),
+    getFilterData: getFilterData({ api: api2, props, state, Table, Tree }),
     watchData: watchData({ api: api2, props, state, Tree }),
     watchDefaultCheckded: watchDefaultCheckded({ api: api2, props, state, Tree }),
     watchChecked: watchChecked({ api: api2, emit, state })