@opentiny/vue-renderless 3.16.1 → 3.17.0

package/carousel/index.js

@@ -2,6 +2,7 @@ import "../chunk-G2ADBYYC.js";
 import throttle from "../common/deps/throttle";
 import { getDirection } from "../common/deps/touch";
 import { POSITION } from "../common";
+import emulate from "../common/deps/touch-emulator";
 const handleMouseEnter = ({ api, state }) => () => {
   state.hover = true;
   api.pauseTimer();
@@ -39,12 +40,19 @@ const resetItemPosition = (state) => (oldIndex) => {
     });
   }
 };
-const playSlides = ({ props, state }) => () => {
+const playSlides = ({ api, props, state }) => () => {
+  let newIndex;
+  let oldIndex = state.activeIndex;
   if (state.activeIndex < state.items.length - 1) {
-    state.activeIndex++;
+    newIndex = state.activeIndex + 1;
   } else if (props.loop) {
-    state.activeIndex = 0;
+    newIndex = 0;
   }
+  api.canActive(newIndex, oldIndex).then((result) => {
+    if (result) {
+      state.activeIndex = newIndex;
+    }
+  });
 };
 const pauseTimer = (state) => () => clearInterval(state.timer);
 const startTimer = ({ api, props, state }) => () => {
@@ -66,25 +74,55 @@ const setActiveItem = ({ api, props, state }) => (index) => {
   }
   const length = state.items.length;
   const oldIndex = state.activeIndex;
+  let newIndex;
   if (index < 0) {
-    state.activeIndex = props.loop ? length - 1 : 0;
+    newIndex = props.loop ? length - 1 : 0;
   } else if (index >= length) {
-    state.activeIndex = props.loop ? 0 : length - 1;
+    newIndex = props.loop ? 0 : length - 1;
   } else {
-    state.activeIndex = index;
+    newIndex = index;
   }
-  if (oldIndex === state.activeIndex) {
-    api.resetItemPosition(oldIndex);
+  const nextProcess = () => {
+    state.activeIndex = newIndex;
+    if (oldIndex === state.activeIndex) {
+      api.resetItemPosition(oldIndex);
+    }
+  };
+  if (newIndex === oldIndex) {
+    nextProcess();
+  } else {
+    api.canActive(newIndex, oldIndex).then((result) => {
+      if (result) {
+        nextProcess();
+      }
+    });
   }
 };
+const canActive = (props) => (newIndex, oldIndex) => {
+  return new Promise((resolve) => {
+    if (typeof props.beforeSwipe === "function") {
+      resolve(props.beforeSwipe(newIndex, oldIndex));
+    } else {
+      resolve(true);
+    }
+  }).then((result) => result !== false);
+};
 const prev = ({ api, state }) => () => api.setActiveItem(state.activeIndex - 1);
 const next = ({ api, state }) => () => api.setActiveItem(state.activeIndex + 1);
-const handleIndicatorClick = (state) => (index) => {
-  state.activeIndex = index;
+const handleIndicatorClick = ({ api, state }) => (index) => {
+  api.canActive(index, state.activeIndex).then((result) => {
+    if (result) {
+      state.activeIndex = index;
+    }
+  });
 };
-const handleIndicatorHover = ({ props, state }) => (index) => {
+const handleIndicatorHover = ({ api, props, state }) => (index) => {
   if (props.trigger === "hover" && index !== state.activeIndex) {
-    state.activeIndex = index;
+    api.canActive(index, state.activeIndex).then((result) => {
+      if (result) {
+        state.activeIndex = index;
+      }
+    });
   }
 };
 const watchItems = ({ props, api }) => (value) => {
@@ -113,20 +151,26 @@ const computedStyle = ({ props }) => () => {
     }
   }
 };
-const onComplete = ({ count, emit, props, state }) => (total) => {
+const onComplete = ({ api, count, emit, props, state }) => (total) => {
   if (count++ === total) {
     state.completed = true;
     if (props.initialIndex < state.items.length && props.initialIndex >= 0) {
-      state.activeIndex = props.initialIndex;
+      api.canActive(props.initialIndex, state.activeIndex).then((result) => {
+        if (result) {
+          state.activeIndex = props.initialIndex;
+        }
+      });
     }
     emit("complete");
   }
 };
-const touchstart = ({ state, api }) => (event) => {
+const touchstart = ({ props, state, api }) => (event) => {
   if (state.items.length <= 1 || ~state.noTouchNode.indexOf(event.target.nodeName))
     return;
-  event.preventDefault();
-  event.stopPropagation();
+  if (!props.swipeable) {
+    event.preventDefault();
+    event.stopPropagation();
+  }
   resetTouchStatus(state);
   api.pauseTimer();
   state.itemsTranslate = state.items.map((item) => item.state.translate);
@@ -188,7 +232,34 @@ function resetTouchStatus(state) {
   state.offsetPos.X = 0;
   state.offsetPos.Y = 0;
 }
+const simulateTouch = ({ props, vm }) => () => {
+  if (props.swipeable && vm.$refs.carousel) {
+    emulate();
+    vm.$refs.carousel.setAttribute("data-tiny-touch-simulate-container", "");
+  }
+};
+const computedHasButtons = ({ props, state, mode }) => () => {
+  if (props.lite) {
+    return false;
+  } else if (mode === "mobile-first") {
+    return props.arrow !== "never" && state.items.length > 1;
+  } else if (mode === "pc") {
+    return props.arrow !== "never";
+  }
+};
+const computedHasIndicators = ({ props, state, mode }) => () => {
+  if (props.lite) {
+    return false;
+  } else if (mode === "mobile-first") {
+    return props.indicatorPosition !== "none" && state.items.length > 1;
+  } else if (mode === "pc") {
+    return props.indicatorPosition !== "none";
+  }
+};
 export {
+  canActive,
+  computedHasButtons,
+  computedHasIndicators,
   computedHasLabel,
   computedStyle,
   handleButtonEnter,
@@ -205,6 +276,7 @@ export {
   prev,
   resetItemPosition,
   setActiveItem,
+  simulateTouch,
   startTimer,
   throttledArrowClick,
   throttledIndicatorHover,

package/carousel/vue.js

@@ -24,7 +24,11 @@ import {
   touchstart,
   touchmove,
   touchend,
-  computedStyle
+  computedStyle,
+  simulateTouch,
+  computedHasButtons,
+  computedHasIndicators,
+  canActive
 } from "./index";
 import { addResizeListener, removeResizeListener } from "../common/deps/resize-event";
 const api = [
@@ -86,26 +90,28 @@ const initState = ({ reactive, computed, api: api2 }) => {
     moveDisable: false,
     noTouchNode: ["svg", "BUTTON", "path", "g"],
     style: computed(() => api2.computedStyle()),
-    hasLabel: computed(() => api2.computedHasLabel(state.items))
+    hasLabel: computed(() => api2.computedHasLabel(state.items)),
+    hasButtons: computed(() => api2.computedHasButtons()),
+    hasIndicators: computed(() => api2.computedHasIndicators())
   });
   return state;
 };
-const initApi = ({ vm, api: api2, state, props, emit }) => {
+const initApi = ({ vm, api: api2, state, props, emit, mode }) => {
   Object.assign(api2, {
     state,
     computedHasLabel,
-    touchend: touchend({ state, api: api2 }),
-    touchstart: touchstart({ state, api: api2 }),
+    touchend: touchend({ props, state, api: api2 }),
+    touchstart: touchstart({ props, state, api: api2 }),
     touchmove: touchmove({ props, state, vm }),
-    playSlides: playSlides({ props, state }),
-    onComplete: onComplete({ count: 0, emit, props, state }),
+    playSlides: playSlides({ api: api2, props, state }),
+    onComplete: onComplete({ api: api2, count: 0, emit, props, state }),
     pauseTimer: pauseTimer(state),
     itemInStage: itemInStage(state),
     resetItemPosition: resetItemPosition(state),
     watchItems: watchItems({ api: api2, props }),
     handleButtonLeave: handleButtonLeave(state),
-    handleIndicatorClick: handleIndicatorClick(state),
-    handleIndicatorHover: handleIndicatorHover({ props, state }),
+    handleIndicatorClick: handleIndicatorClick({ api: api2, state }),
+    handleIndicatorHover: handleIndicatorHover({ api: api2, props, state }),
     watchActiveIndex: watchActiveIndex({ api: api2, emit }),
     watchAutoplay: watchAutoplay(api2),
     startTimer: startTimer({ api: api2, props, state }),
@@ -117,7 +123,11 @@ const initApi = ({ vm, api: api2, state, props, emit }) => {
     handleMouseLeave: handleMouseLeave({ api: api2, state }),
     throttledIndicatorHover: throttledIndicatorHover(api2),
     handleButtonEnter: handleButtonEnter({ api: api2, state }),
-    computedStyle: computedStyle({ props })
+    computedStyle: computedStyle({ props }),
+    simulateTouch: simulateTouch({ props, vm }),
+    computedHasButtons: computedHasButtons({ props, state, mode }),
+    computedHasIndicators: computedHasIndicators({ props, state, mode }),
+    canActive: canActive(props)
   });
 };
 const initWatch = ({ watch, props, api: api2, state }) => {
@@ -127,18 +137,20 @@ const initWatch = ({ watch, props, api: api2, state }) => {
     () => api2.setActiveItem(state.activeIndex)
   );
 };
-const renderless = (props, { computed, onMounted, onBeforeUnmount, reactive, watch }, { vm, parent, emit, constants, childrenHandler }) => {
+const renderless = (props, { computed, onMounted, onBeforeUnmount, reactive, watch, provide }, { vm, parent, emit, mode }) => {
   const api2 = {};
   const state = initState({ reactive, computed, api: api2 });
-  initApi({ vm, api: api2, state, props, emit });
-  const { updateItems } = useItems({ api: api2, vm, onMounted, state, watch, constants, childrenHandler, parent });
+  initApi({ vm, api: api2, state, props, emit, mode });
+  const { updateItems } = useItems({ api: api2, vm, onMounted, state, watch });
   api2.updateItems = updateItems;
   useActiveIndex({ api: api2, parent, props, state, watch });
   useResizeListener({ api: api2, onBeforeUnmount, onMounted, parent });
+  provide("CarouselVm", vm);
   initWatch({ watch, props, api: api2, state });
   onMounted(() => {
     api2.startTimer();
     api2.onComplete(state.items.length);
+    api2.simulateTouch();
   });
   parent.$on("updateItems", api2.updateItems);
   parent.$on("complete", () => {
@@ -146,18 +158,11 @@ const renderless = (props, { computed, onMounted, onBeforeUnmount, reactive, wat
   });
   return api2;
 };
-const useItems = ({ api: api2, onMounted, state, watch, constants, childrenHandler, parent }) => {
-  const updateItems = () => {
-    let $children = [];
-    $children = parent.$children && parent.$children[0].$children.filter((child) => {
-      return child.$el.classList && Array.from(child.$el.classList).includes("tiny-carousel__item");
-    });
-    if (!$children.length) {
-      childrenHandler(({ options, vm }) => {
-        options.name === constants.CHILD_NAME && $children.push(vm);
-      });
+const useItems = ({ api: api2, onMounted, state, watch }) => {
+  const updateItems = (carouselItemVm) => {
+    if (carouselItemVm && !state.items.includes(carouselItemVm)) {
+      state.items.push(carouselItemVm);
     }
-    state.items = $children;
   };
   watch(
     () => state.items,

package/carousel-item/index.js

@@ -21,10 +21,10 @@ const calculateTranslate = ({ CARD_SCALE, state }) => ({ activeIndex, index, par
   }
   return (3 + CARD_SCALE) * parentWidth / 4;
 };
-const translateItem = ({ api, CARD_SCALE, parent, state }) => ({ activeIndex, index, oldIndex }) => {
-  const parentHeight = parent.$parent.$el.offsetHeight;
-  const parentWidth = parent.$parent.$el.offsetWidth;
-  const vnode = parent.$parent;
+const translateItem = ({ api, CARD_SCALE, parent, state, carouselParent }) => ({ activeIndex, index, oldIndex }) => {
+  const parentHeight = carouselParent.$el.offsetHeight;
+  const parentWidth = carouselParent.$el.offsetWidth;
+  const vnode = carouselParent;
   const length = vnode.state.items.length;
   const { TYPE_CARD, TYPE_VERTICAL } = parent.$constants;
   if (vnode.type !== TYPE_CARD && oldIndex !== void 0) {
@@ -45,26 +45,41 @@ const translateItem = ({ api, CARD_SCALE, parent, state }) => ({ activeIndex, in
     state.scale = state.active ? 1 : CARD_SCALE;
   } else {
     state.active = index === activeIndex;
-    state.translate = vnode.type === TYPE_VERTICAL ? parentHeight * (index - activeIndex) : parentWidth * (index - activeIndex);
+    if (length === 2 && !state.active) {
+      state.translate = vnode.type === TYPE_VERTICAL ? -parentHeight : -parentWidth;
+    } else {
+      state.translate = vnode.type === TYPE_VERTICAL ? parentHeight * (index - activeIndex) : parentWidth * (index - activeIndex);
+    }
   }
   state.ready = true;
 };
-const handleItemClick = ({ state, parent }) => () => {
-  const vnode = parent.$parent;
+const handleItemClick = ({ state, parent, carouselParent }) => () => {
+  const vnode = carouselParent;
   if (vnode && vnode.type === parent.$constants.TYPE_CARD) {
     const index = vnode.state.items.findIndex((item) => item.state.translate === state.translate);
     vnode.setActiveItem(index);
   }
 };
-const computedTransform = ({ parent, TYPE_VERTICAL, mode, state }) => () => {
-  const TRANSLATE = parent.$parent.type === TYPE_VERTICAL ? `translateY(${state.translate + state.delta}px) scale(${state.scale})` : `translateX(${state.translate + state.delta}px) scale(${state.scale})`;
+const computedTransform = ({ carouselParent, TYPE_VERTICAL, mode, state }) => () => {
+  const TRANSLATE = carouselParent.type === TYPE_VERTICAL ? `translateY(${state.translate + state.delta}px) scale(${state.scale})` : `translateX(${state.translate + state.delta}px) scale(${state.scale})`;
   const style = mode === "mobile-first" ? { width: "100%", height: "100%" } : {};
+  moveItemBack(carouselParent, state, TYPE_VERTICAL);
   return __spreadValues({
     msTransform: TRANSLATE,
     webkitTransform: TRANSLATE,
     transform: TRANSLATE
   }, style);
 };
+const moveItemBack = (parent, state, TYPE_VERTICAL) => {
+  if (!parent || !parent.$el)
+    return;
+  const length = parent.state.items.length;
+  setTimeout(() => {
+    if (length === 2 && !state.active) {
+      state.translate = parent.type === TYPE_VERTICAL ? parent.$el.offsetHeight : parent.$el.offsetWidth;
+    }
+  }, 300);
+};
 const resetAnimatingMf = (state) => () => {
   state.animatingMf = false;
 };

package/carousel-item/vue.js

@@ -27,10 +27,11 @@ const api = [
   "resetAnimatingMf",
   "setDelta"
 ];
-const renderless = (props, { computed, onMounted, onUnmounted, reactive }, { parent, dispatch, mode }) => {
+const renderless = (props, { computed, onMounted, onUnmounted, reactive, inject }, { parent, dispatch, mode, vm }) => {
   const api2 = {};
   const CARD_SCALE = parent.$constants.CARD_SCALE;
   const TYPE_VERTICAL = parent.$constants.TYPE_VERTICAL;
+  const carouselParent = inject("CarouselVm");
   const state = reactive({
     scale: 1,
     translate: 0,
@@ -41,29 +42,29 @@ const renderless = (props, { computed, onMounted, onUnmounted, reactive }, { par
     animating: false,
     animatingMf: false,
     isOblique: false,
-    carouselParent: parent.$parent,
+    carouselParent,
     hasTitle: computed(() => !!props.title),
-    moving: computed(() => parent.$parent.state.moving),
-    animate: computed(() => Math.abs(parent.$parent.state.delta) > 0 ? !state.animatingMf : state.animating),
+    moving: computed(() => carouselParent.state.moving),
+    animate: computed(() => Math.abs(carouselParent.state.delta) > 0 ? !state.animatingMf : state.animating),
     getTransform: computed(() => api2.computedTransform()),
     delta: 0
   });
   Object.assign(api2, {
     state,
     processIndex,
-    handleItemClick: handleItemClick({ state, parent }),
-    computedTransform: computedTransform({ parent, TYPE_VERTICAL, mode, state }),
+    handleItemClick: handleItemClick({ state, parent, carouselParent }),
+    computedTransform: computedTransform({ carouselParent, TYPE_VERTICAL, mode, state }),
     calculateTranslate: calculateTranslate({ CARD_SCALE, state }),
-    translateItem: translateItem({ api: api2, CARD_SCALE, parent, state }),
+    translateItem: translateItem({ api: api2, CARD_SCALE, parent, state, carouselParent }),
     setDelta: setDelta({ state }),
     resetAnimatingMf: resetAnimatingMf(state)
   });
   onMounted(() => {
-    dispatch("Carousel", "updateItems", []);
+    dispatch("Carousel", "updateItems", [vm]);
     dispatch("Carousel", "complete", []);
   });
   onUnmounted(() => {
-    parent.$parent && parent.$parent.updateItems();
+    carouselParent && carouselParent.updateItems();
   });
   return api2;
 };

package/cascader/vue.js

@@ -56,7 +56,8 @@ const api = [
   "toggleDropDownVisible",
   "handleKeyDown",
   "handleMouseenter",
-  "handleMouseleave"
+  "handleMouseleave",
+  "computePresentContent"
 ];
 const initState = ({
   reactive,

package/cascader-panel/index.js

@@ -144,7 +144,13 @@ const handleExpand = ({ emit, state }) => (node, silent) => {
 const handleCheckChange = (state) => (value) => {
   state.checkedValue = value;
 };
-const lazyLoad = ({ api, $parent, state, Store }) => (currentNode, onFullfiled) => {
+const lazyLoad = ({
+  api,
+  $parent,
+  state,
+  Store,
+  emit
+}) => (currentNode, onFullfiled) => {
   let node = currentNode;
   if (!node) {
     node = node || { root: true, level: 0 };
@@ -157,6 +163,7 @@ const lazyLoad = ({ api, $parent, state, Store }) => (currentNode, onFullfiled)
     dataList && dataList.length && state.store.appendNodes(dataList, parent);
     node.loading = false;
     node.loaded = true;
+    emit("load-data", dataList);
     if (Array.isArray(state.checkedValue)) {
       const nodeValue = state.checkedValue[state.loadCount++];
       const valueKey = state.config.value;

package/cascader-panel/vue.js

@@ -100,7 +100,7 @@ const initApi = ({
     syncMenuState: syncMenuState({ api: api2, nextTick, state }),
     syncMultiCheckState: syncMultiCheckState({ api: api2, state }),
     calculateCheckedNodePaths: calculateCheckedNodePaths({ api: api2, state }),
-    lazyLoad: lazyLoad({ api: api2, $parent: parent, state, Store }),
+    lazyLoad: lazyLoad({ api: api2, $parent: parent, state, Store, emit }),
     syncCheckedValue: syncCheckedValue({ api: api2, props, state }),
     focusNode: focusNode(api2),
     checkNode: checkNode(api2),

package/cascader-select/column-index.js

@@ -103,7 +103,7 @@ const setMove = ({ state, props, api }) => (move, type, time) => {
     let endMove = Math.round(updateMove / +optionHeight) * +optionHeight;
     let deg = `${(Math.abs(Math.round(endMove / +optionHeight)) + 1) * state.rotation}deg`;
     api.setTransform(type, deg, endMove, time);
-    state.currIndex = Math.abs(Math.round(endMove / +optionHeight)) + 1;
+    state.currIndex = state.defaultIndex = Math.abs(Math.round(endMove / +optionHeight)) + 1;
   } else {
     let deg = 0;
     let currentDeg = (-updateMove / +optionHeight + 1) * state.rotation;
@@ -112,7 +112,7 @@ const setMove = ({ state, props, api }) => (move, type, time) => {
     deg = clamp(currentDeg, minDeg, maxDeg);
     if (minDeg < deg && deg < maxDeg) {
       api.setTransform(null, deg + "deg", updateMove, void 0);
-      state.currIndex = Math.abs(Math.round(updateMove / +optionHeight)) + 1;
+      state.currIndex = state.defaultIndex = Math.abs(Math.round(updateMove / +optionHeight)) + 1;
     }
   }
 };
@@ -121,16 +121,21 @@ const setChooseValue = ({ props, state, emit }) => () => {
 };
 const modifyStatus = ({ state, props, api }) => (type) => {
   const { column } = props;
-  let index = column.findIndex((columnItem) => columnItem[props.fieldNames.value] === props.value);
-  state.currIndex = index === -1 ? 1 : index + 1;
+  const value = isEffectVal(props.value) ? props.value : props.defaultValue;
+  const currentIndex = isEffectVal(props.value) ? "currIndex" : "defaultIndex";
+  let index = column.findIndex((columnItem) => columnItem[props.fieldNames.value] === value);
+  state[currentIndex] = index === -1 ? 1 : index + 1;
   let move = index === -1 ? 0 : index * +props.optionHeight;
   type && api.setChooseValue();
   api.setMove(-move);
 };
-const OptionStyle = ({ state }) => (option, column, offset) => {
-  const currentIndex = state.currIndex - 1;
+const OptionStyle = ({ props, state }) => (option, column, offset) => {
+  const currentIndex = isEffectVal(props.value) ? state.currIndex - 1 : state.defaultIndex - 1;
   return option === column[currentIndex + offset] || option === column[currentIndex - offset];
 };
+const isEffectVal = (val) => {
+  return val || val === 0;
+};
 export {
   OptionStyle,
   clamp,

package/cascader-select/column.js

@@ -40,6 +40,7 @@ const renderless = (props, { reactive, computed, watch, ref, onMounted }, { emit
       lastTime: 0
     },
     currIndex: 1,
+    defaultIndex: 1,
     transformY: 0,
     scrollDistance: 0,
     rotation: 20,
@@ -73,7 +74,7 @@ const renderless = (props, { reactive, computed, watch, ref, onMounted }, { emit
   Object.assign(api2, {
     state,
     touch,
-    OptionStyle: OptionStyle({ state }),
+    OptionStyle: OptionStyle({ props, state }),
     setRollerStyle: setRollerStyle({ state }),
     isHidden: isHidden({ state }),
     onTouchStart: onTouchStart({ state, props, touch, vm }),
@@ -100,10 +101,12 @@ const renderless = (props, { reactive, computed, watch, ref, onMounted }, { emit
     }
   );
   watch(
-    () => props.value,
-    () => {
-      state.transformY = 0;
-      api2.modifyStatus(false);
+    () => [props.value, props.defaultValue],
+    (val) => {
+      if ((val || val === 0) && props.visible) {
+        state.transformY = 0;
+        api2.modifyStatus(false);
+      }
     },
     {
       deep: true

package/cascader-select/usePicker.js

@@ -131,7 +131,7 @@ const change = ({ api, state, columnFieldNames, columnsList }) => () => {
   });
 };
 const columnsTypeComputed = ({ state, computed, columnFieldNames }) => computed(() => {
-  const firstColumn = state.formattedColumns[0];
+  const firstColumn = state.formattedColumns && state.formattedColumns[0];
   const fields = columnFieldNames.value;
   if (firstColumn) {
     if (Array.isArray(firstColumn)) {
@@ -173,7 +173,8 @@ const sliceValue = (min, max) => {
 const validArr = (arr) => Array.isArray(arr) && arr.length;
 const validProps = ({ props }) => () => {
   const { modelValue, options } = props;
-  return validArr(modelValue) && validArr(options) && modelValue.length === options.length;
+  const isSameLen = modelValue && modelValue.length ? modelValue.length === options.length : true;
+  return Array.isArray(modelValue) && Array.isArray(options) && isSameLen;
 };
 const parseType = ({ props }) => (values) => {
   const { valueType } = props;

package/checkbox/index.js

@@ -124,21 +124,6 @@ const computedShowText = ({ props }) => () => {
     return props.label;
   }
 };
-const handleLabelMouseenter = ({ state, vm }) => (e) => {
-  const label = e.target;
-  if (label && label.scrollWidth > label.offsetWidth) {
-    const tooltip = vm.$refs.tooltip;
-    tooltip.state.referenceElm = label;
-    tooltip.state.popperElm && (tooltip.state.popperElm.style.display = "none");
-    tooltip.doDestroy();
-    state.tooltipVisible = true;
-    state.displayedValue = label.textContent;
-    setTimeout(tooltip.updatePopper, 20);
-  }
-};
-const handleMouseleave = (state) => () => {
-  state.tooltipVisible = false;
-};
 export {
   addToStore,
   computedCheckboxSize,
@@ -156,8 +141,6 @@ export {
   computedShowText,
   computedStore,
   handleChange,
-  handleLabelMouseenter,
-  handleMouseleave,
   mounted,
   removeFromStore,
   toggleEvent

package/checkbox/vue.js

@@ -18,11 +18,9 @@ import {
   mounted,
   toggleEvent,
   computedIsShowText,
-  computedShowText,
-  handleLabelMouseenter,
-  handleMouseleave
+  computedShowText
 } from "./index";
-const api = ["state", "handleChange", "computedStore", "handleLabelMouseenter", "handleMouseleave"];
+const api = ["state", "handleChange", "computedStore"];
 const initState = ({ reactive, computed, parent, api: api2, inject, props }) => {
   const state = reactive({
     size: computed(() => props.size || inject("size", null) || (parent.tinyForm || {}).size),
@@ -51,9 +49,7 @@ const initState = ({ reactive, computed, parent, api: api2, inject, props }) =>
     }),
     showText: computed(() => api2.computedShowText()),
     isShowText: computed(() => api2.computedIsShowText()),
-    shape: inject("shape", null) || props.shape,
-    tooltipVisible: false,
-    displayedValue: ""
+    shape: inject("shape", null) || props.shape
   });
   return state;
 };
@@ -89,9 +85,7 @@ const initApi = ({
     handleChange: handleChange({ state, props, emit, nextTick, dispatch, constants }),
     computedDisplayLabel: computedDisplayLabel({ state, props, t }),
     computedIsShowText: computedIsShowText({ props }),
-    computedShowText: computedShowText({ props }),
-    handleLabelMouseenter: handleLabelMouseenter({ state, vm }),
-    handleMouseleave: handleMouseleave(state)
+    computedShowText: computedShowText({ props })
   });
 };
 const renderless = (props, { computed, onMounted, onBeforeUnmount, reactive, watch, inject }, { vm, parent, emit, constants, nextTick, dispatch, t }) => {

package/collapse-item/vue.js

@@ -2,7 +2,8 @@ import "../chunk-G2ADBYYC.js";
 import { handleFocus, handleEnterClick, handleHeaderClick } from "./index";
 import { guid } from "../common/string";
 const api = ["state", "isActive", "handleFocus", "handleEnterClick", "handleHeaderClick"];
-const renderless = (props, { computed, reactive }, { parent, constants, dispatch }) => {
+const renderless = (props, { computed, reactive }, { parent, constants, dispatch, designConfig }) => {
+  var _a;
   const _constants = parent.collapse._constants;
   const componentName = _constants.COMPONENT_NAME.Collapse;
   const eventName = _constants.EVENT_NAME.CollapseItemClick;
@@ -12,7 +13,8 @@ const renderless = (props, { computed, reactive }, { parent, constants, dispatch
     focusing: false,
     contentHeight: 0,
     contentWrapStyle: { height: "auto", display: "block" },
-    isActive: computed(() => parent.collapse.state.activeNames.includes(props.name))
+    isActive: computed(() => parent.collapse.state.activeNames.includes(props.name)),
+    arrowIcon: props.expandIcon || ((_a = designConfig == null ? void 0 : designConfig.icons) == null ? void 0 : _a.arrowIcon) || "IconChevronRight"
   });
   const api2 = {
     state,