@opentiny/vue-renderless 3.6.0-alpha.1 → 3.6.1-alpha.0

package/slider/vue.js

@@ -1,12 +1,57 @@
-import { bindKeyDown, bindMouseDown, bindMouseMove, bindMouseUp, bindEvent, unBindEvent, bindResize, setTipStyle, getActiveButtonIndex, setActiveButtonValue, setBarStyle, setButtonStyle, initSlider, calculateValue, changeActiveValue, formatTipValue, getActiveButtonValue, displayTip, hideTip, autoSlider, customBeforeAppearHook, customAfterAppearHook, watchActiveValue, watchModelValue } from './index';
-export var api = ['state', 'bindKeyDown', 'bindMouseDown', 'bindMouseMove', 'bindMouseUp', 'bindEvent', 'unBindEvent', 'bindResize', 'setTipStyle', 'getActiveButtonIndex', 'setActiveButtonValue', 'setBarStyle', 'setButtonStyle', 'initSlider', 'calculateValue', 'changeActiveValue', 'formatTipValue', 'getActiveButtonValue', 'displayTip', 'hideTip', 'autoSlider', 'customBeforeAppearHook', 'customAfterAppearHook'];
-var initState = function initState(_ref) {
-  var reactive = _ref.reactive,
-    computed = _ref.computed,
-    props = _ref.props,
-    api = _ref.api,
-    parent = _ref.parent;
-  var state = reactive({
+import "../chunk-PKUHTIDK.js";
+import {
+  bindKeyDown,
+  bindMouseDown,
+  bindMouseMove,
+  bindMouseUp,
+  bindEvent,
+  unBindEvent,
+  bindResize,
+  setTipStyle,
+  getActiveButtonIndex,
+  setActiveButtonValue,
+  setBarStyle,
+  setButtonStyle,
+  initSlider,
+  calculateValue,
+  changeActiveValue,
+  formatTipValue,
+  getActiveButtonValue,
+  displayTip,
+  hideTip,
+  autoSlider,
+  customBeforeAppearHook,
+  customAfterAppearHook,
+  watchActiveValue,
+  watchModelValue
+} from "./index";
+const api = [
+  "state",
+  "bindKeyDown",
+  "bindMouseDown",
+  "bindMouseMove",
+  "bindMouseUp",
+  "bindEvent",
+  "unBindEvent",
+  "bindResize",
+  "setTipStyle",
+  "getActiveButtonIndex",
+  "setActiveButtonValue",
+  "setBarStyle",
+  "setButtonStyle",
+  "initSlider",
+  "calculateValue",
+  "changeActiveValue",
+  "formatTipValue",
+  "getActiveButtonValue",
+  "displayTip",
+  "hideTip",
+  "autoSlider",
+  "customBeforeAppearHook",
+  "customAfterAppearHook"
+];
+const initState = ({ reactive, computed, props, api: api2, parent }) => {
+  const state = reactive({
     tipStyle: {},
     barStyle: {},
     moveStyle: [],
@@ -23,150 +68,55 @@ var initState = function initState(_ref) {
     leftBtnStyle: {},
     leftBtnPercent: 0,
     leftBtnShow: true,
-    rightBtnStyle: '',
+    rightBtnStyle: "",
     rightBtnPercent: 0,
     rightBtnShow: false,
     innerTrigger: false,
-    rangeDiff: computed(function () {
-      return props.max - props.min;
-    }),
-    tipValue: computed(function () {
-      return api.formatTipValue(state.activeValue);
-    }),
-    formDisabled: computed(function () {
-      return (parent.tinyForm || {}).disabled;
-    }),
-    disabled: computed(function () {
-      return props.disabled || state.formDisabled;
-    })
+    rangeDiff: computed(() => props.max - props.min),
+    tipValue: computed(() => api2.formatTipValue(state.activeValue)),
+    formDisabled: computed(() => (parent.tinyForm || {}).disabled),
+    disabled: computed(() => props.disabled || state.formDisabled)
   });
   return state;
 };
-export var renderless = function renderless(props, _ref2, _ref3) {
-  var computed = _ref2.computed,
-    onBeforeUnmount = _ref2.onBeforeUnmount,
-    onMounted = _ref2.onMounted,
-    reactive = _ref2.reactive,
-    watch = _ref2.watch,
-    inject = _ref2.inject;
-  var parent = _ref3.parent,
-    constants = _ref3.constants,
-    nextTick = _ref3.nextTick,
-    emit = _ref3.emit,
-    mode = _ref3.mode;
-  var api = {};
-  var state = initState({
-    reactive: reactive,
-    computed: computed,
-    props: props,
-    api: api,
-    parent: parent
-  });
-  parent.tinyForm = parent.tinyForm || inject('form', null);
-  Object.assign(api, {
-    state: state,
+const renderless = (props, { computed, onBeforeUnmount, onMounted, reactive, watch, inject }, { parent, constants, nextTick, emit, mode }) => {
+  const api2 = {};
+  const state = initState({ reactive, computed, props, api: api2, parent });
+  parent.tinyForm = parent.tinyForm || inject("form", null);
+  Object.assign(api2, {
+    state,
     hideTip: hideTip(state),
     formatTipValue: formatTipValue(props),
-    setBarStyle: setBarStyle({
-      props: props,
-      state: state
-    }),
+    setBarStyle: setBarStyle({ props, state }),
     changeActiveValue: changeActiveValue(state),
-    bindResize: bindResize({
-      parent: parent,
-      props: props,
-      state: state
-    }),
-    setButtonStyle: setButtonStyle({
-      props: props,
-      state: state
-    }),
-    calculateValue: calculateValue({
-      props: props,
-      state: state
-    }),
+    bindResize: bindResize({ parent, props, state }),
+    setButtonStyle: setButtonStyle({ props, state }),
+    calculateValue: calculateValue({ props, state }),
     getActiveButtonValue: getActiveButtonValue(state),
-    getActiveButtonIndex: getActiveButtonIndex({
-      constants: constants,
-      mode: mode,
-      state: state
-    }),
-    setTipStyle: setTipStyle({
-      constants: constants,
-      mode: mode,
-      emit: emit,
-      parent: parent,
-      props: props,
-      state: state
-    }),
-    customAfterAppearHook: customAfterAppearHook({
-      state: state,
-      props: props
-    }),
+    getActiveButtonIndex: getActiveButtonIndex({ constants, mode, state }),
+    setTipStyle: setTipStyle({ constants, mode, emit, parent, props, state }),
+    customAfterAppearHook: customAfterAppearHook({ state, props }),
     customBeforeAppearHook: customBeforeAppearHook(props),
-    bindEvent: bindEvent(api),
-    autoSlider: autoSlider(api),
-    unBindEvent: unBindEvent(api),
-    displayTip: displayTip({
-      api: api,
-      nextTick: nextTick,
-      state: state
-    }),
-    bindKeyDown: bindKeyDown({
-      api: api,
-      props: props,
-      state: state
-    }),
-    bindMouseUp: bindMouseUp({
-      api: api,
-      emit: emit,
-      state: state
-    }),
-    bindMouseMove: bindMouseMove({
-      api: api,
-      nextTick: nextTick,
-      state: state
-    }),
-    bindMouseDown: bindMouseDown({
-      api: api,
-      constants: constants,
-      mode: mode,
-      emit: emit,
-      state: state
-    }),
-    setActiveButtonValue: setActiveButtonValue({
-      api: api,
-      emit: emit,
-      props: props,
-      state: state
-    }),
-    initSlider: initSlider({
-      api: api,
-      props: props,
-      state: state
-    }),
-    watchModelValue: watchModelValue({
-      api: api,
-      state: state
-    }),
-    watchActiveValue: watchActiveValue({
-      api: api,
-      emit: emit,
-      props: props,
-      state: state
-    })
-  });
-  watch(function () {
-    return props.modelValue;
-  }, api.watchModelValue, {
-    immediate: true
-  });
-  watch(function () {
-    return state.activeValue;
-  }, api.watchActiveValue, {
-    immediate: true
+    bindEvent: bindEvent(api2),
+    autoSlider: autoSlider(api2),
+    unBindEvent: unBindEvent(api2),
+    displayTip: displayTip({ api: api2, nextTick, state }),
+    bindKeyDown: bindKeyDown({ api: api2, props, state }),
+    bindMouseUp: bindMouseUp({ api: api2, emit, state }),
+    bindMouseMove: bindMouseMove({ api: api2, nextTick, state }),
+    bindMouseDown: bindMouseDown({ api: api2, constants, mode, emit, state }),
+    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 })
   });
-  onMounted(api.bindEvent);
-  onBeforeUnmount(api.unBindEvent);
-  return api;
-};
+  watch(() => props.modelValue, api2.watchModelValue, { immediate: true });
+  watch(() => state.activeValue, api2.watchActiveValue, { immediate: true });
+  onMounted(api2.bindEvent);
+  onBeforeUnmount(api2.unBindEvent);
+  return api2;
+};
+export {
+  api,
+  renderless
+};

package/split/index.js

@@ -1,131 +1,82 @@
-export var px2percent = function px2percent(_ref) {
-  var numerator = _ref.numerator,
-    denominator = _ref.denominator;
-  return parseFloat(numerator) / parseFloat(denominator);
+import "../chunk-PKUHTIDK.js";
+const px2percent = ({ numerator, denominator }) => parseFloat(numerator) / parseFloat(denominator);
+const getComputedThresholdValue = ({ api, props, refs, state }) => (type) => {
+  const size = refs.outerWrapper[state.offsetSize];
+  if (state.valueIsPx) {
+    return typeof props[type] === "string" ? props[type] : size * props[type];
+  } else {
+    return typeof props[type] === "string" ? api.px2percent({ numerator: props[type], denominator: size }) : props[type];
+  }
 };
-export var getComputedThresholdValue = function getComputedThresholdValue(_ref2) {
-  var api = _ref2.api,
-    props = _ref2.props,
-    refs = _ref2.refs,
-    state = _ref2.state;
-  return function (type) {
-    var size = refs.outerWrapper[state.offsetSize];
-    if (state.valueIsPx) {
-      return typeof props[type] === 'string' ? props[type] : size * props[type];
-    } else {
-      return typeof props[type] === 'string' ? api.px2percent({
-        numerator: props[type],
-        denominator: size
-      }) : props[type];
-    }
-  };
-};
-export var getleftTopMin = function getleftTopMin(state) {
-  return function (_ref3) {
-    var oldvalue = _ref3.oldvalue,
-      newvalue = _ref3.newvalue;
-    return state.valueIsPx ? "".concat(Math.min(parseFloat(oldvalue), parseFloat(newvalue)), "px") : Math.min(oldvalue, newvalue);
-  };
-};
-export var getrightBottomMin = function getrightBottomMin(state) {
-  return function (_ref4) {
-    var oldvalue = _ref4.oldvalue,
-      newvalue = _ref4.newvalue;
-    return state.valueIsPx ? "".concat(Math.max(parseFloat(oldvalue), parseFloat(newvalue)), "px") : Math.max(oldvalue, newvalue);
-  };
-};
-export var getAnotherOffset = function getAnotherOffset(_ref5) {
-  var refs = _ref5.refs,
-    state = _ref5.state;
-  return function (value) {
-    return state.valueIsPx ? "".concat(refs.outerWrapper[state.offsetSize] - parseFloat(value), "px") : 1 - value;
-  };
-};
-export var handleMove = function handleMove(_ref6) {
-  var api = _ref6.api,
-    emit = _ref6.emit,
-    props = _ref6.props,
-    refs = _ref6.refs,
-    state = _ref6.state;
-  return function (event) {
-    var pageOffset = state.isHorizontal ? event.pageX : event.pageY;
-    var offset = pageOffset - state.initOffset;
-    var outerWidth = refs.outerWrapper[state.offsetSize];
-    var value = state.valueIsPx ? "".concat(parseFloat(state.oldOffset) + offset, "px") : api.px2percent({
-      numerator: outerWidth * state.oldOffset + offset,
-      denominator: outerWidth
+const getleftTopMin = (state) => ({ oldvalue, newvalue }) => state.valueIsPx ? `${Math.min(parseFloat(oldvalue), parseFloat(newvalue))}px` : Math.min(oldvalue, newvalue);
+const getrightBottomMin = (state) => ({ oldvalue, newvalue }) => state.valueIsPx ? `${Math.max(parseFloat(oldvalue), parseFloat(newvalue))}px` : Math.max(oldvalue, newvalue);
+const getAnotherOffset = ({ refs, state }) => (value) => state.valueIsPx ? `${refs.outerWrapper[state.offsetSize] - parseFloat(value)}px` : 1 - value;
+const handleMove = ({ api, emit, props, refs, state }) => (event) => {
+  const pageOffset = state.isHorizontal ? event.pageX : event.pageY;
+  const offset = pageOffset - state.initOffset;
+  const outerWidth = refs.outerWrapper[state.offsetSize];
+  let value = state.valueIsPx ? `${parseFloat(state.oldOffset) + offset}px` : api.px2percent({ numerator: outerWidth * state.oldOffset + offset, denominator: outerWidth });
+  const anotherValue = api.getAnotherOffset(value);
+  if (parseFloat(value) <= parseFloat(state.computedleftTopMin)) {
+    value = api.getrightBottomMin({
+      oldvalue: value,
+      newvalue: state.computedleftTopMin
     });
-    var anotherValue = api.getAnotherOffset(value);
-    if (parseFloat(value) <= parseFloat(state.computedleftTopMin)) {
-      value = api.getrightBottomMin({
-        oldvalue: value,
-        newvalue: state.computedleftTopMin
-      });
-    }
-    if (parseFloat(anotherValue) <= parseFloat(state.computedrightBottomMin)) {
-      value = api.getAnotherOffset(api.getrightBottomMin({
+  }
+  if (parseFloat(anotherValue) <= parseFloat(state.computedrightBottomMin)) {
+    value = api.getAnotherOffset(
+      api.getrightBottomMin({
         oldvalue: anotherValue,
         newvalue: state.computedrightBottomMin
-      }));
-    }
-    event.atMin = props.modelValue === state.computedleftTopMin;
-    event.atMax = state.valueIsPx ? api.getAnotherOffset(props.modelValue) === state.computedrightBottomMin : api.getAnotherOffset(props.modelValue).toFixed(5) === state.computedrightBottomMin.toFixed(5);
-    emit('update:modelValue', value);
-    emit('moving', event);
-  };
+      })
+    );
+  }
+  event.atMin = props.modelValue === state.computedleftTopMin;
+  event.atMax = state.valueIsPx ? api.getAnotherOffset(props.modelValue) === state.computedrightBottomMin : api.getAnotherOffset(props.modelValue).toFixed(5) === state.computedrightBottomMin.toFixed(5);
+  emit("update:modelValue", value);
+  emit("moving", event);
 };
-export var handleUp = function handleUp(_ref7) {
-  var api = _ref7.api,
-    emit = _ref7.emit,
-    off = _ref7.off,
-    state = _ref7.state;
-  return function () {
-    state.isMoving = false;
-    off(document, 'mousemove', api.handleMove);
-    off(document, 'mouseup', api.handleUp);
-    emit('moveend');
-  };
+const handleUp = ({ api, emit, off, state }) => () => {
+  state.isMoving = false;
+  off(document, "mousemove", api.handleMove);
+  off(document, "mouseup", api.handleUp);
+  emit("moveend");
+};
+const handleMousedown = ({ api, emit, on, props, state }) => (event) => {
+  if (state.collapsed)
+    return;
+  state.initOffset = state.isHorizontal ? event.pageX : event.pageY;
+  state.oldOffset = props.modelValue;
+  state.isMoving = true;
+  on(document, "mousemove", api.handleMove);
+  on(document, "mouseup", api.handleUp);
+  emit("movestart");
+};
+const computeOffset = ({ api, nextTick, props, refs, state }) => () => {
+  if (state.valueIsPx) {
+    nextTick(() => {
+      state.offset = api.px2percent({
+        numerator: props.modelValue,
+        denominator: refs.outerWrapper && refs.outerWrapper[state.offsetSize]
+      }) * 1e4 / 100;
+    });
+  } else {
+    state.offset = props.modelValue * 1e4 / 100;
+  }
 };
-export var handleMousedown = function handleMousedown(_ref8) {
-  var api = _ref8.api,
-    emit = _ref8.emit,
-    on = _ref8.on,
-    props = _ref8.props,
-    state = _ref8.state;
-  return function (event) {
-    if (state.collapsed) return;
-    state.initOffset = state.isHorizontal ? event.pageX : event.pageY;
-    state.oldOffset = props.modelValue;
-    state.isMoving = true;
-    on(document, 'mousemove', api.handleMove);
-    on(document, 'mouseup', api.handleUp);
-    emit('movestart');
-  };
+const handleCollapse = ({ emit, state }) => () => {
+  state.collapsed = !state.collapsed;
+  emit("collapsedChange", state.collapsed);
 };
-export var computeOffset = function computeOffset(_ref9) {
-  var api = _ref9.api,
-    nextTick = _ref9.nextTick,
-    props = _ref9.props,
-    refs = _ref9.refs,
-    state = _ref9.state;
-  return function () {
-    if (state.valueIsPx) {
-      nextTick(function () {
-        state.offset = api.px2percent({
-          numerator: props.modelValue,
-          denominator: refs.outerWrapper && refs.outerWrapper[state.offsetSize]
-        }) * 10000 / 100;
-      });
-    } else {
-      state.offset = props.modelValue * 10000 / 100;
-    }
-  };
+export {
+  computeOffset,
+  getAnotherOffset,
+  getComputedThresholdValue,
+  getleftTopMin,
+  getrightBottomMin,
+  handleCollapse,
+  handleMousedown,
+  handleMove,
+  handleUp,
+  px2percent
 };
-export var handleCollapse = function handleCollapse(_ref10) {
-  var emit = _ref10.emit,
-    state = _ref10.state;
-  return function () {
-    state.collapsed = !state.collapsed;
-    emit('collapsedChange', state.collapsed);
-  };
-};

package/split/vue.js

@@ -1,136 +1,83 @@
-import _defineProperty from "@babel/runtime/helpers/defineProperty";
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-import { px2percent, getComputedThresholdValue, getleftTopMin, getrightBottomMin, getAnotherOffset, handleMove, handleUp, handleMousedown, computeOffset, handleCollapse } from './index';
-import { on, off } from '@opentiny/vue-renderless/common/deps/dom';
-export var api = ['state', 'handleMousedown', 'handleCollapse'];
-export var useOffset = function useOffset(_ref) {
-  var nextTick = _ref.nextTick,
-    props = _ref.props,
-    refs = _ref.refs,
-    constants = _ref.constants,
-    hooks = _ref.hooks;
-  var api = {};
-  var computed = hooks.computed,
-    onMounted = hooks.onMounted,
-    onUnmounted = hooks.onUnmounted,
-    reactive = hooks.reactive,
-    toRefs = hooks.toRefs,
-    watch = hooks.watch;
-  var state = reactive({
+import {
+  __spreadProps,
+  __spreadValues
+} from "../chunk-PKUHTIDK.js";
+import {
+  px2percent,
+  getComputedThresholdValue,
+  getleftTopMin,
+  getrightBottomMin,
+  getAnotherOffset,
+  handleMove,
+  handleUp,
+  handleMousedown,
+  computeOffset,
+  handleCollapse
+} from "./index";
+import { on, off } from "@opentiny/vue-renderless/common/deps/dom";
+const api = ["state", "handleMousedown", "handleCollapse"];
+const useOffset = ({ nextTick, props, refs, constants, hooks }) => {
+  const api2 = {};
+  const { computed, onMounted, onUnmounted, reactive, toRefs, watch } = hooks;
+  const state = reactive({
     offset: 0,
-    anotherOffset: computed(function () {
-      return 100 - state.offset;
-    }),
-    valueIsPx: computed(function () {
-      return typeof props.modelValue === 'string';
-    }),
-    isHorizontal: computed(function () {
-      return props.mode === constants.HORIZONTAL;
-    }),
-    offsetSize: computed(function () {
-      return state.isHorizontal ? 'offsetWidth' : 'offsetHeight';
-    })
-  });
-  Object.assign(api, {
-    px2percent: px2percent,
-    computeOffset: computeOffset({
-      api: api,
-      nextTick: nextTick,
-      props: props,
-      refs: refs,
-      state: state
-    })
+    anotherOffset: computed(() => 100 - state.offset),
+    valueIsPx: computed(() => typeof props.modelValue === "string"),
+    isHorizontal: computed(() => props.mode === constants.HORIZONTAL),
+    offsetSize: computed(() => state.isHorizontal ? "offsetWidth" : "offsetHeight")
   });
-  watch(function () {
-    return props.modelValue;
-  }, api.computeOffset, {
-    immediate: true
+  Object.assign(api2, {
+    px2percent,
+    computeOffset: computeOffset({ api: api2, nextTick, props, refs, state })
   });
-  onMounted(function () {
-    on(window, 'resize', api.computeOffset);
+  watch(() => props.modelValue, api2.computeOffset, { immediate: true });
+  onMounted(() => {
+    on(window, "resize", api2.computeOffset);
   });
-  onUnmounted(function () {
-    off(window, 'resize', api.computeOffset);
+  onUnmounted(() => {
+    off(window, "resize", api2.computeOffset);
   });
   return {
-    api: api,
+    api: api2,
     state: toRefs(state)
   };
 };
-export var renderless = function renderless(props, hooks, _ref2) {
-  var refs = _ref2.refs,
-    nextTick = _ref2.nextTick,
-    emit = _ref2.emit,
-    constants = _ref2.constants;
-  var api = {};
-  var computed = hooks.computed,
-    reactive = hooks.reactive;
-  var getUseOffset = useOffset({
-    nextTick: nextTick,
-    props: props,
-    refs: refs,
-    constants: constants,
-    hooks: hooks
-  });
-  var state = reactive(_objectSpread({
+const renderless = (props, hooks, { refs, nextTick, emit, constants }) => {
+  const api2 = {};
+  const { computed, reactive } = hooks;
+  const getUseOffset = useOffset({ nextTick, props, refs, constants, hooks });
+  const state = reactive(__spreadValues({
     oldOffset: 0,
     initOffset: 0,
     isMoving: false,
     prefix: constants.PREFIX,
-    computedleftTopMin: computed(function () {
-      return api.getComputedThresholdValue('leftTopMin');
-    }),
-    computedrightBottomMin: computed(function () {
-      return api.getComputedThresholdValue('rightBottomMin');
-    }),
-    wrapperClasses: computed(function () {
-      return [state.prefix, "".concat(state.prefix, "-wrapper"), state.isMoving ? 'no-select' : ''];
-    }),
-    paneClasses: computed(function () {
-      return ["".concat(state.prefix, "-pane"), _defineProperty({}, "".concat(state.prefix, "-pane-moving"), state.isMoving)];
-    }),
+    computedleftTopMin: computed(() => api2.getComputedThresholdValue("leftTopMin")),
+    computedrightBottomMin: computed(() => api2.getComputedThresholdValue("rightBottomMin")),
+    wrapperClasses: computed(() => [state.prefix, `${state.prefix}-wrapper`, state.isMoving ? "no-select" : ""]),
+    paneClasses: computed(() => [`${state.prefix}-pane`, { [`${state.prefix}-pane-moving`]: state.isMoving }]),
     collapsed: false
   }, getUseOffset.state));
-  Object.assign(api, _objectSpread(_objectSpread({
-    state: state,
+  Object.assign(api2, __spreadProps(__spreadValues({
+    state,
     getleftTopMin: getleftTopMin(state),
     getrightBottomMin: getrightBottomMin(state)
-  }, getUseOffset.api), {}, {
-    handleUp: handleUp({
-      api: api,
-      emit: emit,
-      off: off,
-      state: state
-    }),
-    getAnotherOffset: getAnotherOffset({
-      refs: refs,
-      state: state
-    }),
-    handleMove: handleMove({
-      api: api,
-      emit: emit,
-      props: props,
-      refs: refs,
-      state: state
-    }),
-    handleMousedown: handleMousedown({
-      api: api,
-      emit: emit,
-      on: on,
-      props: props,
-      state: state
-    }),
-    handleCollapse: handleCollapse({
-      emit: emit,
-      state: state
-    }),
+  }, getUseOffset.api), {
+    handleUp: handleUp({ api: api2, emit, off, state }),
+    getAnotherOffset: getAnotherOffset({ refs, state }),
+    handleMove: handleMove({ api: api2, emit, props, refs, state }),
+    handleMousedown: handleMousedown({ api: api2, emit, on, props, state }),
+    handleCollapse: handleCollapse({ emit, state }),
     getComputedThresholdValue: getComputedThresholdValue({
-      api: api,
-      props: props,
-      refs: refs,
-      state: state
+      api: api2,
+      props,
+      refs,
+      state
     })
   }));
-  return api;
-};
+  return api2;
+};
+export {
+  api,
+  renderless,
+  useOffset
+};