@tarojs/components-advanced 3.6.0-canary.10

package/dist/components/virtual-list/vue/list.d.ts

@@ -0,0 +1,119 @@
+import Preset from '../preset';
+declare const _default: {
+    props: {
+        height: {
+            type: (NumberConstructor | StringConstructor)[];
+            required: boolean;
+        };
+        width: {
+            type: (NumberConstructor | StringConstructor)[];
+            required: boolean;
+        };
+        itemCount: {
+            type: NumberConstructor;
+            required: boolean;
+        };
+        itemData: {
+            type: ArrayConstructor;
+            required: boolean;
+        };
+        itemSize: {
+            type: (NumberConstructor | FunctionConstructor)[];
+            required: boolean;
+        };
+        unlimitedSize: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        position: {
+            type: StringConstructor;
+            default: string;
+        };
+        initialScrollOffset: {
+            type: NumberConstructor;
+            default: number;
+        };
+        innerElementType: {
+            type: StringConstructor;
+            default: string;
+        };
+        direction: {
+            type: StringConstructor;
+            default: string;
+        };
+        layout: {
+            type: StringConstructor;
+            default: string;
+        };
+        overscanCount: {
+            type: NumberConstructor;
+            default: number;
+        };
+        placeholderCount: {
+            type: NumberConstructor;
+        };
+        useIsScrolling: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        item: {
+            required: boolean;
+        };
+        itemKey: StringConstructor;
+        itemTagName: {
+            type: StringConstructor;
+            default: string;
+        };
+        innerTagName: {
+            type: StringConstructor;
+            default: string;
+        };
+        outerTagName: {
+            type: StringConstructor;
+            default: string;
+        };
+        itemElementType: StringConstructor;
+        outerElementType: StringConstructor;
+        innerRef: StringConstructor;
+        outerRef: StringConstructor;
+        onItemsRendered: FunctionConstructor;
+        onScrollNative: FunctionConstructor;
+        shouldResetStyleCacheOnItemSizeChange: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    };
+    data(): {
+        itemList: import("../list-set").default;
+        preset: Preset;
+        id: any;
+        instance: any;
+        isScrolling: boolean;
+        scrollDirection: string;
+        scrollOffset: any;
+        scrollUpdateWasRequested: boolean;
+        resetIsScrollingTimeoutId: any;
+    };
+    methods: {
+        refresh(): void;
+        scrollTo(scrollOffset: any): void;
+        scrollToItem(index: any, align?: string): void;
+        _callOnItemsRendered: import("memoize-one").MemoizedFn<(this: any, overscanStartIndex: any, overscanStopIndex: any, visibleStartIndex: any, visibleStopIndex: any) => any>;
+        _callOnScroll: import("memoize-one").MemoizedFn<(this: any, scrollDirection: any, scrollOffset: any, scrollUpdateWasRequested: any) => void>;
+        _callPropsCallbacks(): void;
+        _getSizeUploadSync(index: number, isHorizontal: boolean): Promise<unknown>;
+        _getRangeToRender(): any;
+        _onScrollHorizontal(event: any): void;
+        _onScrollVertical(event: any): void;
+        _outerRefSetter(ref: any): void;
+        _resetIsScrollingDebounced(): void;
+        _resetIsScrolling(): void;
+    };
+    mounted(): void;
+    updated(): void;
+    beforeDestroy(): void;
+    render(): import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>;
+};
+export default _default;

package/dist/components/virtual-list/vue/list.js

@@ -0,0 +1,463 @@
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import memoizeOne from 'memoize-one';
+import { nextTick, renderSlot } from 'vue';
+import { IS_VUE3, IS_WEB } from '../../../utils/constants';
+import { convertNumber2PX } from '../../../utils/convert';
+import { omit } from '../../../utils/lodash';
+import { cancelTimeout, requestTimeout } from '../../../utils/timer';
+import { IS_SCROLLING_DEBOUNCE_INTERVAL } from '../constants';
+import { getRTLOffsetType } from '../dom-helpers';
+import Preset from '../preset';
+import { defaultItemKey, getRectSize } from '../utils';
+import _render from './render';
+export default {
+  props: {
+    height: {
+      type: [String, Number],
+      required: true
+    },
+    width: {
+      type: [String, Number],
+      required: true
+    },
+    itemCount: {
+      type: Number,
+      required: true
+    },
+    itemData: {
+      type: Array,
+      required: true
+    },
+    itemSize: {
+      type: [Number, Function],
+      required: true
+    },
+    unlimitedSize: {
+      type: Boolean,
+      default: false
+    },
+    position: {
+      type: String,
+      default: 'absolute'
+    },
+    initialScrollOffset: {
+      type: Number,
+      default: 0
+    },
+    innerElementType: {
+      type: String,
+      default: IS_WEB ? 'taro-view-core' : 'view'
+    },
+    direction: {
+      type: String,
+      default: 'ltr'
+    },
+    layout: {
+      type: String,
+      default: 'vertical'
+    },
+    overscanCount: {
+      type: Number,
+      default: 1
+    },
+    placeholderCount: {
+      type: Number
+    },
+    useIsScrolling: {
+      type: Boolean,
+      default: false
+    },
+    item: {
+      required: true
+    },
+    itemKey: String,
+    itemTagName: {
+      type: String,
+      default: IS_WEB ? 'taro-view-core' : 'view'
+    },
+    innerTagName: {
+      type: String,
+      default: IS_WEB ? 'taro-view-core' : 'view'
+    },
+    outerTagName: {
+      type: String,
+      default: IS_WEB ? 'taro-scroll-view-core' : 'scroll-view'
+    },
+    itemElementType: String,
+    outerElementType: String,
+    innerRef: String,
+    outerRef: String,
+    onItemsRendered: Function,
+    onScrollNative: Function,
+    shouldResetStyleCacheOnItemSizeChange: {
+      type: Boolean,
+      default: true
+    }
+  },
+  data: function data() {
+    var preset = new Preset(this.$props, this.refresh);
+    return {
+      itemList: preset.itemList,
+      preset: preset,
+      id: this.$props.id || preset.id,
+      instance: this,
+      isScrolling: false,
+      scrollDirection: 'forward',
+      scrollOffset: typeof this.$props.initialScrollOffset === 'number' ? this.$props.initialScrollOffset : 0,
+      scrollUpdateWasRequested: false,
+      resetIsScrollingTimeoutId: null
+    };
+  },
+  methods: {
+    refresh: function refresh() {
+      this.$forceUpdate();
+    },
+    scrollTo: function scrollTo(scrollOffset) {
+      scrollOffset = Math.max(0, scrollOffset);
+      if (this.scrollOffset === scrollOffset) {
+        return;
+      }
+      this.scrollDirection = this.scrollOffset < scrollOffset ? 'forward' : 'backward';
+      this.scrollOffset = scrollOffset;
+      this.scrollUpdateWasRequested = true;
+      nextTick(this._resetIsScrollingDebounced);
+    },
+    scrollToItem: function scrollToItem(index) {
+      var align = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'auto';
+      var itemCount = this.$props.itemCount;
+      var scrollOffset = this.$data.scrollOffset;
+      index = Math.max(0, Math.min(index, itemCount - 1));
+      this.scrollTo(this.itemList.getOffsetForIndexAndAlignment(this.$props, index, align, scrollOffset));
+    },
+    _callOnItemsRendered: memoizeOne(function (overscanStartIndex, overscanStopIndex, visibleStartIndex, visibleStopIndex) {
+      return this.$props.onItemsRendered({
+        overscanStartIndex: overscanStartIndex,
+        overscanStopIndex: overscanStopIndex,
+        visibleStartIndex: visibleStartIndex,
+        visibleStopIndex: visibleStopIndex
+      });
+    }),
+    _callOnScroll: memoizeOne(function (scrollDirection, scrollOffset, scrollUpdateWasRequested) {
+      this.$emit('scroll', {
+        scrollDirection: scrollDirection,
+        scrollOffset: scrollOffset,
+        scrollUpdateWasRequested: scrollUpdateWasRequested
+      });
+    }),
+    _callPropsCallbacks: function _callPropsCallbacks() {
+      var _this = this;
+      if (typeof this.$props.onItemsRendered === 'function') {
+        var itemCount = this.$props.itemCount;
+        if (itemCount > 0) {
+          var _this$_getRangeToRend = this._getRangeToRender(),
+            _this$_getRangeToRend2 = _slicedToArray(_this$_getRangeToRend, 4),
+            overscanStartIndex = _this$_getRangeToRend2[0],
+            overscanStopIndex = _this$_getRangeToRend2[1],
+            visibleStartIndex = _this$_getRangeToRend2[2],
+            visibleStopIndex = _this$_getRangeToRend2[3];
+          this._callOnItemsRendered(overscanStartIndex, overscanStopIndex, visibleStartIndex, visibleStopIndex);
+        }
+      }
+      this._callOnScroll(this.scrollDirection, this.scrollOffset, this.scrollUpdateWasRequested);
+      setTimeout(function () {
+        var _this$_getRangeToRend3 = _this._getRangeToRender(),
+          _this$_getRangeToRend4 = _slicedToArray(_this$_getRangeToRend3, 2),
+          startIndex = _this$_getRangeToRend4[0],
+          stopIndex = _this$_getRangeToRend4[1];
+        var isHorizontal = _this.preset.isHorizontal;
+        for (var index = startIndex; index <= stopIndex; index++) {
+          _this._getSizeUploadSync(index, isHorizontal);
+        }
+      }, 0);
+    },
+    _getSizeUploadSync: function _getSizeUploadSync(index, isHorizontal) {
+      var _this2 = this;
+      var ID = "#".concat(this.$data.id, "-").concat(index);
+      return new Promise(function (resolve) {
+        var success = function success(_ref) {
+          var width = _ref.width,
+            height = _ref.height;
+          var size = isHorizontal ? width : height;
+          if (!_this2.itemList.compareSize(index, size)) {
+            _this2.itemList.setSize(index, size);
+            resolve(_this2.itemList.getSize(index));
+          }
+        };
+        var fail = function fail() {
+          var _this2$_getRangeToRen = _this2._getRangeToRender(),
+            _this2$_getRangeToRen2 = _slicedToArray(_this2$_getRangeToRen, 2),
+            startIndex = _this2$_getRangeToRen2[0],
+            stopIndex = _this2$_getRangeToRen2[1];
+          if (index >= startIndex && index <= stopIndex) {
+            setTimeout(function () {
+              getRectSize(ID, success, fail);
+            }, 100);
+          }
+        };
+        getRectSize(ID, success, fail);
+      });
+    },
+    _getRangeToRender: function _getRangeToRender() {
+      return this.itemList.getRangeToRender(this.$data.scrollDirection, this.$data.scrollOffset, this.$data.isScrolling);
+    },
+    _onScrollHorizontal: function _onScrollHorizontal(event) {
+      var clientWidth = this.$props.width;
+      var _event$currentTarget = event.currentTarget,
+        scrollLeft = _event$currentTarget.scrollLeft,
+        scrollWidth = _event$currentTarget.scrollWidth;
+      if (this.$props.onScrollNative) {
+        this.$props.onScrollNative(event);
+      }
+      if (this.scrollOffset === scrollLeft) {
+        return;
+      }
+      var scrollOffset = scrollLeft;
+      if (this.preset.isRtl) {
+        // TRICKY According to the spec, scrollLeft should be negative for RTL aligned elements.
+        // This is not the case for all browsers though (e.g. Chrome reports values as positive, measured relative to the left).
+        // It's also easier for this component if we convert offsets to the same format as they would be in for ltr.
+        // So the simplest solution is to determine which browser behavior we're dealing with, and convert based on it.
+        switch (getRTLOffsetType()) {
+          case 'negative':
+            scrollOffset = -scrollLeft;
+            break;
+          case 'positive-descending':
+            scrollOffset = scrollWidth - clientWidth - scrollLeft;
+            break;
+        }
+      }
+
+      // Prevent Safari's elastic scrolling from causing visual shaking when scrolling past bounds.
+      scrollOffset = Math.max(0, Math.min(scrollOffset, scrollWidth - clientWidth));
+      this.isScrolling = true;
+      this.scrollDirection = this.scrollOffset < scrollLeft ? 'forward' : 'backward';
+      this.scrollOffset = scrollOffset;
+      this.scrollUpdateWasRequested = false;
+      nextTick(this._resetIsScrollingDebounced);
+    },
+    _onScrollVertical: function _onScrollVertical(event) {
+      var clientHeight = this.$props.height;
+      var _event$currentTarget2 = event.currentTarget,
+        scrollHeight = _event$currentTarget2.scrollHeight,
+        scrollTop = _event$currentTarget2.scrollTop;
+      if (this.$props.onScrollNative) {
+        this.$props.onScrollNative(event);
+      }
+      if (this.scrollOffset === scrollTop) {
+        return;
+      }
+
+      // Prevent Safari's elastic scrolling from causing visual shaking when scrolling past bounds.
+      var scrollOffset = Math.max(0, Math.min(scrollTop, scrollHeight - clientHeight));
+      this.isScrolling = true;
+      this.scrollDirection = this.scrollOffset < scrollOffset ? 'forward' : 'backward';
+      this.scrollOffset = scrollOffset;
+      this.scrollUpdateWasRequested = false;
+      nextTick(this._resetIsScrollingDebounced);
+    },
+    _outerRefSetter: function _outerRefSetter(ref) {
+      var outerRef = this.$props.outerRef;
+      this._outerRef = ref;
+      if (typeof outerRef === 'function') {
+        outerRef(ref);
+      } else if (outerRef != null && _typeof(outerRef) === 'object' && outerRef.hasOwnProperty('value')) {
+        outerRef.value = ref;
+      }
+    },
+    _resetIsScrollingDebounced: function _resetIsScrollingDebounced() {
+      if (this.resetIsScrollingTimeoutId !== null) {
+        cancelTimeout(this.resetIsScrollingTimeoutId);
+      }
+      this.resetIsScrollingTimeoutId = requestTimeout(this._resetIsScrolling, IS_SCROLLING_DEBOUNCE_INTERVAL);
+    },
+    _resetIsScrolling: function _resetIsScrolling() {
+      var _this3 = this;
+      this.resetIsScrollingTimeoutId = null;
+      this.isScrolling = false;
+      nextTick(function () {
+        _this3.preset.getItemStyleCache(-1, null);
+      });
+    }
+  },
+  mounted: function mounted() {
+    var initialScrollOffset = this.$props.initialScrollOffset;
+    if (typeof initialScrollOffset === 'number' && this._outerRef != null) {
+      var outerRef = this._outerRef;
+      if (this.preset.isHorizontal) {
+        outerRef.scrollLeft = initialScrollOffset;
+      } else {
+        outerRef.scrollTop = initialScrollOffset;
+      }
+    }
+    this._callPropsCallbacks();
+  },
+  updated: function updated() {
+    this.preset.update(this.$props);
+    var _this$$data = this.$data,
+      scrollOffset = _this$$data.scrollOffset,
+      scrollUpdateWasRequested = _this$$data.scrollUpdateWasRequested;
+    if (scrollUpdateWasRequested && this._outerRef != null) {
+      var outerRef = this._outerRef;
+      if (this.preset.isHorizontal) {
+        if (this.preset.isRtl) {
+          // TRICKY According to the spec, scrollLeft should be negative for RTL aligned elements.
+          // This is not the case for all browsers though (e.g. Chrome reports values as positive, measured relative to the left).
+          // So we need to determine which browser behavior we're dealing with, and mimic it.
+          switch (getRTLOffsetType()) {
+            case 'negative':
+              outerRef.scrollLeft = -scrollOffset;
+              break;
+            case 'positive-ascending':
+              outerRef.scrollLeft = scrollOffset;
+              break;
+            default:
+              {
+                var clientWidth = outerRef.clientWidth,
+                  scrollWidth = outerRef.scrollWidth;
+                outerRef.scrollLeft = scrollWidth - clientWidth - scrollOffset;
+                break;
+              }
+          }
+        } else {
+          outerRef.scrollLeft = scrollOffset;
+        }
+      } else {
+        outerRef.scrollTop = scrollOffset;
+      }
+    }
+    this._callPropsCallbacks();
+  },
+  beforeDestroy: function beforeDestroy() {
+    if (this.resetIsScrollingTimeoutId !== null) {
+      cancelTimeout(this.resetIsScrollingTimeoutId);
+    }
+  },
+  render: function render() {
+    var _this4 = this;
+    var _omit = omit(this.$props, ['innerElementType', 'innerTagName', 'itemElementType', 'itemTagName', 'outerElementType', 'outerTagName', 'position']),
+      item = _omit.item,
+      direction = _omit.direction,
+      height = _omit.height,
+      innerRef = _omit.innerRef,
+      itemCount = _omit.itemCount,
+      itemData = _omit.itemData,
+      _omit$itemKey = _omit.itemKey,
+      itemKey = _omit$itemKey === void 0 ? defaultItemKey : _omit$itemKey,
+      layout = _omit.layout,
+      useIsScrolling = _omit.useIsScrolling,
+      width = _omit.width;
+    var _this$$data2 = this.$data,
+      id = _this$$data2.id,
+      isScrolling = _this$$data2.isScrolling,
+      scrollOffset = _this$$data2.scrollOffset,
+      scrollUpdateWasRequested = _this$$data2.scrollUpdateWasRequested;
+    var isHorizontal = this.preset.isHorizontal;
+    var placeholderCount = this.preset.placeholderCount;
+    var onScroll = isHorizontal ? this._onScrollHorizontal : this._onScrollVertical;
+    var _this$_getRangeToRend5 = this._getRangeToRender(),
+      _this$_getRangeToRend6 = _slicedToArray(_this$_getRangeToRend5, 2),
+      startIndex = _this$_getRangeToRend6[0],
+      stopIndex = _this$_getRangeToRend6[1];
+    var items = [];
+    if (itemCount > 0) {
+      var prevPlaceholder = startIndex < placeholderCount ? startIndex : placeholderCount;
+      items.push(new Array(prevPlaceholder).fill(-1).map(function (_, index) {
+        return _render(_this4.preset.itemTagName, {
+          key: itemKey(index + startIndex - prevPlaceholder, itemData),
+          style: {
+            display: 'none'
+          }
+        });
+      }));
+      for (var index = startIndex; index <= stopIndex; index++) {
+        var style = this.preset.getItemStyle(index);
+        items.push(_render(this.preset.itemTagName, {
+          key: itemKey(index, itemData),
+          style: style
+        }, [_render(item, {
+          id: "".concat(id, "-").concat(index),
+          props: {
+            id: "".concat(id, "-").concat(index),
+            data: itemData,
+            index: index,
+            isScrolling: useIsScrolling ? isScrolling : undefined
+          }
+        })]));
+      }
+      var restCount = itemCount - stopIndex;
+      var postPlaceholder = restCount < placeholderCount ? restCount : placeholderCount;
+      items.push(new Array(postPlaceholder).fill(-1).map(function (_, index) {
+        return _render(_this4.preset.itemTagName, {
+          key: itemKey(1 + index + stopIndex, itemData),
+          style: {
+            display: 'none'
+          }
+        });
+      }));
+    }
+
+    // Read this value AFTER items have been created,
+    // So their actual sizes (if variable) are taken into consideration.
+    var estimatedTotalSize = convertNumber2PX(this.itemList.getOffsetSize());
+    var outerElementProps = {
+      id: id,
+      ref: this._outerRefSetter,
+      layout: layout,
+      style: {
+        position: 'relative',
+        height: convertNumber2PX(height),
+        width: convertNumber2PX(width),
+        overflow: 'auto',
+        WebkitOverflowScrolling: 'touch',
+        willChange: 'transform',
+        direction: direction
+      },
+      attrs: {
+        scrollY: layout === 'vertical',
+        scrollX: layout === 'horizontal'
+      },
+      on: {
+        scroll: onScroll
+      }
+    };
+    if (scrollUpdateWasRequested) {
+      if (isHorizontal) {
+        outerElementProps.scrollLeft = scrollOffset;
+      } else {
+        outerElementProps.scrollTop = scrollOffset;
+      }
+    }
+    if (this.preset.isRelative) {
+      var pre = convertNumber2PX(this.itemList.getOffsetSize(startIndex));
+      return _render(this.preset.outerTagName, outerElementProps, [IS_VUE3 ? renderSlot(this.$slots, 'top') : this.$slots.top, _render(this.preset.itemTagName, {
+        key: "".concat(id, "-pre"),
+        id: "".concat(id, "-pre"),
+        style: {
+          height: isHorizontal ? '100%' : pre,
+          width: !isHorizontal ? '100%' : pre
+        }
+      }), _render(this.preset.innerTagName, {
+        ref: innerRef,
+        key: "".concat(id, "-inner"),
+        id: "".concat(id, "-inner"),
+        style: {
+          pointerEvents: isScrolling ? 'none' : 'auto',
+          position: 'relative'
+        }
+      }, items), IS_VUE3 ? renderSlot(this.$slots, 'bottom') : this.$slots.bottom]);
+    } else {
+      return _render(this.preset.outerTagName, outerElementProps, [IS_VUE3 ? renderSlot(this.$slots, 'top') : this.$slots.top, _render(this.preset.innerTagName, {
+        ref: innerRef,
+        key: "".concat(id, "-inner"),
+        id: "".concat(id, "-inner"),
+        style: {
+          height: isHorizontal ? '100%' : estimatedTotalSize,
+          pointerEvents: isScrolling ? 'none' : 'auto',
+          position: 'relative',
+          width: !isHorizontal ? '100%' : estimatedTotalSize
+        }
+      }, items), IS_VUE3 ? renderSlot(this.$slots, 'bottom') : this.$slots.bottom]);
+    }
+  }
+};

package/dist/components/virtual-list/vue/render.d.ts

@@ -0,0 +1,3 @@
+export default function (componentName: string, options?: Record<string, any>, children?: any): import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>;

package/dist/components/virtual-list/vue/render.js

@@ -0,0 +1,25 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+var _excluded = ["attrs", "on", "props", "slots"];
+import { h } from 'vue';
+import { IS_VUE3 } from '../../../utils/constants';
+export default function (componentName, options, children) {
+  var _options$attrs = options.attrs,
+    attrs = _options$attrs === void 0 ? {} : _options$attrs,
+    _options$on = options.on,
+    on = _options$on === void 0 ? {} : _options$on,
+    _options$props = options.props,
+    props = _options$props === void 0 ? {} : _options$props,
+    _options$slots = options.slots,
+    slots = _options$slots === void 0 ? {} : _options$slots,
+    el = _objectWithoutProperties(options, _excluded);
+  if (IS_VUE3) {
+    // Events
+    Object.keys(on).forEach(function (key) {
+      var name = "on".concat(key.charAt(0).toUpperCase()).concat(key.slice(1));
+      el[name] = on[key];
+    });
+    return h(componentName, _objectSpread(_objectSpread(_objectSpread(_objectSpread({}, attrs), props), slots), el), children);
+  }
+  return h(componentName, options, children);
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './components';
+export * from './utils';

package/dist/index.js

@@ -0,0 +1,2 @@
+export * from './components';
+export * from './utils';

package/dist/utils/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const IS_PROD: boolean;
+export declare const IS_WEB: boolean;
+export declare const IS_PREACT: boolean;
+export declare const IS_VUE3: boolean;

package/dist/utils/constants.js

@@ -0,0 +1,4 @@
+export var IS_PROD = process.env.NODE_ENV === 'production';
+export var IS_WEB = process.env.TARO_ENV === 'h5';
+export var IS_PREACT = process.env.FRAMEWORK === 'preact';
+export var IS_VUE3 = process.env.FRAMEWORK === 'vue3';

package/dist/utils/convert.d.ts

@@ -0,0 +1,5 @@
+/** 将距离值根据单位转换为 Number 类型
+ * TODO: 未来可以考虑支持更多单位
+ */
+export declare function convertPX2Int(distance: string | number): string | number;
+export declare function convertNumber2PX(styleValue: unknown): unknown;

package/dist/utils/convert.js

@@ -0,0 +1,16 @@
+/** 将距离值根据单位转换为 Number 类型
+ * TODO: 未来可以考虑支持更多单位
+ */
+export function convertPX2Int(distance) {
+  if (typeof distance === 'string') {
+    var str = distance.toLowerCase();
+    if (/px$/.test(str)) {
+      return Number(str.replace(/px$/, ''));
+    }
+  }
+  return distance;
+}
+export function convertNumber2PX(styleValue) {
+  if (!styleValue && styleValue !== 0) return '';
+  return typeof styleValue === 'number' ? styleValue + 'px' : styleValue;
+}

package/dist/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from './convert';
+export * from './timer';

package/dist/utils/index.js

@@ -0,0 +1,2 @@
+export * from './convert';
+export * from './timer';

package/dist/utils/lodash.d.ts

@@ -0,0 +1 @@
+export declare function omit<T extends Record<string, unknown> = Record<string, any>, P extends string = ''>(obj?: T, fields?: P[]): Omit<T, P>;

package/dist/utils/lodash.js

@@ -0,0 +1,10 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+export function omit() {
+  var obj = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var fields = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  var shallow = _objectSpread({}, obj);
+  fields.forEach(function (key) {
+    delete shallow[key];
+  });
+  return shallow;
+}

package/dist/utils/timer.d.ts

@@ -0,0 +1,6 @@
+interface ITimeoutID {
+    id: number;
+}
+export declare function cancelTimeout(timeoutID: ITimeoutID): void;
+export declare function requestTimeout(callback: () => void, delay?: number): ITimeoutID;
+export {};