@opentiny/vue-renderless 3.19.4 → 3.20.0

package/common/event.js

@@ -19,7 +19,28 @@ const getActualTarget = (e) => {
   }
   return e.target.shadowRoot && e.composed ? e.composedPath()[0] || e.target : e.target;
 };
+const correctTarget = (event, target) => {
+  let newTarget;
+  if (event.target === null && target) {
+    newTarget = target;
+  } else {
+    const nodeList = event.composedPath();
+    if (event.target !== nodeList[0]) {
+      newTarget = nodeList[0];
+    }
+  }
+  if (newTarget) {
+    Object.defineProperty(event, "target", {
+      get() {
+        return newTarget;
+      },
+      enumerable: true,
+      configurable: true
+    });
+  }
+};
 export {
+  correctTarget,
   emitEvent,
   getActualTarget
 };

package/common/index.js

@@ -237,7 +237,7 @@ const CASCADER = {
   PropsHover: "hoverThreshold",
   MenuConnector: "cascader-menu-"
 };
-const version = "3.19.4";
+const version = "3.20.0";
 const log = (data, type = "log") => {
   uLog.logger[type](data);
 };

package/common/runtime.js

@@ -22,7 +22,7 @@ import vuePopup from "./deps/vue-popup";
 import validate from "./validate";
 import memorize from "./deps/memorize";
 import * as common from ".";
-const version = "3.19.4";
+const version = "3.20.0";
 const Renderless = {
   browser,
   array,

package/date-picker-mobile/index.js

@@ -46,7 +46,7 @@ const formatDate = ({ props, constants }) => (date, dateFormat) => {
 const getDateFromStr = (dateStr, direction = "top") => {
   const arr = dateStr.split("/").map((item) => +item);
   const yarr = arr[0];
-  const month = direction == "top" ? arr[1] - 1 : arr[1];
+  const month = direction === "top" ? arr[1] - 1 : arr[1];
   return new Date(yarr, month, 1);
 };
 const loadingDate = ({ state, api }) => (direction) => {
@@ -67,11 +67,11 @@ const initPanel = ({ state, api }) => ({ dateValue, direction, isInit }) => {
   }
   let date = new Date(year, month - 1, 1);
   const dateList = {};
-  Array.from({ length: 12 * state.yearNum }).map(() => {
+  Array.from({ length: 12 * state.yearNum }).forEach(() => {
     const startWeek = date.getDay();
     dateList[getDateStr(year, month)] = Array.from({ length: startWeek }).map(() => ({}));
     const days = getDaysByMonth(year, month);
-    Array.from({ length: days }).map((v, index) => {
+    Array.from({ length: days }).forEach((v, index) => {
       const day = index + 1;
       const dayInfo = api.getCurrentDate(new Date(year, month - 1, day));
       dateList[getDateStr(year, month)].push(dayInfo);
@@ -194,8 +194,8 @@ const selectOption = ({ emit, state, props, constants }) => ({ value, index }) =
     }
   } else {
     state.date = new Date(current.value);
-    emit("click", current);
   }
+  emit("click", current);
 };
 const confirm = ({ emit, state, props, api, constants }) => () => {
   const { DATE_TIME, DATE_RANGE, DATE_TIME_RANGE, YEAR_MONTH_RANGE } = constants.TYPE;

package/dialog-box/index.js

@@ -193,7 +193,7 @@ const handleDrag = ({
   emit,
   vm
 }) => (event) => {
-  if (!props.draggable) {
+  if (!props.draggable || state.isFull) {
     return;
   }
   let modalBoxElem = vm.$refs.dialog;

package/dropdown/index.js

@@ -178,7 +178,7 @@ const mounted = ({ api, vm, state, broadcast }) => () => {
   });
   vm.$on("is-disabled", api.clickOutside);
 };
-const beforeDistory = ({ api, state }) => () => {
+const beforeDistory = ({ vm, api, state }) => () => {
   if (state.triggerElm) {
     off(state.triggerElm, "keydown", api.handleTriggerKeyDown);
     off(state.triggerElm, "focus", toggleFocus({ state, value: true }));
@@ -195,6 +195,10 @@ const beforeDistory = ({ api, state }) => () => {
     off(state.dropdownElm, "mouseleave", api.hide);
     state.dropdownElm = null;
   }
+  vm.$off("menu-item-click");
+  vm.$off("current-item-click");
+  vm.$off("selected-index");
+  vm.$off("is-disabled");
 };
 const clickOutside = ({ props, api }) => (disabled) => {
   if (props.hideOnClick) {

package/dropdown/vue.js

@@ -59,8 +59,8 @@ const renderless = (props, { reactive, watch, provide, onMounted, computed }, {
     handleMainButtonClick: handleMainButtonClick({ api: api2, emit }),
     triggerElmFocus: triggerElmFocus(state),
     initDomOperation: initDomOperation({ api: api2, state, vm }),
-    beforeDistory: beforeDistory({ api: api2, state }),
-    clickOutside: clickOutside({ state, props, api: api2 })
+    beforeDistory: beforeDistory({ vm, api: api2, state }),
+    clickOutside: clickOutside({ props, api: api2 })
   });
   watch(() => state.visible, api2.watchVisible);
   watch(() => state.focusing, api2.watchFocusing);

package/file-upload/vue.js

@@ -327,6 +327,7 @@ const renderless = (props, { computed, inject, onBeforeUnmount, provide, reactiv
   onBeforeUnmount(() => {
     api2.onBeforeDestroy();
     api2 = {};
+    vm.$off("drag-over");
   });
   initWatch({ watch, state, api: api2, props, $service });
   return api2;

package/flowchart/index.js

@@ -237,8 +237,9 @@ const drawAfterLink = ({ api, props, state, vm }) => () => {
 };
 const refresh = ({ api, nextTick, state }) => ({ graphWidth = 0, adjustX = 0 } = {}) => {
   api.removeListeners();
-  if (graphWidth && graphWidth !== state.temporary.graphWidth) {
-    state.temporary.graphWidth = graphWidth;
+  const graphWidthAdapt = graphWidth - 1 >= 0 ? graphWidth - 1 : 0;
+  if (graphWidth && graphWidthAdapt !== state.temporary.graphWidth) {
+    state.temporary.graphWidth = graphWidthAdapt;
     state.temporary.adjustX = adjustX;
   }
   if (api.isMf()) {

package/form/index.js

@@ -21,8 +21,8 @@ const computedAutoLabelWidth = ({ state }) => () => {
   return max ? `${max}px` : "";
 };
 const computedHideRequiredAsterisk = ({ props, designConfig }) => () => {
-  var _a, _b;
-  return (_b = (_a = props.hideRequiredAsterisk) != null ? _a : designConfig == null ? void 0 : designConfig.hideRequiredAsterisk) != null ? _b : true;
+  var _a, _b, _c;
+  return (_c = (_b = props.hideRequiredAsterisk) != null ? _b : (_a = designConfig == null ? void 0 : designConfig.props) == null ? void 0 : _a.hideRequiredAsterisk) != null ? _c : false;
 };
 const computedValidateIcon = ({ props, designConfig }) => () => {
   var _a, _b, _c;

package/form-item/index.js

@@ -173,6 +173,7 @@ const mounted = ({ api, vm, props, state }) => () => {
 const unmounted = ({ api, vm, state }) => () => {
   state.canShowTip = false;
   api.dispatch("Form", "form:removeField", vm);
+  api.removeValidateEvents();
 };
 const validate = ({ api, props, state, t }) => (trigger, callback = () => void 0) => {
   state.validateDisabled = false;
@@ -281,7 +282,9 @@ const addValidateEvents = ({ api, vm, props, state }) => () => {
   }
 };
 const removeValidateEvents = (vm) => () => {
-  vm.$off();
+  vm.$off("form.blur");
+  vm.$off("form.change");
+  vm.$off("displayed-value-changed");
 };
 const updateTip = ({ vm, state }) => () => {
   if (state.getValidateType !== "tip" && !state.canShowTip) {

package/grid-select/index.js

@@ -0,0 +1,82 @@
+import {
+  __spreadProps,
+  __spreadValues
+} from "../chunk-G2ADBYYC.js";
+const buildSelectConfig = ({ props, state }) => () => {
+  const checkRowKeys = state.gridCheckedData;
+  const selectConfig = props.selectConfig;
+  return Object.assign({}, selectConfig, { checkRowKeys });
+};
+const buildRadioConfig = ({ props, state }) => () => {
+  const checkRowKey = state.currentKey;
+  const highlight = true;
+  const radioConfig = props.radioConfig;
+  return Object.assign({}, radioConfig, { checkRowKey, highlight });
+};
+const filter = ({ props, state, vm }) => (value) => {
+  const { multiple, valueField, filterMethod, remote, remoteMethod } = props;
+  if ((props.filterable || props.searchable) && typeof filterMethod === "function") {
+    const table = vm.$refs.gridRef.$refs.tinyTable;
+    const fullData = table.afterFullData;
+    vm.$refs.gridRef.scrollTo(null, 0);
+    table.afterFullData = filterMethod(value, fullData) || [];
+    vm.$refs.gridRef.handleTableData(!value);
+    state.previousQuery = value;
+  } else if (remote && typeof remoteMethod === "function") {
+    state.previousQuery = value;
+    remoteMethod(value, props.extraQueryParams).then((data) => {
+      if (multiple) {
+        const selectedIds = state.selected.map((sel) => sel[valueField]);
+        vm.$refs.gridRef.clearSelection();
+        vm.$refs.gridRef.setSelection(
+          data.filter((row) => ~selectedIds.indexOf(row[valueField])),
+          true
+        );
+        state.remoteData = data.filter((row) => !~selectedIds.indexOf(row[valueField])).concat(state.selected);
+      } else {
+        vm.$refs.gridRef.clearRadioRow();
+        vm.$refs.gridRef.setRadioRow(find(data, (item) => props.modelValue === item[props.valueField]));
+        state.remoteData = data;
+      }
+      vm.$refs.gridRef.$refs.tinyTable.lastScrollTop = 0;
+      vm.$refs.gridRef.loadData(data);
+      vm.$refs.gridRef.handleTableData(!value);
+    });
+  }
+};
+const radioChange = ({ props, vm, emit }) => ({ row }) => {
+  if (!props.multiple) {
+    vm.$refs.baseSelectRef.updateSelectedData(__spreadProps(__spreadValues({}, row), {
+      currentLabel: row[props.textField],
+      value: row[props.valueField],
+      state: {
+        currentLabel: row[props.textField]
+      }
+    }));
+    vm.$refs.baseSelectRef.hidePanel();
+    emit("update:modelValue", row);
+    emit("change", row);
+  }
+};
+const selectChange = ({ props, vm, emit }) => ({ $table, selection, checked, row }) => {
+  if (props.multiple) {
+    vm.$refs.baseSelectRef.updateSelectedData(
+      selection.map((node) => {
+        return __spreadProps(__spreadValues({}, node), {
+          currentLabel: node[props.textField],
+          value: node[props.valueField],
+          isGrid: true
+        });
+      })
+    );
+    emit("update:modelValue", selection);
+    emit("change", selection);
+  }
+};
+export {
+  buildRadioConfig,
+  buildSelectConfig,
+  filter,
+  radioChange,
+  selectChange
+};

package/grid-select/vue.js

@@ -0,0 +1,30 @@
+import "../chunk-G2ADBYYC.js";
+import { buildRadioConfig, buildSelectConfig, filter, radioChange, selectChange } from "./index";
+const api = ["state", "buildRadioConfig", "buildSelectConfig", "filter", "radioChange", "selectChange"];
+const renderless = (props, { reactive, watch }, { vm, emit }) => {
+  const api2 = {};
+  const state = reactive({
+    value: props.modelValue,
+    gridData: props.gridOp.data,
+    remoteData: [],
+    selected: props.multiple ? [] : {}
+  });
+  Object.assign(api2, {
+    state,
+    buildRadioConfig: buildRadioConfig({ props, state }),
+    buildSelectConfig: buildSelectConfig({ props, state }),
+    filter: filter({ props, state, vm }),
+    radioChange: radioChange({ props, vm, emit }),
+    selectChange: selectChange({ props, vm, emit })
+  });
+  watch(
+    () => props.gridOp.data,
+    (data) => data && (state.gridData = data),
+    { immediate: true, deep: true }
+  );
+  return api2;
+};
+export {
+  api,
+  renderless
+};

package/input/index.js

@@ -160,7 +160,7 @@ const resizeTextarea = ({ api, parent, vm, state, props }) => () => {
     return;
   }
   const { autosize, type } = parent;
-  if (type !== "textarea") {
+  if (type !== "textarea" || !vm.$refs.textarea) {
     return;
   }
   if (props.hoverExpand && !state.enteredTextarea) {
@@ -170,7 +170,7 @@ const resizeTextarea = ({ api, parent, vm, state, props }) => () => {
     };
     return;
   }
-  if (!autosize) {
+  if (!autosize || state.isDisplayOnly) {
     state.textareaCalcStyle = {
       minHeight: api.calcTextareaHeight(vm.$refs.textarea).minHeight
     };

package/menu/vue.js

@@ -22,7 +22,7 @@ const initState = ({ reactive, computed, props, api: api2 }) => {
   });
   return state;
 };
-const renderless = (props, { reactive, watch, onMounted, computed }, { vm, emit, nextTick }) => {
+const renderless = (props, { reactive, watch, onMounted, computed, onUnmounted }, { vm, emit, nextTick }) => {
   const api2 = {};
   const state = initState({ reactive, computed, props, api: api2 });
   Object.assign(api2, {
@@ -87,6 +87,10 @@ const renderless = (props, { reactive, watch, onMounted, computed }, { vm, emit,
       api2.setIsCurrent(state.data, param);
     });
   });
+  onUnmounted(() => {
+    vm.$off("node-clicked");
+    vm.$off("node-changed");
+  });
   return api2;
 };
 export {

package/modal/index.js

@@ -183,6 +183,8 @@ const open = ({
         }
         if (props.fullscreen) {
           nextTick(api.maximize);
+        } else {
+          api.revert();
         }
       });
     }

package/numeric/index.js

@@ -45,16 +45,19 @@ const internalIncrease = ({ api, state }) => ({ val, step }) => {
   if (decimal.isNaN() && val !== void 0) {
     return state.currentValue;
   }
-  return decimal.add(step).toString();
+  const addValue = decimal.add(step).toString();
+  return addValue;
 };
 const internalDecrease = ({ api, state }) => ({ val, step }) => {
   const decimal = api.getDecimal(val);
   if (decimal.isNaN() && val !== void 0) {
     return state.currentValue;
   }
-  return decimal.add(`-${step}`).toString();
+  const decreaseValue = decimal.add(`-${step}`).toString();
+  return decreaseValue;
 };
 const increase = ({ api, props, state }) => () => {
+  var _a, _b;
   if (state.inputDisabled || state.maxDisabled) {
     return;
   }
@@ -63,7 +66,10 @@ const increase = ({ api, props, state }) => () => {
   if (value.toString().includes("e")) {
     return;
   }
-  let newVal = api.internalIncrease({ val: value, step: props.step });
+  let newVal = api.internalIncrease({
+    val: value,
+    step: (_b = (_a = props.step) == null ? void 0 : _a.value) != null ? _b : props.step
+  });
   if (!props.circulate || !isFinite(props.max) || !isFinite(props.min)) {
     api.setCurrentValue(newVal);
     return;
@@ -74,6 +80,7 @@ const increase = ({ api, props, state }) => () => {
   api.setCurrentValue(newVal);
 };
 const decrease = ({ api, props, state }) => () => {
+  var _a, _b;
   if (state.inputDisabled || state.minDisabled) {
     return;
   }
@@ -82,7 +89,10 @@ const decrease = ({ api, props, state }) => () => {
   if (value.toString().includes("e")) {
     return;
   }
-  let newVal = api.internalDecrease({ val: value, step: props.step });
+  let newVal = api.internalDecrease({
+    val: value,
+    step: (_b = (_a = props.step) == null ? void 0 : _a.value) != null ? _b : props.step
+  });
   if (!props.circulate || !isFinite(props.max) || !isFinite(props.min)) {
     api.setCurrentValue(newVal);
     return;
@@ -163,6 +173,7 @@ const setCurrentValue = ({
   props,
   state
 }) => (newVal, emitChangeFlag = true) => {
+  var _a, _b;
   const { max, min, allowEmpty, validateEvent, stringMode, plugin, emptyValue } = props;
   const { format } = state;
   const oldVal = state.currentValue;
@@ -193,6 +204,13 @@ const setCurrentValue = ({
     if (validateEvent) {
       dispatch(constants.COMPONENT_NAME, constants.EVENT_NAME.change, [state.currentValue]);
     }
+    if (props.step instanceof Object && ((_a = props.step) == null ? void 0 : _a.mode) === "restore" && ((_b = props.step) == null ? void 0 : _b.value)) {
+      const stepValue = Number(props.step.value);
+      if (stepValue > 1 && newVal % stepValue !== 0) {
+        state.currentValue = oldVal;
+        state.userInput = oldVal;
+      }
+    }
   }
 };
 const handleInput = ({ state, api, emit, props }) => (event) => {
@@ -224,13 +242,13 @@ const handleInput = ({ state, api, emit, props }) => (event) => {
   state.userInput = value;
 };
 const handleInputChange = ({ api, state, props }) => (event) => {
-  var _a, _b;
+  var _a, _b, _c;
   const value = ((_a = event.target) == null ? void 0 : _a.value) === "-" ? 0 : (_b = event.target) == null ? void 0 : _b.value;
-  if (props.stepStrictly) {
+  if (props.stepStrictly || typeof props.step === "object" && ((_c = props.step) == null ? void 0 : _c.mode) === "strictly") {
     const previousValue = Number((props.mouseWheel ? state.displayValue : props.modelValue) || 0);
-    if (Math.abs(previousValue - value) % Number(props.step) === 0)
+    if (Math.abs(previousValue - value) % Number(props.step) === 0 || Math.abs(previousValue - value) % Number(props.step.value) === 0)
       return api.setCurrentValue(value);
-    const step = Number(props.step);
+    const step = Number(props.step) || Number(props.step.value);
     const difference = value - previousValue;
     const sign = difference >= 0 ? 1 : -1;
     return api.setCurrentValue(sign * Math.round(Math.abs(difference) / step) * step + previousValue);
@@ -286,7 +304,9 @@ const displayValue = ({ props, state, api }) => () => {
   return formatNumber(currentValue, state.format);
 };
 const getNumPecision = ({ api, props }) => () => {
-  const stepPrecision = api.getPrecision(props.step);
+  var _a, _b;
+  const stepValue = (_b = (_a = props.step) == null ? void 0 : _a.value) != null ? _b : props.step;
+  const stepPrecision = api.getPrecision(stepValue);
   if (props.precision !== void 0) {
     return props.precision;
   } else {

package/option/index.js

@@ -23,6 +23,11 @@ const handleGroupDisabled = ({ state, vm }) => (val) => {
   state.groupDisabled = val;
   vm.groupDisabled = val;
 };
+const hoverItem = ({ select, props, state }) => () => {
+  if (!props.disabled && !state.groupDisabled && !select.state.disabledOptionHover) {
+    select.state.hoverIndex = select.state.optionIndexArr.indexOf(state.index);
+  }
+};
 const selectOptionClick = ({ props, state, select, constants, vm }) => () => {
   if (props.disabled !== true && state.groupDisabled !== true) {
     if (select.multiple && props.required === true)
@@ -53,6 +58,7 @@ export {
   contains,
   escapeRegexpString,
   handleGroupDisabled,
+  hoverItem,
   initValue,
   isEqual,
   queryChange,

package/option/vue.js

@@ -2,8 +2,17 @@ import {
   __spreadProps,
   __spreadValues
 } from "../chunk-G2ADBYYC.js";
-import { isEqual, contains, handleGroupDisabled, selectOptionClick, queryChange, toggleEvent, initValue } from "./index";
-const api = ["state", "visible", "selectOptionClick"];
+import {
+  isEqual,
+  contains,
+  handleGroupDisabled,
+  hoverItem,
+  selectOptionClick,
+  queryChange,
+  toggleEvent,
+  initValue
+} from "./index";
+const api = ["state", "visible", "hoverItem", "selectOptionClick"];
 const initState = ({ reactive, computed, props, api: api2, markRaw, select, parent }) => {
   const state = reactive({
     parent: markRaw(parent),
@@ -44,6 +53,7 @@ const initApi = ({ api: api2, props, state, select, constants, vm }) => {
     state,
     isEqual: isEqual({ select, state }),
     contains: contains({ select, state }),
+    hoverItem: hoverItem({ select, props, state }),
     queryChange: queryChange({ select, props, state }),
     selectOptionClick: selectOptionClick({ constants, vm, props, state, select }),
     handleGroupDisabled: handleGroupDisabled({ state, vm }),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opentiny/vue-renderless",
-  "version": "3.19.4",
+  "version": "3.20.0",
   "description": "An enterprise-class UI component library, support both Vue.js 2 and Vue.js 3, as well as PC and mobile.",
   "author": "OpenTiny Team",
   "license": "MIT",

package/picker/index.js

@@ -982,7 +982,7 @@ const initPopper = ({ props, hooks, vnode }) => {
     emit,
     props: __spreadProps(__spreadValues({}, props), {
       popperOptions: Object.assign({ boundariesPadding: 0, gpuAcceleration: false }, props.popperOptions),
-      visibleArrow: true,
+      visibleArrow: false,
       offset: 0,
       boundariesPadding: 5,
       arrowOffset: 35,

package/recycle-scroller/index.js

@@ -6,7 +6,6 @@ if (typeof window !== "undefined") {
   supportsPassive = false;
   try {
     const opts = Object.defineProperty({}, "passive", {
-      // eslint-disable-next-line getter-return
       get() {
         supportsPassive = true;
       }
@@ -27,6 +26,10 @@ const handleVisibilityChange = ({ api, emit, state }) => (isVisible, entry) => {
     }
   }
 };
+const init = ({ api }) => () => {
+  api.resetTemporary();
+  api.updateVisibleItems(true);
+};
 const updateVisibleItems = ({ api, emit, props, state, vm }) => (checkItem, checkPositionDiff = false) => {
   const itemSize = props.itemSize;
   const gridItems = props.gridItems || 1;
@@ -87,18 +90,18 @@ const computedSizes = ({ props, state }) => () => {
     const items = props.items;
     const field = props.sizeField;
     const minItemSize = props.minItemSize;
-    let computedMinSize = 1e4;
+    let computedMinItemSize = 1e4;
     let accumulator = 0;
     let current;
-    for (let i = 0, l = items.length; i < l; i++) {
+    for (let i = 0, len = items.length; i < len; i++) {
       current = items[i][field] || minItemSize;
-      if (current < computedMinSize) {
-        computedMinSize = current;
+      if (current < computedMinItemSize) {
+        computedMinItemSize = current;
       }
       accumulator += current;
       sizes[i] = { accumulator, size: current };
     }
-    state.temporary.computedMinItemSize = computedMinSize;
+    state.temporary.computedMinItemSize = computedMinItemSize;
     return sizes;
   }
   return [];
@@ -117,10 +120,10 @@ const getScroll = ({ props, vm }) => () => {
   const isVertical = direction === "vertical";
   let scrollRange;
   if (props.pageMode) {
-    const bounds = el.getBoundingClientRect();
-    const boundsSize = isVertical ? bounds.height : bounds.width;
+    const boundRect = el.getBoundingClientRect();
+    const boundsSize = isVertical ? boundRect.height : boundRect.width;
     let size = isVertical ? window.innerHeight : window.innerWidth;
-    let start = -(isVertical ? bounds.top : bounds.left);
+    let start = -(isVertical ? boundRect.top : boundRect.left);
     if (start < 0) {
       size += start;
       start = 0;
@@ -138,11 +141,11 @@ const getScroll = ({ props, vm }) => () => {
 };
 const unuseView = (state) => (view, fake = false) => {
   const unusedViews = state.temporary.unusedViews;
-  const type = view.nr.type;
-  let unusedPool = unusedViews.get(type);
+  const { type: nrType } = view.nr;
+  let unusedPool = unusedViews.get(nrType);
   if (!unusedPool) {
     unusedPool = [];
-    unusedViews.set(type, unusedPool);
+    unusedViews.set(nrType, unusedPool);
   }
   unusedPool.push(view);
   if (!fake) {
@@ -297,24 +300,24 @@ const computeRange = (args) => {
 const computeRangeVariableSizeMode = (args) => {
   let { count, sizes, scroll, startIndex, totalSize, endIndex } = args;
   let { items, visibleStartIndex, beforeSize, visibleEndIndex } = args;
-  let h, a, b, i, oldI;
-  a = 0;
-  b = count - 1;
-  i = ~~(count / 2);
+  let height, lower, upper, cursor, oldCursor;
+  lower = 0;
+  upper = count - 1;
+  cursor = ~~(count / 2);
   do {
-    oldI = i;
-    h = sizes[i].accumulator;
-    if (h < scroll.start) {
-      a = i;
-    } else if (i < count - 1 && sizes[i + 1].accumulator > scroll.start) {
-      b = i;
+    oldCursor = cursor;
+    height = sizes[cursor].accumulator;
+    if (height < scroll.start) {
+      lower = cursor;
+    } else if (cursor < count - 1 && sizes[cursor + 1].accumulator > scroll.start) {
+      upper = cursor;
     }
-    i = ~~((a + b) / 2);
-  } while (i !== oldI);
-  i < 0 && (i = 0);
-  startIndex = i;
+    cursor = ~~((lower + upper) / 2);
+  } while (cursor !== oldCursor);
+  cursor < 0 && (cursor = 0);
+  startIndex = cursor;
   totalSize = sizes[count - 1].accumulator;
-  for (endIndex = i; endIndex < count && sizes[endIndex].accumulator < scroll.end; endIndex++) {
+  for (endIndex = cursor; endIndex < count && sizes[endIndex].accumulator < scroll.end; endIndex++) {
   }
   if (endIndex === -1) {
     endIndex = items.length - 1;
@@ -448,6 +451,17 @@ const computeViewEvent = ({ props, state }) => (view) => {
     };
   }
 };
+const resetTemporary = ({ state }) => () => {
+  state.temporary = {
+    startIndex: 0,
+    endIndex: 0,
+    views: /* @__PURE__ */ new Map(),
+    unusedViews: /* @__PURE__ */ new Map(),
+    scrollDirty: false,
+    lastUpdateScrollPosition: 0
+  };
+  state.pool = [];
+};
 export {
   addListeners,
   addView,
@@ -461,7 +475,9 @@ export {
   handleResize,
   handleScroll,
   handleVisibilityChange,
+  init,
   removeListeners,
+  resetTemporary,
   scrollToItem,
   scrollToPosition,
   sortViews,