@arco-design/mobile-react 2.19.0

package/umd/show-monitor/index.js

@@ -0,0 +1,434 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "react", "lodash.throttle", "@arco-design/mobile-utils", "../context-provider"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("react"), require("lodash.throttle"), require("@arco-design/mobile-utils"), require("../context-provider"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.react, global.lodash, global.mobileUtils, global.contextProvider);
+    global.index = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _react, _lodash, _mobileUtils, _contextProvider) {
+  "use strict";
+
+  var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+  _exports.__esModule = true;
+  _exports.default = void 0;
+  _react = _interopRequireWildcard(_react);
+  _lodash = _interopRequireDefault(_lodash);
+
+  function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+  function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+  var LISTEN_FLAG = 'data-show-listened';
+  /**
+   * 父 dom 节点集合
+   * @en Parent dom node collection
+   */
+
+  var wrapperNodeList = [];
+  /**
+   * 同一父节点下监听队列
+   * @en Listening queue under the same parent node
+   */
+
+  var listeners = {};
+  var onOnceEmittedListeners = {};
+  var throttlingVisibleChange;
+  /**
+   * 通过滚动事件监测 children 是否进入视口或离开视口。
+   * @en Use scroll events to monitor whether children enter or leave the viewport.
+   * @type 其他
+   * @type_en Others
+   * @name 滚动视口监听
+   * @name_en ShowMonitor
+   */
+
+  var ShowMonitor = /*#__PURE__*/(0, _react.forwardRef)(function (props, ref) {
+    var className = props.className,
+        style = props.style,
+        getScrollContainer = props.getScrollContainer,
+        _props$throttle = props.throttle,
+        throttle = _props$throttle === void 0 ? 300 : _props$throttle,
+        _props$listenResize = props.listenResize,
+        listenResize = _props$listenResize === void 0 ? true : _props$listenResize,
+        _props$listenScroll = props.listenScroll,
+        listenScroll = _props$listenScroll === void 0 ? true : _props$listenScroll,
+        _props$overflow = props.overflow,
+        overflow = _props$overflow === void 0 ? false : _props$overflow,
+        _props$offset = props.offset,
+        offset = _props$offset === void 0 ? 0 : _props$offset,
+        _props$threshold = props.threshold,
+        threshold = _props$threshold === void 0 ? 0 : _props$threshold,
+        _props$once = props.once,
+        once = _props$once === void 0 ? false : _props$once,
+        _props$children = props.children,
+        children = _props$children === void 0 ? null : _props$children,
+        _props$disabled = props.disabled,
+        disabled = _props$disabled === void 0 ? false : _props$disabled,
+        onVisibleChange = props.onVisibleChange,
+        onClick = props.onClick;
+    var domRef = (0, _react.useRef)(null);
+    /**
+     * 滚动容器父级元素
+     * @en Scroll container parent element
+     */
+
+    var scrollPort = (0, _react.useRef)(null);
+    /**
+     * 局部滚动元素父节点
+     * @en Parent node of the local scroll element
+     */
+
+    var domRefParent = (0, _react.useRef)(null);
+    /**
+     * 当前元素是否在可视区域内
+     * @en Whether the current element is in the visible area
+     */
+
+    var isVisible = (0, _react.useRef)(false);
+    /**
+     * 保存当前节点信息，类似于 class component 中 this
+     * @en Save current node information, similar to this in class component
+     */
+
+    var listener = (0, _react.useRef)(null);
+    /**
+     * Intersection Observer 实例化对象
+     * @en Instantiated object of Intersection Observer
+     */
+
+    var io = (0, _react.useRef)(null);
+    /**
+     * 父容器唯一 key（wrapperNodeList index）
+     * @en The unique key of the parent container (wrapperNodeList index)
+     */
+
+    var wrapperKey = (0, _react.useRef)(-1);
+    var isChildrenExist = (0, _react.useRef)(Boolean(children));
+    var isSupportNativeApi = (0, _react.useMemo)(function () {
+      return typeof IntersectionObserver === 'function';
+    }, []); // 是否支持 Intersection Observer
+
+    (0, _react.useImperativeHandle)(ref, function () {
+      return {
+        dom: domRef.current,
+
+        /**
+         * 提供检查元素是否可见的api
+         * @en Provides an api to check whether the element is visible
+         */
+        checkVisible: function checkVisible() {
+          return _checkVisible({
+            node: domRef.current,
+            overflow: overflow,
+            onVisibleChange: onVisibleChange,
+            offset: offset,
+            threshold: threshold
+          }, true);
+        }
+      };
+    });
+
+    function _checkVisible(component, ignoreCheckPreVisibleStatus) {
+      if (ignoreCheckPreVisibleStatus === void 0) {
+        ignoreCheckPreVisibleStatus = false;
+      }
+
+      var node = component.node,
+          compOverflow = component.overflow,
+          compOnce = component.once,
+          onCompVisibleChange = component.onVisibleChange,
+          preVisible = component.isVisible;
+
+      if (!(node instanceof HTMLElement)) {
+        return;
+      }
+
+      var parent = (0, _mobileUtils.scrollParent)(node);
+      /**
+       * 当前元素为非 document 元素，即为局部滚动
+       * @en If the current element is a non-document element, it's local scrolling
+       */
+
+      var isOverflow = compOverflow && [node.ownerDocument, document, document.documentElement].indexOf(parent) === -1;
+      /**
+       * 检查元素是否可见
+       * @en Check if element is visible
+       */
+
+      var curVisible = isOverflow ? (0, _mobileUtils.checkOverflowVisible)(component, parent) : (0, _mobileUtils.checkNormalVisible)(component);
+      /**
+       * 忽略前后可见状态判断
+       * @en Ignore the visible state judgment before and after
+       */
+
+      if (ignoreCheckPreVisibleStatus) {
+        return curVisible;
+      }
+      /**
+       * 当前元素 visible 对比之前发生改变，触发回调函数
+       * @en The current element visible is changed before the comparison, and the callback function is triggered
+       */
+
+
+      curVisible !== preVisible.current && handleCheckChildrenExist() && onCompVisibleChange(curVisible, node);
+      var key = wrapperKey.current;
+      /**
+       * 监听一次后加入 pendingList 队列，随后被 listeners 过滤掉
+       * @en After listening once, it is added to the pendingList queue, and then filtered out by listeners
+       */
+
+      if (!onOnceEmittedListeners[key]) {
+        onOnceEmittedListeners[key] = [];
+      }
+      /**
+       * 当前元素不可见 -> 可见，且 once, 触发回调函数
+       * @en The current element is invisible -> visible, and once, triggers the callback function
+       */
+
+
+      curVisible && !preVisible.current && compOnce && onOnceEmittedListeners[key].push(component);
+      preVisible.current = curVisible;
+    }
+
+    var checkVisibleHandler = (0, _react.useCallback)(function () {
+      var key = wrapperKey.current;
+      var curListeners = listeners[key] || [];
+      curListeners.forEach(function (listen) {
+        return _checkVisible(listen);
+      });
+      listeners[key] = curListeners.filter(function (item) {
+        return onOnceEmittedListeners[key].indexOf(item) === -1;
+      });
+      onOnceEmittedListeners[key] = [];
+    }, []);
+
+    function handleCheckChildrenExist() {
+      return isChildrenExist.current && domRef.current && domRef.current.children.length;
+    }
+
+    function handleObserverStatusChange(entries) {
+      var _io$current;
+
+      var isIntersecting = entries[0].isIntersecting;
+      /**
+       * 当前元素 visible 对比之前发生改变，触发回调函数
+       * @en Callback when the visible status of current element changes before the comparison
+       */
+
+      isIntersecting !== isVisible.current && handleCheckChildrenExist() && onVisibleChange(isIntersecting, domRef.current);
+      /**
+       * 当前元素不可见 -> 可见，且 once, 触发回调函数
+       * @en The current element is invisible -> visible, and once, triggers the callback
+       */
+
+      isIntersecting && !isVisible.current && once && domRef.current && ((_io$current = io.current) == null ? void 0 : _io$current.unobserve(domRef.current));
+      isVisible.current = isIntersecting;
+    }
+    /**
+     * 非首次下disabled变化时，重新监听元素
+     * @en Re-listen to the element when it is not the first time that the disabled status changes,
+     */
+
+
+    (0, _react.useEffect)(function () {
+      if (isSupportNativeApi) {
+        // 非首次下
+        // @en Not for the first time
+        if (io.current && domRef.current) {
+          // 禁用监听 || 监听
+          disabled ? io.current.unobserve(domRef.current) : io.current.observe(domRef.current);
+        }
+      } else {
+        // 非首次下
+        // @en Not for the first time
+        if (wrapperKey.current !== -1 && listener.current && listeners[wrapperKey.current]) {
+          // 禁用监听，找到对应listener并删除
+          // @en Disable listening, find the corresponding listener and delete it
+          if (disabled) {
+            var isExist = listeners[wrapperKey.current].findIndex(function (item) {
+              return item.node === domRef.current;
+            });
+
+            if (isExist !== -1) {
+              listeners[wrapperKey.current].splice(0, 1);
+            }
+          } else {
+            // 开启监听
+            // @en Start to listen
+            listeners[wrapperKey.current].push(listener.current);
+          }
+        }
+      }
+    }, [disabled]);
+    (0, _react.useEffect)(function () {
+      isChildrenExist.current = Boolean(children);
+    }, [children]);
+    (0, _react.useEffect)(function () {
+      scrollPort.current = getScrollContainer ? getScrollContainer() : window;
+      if (!scrollPort.current) return;
+      var wrapperNodeIndex = wrapperNodeList.indexOf(scrollPort.current);
+
+      if (wrapperNodeIndex === -1) {
+        // 当前滚动视口元素不在 wrapperNodeList 中, 入队列
+        // @en The current scroll viewport element is not in the wrapperNodeList, push it into the list
+        wrapperNodeList.push(scrollPort.current);
+        wrapperKey.current = wrapperNodeList.length - 1;
+      } else {
+        // 取当前 index 作为 key
+        // @en Take the current index as the key
+        wrapperKey.current = wrapperNodeIndex;
+      }
+
+      var curWrapperKey = wrapperKey.current;
+
+      if (isSupportNativeApi) {
+        if (domRef.current) {
+          domRefParent.current = (0, _mobileUtils.scrollParent)(domRef.current);
+          var parent = domRefParent.current;
+          var isHTMLElement = [domRef.current.ownerDocument, document, document.documentElement].indexOf(parent) === -1;
+          var overflowRoot = isHTMLElement ? parent : null;
+          var root = overflow ? overflowRoot : scrollPort.current === window ? null : scrollPort.current;
+          var rootMargin = '';
+
+          if (Array.isArray(offset)) {
+            if (offset.length === 2) {
+              rootMargin = offset[0] + "px 0px " + offset[1] + "px";
+            } else {
+              offset.forEach(function (val, index) {
+                var space = index === 0 ? '' : ' ';
+                rootMargin += "" + space + val + "px";
+              });
+            }
+          } else {
+            rootMargin = offset + "px";
+          }
+
+          io.current = new IntersectionObserver(handleObserverStatusChange, {
+            root: root,
+            rootMargin: rootMargin,
+            threshold: threshold
+          });
+          !disabled && io.current.observe(domRef.current);
+        }
+      } else {
+        // 节流后回调函数
+        // @en Callback after throttling
+        throttlingVisibleChange = checkVisibleHandler;
+        throttle && (throttlingVisibleChange = (0, _lodash.default)(throttlingVisibleChange, throttle));
+
+        if (overflow) {
+          if (domRef.current) {
+            domRefParent.current = (0, _mobileUtils.scrollParent)(domRef.current);
+            var _parent = domRefParent.current;
+
+            if (_parent && _parent instanceof HTMLElement && typeof _parent.getAttribute === 'function') {
+              var listenerCount = 1 + Number(_parent.getAttribute(LISTEN_FLAG));
+
+              if (!listeners[curWrapperKey]) {
+                listeners[curWrapperKey] = [];
+              }
+
+              if (listenerCount === 1) {
+                // listener 数量为1时监听事件（列表中插入 ShowMonitor 时做判断）
+                // @en Listen when the number of listeners is 1 (judging when ShowMonitor is inserted into the list)
+                _parent.addEventListener('scroll', throttlingVisibleChange);
+              }
+
+              _parent.setAttribute(LISTEN_FLAG, String(listenerCount));
+            }
+          }
+        } else if (!listeners[curWrapperKey] || listeners[curWrapperKey].length === 0 || // 相同curWrapperKey内全部为overflow场景，需要单独注册scroll事件
+        // @en It need to register the scroll event separately when all values in the same curWrapperKey are overflow
+        listeners[curWrapperKey] && listeners[curWrapperKey].every(function (it) {
+          return it.overflow;
+        })) {
+          if (!listeners[curWrapperKey]) {
+            listeners[curWrapperKey] = [];
+          }
+
+          listenScroll && scrollPort.current.addEventListener('scroll', throttlingVisibleChange);
+          listenResize && scrollPort.current.addEventListener('resize', throttlingVisibleChange);
+        }
+
+        listener.current = {
+          node: domRef.current,
+          isVisible: isVisible,
+          overflow: overflow,
+          once: once,
+          offset: offset,
+          threshold: threshold,
+          onVisibleChange: onVisibleChange
+        }; // 将当前 listener 存入 listeners
+
+        !disabled && listeners[curWrapperKey].push(listener.current);
+        (0, _mobileUtils.nextTick)(function () {
+          !disabled && _checkVisible(listener.current);
+        });
+      }
+    }, []);
+    (0, _react.useEffect)(function () {
+      return function () {
+        if (isSupportNativeApi) {
+          var _io$current2;
+
+          domRef.current && ((_io$current2 = io.current) == null ? void 0 : _io$current2.unobserve(domRef.current));
+        } else {
+          if (overflow) {
+            var parent = domRefParent.current;
+
+            if (parent && parent instanceof HTMLElement && typeof parent.getAttribute === 'function') {
+              var listenerCount = Number(parent.getAttribute(LISTEN_FLAG) || 0) - 1;
+
+              if (listenerCount === 0) {
+                // 如果监听队列中无节点，解绑事件
+                // @en If there is no node in the listening queue, unbind the event
+                parent.removeEventListener('scroll', throttlingVisibleChange);
+              } else {
+                // 如果监听队列中有元素节点，将 dataset 减1
+                // @en If there are element nodes in the listening queue, decrement dataset by 1
+                parent.setAttribute(LISTEN_FLAG, String(listenerCount));
+              }
+            }
+          }
+
+          var _key = wrapperKey.current;
+          var curListeners = listeners[_key];
+
+          if (curListeners) {
+            // 不在监听队列中，移除
+            // @en Not in the listening queue, remove it
+            var index = curListeners.indexOf(listener.current);
+            index !== -1 && curListeners.splice(index, 1); // 监听队列为空，解绑 scroll、resize 事件
+            // @en When the listening queue is empty, unbind scroll and resize events
+
+            if (curListeners.length === 0) {
+              delete listeners[_key];
+
+              if (scrollPort.current) {
+                scrollPort.current.removeEventListener('scroll', throttlingVisibleChange);
+                scrollPort.current.removeEventListener('resize', throttlingVisibleChange);
+              }
+            }
+          }
+        }
+      };
+    }, []);
+    return /*#__PURE__*/_react.default.createElement(_contextProvider.ContextLayout, null, function (_ref) {
+      var prefixCls = _ref.prefixCls;
+      return /*#__PURE__*/_react.default.createElement("div", {
+        className: (0, _mobileUtils.cls)(prefixCls + "-show-monitor", className),
+        style: style,
+        ref: domRef,
+        onClick: onClick
+      }, children);
+    });
+  });
+  var _default = ShowMonitor;
+  _exports.default = _default;
+});

package/umd/show-monitor/style/css/index.d.ts

@@ -0,0 +1,2 @@
+import '../../../../style/css/public.css';
+import './index.css';

package/umd/show-monitor/style/css/index.js

@@ -0,0 +1,15 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["../../../../style/css/public.css", "./index.css"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(require("../../../../style/css/public.css"), require("./index.css"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(global._public, global.index);
+    global.index = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_public, _index) {
+  "use strict";
+});

package/umd/show-monitor/style/index.d.ts

@@ -0,0 +1,2 @@
+import '../../../style/public.less';
+import './index.less';

package/umd/show-monitor/style/index.js

@@ -0,0 +1,15 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["../../../style/public.less", "./index.less"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(require("../../../style/public.less"), require("./index.less"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(global._public, global.index);
+    global.index = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_public, _index) {
+  "use strict";
+});

package/umd/show-monitor/style/index.less

@@ -0,0 +1 @@
+// 这里啥也没有，但是为了兼容 babel-plugin-import的统一引用，还是需要创建下文件

package/umd/slider/demo/style/css/mobile.css

@@ -0,0 +1,16 @@
+#demo-slider .slider-custom-yellow .arco-slider-line.is-activated {
+  background: #ffb400;
+}
+#demo-slider .slider-custom-thumb-two {
+  padding: 2px 8px;
+  color: white;
+  font-size: 14px;
+  text-align: center;
+  line-height: 20px;
+  background:  #165dff ;
+  box-shadow: 0px 2px 8px rgba(0, 0, 0, 0.1);
+  border-radius: 12px;
+}
+#demo-slider .slider-custom-marks .arco-slider-marks-item-label {
+  white-space: nowrap;
+}

package/umd/slider/demo/style/mobile.less

@@ -0,0 +1,26 @@
+@import '../../../../style/mixin.less';
+
+#demo-slider {
+    .slider-custom {
+        &-yellow {
+            .@{prefix}-slider-line.is-activated {
+                background: #ffb400;
+            }
+        }
+        &-thumb-two {
+            padding: 2px 8px;
+            color: white;
+            font-size: 14px;
+            text-align: center;
+            line-height: 20px;
+            .use-var(background, primary-color);
+            box-shadow: 0px 2px 8px rgba(0, 0, 0, 0.1);
+            border-radius: 12px;
+        }
+        &-marks {
+            .@{prefix}-slider-marks-item-label {
+                white-space: nowrap;
+            }
+        }
+    }
+}

package/umd/slider/hooks/index.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import { SliderProps } from '../';
+export declare const baseRenderThumb: (prefixCls: string) => () => JSX.Element;
+export declare type LinePosition = {
+    length: number;
+    start: number;
+};
+export declare const SliderContext: React.Context<Required<Pick<SliderProps, "max" | "disabled" | "style" | "size" | "step" | "type" | "className" | "onChange" | "min" | "onAfterChange" | "suffixLabel" | "prefixLabel" | "useRange" | "useAnimation" | "showTooltip" | "showMarks" | "useMarkOnly" | "draggableTrackOnly" | "formatTooltip" | "renderThumb">> & Pick<SliderProps, "value" | "defaultValue" | "marks">>;
+export * from './useSliderIcon';
+export * from './useSliderInit';
+export * from './useSliderStyle';
+export * from './useSliderEvents';

package/umd/slider/hooks/index.js

@@ -0,0 +1,89 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "react", "./useSliderIcon", "./useSliderInit", "./useSliderStyle", "./useSliderEvents"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("react"), require("./useSliderIcon"), require("./useSliderInit"), require("./useSliderStyle"), require("./useSliderEvents"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.react, global.useSliderIcon, global.useSliderInit, global.useSliderStyle, global.useSliderEvents);
+    global.index = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _react, _useSliderIcon, _useSliderInit, _useSliderStyle, _useSliderEvents) {
+  "use strict";
+
+  _exports.__esModule = true;
+  var _exportNames = {
+    baseRenderThumb: true,
+    SliderContext: true
+  };
+  _exports.baseRenderThumb = _exports.SliderContext = void 0;
+  _react = _interopRequireWildcard(_react);
+  Object.keys(_useSliderIcon).forEach(function (key) {
+    if (key === "default" || key === "__esModule") return;
+    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+    if (key in _exports && _exports[key] === _useSliderIcon[key]) return;
+    _exports[key] = _useSliderIcon[key];
+  });
+  Object.keys(_useSliderInit).forEach(function (key) {
+    if (key === "default" || key === "__esModule") return;
+    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+    if (key in _exports && _exports[key] === _useSliderInit[key]) return;
+    _exports[key] = _useSliderInit[key];
+  });
+  Object.keys(_useSliderStyle).forEach(function (key) {
+    if (key === "default" || key === "__esModule") return;
+    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+    if (key in _exports && _exports[key] === _useSliderStyle[key]) return;
+    _exports[key] = _useSliderStyle[key];
+  });
+  Object.keys(_useSliderEvents).forEach(function (key) {
+    if (key === "default" || key === "__esModule") return;
+    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+    if (key in _exports && _exports[key] === _useSliderEvents[key]) return;
+    _exports[key] = _useSliderEvents[key];
+  });
+
+  function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+  function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+  var baseRenderThumb = function baseRenderThumb(prefixCls) {
+    return function () {
+      return /*#__PURE__*/_react.default.createElement("div", {
+        className: prefixCls + "-slider-thumb"
+      });
+    };
+  };
+
+  _exports.baseRenderThumb = baseRenderThumb;
+  // 因为子组件和 hooks 较多, 为了代码整洁和可读性，做了拆分。
+  // 参数通过 context 共享
+  // @en Parameters are shared through context
+  var SliderContext = /*#__PURE__*/(0, _react.createContext)({
+    className: '',
+    style: {},
+    disabled: false,
+    useRange: false,
+    useAnimation: true,
+    size: 2,
+    min: 0,
+    max: 100,
+    step: 1,
+    type: 'horizontal',
+    showTooltip: 'auto',
+    useMarkOnly: false,
+    showMarks: false,
+    prefixLabel: false,
+    suffixLabel: false,
+    draggableTrackOnly: false,
+    formatTooltip: function formatTooltip(value) {
+      return String(value);
+    },
+    onChange: function onChange() {},
+    onAfterChange: function onAfterChange() {},
+    renderThumb: baseRenderThumb('')
+  });
+  _exports.SliderContext = SliderContext;
+});

package/umd/slider/hooks/useSliderEvents.d.ts

@@ -0,0 +1,17 @@
+import React, { RefObject } from 'react';
+import { LinePosition } from '.';
+declare enum IsTouchingStatus {
+    Idle = 0,
+    Start = 1,
+    Moving = 2
+}
+export declare const useSliderEvents: ({ getLinePosition, lineRef, valueGroup, setValueGroup, setCommonIsTouching, }: {
+    getLinePosition: () => LinePosition;
+    lineRef: RefObject<HTMLDivElement>;
+    valueGroup: number | number[];
+    setValueGroup: React.Dispatch<React.SetStateAction<number | [number, number]>>;
+    setCommonIsTouching: React.Dispatch<React.SetStateAction<number>>;
+}) => {
+    isTouching: IsTouchingStatus;
+};
+export {};