@opentiny/vue-renderless 3.6.8 → 3.8.0

package/column-list-group/vue.js

@@ -0,0 +1,14 @@
+import "../chunk-PKUHTIDK.js";
+const api = ["state"];
+const renderless = (props, { reactive }) => {
+  const api2 = {};
+  const state = reactive({});
+  Object.assign(api2, {
+    state
+  });
+  return api2;
+};
+export {
+  api,
+  renderless
+};

package/column-list-item/index.js

@@ -0,0 +1,50 @@
+import "../chunk-PKUHTIDK.js";
+import { isNull } from "../common/type";
+const handelIconClick = ({ emit }) => (item, index) => {
+  if (item.disabled)
+    return;
+  emit("icon-click", item, index);
+};
+const handleChange = ({ constants, dispatch, emit, state, nextTick }) => () => {
+  nextTick(() => {
+    emit("change", state.model);
+    state.isGroup && dispatch(constants.COLUMN_GROUP, "change", [state.model]);
+  });
+};
+const getIsGroup = ({ constants, parent: $parent, state }) => () => {
+  let parent = $parent;
+  while (parent) {
+    if (parent.$options.componentName !== constants.COLUMN_GROUP) {
+      parent = parent.$parent;
+    } else {
+      state.columnGroup = parent;
+      return true;
+    }
+  }
+  return false;
+};
+const getSize = ({ props, state }) => () => state.isGroup ? state.columnGroup.size || props.size : props.size;
+const isDisabled = ({ props, state }) => () => props.checkboxDisabled || state.columnGroup.disabled;
+const getModel = ({ props, state }) => () => {
+  const model = state.isGroup ? state.store : props.modelValue !== void 0 ? props.modelValue : state.selfModel;
+  return isNull(model) ? [] : model;
+};
+const setModel = ({ constants, dispatch, emit, state }) => (val) => {
+  if (state.isGroup) {
+    dispatch(constants.COLUMN_GROUP, "update:modelValue", [val]);
+  } else {
+    emit("update:modelValue", val);
+    state.selfModel = val;
+  }
+};
+const computedStore = ({ state, props }) => () => state.isGroup ? state.columnGroup.modelValue : props.modelValue;
+export {
+  computedStore,
+  getIsGroup,
+  getModel,
+  getSize,
+  handelIconClick,
+  handleChange,
+  isDisabled,
+  setModel
+};

package/column-list-item/vue.js

@@ -0,0 +1,39 @@
+import "../chunk-PKUHTIDK.js";
+import { handelIconClick, handleChange, getIsGroup, getSize, isDisabled, getModel, setModel, computedStore } from "./index";
+const api = ["state", "handelIconClick"];
+const renderless = (props, { reactive, watch, computed }, { vm, parent, emit, constants, nextTick, dispatch }) => {
+  const api2 = {};
+  const state = reactive({
+    columnGroup: {},
+    itemChecked: props.modelValue,
+    sliceNum: computed(() => props.size === "small" ? 1 : 2),
+    iconNum: computed(() => props.size === "small" ? 2 : 3),
+    effectOptions: computed(() => props.options.filter((item) => !item.hidden)),
+    showCheckbox: computed(() => props.showCheckbox || state.columnGroup.showCheckbox),
+    store: computed(() => api2.computedStore()),
+    getIsGroup: computed(() => api2.getIsGroup()),
+    size: computed(() => api2.getSize()),
+    disabled: computed(() => api2.isDisabled()),
+    model: computed({
+      get: () => api2.getModel(),
+      set: (val) => api2.setModel(val)
+    })
+  });
+  Object.assign(api2, {
+    state,
+    getSize: getSize({ props, state }),
+    getModel: getModel({ props, state }),
+    getIsGroup: getIsGroup({ constants, parent, state }),
+    isDisabled: isDisabled({ props, state }),
+    setModel: setModel({ constants, dispatch, emit, props, vm, state }),
+    handleChange: handleChange({ constants, dispatch, emit, state, nextTick }),
+    computedStore: computedStore({ state, props }),
+    handelIconClick: handelIconClick({ emit })
+  });
+  watch(() => state.model, api2.handleChange, { deep: true });
+  return api2;
+};
+export {
+  api,
+  renderless
+};

package/common/array.js

@@ -1,9 +1,9 @@
 import {
   __spreadValues
 } from "../chunk-PKUHTIDK.js";
-import { SORT } from "@opentiny/vue-renderless/common";
-import { isSame } from "@opentiny/vue-renderless/common/type";
-import { getObj } from "@opentiny/vue-renderless/common/object";
+import { SORT } from "./index";
+import { isSame } from "./type";
+import { getObj } from "./object";
 const indexOf = (arr, data, predicate = isSame) => {
   if (Array.isArray(arr) && typeof predicate === "function") {
     for (let i = 0, len = arr.length; i < len; i++) {

package/common/bigInt.js

@@ -1,5 +1,5 @@
 import "../chunk-PKUHTIDK.js";
-import { fillChar } from "@opentiny/vue-renderless/common/string";
+import { fillChar } from "./string";
 const BigInt = window.BigInt;
 function supportBigInt() {
   return typeof BigInt === "function";
@@ -116,7 +116,10 @@ class BigIntDecimal {
       num2str(mergedValue);
     }
     const f = Function;
-    const convertBigInt = (str) => f(`return BigInt(${str})`)();
+    const convertBigInt = (str) => {
+      const validStr = str.replace(/^0+/, "") || "0";
+      return f(`return BigInt(${validStr})`)();
+    };
     if (validateNumber(mergedValue)) {
       const trimRet = trimNumber(mergedValue);
       this.negative = trimRet.negative;

package/common/dataset/index.js

@@ -2,9 +2,9 @@ import {
   __objRest,
   __spreadValues
 } from "../../chunk-PKUHTIDK.js";
-import { format } from "@opentiny/vue-renderless/common/string";
-import { isObject } from "@opentiny/vue-renderless/common/type";
-import { transformTreeData } from "@opentiny/vue-renderless/common/array";
+import { format } from "../string";
+import { isObject } from "../type";
+import { transformTreeData } from "../array";
 const getFilterStr = (filters) => {
   const filterArr = {};
   Object.keys(filters).forEach((property) => {

package/common/date.js

@@ -1,6 +1,6 @@
 import "../chunk-PKUHTIDK.js";
-import { isDate, isNumber, isNumeric } from "@opentiny/vue-renderless/common/type";
-import { fillChar } from "@opentiny/vue-renderless/common/string";
+import { isDate, isNumber, isNumeric } from "./type";
+import { fillChar } from "./string";
 const daysInMonths = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
 const yyyymmddReg = new RegExp(
   "^(\\d{4})(/|-)(((0)?[1-9])|(1[0-2]))((/|-)(((0)?[1-9])|([1-2][0-9])|(3[0-1])))?( ((0)?[0-9]|1[0-9]|20|21|22|23):([0-5]?[0-9])((:([0-5]?[0-9]))?(.([0-9]{1,6}))?)?)?$"

package/common/deps/ResizeObserver.js

@@ -1,5 +1,5 @@
 import "../../chunk-PKUHTIDK.js";
-import { on, off } from "@opentiny/vue-renderless/common/deps/dom";
+import { on, off } from "./dom";
 const MapShim = function() {
   if (typeof Map !== "undefined") {
     return Map;

package/common/deps/clickoutside.js

@@ -1,5 +1,5 @@
 import "../../chunk-PKUHTIDK.js";
-import { on } from "@opentiny/vue-renderless/common/deps/dom";
+import { on } from "./dom";
 const isServer = typeof window === "undefined";
 const nodeList = [];
 const nameSpace = "@@clickoutsideContext";

package/common/deps/date-util.js

@@ -1,8 +1,8 @@
 import "../../chunk-PKUHTIDK.js";
-import fecha from "@opentiny/vue-renderless/common/deps/date";
-import { isNull } from "@opentiny/vue-renderless/common/type";
-import { isLeapYear } from "@opentiny/vue-renderless/common/date";
-import { DATEPICKER } from "@opentiny/vue-renderless/common";
+import fecha from "./date";
+import { isNull } from "../type";
+import { isLeapYear } from "../date";
+import { DATEPICKER } from "../index";
 const weeks = DATEPICKER.Weeks;
 const months = DATEPICKER.MonhtList;
 const defaultYMD = DATEPICKER.DateFormats.date;

package/common/deps/date.js

@@ -1,6 +1,6 @@
 import "../../chunk-PKUHTIDK.js";
-import { DATEPICKER } from "@opentiny/vue-renderless/common";
-import { isNull, isDate } from "@opentiny/vue-renderless/common/type";
+import { DATEPICKER } from "../index";
+import { isNull, isDate } from "../type";
 const fecha = {};
 const digitsReg = ["\\d\\d?", "\\d{3}", "\\d{4}"];
 const twoDigits = digitsReg[0];

package/common/deps/debounce.js

@@ -1,5 +1,5 @@
 import "../../chunk-PKUHTIDK.js";
-import throttle from "@opentiny/vue-renderless/common/deps/throttle";
+import throttle from "./throttle";
 function debounce_default(delay, atBegin, callback) {
   return callback === void 0 ? throttle(delay, atBegin, false) : throttle(delay, callback, atBegin !== false);
 }

package/common/deps/dom.js

@@ -1,5 +1,5 @@
 import "../../chunk-PKUHTIDK.js";
-import { hasOwn, isObject, isNull } from "@opentiny/vue-renderless/common/type";
+import { hasOwn, isObject, isNull } from "../type";
 const isServer = typeof window === "undefined";
 const SPECIAL_CHARS_REGEXP = /([:\-_]+(.))/g;
 const MOZ_HACK_REGEXP = /^moz([A-Z])/;

package/common/deps/fullscreen/apis.js

@@ -1,7 +1,7 @@
 import "../../../chunk-PKUHTIDK.js";
-import { extend } from "@opentiny/vue-renderless/common/object";
-import { on, off } from "@opentiny/vue-renderless/common/deps/dom";
-import screenfull from "@opentiny/vue-renderless/common/deps/fullscreen/screenfull";
+import { extend } from "../../object";
+import { on, off } from "../dom";
+import screenfull from "./screenfull";
 const defaults = {
   callback: () => void 0,
   fullscreenClass: "fullscreen",

package/common/deps/fullscreen/screenfull.js

@@ -1,5 +1,5 @@
 import "../../../chunk-PKUHTIDK.js";
-import { on, off } from "@opentiny/vue-renderless/common/deps/dom";
+import { on, off } from "../dom";
 const fullscreenApi = ["fullscreenElement", "fullscreenEnabled", "requestFullscreen", "exitFullscreen", "fullscreenchange", "fullscreenerror"];
 const fullscreenApiMoz = [
   "mozFullScreenElement",

package/common/deps/infinite-scroll.js

@@ -0,0 +1,176 @@
+import "../../chunk-PKUHTIDK.js";
+import throttle from "./throttle";
+const CONTEXT_KEY = "@@infinitescrollContext";
+const OBSERVER_CHECK_INTERVAL = 50;
+const ATTR_DEFAULT_DELAY = 200;
+const ATTR_DEFAULT_DISTANCE = 0;
+const attrs = {
+  delay: { type: Number, default: ATTR_DEFAULT_DELAY },
+  disabled: { type: Boolean, default: false },
+  distance: { type: Number, default: ATTR_DEFAULT_DISTANCE },
+  immediate: { type: Boolean, default: true }
+};
+const isNull = (val) => val === null;
+const parseAttrValue = (attrVal, type, defaultVal) => {
+  if (isNull(attrVal))
+    return defaultVal;
+  if (type === Boolean) {
+    return attrVal !== "false";
+  } else if (type === Number) {
+    return Number(attrVal);
+  }
+};
+const computeScrollOptions = (el, instance) => Object.entries(attrs).reduce((accumulator, [name, option]) => {
+  const { type, default: defaultValue } = option;
+  const attrKey = `infinite-scroll-${name}`;
+  const $attrValue = instance.$el.getAttribute(attrKey);
+  const attrValue = el.getAttribute(attrKey);
+  let value;
+  if (isNull(attrValue) && isNull($attrValue) || !isNull(attrValue)) {
+    value = parseAttrValue(attrValue, type, defaultValue);
+  }
+  if (isNull(attrValue) && !isNull($attrValue)) {
+    value = parseAttrValue($attrValue, type, defaultValue);
+  }
+  accumulator[name] = Number.isNaN(value) ? defaultValue : value;
+  return accumulator;
+}, {});
+const stopObserver = (el) => {
+  const { observer } = el[CONTEXT_KEY];
+  if (observer) {
+    observer.disconnect();
+    delete el[CONTEXT_KEY].observer;
+  }
+};
+const accumOffsetTop = (el) => {
+  let totalOffset = 0;
+  let parent = el;
+  while (parent) {
+    totalOffset += parent.offsetTop;
+    parent = parent.offsetParent;
+  }
+  return totalOffset;
+};
+const distanceOffsetTop = (el, containerEl) => Math.abs(accumOffsetTop(el) - accumOffsetTop(containerEl));
+const scroller = (el, cb) => {
+  const { container, containerEl, instance, observer, lastScrollTop } = el[CONTEXT_KEY];
+  const { disabled, distance } = computeScrollOptions(el, instance);
+  const { clientHeight, scrollHeight, scrollTop } = containerEl;
+  const deltaTop = scrollTop - lastScrollTop;
+  el[CONTEXT_KEY].lastScrollTop = scrollTop;
+  if (observer || disabled || deltaTop < 0)
+    return;
+  let isTrigger = false;
+  if (container === el) {
+    isTrigger = scrollHeight - (clientHeight + scrollTop) <= distance;
+  } else {
+    const { clientTop, scrollHeight: height } = el;
+    const offsetTop = distanceOffsetTop(el, containerEl);
+    isTrigger = scrollTop + clientHeight >= offsetTop + clientTop + height - distance;
+  }
+  if (isTrigger) {
+    cb.call(instance);
+  }
+};
+function observerChecker(el, cb) {
+  const { containerEl, instance } = el[CONTEXT_KEY];
+  const { disabled } = computeScrollOptions(el, instance);
+  if (disabled || containerEl.clientHeight === 0)
+    return;
+  if (containerEl.scrollHeight <= containerEl.clientHeight) {
+    cb.call(instance);
+  } else {
+    stopObserver(el);
+  }
+}
+const cached = (fn) => {
+  const cache = /* @__PURE__ */ Object.create(null);
+  return (str) => cache[str] || (cache[str] = fn(str));
+};
+const camelizeRE = /-(\w)/g;
+const camelize = cached((str) => str.replace(camelizeRE, (_, c) => c ? c.toUpperCase() : ""));
+const getElementStyle = (elem, styleKey) => {
+  if (!elem || !styleKey)
+    return "";
+  let key = camelize(styleKey);
+  if (key === "float")
+    key = "cssFloat";
+  try {
+    const styleValue = elem.style[key];
+    if (styleValue)
+      return styleValue;
+    const computedStyle = document.defaultView ? document.defaultView.getComputedStyle(elem, "") : null;
+    return computedStyle ? computedStyle[key] : "";
+  } catch (e) {
+    return elem.style[key];
+  }
+};
+const canScroll = (el, isVertical) => {
+  const overflowKey = { undefined: "overflow", true: "overflow-y", false: "overflow-x" }[String(isVertical)];
+  const overflowVal = getElementStyle(el, overflowKey);
+  return ["scroll", "auto", "overlay"].some((s) => overflowVal.includes(s));
+};
+const getScrollContainer = (el, isVertical) => {
+  let parentEl = el;
+  while (parentEl) {
+    if ([window, document, document.documentElement].includes(parentEl))
+      return window;
+    if (canScroll(parentEl, isVertical))
+      return parentEl;
+    parentEl = parentEl.parentNode;
+  }
+  return parentEl;
+};
+const bind = (el, binding, vnode) => {
+  const instance = binding.instance || vnode.context;
+  const { value: cb } = binding;
+  if (typeof cb !== "function") {
+    throw new TypeError('[TINY Error][InfiniteScroll] "v-infinite-scroll" binding value must be a function');
+  }
+  instance.$nextTick(() => {
+    const { delay, immediate } = computeScrollOptions(el, instance);
+    const container = getScrollContainer(el, true);
+    const containerEl = container === window ? document.documentElement : container;
+    const onScroll = throttle(delay, scroller.bind(null, el, cb));
+    if (!container)
+      return;
+    el[CONTEXT_KEY] = { instance, container, containerEl, delay, cb, onScroll, lastScrollTop: containerEl.scrollTop };
+    if (immediate) {
+      const observer = new MutationObserver(throttle(OBSERVER_CHECK_INTERVAL, observerChecker.bind(null, el, cb)));
+      el[CONTEXT_KEY].observer = observer;
+      observer.observe(el, { childList: true, subtree: true });
+      observerChecker(el, cb);
+    }
+    container.addEventListener("scroll", onScroll);
+  });
+};
+const update = (el, binding, vnode) => {
+  if (!el[CONTEXT_KEY]) {
+    const instance = binding.instance || vnode.context;
+    return instance.$nextTick();
+  } else {
+    const { containerEl, cb, observer } = el[CONTEXT_KEY];
+    if (containerEl.clientHeight && observer) {
+      observerChecker(el, cb);
+    }
+  }
+};
+const unbind = (el) => {
+  const { container, onScroll } = el[CONTEXT_KEY];
+  if (container)
+    container.removeEventListener("scroll", onScroll);
+  stopObserver(el);
+};
+const InfiniteScroll = {
+  bind,
+  update,
+  unbind,
+  beforeMount: bind,
+  updated: update,
+  unmounted: unbind
+};
+var infinite_scroll_default = InfiniteScroll;
+export {
+  infinite_scroll_default as default,
+  getScrollContainer
+};

package/common/deps/letter-only.js

@@ -1,5 +1,5 @@
 import "../../chunk-PKUHTIDK.js";
-import { on, off } from "@opentiny/vue-renderless/common/deps/dom";
+import { on, off } from "./dom";
 const checkValue = (event) => {
   if (event.charCode >= 48 && event.charCode <= 57) {
     event.preventDefault();

package/common/deps/number-only.js

@@ -1,5 +1,5 @@
 import "../../chunk-PKUHTIDK.js";
-import { on, off } from "@opentiny/vue-renderless/common/deps/dom";
+import { on, off } from "./dom";
 const checkValue = (event) => {
   event.target.value = event.target.value.replace(/[^0-9]/g, "");
   if (event.charCode >= 48 && event.charCode <= 57) {

package/common/deps/observe-visibility.js

@@ -0,0 +1,106 @@
+import "../../chunk-PKUHTIDK.js";
+import throttle from "./throttle";
+import { isEqual } from "../object";
+const CONTEXT_KEY = "@@observevisibilityContext";
+const processOptions = (value) => {
+  let options;
+  if (typeof value === "function") {
+    options = { callback: value };
+  } else {
+    options = value;
+  }
+  return options;
+};
+const createObserver = ({ options, instance, state }) => {
+  if (state.observer) {
+    destroyObserver(state);
+  }
+  if (state.frozen)
+    return;
+  state.options = processOptions(options);
+  state.callback = (result, entry) => {
+    state.options.callback(result, entry);
+    if (result && state.options.once) {
+      state.frozen = true;
+      destroyObserver(state);
+    }
+  };
+  if (state.callback && state.options.throttle) {
+    state.callback = throttle(state.options.throttleDelay || 20, state.callback);
+  }
+  state.observer = new IntersectionObserver((entries) => {
+    let entry = entries[0];
+    if (entries.length > 1) {
+      const intersectingEntry = entries.find((e) => e.isIntersecting);
+      if (intersectingEntry) {
+        entry = intersectingEntry;
+      }
+    }
+    if (state.callback) {
+      state.callback(entry.isIntersecting, entry);
+    }
+  }, state.options.intersection);
+  instance.$nextTick(() => {
+    if (state.observer) {
+      state.observer.observe(state.el);
+    }
+  });
+};
+const destroyObserver = (state) => {
+  if (state.observer) {
+    state.observer.disconnect();
+    state.observer = null;
+  }
+  if (state.callback) {
+    state.callback = null;
+  }
+};
+const createVisibilityState = ({ el, options, instance }) => {
+  const state = { el, observer: null, frozen: false };
+  createObserver({ options, instance, state });
+  return state;
+};
+const bind = (el, { value, instance }, { context }) => {
+  if (!value)
+    return;
+  if (typeof IntersectionObserver === "undefined") {
+    throw new TypeError("[TINY Error][ObserveVisibility] IntersectionObserver API is not available in your browser");
+  } else {
+    instance = instance || context;
+    el[CONTEXT_KEY] = createVisibilityState({ el, options: value, instance });
+  }
+};
+const update = (el, { value, oldValue, instance }, { context }) => {
+  if (isEqual(value, oldValue))
+    return;
+  const state = el[CONTEXT_KEY];
+  if (!value) {
+    unbind(el);
+    return;
+  }
+  instance = instance || context;
+  if (state) {
+    createObserver({ options: value, instance, state });
+  } else {
+    bind(el, { value, instance }, { context });
+  }
+};
+const unbind = (el) => {
+  const state = el[CONTEXT_KEY];
+  if (state) {
+    destroyObserver(state);
+    delete el[CONTEXT_KEY];
+  }
+};
+const ObserveVisibility = {
+  bind,
+  update,
+  unbind,
+  beforeMount: bind,
+  updated: update,
+  unmounted: unbind
+};
+var observe_visibility_default = ObserveVisibility;
+export {
+  observe_visibility_default as default
+};

package/common/deps/popper.js

@@ -1,10 +1,10 @@
 import {
   __spreadValues
 } from "../../chunk-PKUHTIDK.js";
-import { on, off } from "@opentiny/vue-renderless/common/deps/dom";
-import PopupManager from "@opentiny/vue-renderless/common/deps/popup-manager";
-import { typeOf } from "@opentiny/vue-renderless/common/type";
-import { xss } from "@opentiny/vue-renderless/common/xss.js";
+import { on, off } from "./dom";
+import PopupManager from "./popup-manager";
+import { typeOf } from "../type";
+import { xss } from "../xss";
 const win = window;
 const positions = ["left", "right", "top", "bottom"];
 const modifiers = ["shift", "offset", "preventOverflow", "keepTogether", "arrow", "flip", "applyStyle"];
@@ -128,24 +128,13 @@ const getOffsetRectRelativeToCustomParent = (el, parent, fixed) => {
   };
   return rect;
 };
-const getScrollTopValue = (el) => el == document.body ? Math.max(document.documentElement.scrollTop, document.body.scrollTop) : el.scrollTop;
-const getScrollLeftValue = (el) => el == document.body ? Math.max(document.documentElement.scrollLeft, document.body.scrollLeft) : el.scrollLeft;
+const getScrollTopValue = (el) => el === document.body ? Math.max(document.documentElement.scrollTop, document.body.scrollTop) : el.scrollTop;
+const getScrollLeftValue = (el) => el === document.body ? Math.max(document.documentElement.scrollLeft, document.body.scrollLeft) : el.scrollLeft;
 const getMaxWH = (body, html) => {
   const height = Math.max(body.scrollHeight, body.offsetHeight, html.clientHeight, html.scrollHeight, html.offsetHeight);
   const width = Math.max(body.scrollWidth, body.offsetWidth, html.clientWidth, html.scrollWidth, html.offsetWidth);
   return { width, height };
 };
-const adjustArrowStyle = (arrowStyle, side, arrowRect, popperRect, popperOptions) => {
-  let params = popperOptions.placement.split("-");
-  if (popperOptions.adjustArrow && ~["top", "bottom"].indexOf(params[0]) && side === "left") {
-    if (params[1] === "start") {
-      arrowStyle.left = 8;
-    } else if (!params[1]) {
-      arrowStyle.left = (popperRect.width - arrowRect.width) / 2;
-    }
-  }
-  return arrowStyle;
-};
 const getOuterSizes = (el) => {
   let _display = el.style.display;
   let _visibility = el.style.visibility;
@@ -594,25 +583,34 @@ Popper.prototype.modifiers.arrow = function(data) {
   let popper = getPopperClientRect(data.offsets.popper);
   let reference = data.offsets.reference;
   let isVertical = ~["left", "right"].indexOf(placement);
-  let len = isVertical ? "height" : "width";
+  let calcProp = isVertical ? "height" : "width";
   let opSide = isVertical ? "bottom" : "right";
   let altSide = isVertical ? "left" : "top";
   let side = isVertical ? "top" : "left";
   let popperRect = this.popperOuterSize ? this.popperOuterSize : this.popperOuterSize = getOuterSizes(this._popper);
   let arrowRect = getOuterSizes(arrow);
-  let arrowSize = arrowRect[len];
+  let arrowSize = arrowRect[calcProp];
   if (reference[opSide] - arrowSize < popper[side]) {
     data.offsets.popper[side] -= popper[side] - (reference[opSide] - arrowSize);
   }
   if (reference[side] + arrowSize > popper[opSide]) {
     data.offsets.popper[side] += reference[side] + arrowSize - popper[opSide];
   }
-  let center = reference[side] + (arrowOffset || reference[len] / 2 - arrowSize / 2);
+  let center = reference[side] + (arrowOffset || reference[calcProp] / 2 - arrowSize / 2);
   let sideValue = center - popper[side];
-  sideValue = Math.max(Math.min(popper[len] - arrowSize - 8, sideValue), 8);
+  sideValue = Math.max(Math.min(popper[calcProp] - arrowSize - 8, sideValue), 8);
   arrowStyle[side] = sideValue;
   arrowStyle[altSide] = "";
-  data.offsets.arrow = adjustArrowStyle(arrowStyle, side, arrowRect, popperRect, this._options);
+  const popperOptions = this._options;
+  const params = popperOptions.placement.split("-");
+  if (popperOptions.adjustArrow && ~["top", "bottom"].indexOf(params[0]) && side === "left") {
+    if (params[1] === "start") {
+      arrowStyle.left = 8;
+    } else if (!params[1]) {
+      arrowStyle.left = (popperRect.width - arrowRect.width) / 2;
+    }
+  }
+  data.offsets.arrow = arrowStyle;
   data.arrowElement = arrow;
   return data;
 };

package/common/deps/popup-manager.js

@@ -1,6 +1,6 @@
 import "../../chunk-PKUHTIDK.js";
-import { KEY_CODE } from "@opentiny/vue-renderless/common";
-import { addClass, removeClass, on } from "@opentiny/vue-renderless/common/deps/dom";
+import { KEY_CODE } from "../index";
+import { addClass, removeClass, on } from "./dom";
 let hasModal = false;
 const isServer = typeof window === "undefined";
 const instances = {};

package/common/deps/repeat-click.js

@@ -1,5 +1,5 @@
 import "../../chunk-PKUHTIDK.js";
-import { on, once } from "@opentiny/vue-renderless/common/deps/dom";
+import { on, once } from "./dom";
 var repeat_click_default = (el, binding) => {
   let interval = null;
   let startTime;

package/common/deps/resize-event.js

@@ -1,5 +1,5 @@
 import "../../chunk-PKUHTIDK.js";
-import ResizeObserver from "@opentiny/vue-renderless/common/deps/ResizeObserver";
+import ResizeObserver from "./ResizeObserver";
 const isServer = typeof window === "undefined";
 const cacheKey = "__resizeListeners__";
 const resizeHandler = (entries) => {