@opentiny/vue-renderless 3.6.8 → 3.8.0

package/selected-box/vue.js

@@ -0,0 +1,98 @@
+import "../chunk-PKUHTIDK.js";
+import {
+  init,
+  submitSelection,
+  getSelection,
+  i18nSelected,
+  computedShowAuxi,
+  textPrimary,
+  textAuxi,
+  handleMouseenter,
+  handleMouseleave,
+  handleClear,
+  handleDelete,
+  emitChange,
+  keyOption,
+  keyType,
+  initDrag,
+  unmount,
+  arrayMinus,
+  batchSubmit,
+  getParams,
+  coverSubmit
+} from "./index";
+const api = [
+  "state",
+  "init",
+  "submitSelection",
+  "getSelection",
+  "i18nSelected",
+  "textPrimary",
+  "textAuxi",
+  "handleMouseenter",
+  "handleMouseleave",
+  "handleClear",
+  "handleDelete",
+  "keyOption",
+  "keyType",
+  "batchSubmit",
+  "coverSubmit"
+];
+const renderless = (props, { reactive, computed, onBeforeMount, onMounted, onBeforeUnmount, watch, markRaw }, { emit, t, vm }) => {
+  const state = reactive({
+    inverse: false,
+    total: 0,
+    select: [],
+    refresh: 0,
+    optionSelector: '[data-tag="tiny-selected-box-item"]',
+    dragAnimation: 100,
+    showAuxi: computed(() => api2.computedShowAuxi()),
+    popoverVisible: false,
+    popoverContent: "",
+    dragInstance: null,
+    slotParams: computed(() => ({ inverse: state.inverse, total: state.total, select: state.select }))
+  });
+  const api2 = {
+    state,
+    init: init({ props, state }),
+    i18nSelected: i18nSelected({ state, t }),
+    computedShowAuxi: computedShowAuxi(props),
+    textPrimary: textPrimary(props),
+    textAuxi: textAuxi(props),
+    handleMouseenter: handleMouseenter({ state, vm }),
+    handleMouseleave: handleMouseleave(state),
+    keyType: keyType(props),
+    unmount: unmount(state),
+    getParams: getParams(state)
+  };
+  Object.assign(api2, {
+    submitSelection: submitSelection({ api: api2, state }),
+    handleClear: handleClear({ api: api2, emit, props, state }),
+    handleDelete: handleDelete({ api: api2, emit, state }),
+    emitChange: emitChange({ api: api2, emit }),
+    initDrag: initDrag({ api: api2, emit, markRaw, props, state, vm }),
+    arrayMinus: arrayMinus(api2),
+    batchSubmit: batchSubmit({ api: api2, state }),
+    getSelection: getSelection({ api: api2, state }),
+    coverSubmit: coverSubmit({ api: api2, props, state }),
+    keyOption: keyOption({ api: api2, props })
+  });
+  onBeforeMount(() => {
+    api2.init();
+  });
+  onMounted(() => {
+    api2.initDrag();
+  });
+  onBeforeUnmount(() => {
+    api2.unmount();
+  });
+  watch(
+    () => props.inverse,
+    () => api2.init()
+  );
+  return api2;
+};
+export {
+  api,
+  renderless
+};

package/slide-bar/index.js

@@ -1,5 +1,5 @@
 import "../chunk-PKUHTIDK.js";
-import { emitEvent } from "@opentiny/vue-renderless/common/event";
+import { emitEvent } from "../common/event";
 const leftClick = ({ api, props, refs, state }) => () => {
   if (state.leftLength >= 0) {
     return;

package/slider/index.js

@@ -1,8 +1,8 @@
 import "../chunk-PKUHTIDK.js";
-import { KEY_CODE } from "@opentiny/vue-renderless/common";
-import { emitEvent } from "@opentiny/vue-renderless/common/event";
-import { on, off, hasClass } from "@opentiny/vue-renderless/common/deps/dom";
-import { toNumber } from "@opentiny/vue-renderless/common/string";
+import { KEY_CODE } from "../common";
+import { emitEvent } from "../common/event";
+import { on, off, hasClass } from "../common/deps/dom";
+import { toNumber } from "../common/string";
 const bindEvent = (api) => () => {
   on(window, "resize", api.bindResize);
   api.bindResize();
@@ -314,6 +314,48 @@ const watchModelValue = ({ api, state }) => (value) => {
     }
   }
 };
+const getPoints = ({ props, state }) => () => {
+  if (props.showSteps && props.step > 0) {
+    state.points = [];
+    const num = parseInt(props.max / props.step);
+    for (let i = 1; i < num; i++) {
+      const point = {
+        position: i / num * 100 + "%",
+        value: i / num * props.max
+      };
+      state.points.push(point);
+    }
+  }
+};
+const getLabels = ({ props, state }) => () => {
+  if (props.showLabel) {
+    state.labels = [];
+    const isFunction = props.formatLabel instanceof Function;
+    const num = parseInt(props.max / props.step);
+    for (let i = 0; i <= num; i++) {
+      const val = i / num * props.max;
+      const label = {
+        position: i / num * 100 + "%",
+        label: isFunction ? props.formatLabel(val, i) : val,
+        value: val
+      };
+      state.labels.push(label);
+    }
+  }
+};
+const inputValueChange = ({ props, state, api }) => ($event, pos) => {
+  if (props.disabled || !state.isDouble)
+    return;
+  if (!/^\d+$/.test($event.target.value)) {
+    if (pos === "left") {
+      state.inputValue.splice(0, 1, state.leftBtnValue);
+    } else {
+      state.inputValue.splice(1, 1, state.rightBtnValue);
+    }
+    return;
+  }
+  api.initSlider([Math.min(...state.inputValue), Math.max(...state.inputValue)]);
+};
 export {
   autoSlider,
   bindEvent,
@@ -330,8 +372,11 @@ export {
   formatTipValue,
   getActiveButtonIndex,
   getActiveButtonValue,
+  getLabels,
+  getPoints,
   hideTip,
   initSlider,
+  inputValueChange,
   setActiveButtonValue,
   setBarStyle,
   setButtonStyle,

package/slider/vue.js

@@ -23,7 +23,10 @@ import {
   customBeforeAppearHook,
   customAfterAppearHook,
   watchActiveValue,
-  watchModelValue
+  watchModelValue,
+  getPoints,
+  getLabels,
+  inputValueChange
 } from "./index";
 const api = [
   "state",
@@ -48,7 +51,8 @@ const api = [
   "hideTip",
   "autoSlider",
   "customBeforeAppearHook",
-  "customAfterAppearHook"
+  "customAfterAppearHook",
+  "inputValueChange"
 ];
 const initState = ({ reactive, computed, props, api: api2, parent }) => {
   const state = reactive({
@@ -108,11 +112,18 @@ const renderless = (props, { computed, onBeforeUnmount, onMounted, reactive, wat
     setActiveButtonValue: setActiveButtonValue({ api: api2, emit, props, state }),
     initSlider: initSlider({ api: api2, props, state }),
     watchModelValue: watchModelValue({ api: api2, state }),
-    watchActiveValue: watchActiveValue({ api: api2, emit, props, state })
+    watchActiveValue: watchActiveValue({ api: api2, emit, props, state }),
+    getPoints: getPoints({ props, state }),
+    getLabels: getLabels({ props, state }),
+    inputValueChange: inputValueChange({ props, api: api2, state })
   });
   watch(() => props.modelValue, api2.watchModelValue, { immediate: true });
   watch(() => state.activeValue, api2.watchActiveValue, { immediate: true });
-  onMounted(api2.bindEvent);
+  onMounted(() => {
+    api2.bindEvent();
+    api2.getPoints();
+    api2.getLabels();
+  });
   onBeforeUnmount(api2.unBindEvent);
   return api2;
 };

package/split/vue.js

@@ -14,7 +14,7 @@ import {
   computeOffset,
   handleCollapse
 } from "./index";
-import { on, off } from "@opentiny/vue-renderless/common/deps/dom";
+import { on, off } from "../common/deps/dom";
 const api = ["state", "handleMousedown", "handleCollapse"];
 const useOffset = ({ nextTick, props, refs, constants, hooks }) => {
   const api2 = {};

package/standard-list-item/index.js

@@ -0,0 +1,18 @@
+import "../chunk-PKUHTIDK.js";
+const handleEnterDesc = ({ state, props }) => ($event) => {
+  const target = $event.target;
+  if (target && target.scrollHeight > target.offsetHeight) {
+    state.descTooltip = props.data.desc;
+  } else {
+    state.descTooltip = "";
+  }
+};
+const handelIconClick = ({ emit }) => (item, index) => {
+  if (item.disabled)
+    return;
+  emit("icon-click", item, index);
+};
+export {
+  handelIconClick,
+  handleEnterDesc
+};

package/standard-list-item/vue.js

@@ -0,0 +1,22 @@
+import "../chunk-PKUHTIDK.js";
+import { handleEnterDesc, handelIconClick } from "./index";
+const api = ["state", "handelIconClick", "handleEnterDesc"];
+const renderless = (props, { computed, reactive }, { emit }) => {
+  const state = reactive({
+    descTooltip: "",
+    sliceNum: 2,
+    iconNum: 3,
+    effectOptions: computed(() => props.options.filter((item) => !item.hidden))
+  });
+  const api2 = {};
+  Object.assign(api2, {
+    state,
+    handelIconClick: handelIconClick({ emit }),
+    handleEnterDesc: handleEnterDesc({ state, props })
+  });
+  return api2;
+};
+export {
+  api,
+  renderless
+};

package/steps/index.js

@@ -0,0 +1,30 @@
+import "../chunk-PKUHTIDK.js";
+const updateStartIndex = ({ state, props }) => () => {
+  const { visibleNum, active } = props;
+  const maxStartIndex = Math.min(props.data.length - visibleNum, active - Math.floor(visibleNum / 2));
+  state.startIndex = Math.max(0, maxStartIndex);
+};
+const isVisibleHandler = ({ state, props }) => (index) => {
+  if (index < state.startIndex) {
+    return "hidden-left";
+  } else if (index >= state.startIndex + props.visibleNum) {
+    return "hidden-right";
+  } else {
+    return "visible";
+  }
+};
+const computedRightNodePos = ({ state, props }) => () => {
+  const { data } = props;
+  const { endIndex } = state;
+  const dataLength = data.length;
+  const nodesLength = dataLength - 1 - endIndex;
+  return Array.from({ length: nodesLength }).map((item, index) => ({
+    zIndex: dataLength - index,
+    right: -(index + 1) * 4 + "px"
+  }));
+};
+export {
+  computedRightNodePos,
+  isVisibleHandler,
+  updateStartIndex
+};

package/steps/slide-bar.js

@@ -0,0 +1,122 @@
+import "../chunk-PKUHTIDK.js";
+import debounce from "../common/deps/debounce";
+import { on, off } from "../common/deps/dom";
+const getBoundingPosition = ({ state }) => () => {
+  const { slideMainPostion, positionList } = state;
+  const list = positionList.slice();
+  const len = list.length;
+  state.boundingIndex = {
+    left: -1,
+    right: -1
+  };
+  for (let i = 0; i < len; i++) {
+    if (list[i].right > slideMainPostion.right + 2) {
+      state.boundingIndex.right = i;
+      break;
+    }
+  }
+  for (let i = len - 1; i >= 0; i--) {
+    if (list[i].left < slideMainPostion.left) {
+      state.boundingIndex.left = i;
+      break;
+    }
+  }
+};
+const leftSlideHandler = ({ state, api: api2 }) => () => {
+  const { canLeftScroll, slideMainPostion, positionList, boundingIndex } = state;
+  if (!canLeftScroll || state.timer) {
+    return;
+  }
+  const position = boundingIndex.left !== -1 && positionList[boundingIndex.left];
+  if (position) {
+    api2.animationHandler(position.left - slideMainPostion.left);
+  }
+};
+const rightSlideHandler = ({ state, api: api2 }) => () => {
+  const { canRightScroll, slideMainPostion, positionList, boundingIndex } = state;
+  if (!canRightScroll || state.timer) {
+    return;
+  }
+  const position = boundingIndex.right !== -1 && positionList[boundingIndex.right];
+  if (position) {
+    api2.animationHandler(position.right - slideMainPostion.right);
+  }
+};
+const updatePosition = ({ state, vm, props, api: api2 }) => debounce(10, (isInit) => {
+  state.positionList = props.data.map((item, index) => {
+    const blockRef = vm.$refs["block" + index];
+    const position = blockRef && blockRef[0].getBoundingClientRect() || {};
+    return Object.assign(position, { index });
+  });
+  state.slideMainPostion = vm.$refs.slideMain.getBoundingClientRect();
+  api2.getBoundingPosition();
+  isInit === true && api2.updatePosition();
+});
+const animationLoop = ({ state, api: api2, vm }) => (offset, delay, scorllLeft, cb) => {
+  const elScrollLeft = vm.$refs.slideMain.scrollLeft;
+  clearTimeout(state.timer);
+  if (elScrollLeft !== state.oldScrollLeft && Math.abs(elScrollLeft - scorllLeft) > Math.abs(offset)) {
+    state.timer = setTimeout(() => {
+      vm.$refs.slideMain.scrollLeft += offset;
+      state.oldScrollLeft = elScrollLeft;
+      api2.animationLoop(offset, delay, scorllLeft, cb);
+    }, delay);
+  } else {
+    state.timer = null;
+    vm.$refs.slideMain.scrollLeft = scorllLeft;
+    cb && cb();
+  }
+};
+const animationHandler = ({ api: api2, vm, props }) => (allOffset) => {
+  const { duration, delay } = props;
+  const mathFn = allOffset > 0 ? Math.ceil : Math.floor;
+  const offsetInt = mathFn(allOffset);
+  if (!duration) {
+    vm.$refs.slideMain.scrollLeft += offsetInt;
+    api2.updatePosition();
+    return;
+  }
+  const offset = mathFn(offsetInt / (duration / delay));
+  const scorllLeft = vm.$refs.slideMain.scrollLeft + offsetInt;
+  api2.animationLoop(offset, delay, scorllLeft, () => {
+    api2.updatePosition();
+  });
+};
+const api = ["slideBarState", "leftSlideHandler", "rightSlideHandler", "updatePosition"];
+const renderless = (props, { reactive, onMounted, onUnmounted, computed }, { vm }) => {
+  const state = reactive({
+    timer: null,
+    oldScrollLeft: -1,
+    slideMainPostion: {},
+    positionList: [],
+    canLeftScroll: computed(() => !props.noArrow && state.boundingIndex.left !== -1),
+    canRightScroll: computed(() => !props.noArrow && state.boundingIndex.right !== -1),
+    boundingIndex: {
+      left: -1,
+      right: -1
+    }
+  });
+  const api2 = {};
+  Object.assign(api2, {
+    slideBarState: state,
+    // 内部 state 重命名，避免使用插槽时 state 覆盖问题
+    leftSlideHandler: leftSlideHandler({ state, api: api2 }),
+    rightSlideHandler: rightSlideHandler({ state, api: api2 }),
+    animationHandler: animationHandler({ api: api2, vm, props }),
+    animationLoop: animationLoop({ state, api: api2, vm }),
+    getBoundingPosition: getBoundingPosition({ state, api: api2, vm }),
+    updatePosition: updatePosition({ state, vm, props, api: api2 })
+  });
+  onMounted(() => {
+    api2.updatePosition(true);
+    on(window, "resize", api2.updatePosition);
+  });
+  onUnmounted(() => {
+    off(window, "resize", api2.updatePosition);
+  });
+  return api2;
+};
+export {
+  api,
+  renderless
+};

package/steps/vue.js

@@ -1,7 +1,19 @@
 import "../chunk-PKUHTIDK.js";
-const api = [];
-const renderless = function() {
-  return {};
+import { updateStartIndex, isVisibleHandler, computedRightNodePos } from "./index";
+const api = ["state", "isVisibleHandler"];
+const renderless = (props, { reactive, watch, computed }) => {
+  const state = reactive({
+    startIndex: 0,
+    endIndex: computed(() => state.startIndex + props.visibleNum),
+    rightNodePositions: computed(() => api2.computedRightNodePos())
+  });
+  const api2 = {
+    updateStartIndex: updateStartIndex({ state, props }),
+    isVisibleHandler: isVisibleHandler({ state, props }),
+    computedRightNodePos: computedRightNodePos({ state, props })
+  };
+  watch(() => props.active, api2.updateStartIndex, { immediate: true });
+  return Object.assign(api2, { state });
 };
 export {
   api,

package/switch/index.js

@@ -1,5 +1,5 @@
 import "../chunk-PKUHTIDK.js";
-import { isNull } from "@opentiny/vue-renderless/common/type";
+import { isNull } from "../common/type";
 const toggle = ({ emit, props, state }) => (event) => {
   event.preventDefault();
   if (state.disabled) {

package/switch/vue.js

@@ -13,7 +13,8 @@ const renderless = (props, { computed, watch, reactive, inject }, { parent, cons
     wrapClasses: computed(() => api2.computedWarpClasses()),
     style: computed(() => api2.computedStyle()),
     formDisabled: computed(() => (parent.tinyForm || {}).disabled),
-    disabled: computed(() => props.disabled || state.formDisabled)
+    disabled: computed(() => props.disabled || state.formDisabled),
+    isDisplayOnly: computed(() => props.displayOnly || (parent.tinyForm || {}).displayOnly)
   });
   Object.assign(api2, {
     state,

package/tab-bar/index.js

@@ -1,6 +1,6 @@
 import "../chunk-PKUHTIDK.js";
-import { POSITION } from "@opentiny/vue-renderless/common";
-import { capitalize } from "@opentiny/vue-renderless/common/string";
+import { POSITION } from "../common";
+import { capitalize } from "../common/string";
 const computedBarStyle = (parent) => (props, state) => {
   const style = {};
   let offset = 0;

package/tab-item/index.js

@@ -1,7 +1,7 @@
 import "../chunk-PKUHTIDK.js";
 const computedIsClosable = ({ parent, props }) => () => props.withClose || parent.withClose;
-const computedActive = ({ parent, nextTick, props, state }) => () => {
-  const active = parent.state.currentName === (props.name || state.index);
+const computedActive = ({ nextTick, props, state }) => () => {
+  const active = state.rootTabs.state.currentName === (props.name || state.index);
   if (active) {
     state.loaded = true;
     nextTick(() => {

package/tab-item/vue.js

@@ -17,7 +17,7 @@ const renderless = (props, { computed, inject, reactive, watch }, { parent, next
   });
   Object.assign(api2, {
     state,
-    computedActive: computedActive({ parent, nextTick, props, state }),
+    computedActive: computedActive({ nextTick, props, state }),
     computedPaneName: computedPaneName({ props, state })
   });
   watch(() => props.title, api2.watchTitle);

package/tab-item-mf/vue.js

@@ -0,0 +1,16 @@
+import "../chunk-PKUHTIDK.js";
+const renderless = (props, { inject }, { slots }) => {
+  const tabs = inject("tabs", null);
+  const { title, name } = props;
+  const item = { title, name, slotDefault: slots.default, slotTitle: slots.title, slotSetting: slots.setting };
+  if (props.renderTitle)
+    item.slotTitle = props.renderTitle;
+  if (props.renderSetting)
+    item.slotSetting = props.renderSetting;
+  item.selected = (tabs.activeName || tabs.modelValue) === name;
+  tabs.addItem(item);
+  return {};
+};
+export {
+  renderless
+};

package/tab-nav/index.js

@@ -1,8 +1,8 @@
 import "../chunk-PKUHTIDK.js";
-import { KEY_CODE, POSITION } from "@opentiny/vue-renderless/common";
-import { capitalize } from "@opentiny/vue-renderless/common/string";
-import { addResizeListener, removeResizeListener } from "@opentiny/vue-renderless/common/deps/resize-event";
-import { on, off } from "@opentiny/vue-renderless/common/deps/dom";
+import { KEY_CODE, POSITION } from "../common";
+import { capitalize } from "../common/string";
+import { addResizeListener, removeResizeListener } from "../common/deps/resize-event";
+import { on, off } from "../common/deps/dom";
 const computedNavStyle = (state) => {
   const dir = ~[POSITION.Top, POSITION.Bottom].indexOf(state.rootTabs.position) ? "X" : "Y";
   if (state.mode === "mobile") {
@@ -75,6 +75,7 @@ const mounted = ({ api, parent }) => {
   on(window, "focus", api.windowFocusHandler);
   api.scrollToActiveTab();
   api.scrollIntoView();
+  api.sortableEvent();
 };
 const beforeUnmount = ({ api, parent }) => {
   const el = parent.$refs.nav && parent.$refs.nav.$el;
@@ -208,6 +209,75 @@ const computedHeaderStyle = ({ refs, state }) => () => {
   }
   return state.expandHeaderStyle;
 };
+const handleTabDragStart = ({ state, vm, emit }) => (event) => {
+  state.dragging = true;
+  if ([POSITION.Top, POSITION.Bottom].indexOf(state.rootTabs.position) === -1) {
+    emit("tab-drag-start", event);
+    return;
+  }
+  const navContainer = vm.$refs.navScroll;
+  const nav = vm.$refs.nav;
+  const containerWidth = navContainer.offsetWidth;
+  const navWidth = nav.offsetWidth;
+  if (navWidth > containerWidth) {
+    const navHeight = nav.offsetHeight;
+    navContainer.style.height = navHeight + "px";
+    nav.style.transition = "none";
+    nav.style.transform = "";
+    nav.style.width = containerWidth + "px";
+    nav.style.overflowX = "scroll";
+    nav.scrollTo(state.navOffset, 0);
+  }
+  emit("tab-drag-start", event);
+};
+const handleTabDragEnd = ({ vm, state, nextTick }) => () => {
+  state.dragging = false;
+  if ([POSITION.Top, POSITION.Bottom].indexOf(state.rootTabs.position) === -1) {
+    return;
+  }
+  const nav = vm.$refs.nav;
+  if (nav.style.width) {
+    const navOffset = nav.scrollLeft;
+    const navContainer = vm.$refs.navScroll;
+    navContainer.style.height = "";
+    nav.style.width = "";
+    nav.style.overflowX = "";
+    state.navOffset = navOffset;
+    nextTick(() => {
+      nav.style.transition = "";
+    });
+  }
+};
+const sortableEvent = ({ api, props, state, vm, emit, markRaw }) => () => {
+  if (!props.dropConfig || typeof props.dropConfig.plugin !== "function") {
+    return;
+  }
+  const navSortableObj = new props.dropConfig.plugin(vm.$refs.nav, {
+    sort: true,
+    draggable: ".tiny-tabs__item",
+    onUpdate(event) {
+      emit("tab-drag-end", event);
+    },
+    onMove(event) {
+      emit("tab-drag-over", event);
+    },
+    onStart(event) {
+      api.handleTabDragStart(event);
+    },
+    onEnd(event) {
+      api.handleTabDragEnd(event);
+    }
+  });
+  state.navSortableObj = markRaw(navSortableObj);
+};
+const watchCurrentName = ({ nextTick, vm, state }) => () => {
+  nextTick(() => {
+    const tabBarVnode = vm.$refs.tabBar;
+    if (tabBarVnode) {
+      tabBarVnode.state.barStyle = tabBarVnode.computedBarStyle(tabBarVnode, state);
+    }
+  });
+};
 export {
   beforeUnmount,
   changeTab,
@@ -216,6 +286,8 @@ export {
   computedSizeName,
   expandTabHide,
   expandTabShow,
+  handleTabDragEnd,
+  handleTabDragStart,
   moreTabShow,
   mounted,
   removeFocus,
@@ -224,8 +296,10 @@ export {
   scrollPrev,
   scrollToActiveTab,
   setFocus,
+  sortableEvent,
   updated,
   visibilityChangeHandler,
+  watchCurrentName,
   windowBlurHandler,
   windowFocusHandler
 };

package/tab-nav/vue.js

@@ -18,7 +18,11 @@ import {
   scrollNext,
   changeTab,
   setFocus,
-  removeFocus
+  removeFocus,
+  sortableEvent,
+  handleTabDragStart,
+  handleTabDragEnd,
+  watchCurrentName
 } from "./index";
 const api = [
   "state",
@@ -35,7 +39,7 @@ const api = [
   "computedHeaderStyle",
   "swiperHandle"
 ];
-const renderless = (props, { computed, inject, onBeforeUnmount, onMounted, onUpdated, reactive }, { parent, refs, mode: tinyMode }) => {
+const renderless = (props, { computed, inject, onBeforeUnmount, onMounted, onUpdated, reactive, markRaw }, { parent, vm, nextTick, refs, mode: tinyMode, emit }) => {
   const api2 = { mounted, beforeUnmount, computedNavStyle, computedSizeName };
   const state = reactive({
     navOffset: 0,
@@ -68,7 +72,11 @@ const renderless = (props, { computed, inject, onBeforeUnmount, onMounted, onUpd
     visibilityChangeHandler: visibilityChangeHandler(state),
     scrollToActiveTab: scrollToActiveTab({ props, parent, refs, state }),
     scrollIntoView: scrollIntoView({ props, parent, refs, state }),
-    computedHeaderStyle: computedHeaderStyle({ refs, state })
+    computedHeaderStyle: computedHeaderStyle({ refs, state }),
+    watchCurrentName: watchCurrentName({ nextTick, vm, state }),
+    handleTabDragStart: handleTabDragStart({ state, vm, emit }),
+    handleTabDragEnd: handleTabDragEnd({ state, vm, nextTick }),
+    sortableEvent: sortableEvent({ api: api2, props, state, vm, emit, markRaw })
   });
   Object.assign(api2, { updated: updated({ api: api2, props, refs, state }), changeTab: changeTab(api2) });
   onUpdated(() => api2.updated());

package/tabbar-item/index.js

@@ -1,5 +1,5 @@
 import "../chunk-PKUHTIDK.js";
-import { isObject, isNull } from "@opentiny/vue-renderless/common/type";
+import { isObject, isNull } from "../common/type";
 const getRouteActive = ({ props, route }) => () => {
   if (props.to && route) {
     const config = isObject(props.to) ? props.to : { path: props.to };