@1money/component-ui 0.0.1

package/es/components/Table/internal/kernel/selector-context/Immutable.js

@@ -0,0 +1,73 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import * as React from 'react';
+import { supportRef } from '../../../../ResizeObserver/utils/reactUtil';
+/**
+ * Create Immutable pair for `makeImmutable` and `responseImmutable`.
+ */
+export default function createImmutable() {
+  var ImmutableContext = /*#__PURE__*/React.createContext(null);
+  /**
+   * Get render update mark by `makeImmutable` root.
+   */
+  function useImmutableMark() {
+    return React.useContext(ImmutableContext);
+  }
+  /**
+   * Wrapped Component will be marked as Immutable.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  function makeImmutable(Component, shouldTriggerRender) {
+    var refAble = supportRef(Component);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    var ImmutableComponent = function ImmutableComponent(props, ref) {
+      var refProps = refAble ? {
+        ref: ref
+      } : {};
+      var renderTimesRef = React.useRef(0);
+      var prevProps = React.useRef(props);
+      // If parent has the context, we do not wrap it
+      var mark = useImmutableMark();
+      if (mark !== null) {
+        return _jsx(Component, Object.assign({}, props, refProps));
+      }
+      if (!shouldTriggerRender || shouldTriggerRender(prevProps.current, props)) {
+        renderTimesRef.current += 1;
+      }
+      prevProps.current = props;
+      return _jsx(ImmutableContext.Provider, {
+        value: renderTimesRef.current,
+        children: _jsx(Component, Object.assign({}, props, refProps))
+      });
+    };
+    var componentWithMeta = Component;
+    ImmutableComponent.displayName = "ImmutableRoot(".concat(componentWithMeta.displayName || componentWithMeta.name, ")");
+    return refAble ? /*#__PURE__*/React.forwardRef(ImmutableComponent) : ImmutableComponent;
+  }
+  /**
+   * Wrapped Component with `React.memo`.
+   * But will rerender when parent with `makeImmutable` rerender.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  function responseImmutable(Component, propsAreEqual) {
+    var refAble = supportRef(Component);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    var ImmutableComponent = function ImmutableComponent(props, ref) {
+      var refProps = refAble ? {
+        ref: ref
+      } : {};
+      useImmutableMark();
+      return _jsx(Component, Object.assign({}, props, refProps));
+    };
+    var componentWithMeta = Component;
+    ImmutableComponent.displayName = "ImmutableResponse(".concat(componentWithMeta.displayName || componentWithMeta.name, ")");
+    var Wrapped = refAble ? /*#__PURE__*/React.forwardRef(ImmutableComponent) : ImmutableComponent;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return /*#__PURE__*/React.memo(Wrapped, propsAreEqual);
+  }
+  return {
+    makeImmutable: makeImmutable,
+    responseImmutable: responseImmutable,
+    useImmutableMark: useImmutableMark
+  };
+}
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["components/Table/internal/kernel/selector-context/Immutable.js","components/Table/internal/kernel/src/components/Table/internal/kernel/selector-context/Immutable.tsx"],"names":["jsx","_jsx","React","supportRef","createImmutable","ImmutableContext","createContext","useImmutableMark","useContext","makeImmutable","Component","shouldTriggerRender","refAble","ImmutableComponent","props","ref","refProps","renderTimesRef","useRef","prevProps","mark","Object","assign","current","Provider","value","children","componentWithMeta","displayName","concat","name","forwardRef","responseImmutable","propsAreEqual","Wrapped","memo"],"mappings":"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","file":"components/Table/internal/kernel/selector-context/Immutable.js","sourcesContent":["import { jsx as _jsx } from \"react/jsx-runtime\";\nimport * as React from 'react';\nimport { supportRef } from '../../../../ResizeObserver/utils/reactUtil';\n/**\n * Create Immutable pair for `makeImmutable` and `responseImmutable`.\n */\nexport default function createImmutable() {\n    const ImmutableContext = React.createContext(null);\n    /**\n     * Get render update mark by `makeImmutable` root.\n     */\n    function useImmutableMark() {\n        return React.useContext(ImmutableContext);\n    }\n    /**\n     * Wrapped Component will be marked as Immutable.\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    function makeImmutable(Component, shouldTriggerRender) {\n        const refAble = supportRef(Component);\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        const ImmutableComponent = (props, ref) => {\n            const refProps = refAble ? { ref } : {};\n            const renderTimesRef = React.useRef(0);\n            const prevProps = React.useRef(props);\n            // If parent has the context, we do not wrap it\n            const mark = useImmutableMark();\n            if (mark !== null) {\n                return _jsx(Component, Object.assign({}, props, refProps));\n            }\n            if (!shouldTriggerRender || shouldTriggerRender(prevProps.current, props)) {\n                renderTimesRef.current += 1;\n            }\n            prevProps.current = props;\n            return (_jsx(ImmutableContext.Provider, { value: renderTimesRef.current, children: _jsx(Component, Object.assign({}, props, refProps)) }));\n        };\n        const componentWithMeta = Component;\n        ImmutableComponent.displayName = `ImmutableRoot(${componentWithMeta.displayName || componentWithMeta.name})`;\n        return refAble\n            ? React.forwardRef(ImmutableComponent)\n            : ImmutableComponent;\n    }\n    /**\n     * Wrapped Component with `React.memo`.\n     * But will rerender when parent with `makeImmutable` rerender.\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    function responseImmutable(Component, propsAreEqual) {\n        const refAble = supportRef(Component);\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        const ImmutableComponent = (props, ref) => {\n            const refProps = refAble ? { ref } : {};\n            useImmutableMark();\n            return _jsx(Component, Object.assign({}, props, refProps));\n        };\n        const componentWithMeta = Component;\n        ImmutableComponent.displayName = `ImmutableResponse(${componentWithMeta.displayName || componentWithMeta.name})`;\n        const Wrapped = refAble ? React.forwardRef(ImmutableComponent) : ImmutableComponent;\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        return React.memo(Wrapped, propsAreEqual);\n    }\n    return {\n        makeImmutable,\n        responseImmutable,\n        useImmutableMark,\n    };\n}",null],"sourceRoot":"../../../../../../../../../../../../src"}

package/es/components/Table/internal/kernel/selector-context/context.d.ts

@@ -0,0 +1,26 @@
+import * as React from 'react';
+export type Selector<ContextProps, SelectorValue = ContextProps> = (value: ContextProps) => SelectorValue;
+export type Trigger<ContextProps> = (value: ContextProps) => void;
+export type Listeners<ContextProps> = Set<Trigger<ContextProps>>;
+export interface Context<ContextProps> {
+    getValue: () => ContextProps;
+    listeners: Listeners<ContextProps>;
+}
+export interface ContextSelectorProviderProps<T> {
+    value: T;
+    children?: React.ReactNode;
+}
+export interface SelectorContext<ContextProps> {
+    Context: React.Context<Context<ContextProps>>;
+    Provider: React.ComponentType<ContextSelectorProviderProps<ContextProps>>;
+    defaultValue?: ContextProps;
+}
+export declare function createContext<ContextProps>(defaultValue?: ContextProps): SelectorContext<ContextProps>;
+/** e.g. useSelect(userContext) => user */
+export declare function useContext<ContextProps>(holder: SelectorContext<ContextProps>): ContextProps;
+/** e.g. useSelect(userContext, user => user.name) => user.name */
+export declare function useContext<ContextProps, SelectorValue>(holder: SelectorContext<ContextProps>, selector: Selector<ContextProps, SelectorValue>): SelectorValue;
+/** e.g. useSelect(userContext, ['name', 'age']) => user { name, age } */
+export declare function useContext<ContextProps, SelectorValue extends Partial<ContextProps>>(holder: SelectorContext<ContextProps>, selector: (keyof ContextProps)[]): SelectorValue;
+/** e.g. useSelect(userContext, 'name') => user.name */
+export declare function useContext<ContextProps, PropName extends keyof ContextProps>(holder: SelectorContext<ContextProps>, selector: PropName): ContextProps[PropName];

package/es/components/Table/internal/kernel/selector-context/context.js

@@ -0,0 +1,83 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEventCallback } from '@1money/hooks';
+import { useLayoutEffect } from '@1money/hooks';
+import * as React from 'react';
+import { unstable_batchedUpdates } from 'react-dom';
+import isEqual from './isEqual';
+export function createContext(defaultValue) {
+  var Context = /*#__PURE__*/React.createContext(undefined);
+  var Provider = function Provider(_ref) {
+    var value = _ref.value,
+      children = _ref.children;
+    var valueRef = React.useRef(value);
+    valueRef.current = value;
+    var _React$useState = React.useState(function () {
+        return {
+          getValue: function getValue() {
+            return valueRef.current;
+          },
+          listeners: new Set()
+        };
+      }),
+      _React$useState2 = _slicedToArray(_React$useState, 1),
+      context = _React$useState2[0];
+    useLayoutEffect(function () {
+      unstable_batchedUpdates(function () {
+        context.listeners.forEach(function (listener) {
+          listener(value);
+        });
+      });
+    }, [value]);
+    return _jsx(Context.Provider, {
+      value: context,
+      children: children
+    });
+  };
+  return {
+    Context: Context,
+    Provider: Provider,
+    defaultValue: defaultValue
+  };
+}
+export function useContext(holder, selector) {
+  var eventSelector = useEventCallback(typeof selector === 'function' ? selector : function (ctx) {
+    if (selector === undefined) {
+      return ctx;
+    }
+    if (!Array.isArray(selector)) {
+      return ctx[selector];
+    }
+    var obj = {};
+    selector.forEach(function (key) {
+      obj[key] = ctx[key];
+    });
+    return obj;
+  });
+  var context = React.useContext(holder === null || holder === void 0 ? void 0 : holder.Context);
+  var _ref2 = context || {},
+    listeners = _ref2.listeners,
+    getValue = _ref2.getValue;
+  var valueRef = React.useRef(undefined);
+  valueRef.current = eventSelector(context ? getValue() : holder === null || holder === void 0 ? void 0 : holder.defaultValue);
+  var _React$useState3 = React.useState({}),
+    _React$useState4 = _slicedToArray(_React$useState3, 2),
+    forceUpdate = _React$useState4[1];
+  useLayoutEffect(function () {
+    if (!context) {
+      return;
+    }
+    function trigger(nextValue) {
+      var nextSelectorValue = eventSelector(nextValue);
+      if (!isEqual(valueRef.current, nextSelectorValue, true)) {
+        forceUpdate({});
+      }
+    }
+    listeners.add(trigger);
+    return function () {
+      listeners["delete"](trigger);
+    };
+  }, [context]);
+  return valueRef.current;
+}
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/es/components/Table/internal/kernel/selector-context/index.d.ts

@@ -0,0 +1,7 @@
+import type { SelectorContext } from './context';
+import { createContext, useContext } from './context';
+import createImmutable from './Immutable';
+declare const makeImmutable: <T extends import("react").ComponentType<any>>(Component: T, shouldTriggerRender?: import("./Immutable").CompareProps<T>) => T, responseImmutable: <T extends import("react").ComponentType<any>>(Component: T, propsAreEqual?: import("./Immutable").CompareProps<T>) => T, useImmutableMark: () => number | null;
+export { createContext, useContext, createImmutable, makeImmutable, responseImmutable, useImmutableMark, };
+export type { SelectorContext };
+export type { CompareProps } from './Immutable';

package/es/components/Table/internal/kernel/selector-context/index.js

@@ -0,0 +1,9 @@
+import { createContext, useContext } from './context';
+import createImmutable from './Immutable';
+// For legacy usage, we export it directly
+var _createImmutable = createImmutable(),
+  makeImmutable = _createImmutable.makeImmutable,
+  responseImmutable = _createImmutable.responseImmutable,
+  useImmutableMark = _createImmutable.useImmutableMark;
+export { createContext, useContext, createImmutable, makeImmutable, responseImmutable, useImmutableMark };
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImNvbXBvbmVudHMvVGFibGUvaW50ZXJuYWwva2VybmVsL3NyYy9jb21wb25lbnRzL1RhYmxlL2ludGVybmFsL2tlcm5lbC9zZWxlY3Rvci1jb250ZXh0L2luZGV4LnRzIl0sIm5hbWVzIjpbImNyZWF0ZUNvbnRleHQiLCJ1c2VDb250ZXh0IiwiY3JlYXRlSW1tdXRhYmxlIiwiX2NyZWF0ZUltbXV0YWJsZSIsIm1ha2VJbW11dGFibGUiLCJyZXNwb25zZUltbXV0YWJsZSIsInVzZUltbXV0YWJsZU1hcmsiXSwibWFwcGluZ3MiOiJBQUNBLFNBQVNBLGFBQWEsRUFBRUMsVUFBVSxRQUFRLFdBQVc7QUFDckQsT0FBT0MsZUFBZSxNQUFNLGFBQWE7QUFFekM7QUFDQSxJQUFBQyxnQkFBQSxHQUErREQsZUFBZSxDQUFBLENBQUU7RUFBeEVFLGFBQWEsR0FBQUQsZ0JBQUEsQ0FBYkMsYUFBYTtFQUFFQyxpQkFBaUIsR0FBQUYsZ0JBQUEsQ0FBakJFLGlCQUFpQjtFQUFFQyxnQkFBZ0IsR0FBQUgsZ0JBQUEsQ0FBaEJHLGdCQUFnQjtBQUUxRCxTQUNFTixhQUFhLEVBQ2JDLFVBQVUsRUFDVkMsZUFBZSxFQUNmRSxhQUFhLEVBQ2JDLGlCQUFpQixFQUNqQkMsZ0JBQWdCIiwiZmlsZSI6ImNvbXBvbmVudHMvVGFibGUvaW50ZXJuYWwva2VybmVsL3NlbGVjdG9yLWNvbnRleHQvaW5kZXguanMiLCJzb3VyY2VzQ29udGVudCI6W251bGxdLCJzb3VyY2VSb290IjoiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vc3JjIn0=

package/es/components/Table/internal/kernel/selector-context/isEqual.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Shallow-aware equality check. When `shallow` is true,
+ * only compares one level deep (arrays/objects by reference after level 1).
+ */
+export default function isEqual(obj1: unknown, obj2: unknown, shallow?: boolean): boolean;

package/es/components/Table/internal/kernel/selector-context/isEqual.js

@@ -0,0 +1,48 @@
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+/**
+ * Shallow-aware equality check. When `shallow` is true,
+ * only compares one level deep (arrays/objects by reference after level 1).
+ */
+export default function isEqual(obj1, obj2) {
+  var shallow = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  var refSet = new Set();
+  function deepEqual(a, b) {
+    var level = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;
+    if (refSet.has(a)) {
+      return false;
+    }
+    if (a === b) {
+      return true;
+    }
+    if (shallow && level > 1) {
+      return false;
+    }
+    refSet.add(a);
+    var newLevel = level + 1;
+    if (Array.isArray(a)) {
+      if (!Array.isArray(b) || a.length !== b.length) {
+        return false;
+      }
+      for (var i = 0; i < a.length; i++) {
+        if (!deepEqual(a[i], b[i], newLevel)) {
+          return false;
+        }
+      }
+      return true;
+    }
+    if (a && b && _typeof(a) === 'object' && _typeof(b) === 'object') {
+      var aObj = a;
+      var bObj = b;
+      var keys = Object.keys(aObj);
+      if (keys.length !== Object.keys(bObj).length) {
+        return false;
+      }
+      return keys.every(function (key) {
+        return deepEqual(aObj[key], bObj[key], newLevel);
+      });
+    }
+    return false;
+  }
+  return deepEqual(obj1, obj2);
+}
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/es/components/Table/internal/kernel/stickyScrollBar.d.ts

@@ -0,0 +1,12 @@
+import * as React from 'react';
+interface StickyScrollBarProps {
+    scrollBodyRef: React.RefObject<HTMLDivElement>;
+    onScroll: (params: {
+        scrollLeft?: number;
+    }) => void;
+    offsetScroll: number;
+    container: HTMLElement | Window;
+    direction: string;
+}
+declare const _default: React.ForwardRefExoticComponent<StickyScrollBarProps & React.RefAttributes<unknown>>;
+export default _default;

package/es/components/Table/internal/kernel/stickyScrollBar.js

@@ -0,0 +1,192 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import { jsx as _jsx } from "react/jsx-runtime";
+// @ts-nocheck
+import { useContext } from './selector-context';
+import { clsx } from 'clsx';
+import getScrollBarSize from './utils/getScrollBarSize';
+import * as React from 'react';
+import TableContext from './context/TableContext';
+import { useLayoutState } from './hooks/useFrame';
+import raf from '../../../VirtualList/utils/raf';
+import { getOffset } from './utils/offsetUtil';
+import { getDOM } from '../../../ResizeObserver/utils/reactUtil';
+var MOUSEUP_EVENT = 'mouseup';
+var MOUSEMOVE_EVENT = 'mousemove';
+var SCROLL_EVENT = 'scroll';
+var RESIZE_EVENT = 'resize';
+var StickyScrollBar = function StickyScrollBar(props, ref) {
+  var _a, _b;
+  var scrollBodyRef = props.scrollBodyRef,
+    onScroll = props.onScroll,
+    offsetScroll = props.offsetScroll,
+    container = props.container,
+    direction = props.direction;
+  var prefixCls = useContext(TableContext, 'prefixCls');
+  var bodyScrollWidth = ((_a = scrollBodyRef.current) === null || _a === void 0 ? void 0 : _a.scrollWidth) || 0;
+  var bodyWidth = ((_b = scrollBodyRef.current) === null || _b === void 0 ? void 0 : _b.clientWidth) || 0;
+  var scrollBarWidth = bodyScrollWidth && bodyWidth * (bodyWidth / bodyScrollWidth);
+  var scrollBarRef = React.useRef(null);
+  var _useLayoutState = useLayoutState({
+      scrollLeft: 0,
+      isHiddenScrollBar: true
+    }),
+    _useLayoutState2 = _slicedToArray(_useLayoutState, 2),
+    scrollState = _useLayoutState2[0],
+    setScrollState = _useLayoutState2[1];
+  var refState = React.useRef({
+    delta: 0,
+    x: 0
+  });
+  var _React$useState = React.useState(false),
+    _React$useState2 = _slicedToArray(_React$useState, 2),
+    isActive = _React$useState2[0],
+    setActive = _React$useState2[1];
+  var rafRef = React.useRef(null);
+  React.useEffect(function () {
+    return function () {
+      raf.cancel(rafRef.current);
+    };
+  }, []);
+  var onMouseUp = function onMouseUp() {
+    setActive(false);
+  };
+  var onMouseDown = function onMouseDown(event) {
+    event.persist();
+    refState.current.delta = event.pageX - scrollState.scrollLeft;
+    refState.current.x = 0;
+    setActive(true);
+    event.preventDefault();
+  };
+  var onMouseMove = function onMouseMove(event) {
+    // https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/buttons
+    var _ref = event || (window === null || window === void 0 ? void 0 : window.event),
+      buttons = _ref.buttons;
+    if (!isActive || buttons === 0) {
+      // If out body mouse up, we can set isActive false when mouse move
+      if (isActive) {
+        setActive(false);
+      }
+      return;
+    }
+    var left = refState.current.x + event.pageX - refState.current.x - refState.current.delta;
+    var isRTL = direction === 'rtl';
+    // Limit scroll range
+    left = Math.max(isRTL ? scrollBarWidth - bodyWidth : 0, Math.min(isRTL ? 0 : bodyWidth - scrollBarWidth, left));
+    // Calculate the scroll position and update
+    var shouldScroll = !isRTL || Math.abs(left) + Math.abs(scrollBarWidth) < bodyWidth;
+    if (shouldScroll) {
+      onScroll({
+        scrollLeft: left / bodyWidth * (bodyScrollWidth + 2)
+      });
+      refState.current.x = event.pageX;
+    }
+  };
+  var checkScrollBarVisible = function checkScrollBarVisible() {
+    raf.cancel(rafRef.current);
+    rafRef.current = raf(function () {
+      if (!scrollBodyRef.current) {
+        return;
+      }
+      var tableOffsetTop = getOffset(scrollBodyRef.current).top;
+      var tableBottomOffset = tableOffsetTop + scrollBodyRef.current.offsetHeight;
+      var currentClientOffset = container === window ? document.documentElement.scrollTop + window.innerHeight : getOffset(container).top + container.clientHeight;
+      if (tableBottomOffset - getScrollBarSize() <= currentClientOffset || tableOffsetTop >= currentClientOffset - offsetScroll) {
+        setScrollState(function (state) {
+          return Object.assign(Object.assign({}, state), {
+            isHiddenScrollBar: true
+          });
+        });
+      } else {
+        setScrollState(function (state) {
+          return Object.assign(Object.assign({}, state), {
+            isHiddenScrollBar: false
+          });
+        });
+      }
+    });
+  };
+  var setScrollLeft = function setScrollLeft(left) {
+    setScrollState(function (state) {
+      return Object.assign(Object.assign({}, state), {
+        scrollLeft: left / bodyScrollWidth * bodyWidth || 0
+      });
+    });
+  };
+  React.useImperativeHandle(ref, function () {
+    return {
+      setScrollLeft: setScrollLeft,
+      checkScrollBarVisible: checkScrollBarVisible
+    };
+  });
+  React.useEffect(function () {
+    document.body.addEventListener(MOUSEUP_EVENT, onMouseUp, false);
+    document.body.addEventListener(MOUSEMOVE_EVENT, onMouseMove, false);
+    checkScrollBarVisible();
+    return function () {
+      document.body.removeEventListener(MOUSEUP_EVENT, onMouseUp);
+      document.body.removeEventListener(MOUSEMOVE_EVENT, onMouseMove);
+    };
+  }, [scrollBarWidth, isActive]);
+  // Loop for scroll event check
+  React.useEffect(function () {
+    if (scrollBodyRef.current) {
+      var scrollParents = [];
+      var parent = getDOM(scrollBodyRef.current);
+      while (parent) {
+        scrollParents.push(parent);
+        parent = parent.parentElement;
+      }
+      scrollParents.forEach(function (p) {
+        p.addEventListener(SCROLL_EVENT, checkScrollBarVisible, false);
+      });
+      window.addEventListener(RESIZE_EVENT, checkScrollBarVisible, false);
+      window.addEventListener(SCROLL_EVENT, checkScrollBarVisible, false);
+      container.addEventListener(SCROLL_EVENT, checkScrollBarVisible, false);
+      return function () {
+        scrollParents.forEach(function (p) {
+          p.removeEventListener(SCROLL_EVENT, checkScrollBarVisible);
+        });
+        window.removeEventListener(RESIZE_EVENT, checkScrollBarVisible);
+        window.removeEventListener(SCROLL_EVENT, checkScrollBarVisible);
+        container.removeEventListener(SCROLL_EVENT, checkScrollBarVisible);
+      };
+    }
+  }, [container]);
+  React.useEffect(function () {
+    if (!scrollState.isHiddenScrollBar) {
+      setScrollState(function (state) {
+        var bodyNode = scrollBodyRef.current;
+        if (!bodyNode) {
+          return state;
+        }
+        return Object.assign(Object.assign({}, state), {
+          scrollLeft: bodyNode.scrollLeft / bodyNode.scrollWidth * bodyNode.clientWidth
+        });
+      });
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [scrollState.isHiddenScrollBar]);
+  if (bodyScrollWidth <= bodyWidth || !scrollBarWidth || scrollState.isHiddenScrollBar) {
+    return null;
+  }
+  return _jsx("div", {
+    style: {
+      height: getScrollBarSize(),
+      width: bodyWidth,
+      bottom: offsetScroll
+    },
+    className: "".concat(prefixCls, "-sticky-scroll"),
+    children: _jsx("div", {
+      onMouseDown: onMouseDown,
+      ref: scrollBarRef,
+      className: clsx("".concat(prefixCls, "-sticky-scroll-bar"), _defineProperty({}, "".concat(prefixCls, "-sticky-scroll-bar-active"), isActive)),
+      style: {
+        width: "".concat(scrollBarWidth, "px"),
+        transform: "translate3d(".concat(scrollState.scrollLeft, "px, 0, 0)")
+      }
+    })
+  });
+};
+export default /*#__PURE__*/React.forwardRef(StickyScrollBar);
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["components/Table/internal/kernel/stickyScrollBar.js","components/Table/internal/src/components/Table/internal/kernel/stickyScrollBar.tsx"],"names":["jsx","_jsx","useContext","clsx","getScrollBarSize","React","TableContext","useLayoutState","raf","getOffset","getDOM","MOUSEUP_EVENT","MOUSEMOVE_EVENT","SCROLL_EVENT","RESIZE_EVENT","StickyScrollBar","props","ref","_a","_b","scrollBodyRef","onScroll","offsetScroll","container","direction","prefixCls","bodyScrollWidth","current","scrollWidth","bodyWidth","clientWidth","scrollBarWidth","scrollBarRef","useRef","_useLayoutState","scrollLeft","isHiddenScrollBar","_useLayoutState2","_slicedToArray","scrollState","setScrollState","refState","delta","x","_React$useState","useState","_React$useState2","isActive","setActive","rafRef","useEffect","cancel","onMouseUp","onMouseDown","event","persist","pageX","preventDefault","onMouseMove","_ref","window","buttons","left","isRTL","Math","max","min","shouldScroll","abs","checkScrollBarVisible","tableOffsetTop","top","tableBottomOffset","offsetHeight","currentClientOffset","document","documentElement","scrollTop","innerHeight","clientHeight","state","Object","assign","setScrollLeft","useImperativeHandle","body","addEventListener","removeEventListener","scrollParents","parent","push","parentElement","forEach","p","bodyNode","style","height","width","bottom","className","concat","children","_defineProperty","transform","forwardRef"],"mappings":"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","file":"components/Table/internal/kernel/stickyScrollBar.js","sourcesContent":["import { jsx as _jsx } from \"react/jsx-runtime\";\n// @ts-nocheck\nimport { useContext } from './selector-context';\nimport { clsx } from 'clsx';\nimport getScrollBarSize from './utils/getScrollBarSize';\nimport * as React from 'react';\nimport TableContext from './context/TableContext';\nimport { useLayoutState } from './hooks/useFrame';\nimport raf from '../../../VirtualList/utils/raf';\nimport { getOffset } from './utils/offsetUtil';\nimport { getDOM } from '../../../ResizeObserver/utils/reactUtil';\nconst MOUSEUP_EVENT = 'mouseup';\nconst MOUSEMOVE_EVENT = 'mousemove';\nconst SCROLL_EVENT = 'scroll';\nconst RESIZE_EVENT = 'resize';\nconst StickyScrollBar = (props, ref) => {\n    var _a, _b;\n    const { scrollBodyRef, onScroll, offsetScroll, container, direction } = props;\n    const prefixCls = useContext(TableContext, 'prefixCls');\n    const bodyScrollWidth = ((_a = scrollBodyRef.current) === null || _a === void 0 ? void 0 : _a.scrollWidth) || 0;\n    const bodyWidth = ((_b = scrollBodyRef.current) === null || _b === void 0 ? void 0 : _b.clientWidth) || 0;\n    const scrollBarWidth = bodyScrollWidth && bodyWidth * (bodyWidth / bodyScrollWidth);\n    const scrollBarRef = React.useRef(null);\n    const [scrollState, setScrollState] = useLayoutState({ scrollLeft: 0, isHiddenScrollBar: true });\n    const refState = React.useRef({ delta: 0, x: 0 });\n    const [isActive, setActive] = React.useState(false);\n    const rafRef = React.useRef(null);\n    React.useEffect(() => () => {\n        raf.cancel(rafRef.current);\n    }, []);\n    const onMouseUp = () => {\n        setActive(false);\n    };\n    const onMouseDown = (event) => {\n        event.persist();\n        refState.current.delta = event.pageX - scrollState.scrollLeft;\n        refState.current.x = 0;\n        setActive(true);\n        event.preventDefault();\n    };\n    const onMouseMove = (event) => {\n        // https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/buttons\n        const { buttons } = event || (window === null || window === void 0 ? void 0 : window.event);\n        if (!isActive || buttons === 0) {\n            // If out body mouse up, we can set isActive false when mouse move\n            if (isActive) {\n                setActive(false);\n            }\n            return;\n        }\n        let left = refState.current.x + event.pageX - refState.current.x - refState.current.delta;\n        const isRTL = direction === 'rtl';\n        // Limit scroll range\n        left = Math.max(isRTL ? scrollBarWidth - bodyWidth : 0, Math.min(isRTL ? 0 : bodyWidth - scrollBarWidth, left));\n        // Calculate the scroll position and update\n        const shouldScroll = !isRTL || Math.abs(left) + Math.abs(scrollBarWidth) < bodyWidth;\n        if (shouldScroll) {\n            onScroll({\n                scrollLeft: (left / bodyWidth) * (bodyScrollWidth + 2),\n            });\n            refState.current.x = event.pageX;\n        }\n    };\n    const checkScrollBarVisible = () => {\n        raf.cancel(rafRef.current);\n        rafRef.current = raf(() => {\n            if (!scrollBodyRef.current) {\n                return;\n            }\n            const tableOffsetTop = getOffset(scrollBodyRef.current).top;\n            const tableBottomOffset = tableOffsetTop + scrollBodyRef.current.offsetHeight;\n            const currentClientOffset = container === window\n                ? document.documentElement.scrollTop + window.innerHeight\n                : getOffset(container).top + container.clientHeight;\n            if (tableBottomOffset - getScrollBarSize() <= currentClientOffset ||\n                tableOffsetTop >= currentClientOffset - offsetScroll) {\n                setScrollState(state => (Object.assign(Object.assign({}, state), { isHiddenScrollBar: true })));\n            }\n            else {\n                setScrollState(state => (Object.assign(Object.assign({}, state), { isHiddenScrollBar: false })));\n            }\n        });\n    };\n    const setScrollLeft = (left) => {\n        setScrollState(state => {\n            return Object.assign(Object.assign({}, state), { scrollLeft: (left / bodyScrollWidth) * bodyWidth || 0 });\n        });\n    };\n    React.useImperativeHandle(ref, () => ({\n        setScrollLeft,\n        checkScrollBarVisible,\n    }));\n    React.useEffect(() => {\n        document.body.addEventListener(MOUSEUP_EVENT, onMouseUp, false);\n        document.body.addEventListener(MOUSEMOVE_EVENT, onMouseMove, false);\n        checkScrollBarVisible();\n        return () => {\n            document.body.removeEventListener(MOUSEUP_EVENT, onMouseUp);\n            document.body.removeEventListener(MOUSEMOVE_EVENT, onMouseMove);\n        };\n    }, [scrollBarWidth, isActive]);\n    // Loop for scroll event check\n    React.useEffect(() => {\n        if (scrollBodyRef.current) {\n            const scrollParents = [];\n            let parent = getDOM(scrollBodyRef.current);\n            while (parent) {\n                scrollParents.push(parent);\n                parent = parent.parentElement;\n            }\n            scrollParents.forEach(p => {\n                p.addEventListener(SCROLL_EVENT, checkScrollBarVisible, false);\n            });\n            window.addEventListener(RESIZE_EVENT, checkScrollBarVisible, false);\n            window.addEventListener(SCROLL_EVENT, checkScrollBarVisible, false);\n            container.addEventListener(SCROLL_EVENT, checkScrollBarVisible, false);\n            return () => {\n                scrollParents.forEach(p => {\n                    p.removeEventListener(SCROLL_EVENT, checkScrollBarVisible);\n                });\n                window.removeEventListener(RESIZE_EVENT, checkScrollBarVisible);\n                window.removeEventListener(SCROLL_EVENT, checkScrollBarVisible);\n                container.removeEventListener(SCROLL_EVENT, checkScrollBarVisible);\n            };\n        }\n    }, [container]);\n    React.useEffect(() => {\n        if (!scrollState.isHiddenScrollBar) {\n            setScrollState(state => {\n                const bodyNode = scrollBodyRef.current;\n                if (!bodyNode) {\n                    return state;\n                }\n                return Object.assign(Object.assign({}, state), { scrollLeft: (bodyNode.scrollLeft / bodyNode.scrollWidth) * bodyNode.clientWidth });\n            });\n        }\n        // eslint-disable-next-line react-hooks/exhaustive-deps\n    }, [scrollState.isHiddenScrollBar]);\n    if (bodyScrollWidth <= bodyWidth || !scrollBarWidth || scrollState.isHiddenScrollBar) {\n        return null;\n    }\n    return (_jsx(\"div\", { style: { height: getScrollBarSize(), width: bodyWidth, bottom: offsetScroll }, className: `${prefixCls}-sticky-scroll`, children: _jsx(\"div\", { onMouseDown: onMouseDown, ref: scrollBarRef, className: clsx(`${prefixCls}-sticky-scroll-bar`, {\n                [`${prefixCls}-sticky-scroll-bar-active`]: isActive,\n            }), style: {\n                width: `${scrollBarWidth}px`,\n                transform: `translate3d(${scrollState.scrollLeft}px, 0, 0)`,\n            } }) }));\n};\nexport default React.forwardRef(StickyScrollBar);",null],"sourceRoot":"../../../../../../../../../../../src"}

package/es/components/Table/internal/kernel/sugar/Column.d.ts

@@ -0,0 +1,10 @@
+import type { ColumnType } from '../interface';
+export interface ColumnProps<RecordType> extends ColumnType<RecordType> {
+    children?: null;
+}
+/**
+ * This is a syntactic sugar for `columns` prop.
+ * So HOC will not work on this.
+ */
+declare function Column<RecordType>(_: ColumnProps<RecordType>): null;
+export default Column;

package/es/components/Table/internal/kernel/sugar/Column.js

@@ -0,0 +1,11 @@
+/* istanbul ignore next */
+/**
+ * This is a syntactic sugar for `columns` prop.
+ * So HOC will not work on this.
+ */
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+function Column(_) {
+  return null;
+}
+export default Column;
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImNvbXBvbmVudHMvVGFibGUvaW50ZXJuYWwva2VybmVsL3NyYy9jb21wb25lbnRzL1RhYmxlL2ludGVybmFsL2tlcm5lbC9zdWdhci9Db2x1bW4udHN4IiwiY29tcG9uZW50cy9UYWJsZS9pbnRlcm5hbC9rZXJuZWwvc3VnYXIvQ29sdW1uLmpzIl0sIm5hbWVzIjpbIkNvbHVtbiIsIl8iXSwibWFwcGluZ3MiOiJBQU9BO0FBQ0E7QUNOQTtBQUNBO0FBQ0E7QURRQTtBQUNBLFNBQVNBLE1BQU1BLENBQWFDLENBQTBCLEVBQUE7RUFDcEQsT0FBTyxJQUFJO0FBQ2I7QUFFQSxlQUFlRCxNQUFNIiwiZmlsZSI6ImNvbXBvbmVudHMvVGFibGUvaW50ZXJuYWwva2VybmVsL3N1Z2FyL0NvbHVtbi5qcyIsInNvdXJjZXNDb250ZW50IjpbbnVsbCwiLyogaXN0YW5idWwgaWdub3JlIG5leHQgKi9cbi8qKlxuICogVGhpcyBpcyBhIHN5bnRhY3RpYyBzdWdhciBmb3IgYGNvbHVtbnNgIHByb3AuXG4gKiBTbyBIT0Mgd2lsbCBub3Qgd29yayBvbiB0aGlzLlxuICovXG4vLyBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgQHR5cGVzY3JpcHQtZXNsaW50L25vLXVudXNlZC12YXJzXG5mdW5jdGlvbiBDb2x1bW4oXykge1xuICAgIHJldHVybiBudWxsO1xufVxuZXhwb3J0IGRlZmF1bHQgQ29sdW1uOyJdLCJzb3VyY2VSb290IjoiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vc3JjIn0=

package/es/components/Table/internal/kernel/sugar/ColumnGroup.d.ts

@@ -0,0 +1,12 @@
+import type * as React from 'react';
+import type { ColumnProps } from './Column';
+import type { ColumnType } from '../interface';
+export interface ColumnGroupProps<RecordType> extends Omit<ColumnType<RecordType>, 'children'> {
+    children: React.ReactElement<ColumnProps<RecordType>> | readonly React.ReactElement<ColumnProps<RecordType>>[];
+}
+/**
+ * This is a syntactic sugar for `columns` prop.
+ * So HOC will not work on this.
+ */
+declare function ColumnGroup<RecordType>(_: ColumnGroupProps<RecordType>): null;
+export default ColumnGroup;

package/es/components/Table/internal/kernel/sugar/ColumnGroup.js

@@ -0,0 +1,11 @@
+/* istanbul ignore next */
+/**
+ * This is a syntactic sugar for `columns` prop.
+ * So HOC will not work on this.
+ */
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+function ColumnGroup(_) {
+  return null;
+}
+export default ColumnGroup;
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImNvbXBvbmVudHMvVGFibGUvaW50ZXJuYWwva2VybmVsL3NyYy9jb21wb25lbnRzL1RhYmxlL2ludGVybmFsL2tlcm5lbC9zdWdhci9Db2x1bW5Hcm91cC50c3giLCJjb21wb25lbnRzL1RhYmxlL2ludGVybmFsL2tlcm5lbC9zdWdhci9Db2x1bW5Hcm91cC5qcyJdLCJuYW1lcyI6WyJDb2x1bW5Hcm91cCIsIl8iXSwibWFwcGluZ3MiOiJBQVdBO0FBQ0E7QUNWQTtBQUNBO0FBQ0E7QURZQTtBQUNBLFNBQVNBLFdBQVdBLENBQWFDLENBQStCLEVBQUE7RUFDOUQsT0FBTyxJQUFJO0FBQ2I7QUFFQSxlQUFlRCxXQUFXIiwiZmlsZSI6ImNvbXBvbmVudHMvVGFibGUvaW50ZXJuYWwva2VybmVsL3N1Z2FyL0NvbHVtbkdyb3VwLmpzIiwic291cmNlc0NvbnRlbnQiOltudWxsLCIvKiBpc3RhbmJ1bCBpZ25vcmUgbmV4dCAqL1xuLyoqXG4gKiBUaGlzIGlzIGEgc3ludGFjdGljIHN1Z2FyIGZvciBgY29sdW1uc2AgcHJvcC5cbiAqIFNvIEhPQyB3aWxsIG5vdCB3b3JrIG9uIHRoaXMuXG4gKi9cbi8vIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBAdHlwZXNjcmlwdC1lc2xpbnQvbm8tdW51c2VkLXZhcnNcbmZ1bmN0aW9uIENvbHVtbkdyb3VwKF8pIHtcbiAgICByZXR1cm4gbnVsbDtcbn1cbmV4cG9ydCBkZWZhdWx0IENvbHVtbkdyb3VwOyJdLCJzb3VyY2VSb290IjoiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vc3JjIn0=

package/es/components/Table/internal/kernel/utils/dom/canUseDom.d.ts

@@ -0,0 +1 @@
+export default function canUseDom(): boolean;

package/es/components/Table/internal/kernel/utils/dom/canUseDom.js

@@ -0,0 +1,4 @@
+export default function canUseDom() {
+  return !!(typeof window !== 'undefined' && window.document && window.document.createElement);
+}
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImNvbXBvbmVudHMvVGFibGUvaW50ZXJuYWwva2VybmVsL3V0aWxzL3NyYy9jb21wb25lbnRzL1RhYmxlL2ludGVybmFsL2tlcm5lbC91dGlscy9kb20vY2FuVXNlRG9tLnRzIl0sIm5hbWVzIjpbImNhblVzZURvbSIsIndpbmRvdyIsImRvY3VtZW50IiwiY3JlYXRlRWxlbWVudCJdLCJtYXBwaW5ncyI6IkFBQUEsZUFBYyxTQUFVQSxTQUFTQSxDQUFBLEVBQUE7RUFDL0IsT0FBTyxDQUFDLEVBQ04sT0FBT0MsTUFBTSxLQUFLLFdBQVcsSUFDN0JBLE1BQU0sQ0FBQ0MsUUFBUSxJQUNmRCxNQUFNLENBQUNDLFFBQVEsQ0FBQ0MsYUFBYSxDQUM5QjtBQUNIIiwiZmlsZSI6ImNvbXBvbmVudHMvVGFibGUvaW50ZXJuYWwva2VybmVsL3V0aWxzL2RvbS9jYW5Vc2VEb20uanMiLCJzb3VyY2VzQ29udGVudCI6W251bGxdLCJzb3VyY2VSb290IjoiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vc3JjIn0=

package/es/components/Table/internal/kernel/utils/dom/isVisible.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (element: Element) => boolean;
+export default _default;