@dtjoy/dt-design 1.1.2 → 1.1.5

package/es/_util/context/createContextSelector.d.ts

@@ -0,0 +1,28 @@
+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, Keys extends keyof ContextProps>(holder: SelectorContext<ContextProps>, selector: Keys[]): {
+    [K in Keys]: ContextProps[K];
+};
+/** 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/_util/context/createContextSelector.js

@@ -0,0 +1,110 @@
+var _unstable_batchedUpda;
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+/**
+ * Local shim for `@rc-component/context` - context.tsx
+ *
+ * Based on @rc-component/context source. Replaced `@rc-component/util`
+ * imports with `rc-util` subpath imports. The keys-array `useContext`
+ * overload was retyped to return a precise `Pick` of the selected keys
+ * (instead of `Partial<ContextProps>`) so consumers get non-optional fields.
+ */
+import isEqual from 'rc-util/lib/isEqual';
+import useEvent from 'rc-util/lib/hooks/useEvent';
+import useLayoutEffect from 'rc-util/lib/hooks/useLayoutEffect';
+import * as React from 'react';
+import * as ReactDOM from 'react-dom';
+
+// React 19 的生产构建移除了 unstable_batchedUpdates(React 18 起已是 no-op),
+// 直接命名导入会在 React 19 生产环境调用 undefined 而崩溃。
+// 经命名空间属性访问并在缺失时降级为直接调用。
+var batchedUpdates = (_unstable_batchedUpda = ReactDOM.unstable_batchedUpdates) !== null && _unstable_batchedUpda !== void 0 ? _unstable_batchedUpda : function (fn) {
+  return fn();
+};
+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 () {
+      batchedUpdates(function () {
+        context.listeners.forEach(function (listener) {
+          listener(value);
+        });
+      });
+    }, [value]);
+    return /*#__PURE__*/React.createElement(Context.Provider, {
+      value: context
+    }, children);
+  };
+  return {
+    Context: Context,
+    Provider: Provider,
+    defaultValue: defaultValue
+  };
+}
+
+/** e.g. useSelect(userContext) => user */
+
+/** e.g. useSelect(userContext, user => user.name) => user.name */
+
+/** e.g. useSelect(userContext, ['name', 'age']) => user { name, age } */
+
+/** e.g. useSelect(userContext, 'name') => user.name */
+
+export function useContext(holder, selector) {
+  var eventSelector = useEvent(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;
+}

package/es/_util/context/immutable.d.ts

@@ -0,0 +1,10 @@
+import * as React from 'react';
+export type CompareProps<T extends React.ComponentType<any>> = (prevProps: Readonly<React.ComponentProps<T>>, nextProps: Readonly<React.ComponentProps<T>>) => boolean;
+/**
+ * Create Immutable pair for `makeImmutable` and `responseImmutable`.
+ */
+export default function createImmutable(): {
+    makeImmutable: <T extends React.ComponentType<any>>(Component: T, shouldTriggerRender?: CompareProps<T>) => T;
+    responseImmutable: <T extends React.ComponentType<any>>(Component: T, propsAreEqual?: CompareProps<T>) => T;
+    useImmutableMark: () => number | null;
+};

package/es/_util/context/immutable.js

@@ -0,0 +1,84 @@
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+/**
+ * Local shim for `@rc-component/context` - Immutable.tsx
+ *
+ * Direct copy from @rc-component/context source.
+ * Replaced `@rc-component/util` imports with `rc-util` subpath imports.
+ */
+import { supportRef } from 'rc-util/lib/ref';
+import * as React from 'react';
+/**
+ * Create Immutable pair for `makeImmutable` and `responseImmutable`.
+ */
+export default function createImmutable() {
+  var ImmutableContext = /*#__PURE__*/React.createContext(null);
+
+  /**
+   * Get render update mark by `makeImmutable` root.
+   * Do not deps on the return value as render times
+   * but only use for `useMemo` or `useCallback` deps.
+   */
+  function useImmutableMark() {
+    return React.useContext(ImmutableContext);
+  }
+
+  /**
+   * Wrapped Component will be marked as Immutable.
+   * When Component parent trigger render,
+   * it will notice children component (use with `responseImmutable`) node that parent has updated.
+   */
+  function makeImmutable(Component, shouldTriggerRender) {
+    var refAble = supportRef(Component);
+    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 /*#__PURE__*/React.createElement(Component, _extends({}, props, refProps));
+      }
+      if (
+      // Always trigger re-render if `shouldTriggerRender` is not provided
+      !shouldTriggerRender || shouldTriggerRender(prevProps.current, props)) {
+        renderTimesRef.current += 1;
+      }
+      prevProps.current = props;
+      return /*#__PURE__*/React.createElement(ImmutableContext.Provider, {
+        value: renderTimesRef.current
+      }, /*#__PURE__*/React.createElement(Component, _extends({}, props, refProps)));
+    };
+    if (process.env.NODE_ENV !== 'production') {
+      ImmutableComponent.displayName = "ImmutableRoot(".concat(Component.displayName || Component.name, ")");
+    }
+    return refAble ? /*#__PURE__*/React.forwardRef(ImmutableComponent) : ImmutableComponent;
+  }
+
+  /**
+   * Wrapped Component with `React.memo`.
+   * But will rerender when parent with `makeImmutable` rerender.
+   */
+  function responseImmutable(Component, propsAreEqual) {
+    var refAble = supportRef(Component);
+    var ImmutableComponent = function ImmutableComponent(props, ref) {
+      var refProps = refAble ? {
+        ref: ref
+      } : {};
+      useImmutableMark();
+      return /*#__PURE__*/React.createElement(Component, _extends({}, props, refProps));
+    };
+    if (process.env.NODE_ENV !== 'production') {
+      ImmutableComponent.displayName = "ImmutableResponse(".concat(Component.displayName || Component.name, ")");
+    }
+    var MemoComponent = refAble ? /*#__PURE__*/React.forwardRef(ImmutableComponent) : ImmutableComponent;
+    return /*#__PURE__*/React.memo(MemoComponent, propsAreEqual);
+  }
+  return {
+    makeImmutable: makeImmutable,
+    responseImmutable: responseImmutable,
+    useImmutableMark: useImmutableMark
+  };
+}

package/es/_util/context/index.d.ts

@@ -0,0 +1,3 @@
+export * from './createContextSelector';
+export { default as createImmutable } from './immutable';
+export * from './immutable';

package/es/_util/context/index.js

@@ -0,0 +1,3 @@
+export * from "./createContextSelector";
+export { default as createImmutable } from "./immutable";
+export * from "./immutable";

package/es/_util/easings.d.ts

@@ -0,0 +1 @@
+export declare function easeInOutCubic(t: number, b: number, c: number, d: number): number;

package/es/_util/gapSize.d.ts

@@ -0,0 +1,3 @@
+import type { SizeType } from 'antd/lib/config-provider/SizeContext';
+export declare function isPresetSize(size?: SizeType | string | number): size is SizeType;
+export declare function isValidGapNumber(size?: SizeType | string | number): size is number;

package/es/_util/getScroll.d.ts

@@ -0,0 +1,3 @@
+export declare function isWindow(obj: any): obj is Window;
+declare const getScroll: (target: HTMLElement | Window | Document | null) => number;
+export default getScroll;

package/{esm → es}/_util/getScroll.js

@@ -1,4 +1,4 @@
-import isNonNullable from "./isNonNullable";
+import { isNonNullable } from "./is";
 export function isWindow(obj) {
   return isNonNullable(obj) && obj === obj.window;
 }

package/es/_util/hooks/index.d.ts

@@ -0,0 +1,11 @@
+export { default as useBreakpoint } from './useBreakpoint';
+export * from './useBreakpoint';
+export { default as useCssVar } from './useCssVar';
+export { default as useEvent } from './useEvent';
+export * from './useForceUpdate';
+export { default as useLayoutEffect } from './useLayoutEffect';
+export * from './useMultipleSelect';
+export * from './useOrientation';
+export * from './useProxyImperativeHandle';
+export * from './useSyncState';
+export * from './useTimeoutLock';

package/es/_util/hooks/index.js

@@ -0,0 +1,11 @@
+export { default as useBreakpoint } from "./useBreakpoint";
+export * from "./useBreakpoint";
+export { default as useCssVar } from "./useCssVar";
+export { default as useEvent } from "./useEvent";
+export * from "./useForceUpdate";
+export { default as useLayoutEffect } from "./useLayoutEffect";
+export * from "./useMultipleSelect";
+export * from "./useOrientation";
+export * from "./useProxyImperativeHandle";
+export * from "./useSyncState";
+export * from "./useTimeoutLock";

package/es/_util/hooks/useBreakpoint.d.ts

@@ -0,0 +1,5 @@
+export declare const responsiveArray: readonly ["xxxl", "xxl", "xl", "lg", "md", "sm", "xs"];
+export type Breakpoint = (typeof responsiveArray)[number];
+export type ScreenMap = Partial<Record<Breakpoint, boolean>>;
+export declare function useBreakpoint(needResponsive?: boolean): ScreenMap;
+export default useBreakpoint;

package/es/_util/hooks/useBreakpoint.js

@@ -0,0 +1,75 @@
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+import * as React from 'react';
+export var responsiveArray = ['xxxl', 'xxl', 'xl', 'lg', 'md', 'sm', 'xs'];
+// Simplified responsive observer that always returns all breakpoints as true
+// (We don't depend on antd v5 theme tokens for screen sizes)
+var defaultScreenMap = {
+  xxxl: true,
+  xxl: true,
+  xl: true,
+  lg: true,
+  md: true,
+  sm: true,
+  xs: true
+};
+export function useBreakpoint(needResponsive) {
+  var _React$useState = React.useState(defaultScreenMap),
+    _React$useState2 = _slicedToArray(_React$useState, 2),
+    screens = _React$useState2[0],
+    setScreens = _React$useState2[1];
+  React.useEffect(function () {
+    if (!needResponsive) {
+      return;
+    }
+    var mediaQueries = {
+      xs: window.matchMedia('(max-width: 575px)'),
+      sm: window.matchMedia('(min-width: 576px)'),
+      md: window.matchMedia('(min-width: 768px)'),
+      lg: window.matchMedia('(min-width: 992px)'),
+      xl: window.matchMedia('(min-width: 1200px)'),
+      xxl: window.matchMedia('(min-width: 1600px)'),
+      xxxl: window.matchMedia('(min-width: 2000px)')
+    };
+    var update = function update() {
+      var newScreens = {};
+      Object.keys(mediaQueries).forEach(function (key) {
+        newScreens[key] = mediaQueries[key].matches;
+      });
+      setScreens(newScreens);
+    };
+    update();
+    var mqlList = [];
+    var handlerList = [];
+    Object.keys(mediaQueries).forEach(function (key) {
+      var mql = mediaQueries[key];
+      var handler = function handler() {
+        return update();
+      };
+      if (mql.addEventListener) {
+        mql.addEventListener('change', handler);
+      } else {
+        // Legacy browsers use deprecated addListener API
+        mql.addListener(handler);
+      }
+      mqlList.push(mql);
+      handlerList.push(handler);
+    });
+    return function () {
+      mqlList.forEach(function (mql, index) {
+        var handler = handlerList[index];
+        if (mql.removeEventListener) {
+          mql.removeEventListener('change', handler);
+        } else {
+          mql.removeListener(handler);
+        }
+      });
+    };
+  }, [needResponsive]);
+  return screens;
+}
+export default useBreakpoint;

package/es/_util/hooks/useCssVar.d.ts

@@ -0,0 +1,3 @@
+import * as React from 'react';
+declare function useCssVar<T extends HTMLElement>(ref: React.RefObject<T | null>, varName: string, fallback?: number): number | undefined;
+export default useCssVar;

package/es/_util/hooks/useCssVar.js

@@ -0,0 +1,28 @@
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+import * as React from 'react';
+function useCssVar(ref, varName, fallback) {
+  var _React$useState = React.useState(fallback),
+    _React$useState2 = _slicedToArray(_React$useState, 2),
+    value = _React$useState2[0],
+    setValue = _React$useState2[1];
+  React.useLayoutEffect(function () {
+    var el = ref.current;
+    if (!el) {
+      return;
+    }
+    var computed = getComputedStyle(el).getPropertyValue(varName).trim();
+    if (computed) {
+      var num = Number.parseInt(computed, 10);
+      if (!Number.isNaN(num)) {
+        setValue(num);
+      }
+    }
+  }, [ref, varName, fallback]);
+  return value;
+}
+export default useCssVar;

package/es/_util/hooks/useEvent.d.ts

@@ -0,0 +1 @@
+export { default } from 'rc-util/lib/hooks/useEvent';

package/es/_util/hooks/useEvent.js

@@ -0,0 +1 @@
+export { default } from 'rc-util/lib/hooks/useEvent';

package/es/_util/hooks/useForceUpdate.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare const useForceUpdate: () => [any, React.DispatchWithoutAction];

package/es/_util/hooks/useLayoutEffect.d.ts

@@ -0,0 +1 @@
+export { default } from 'rc-util/lib/hooks/useLayoutEffect';

package/es/_util/hooks/useLayoutEffect.js

@@ -0,0 +1 @@
+export { default } from 'rc-util/lib/hooks/useLayoutEffect';

package/es/_util/hooks/useMultipleSelect.d.ts

@@ -0,0 +1,2 @@
+export type PrevSelectedIndex = null | number;
+export declare const useMultipleSelect: <T, K>(getKey: (item: T, index: number, array: T[]) => K) => readonly [(currentSelectedIndex: number, data: T[], selectedKeys: Set<K>) => K[], import("react").Dispatch<import("react").SetStateAction<PrevSelectedIndex>>];

package/es/_util/hooks/useMultipleSelect.js

@@ -0,0 +1,37 @@
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+import { useCallback, useState } from 'react';
+export var useMultipleSelect = function useMultipleSelect(getKey) {
+  var _useState = useState(null),
+    _useState2 = _slicedToArray(_useState, 2),
+    prevSelectedIndex = _useState2[0],
+    setPrevSelectedIndex = _useState2[1];
+  var multipleSelect = useCallback(function (currentSelectedIndex, data, selectedKeys) {
+    var configPrevSelectedIndex = prevSelectedIndex !== null && prevSelectedIndex !== void 0 ? prevSelectedIndex : currentSelectedIndex;
+    var startIndex = Math.min(configPrevSelectedIndex || 0, currentSelectedIndex);
+    var endIndex = Math.max(configPrevSelectedIndex || 0, currentSelectedIndex);
+    var rangeKeys = data.slice(startIndex, endIndex + 1).map(getKey);
+    var shouldSelected = rangeKeys.some(function (rangeKey) {
+      return !selectedKeys.has(rangeKey);
+    });
+    var changedKeys = [];
+    rangeKeys.forEach(function (item) {
+      if (shouldSelected) {
+        if (!selectedKeys.has(item)) {
+          changedKeys.push(item);
+        }
+        selectedKeys.add(item);
+      } else {
+        selectedKeys.delete(item);
+        changedKeys.push(item);
+      }
+    });
+    setPrevSelectedIndex(shouldSelected ? endIndex : null);
+    return changedKeys;
+  }, [prevSelectedIndex]);
+  return [multipleSelect, setPrevSelectedIndex];
+};

package/es/_util/hooks/useOrientation.d.ts

@@ -0,0 +1,2 @@
+export type Orientation = 'horizontal' | 'vertical';
+export declare const useOrientation: (orientation?: Orientation, vertical?: boolean, legacyDirection?: Orientation) => [Orientation, boolean];

package/es/_util/hooks/useProxyImperativeHandle.d.ts

@@ -0,0 +1,4 @@
+import type { DependencyList, Ref } from 'react';
+export declare const useProxyImperativeHandle: <NativeElementType extends HTMLElement, ReturnRefType extends {
+    nativeElement: NativeElementType;
+}>(ref: Ref<any> | undefined, init: () => ReturnRefType, deps?: DependencyList) => void;

package/{esm → es}/_util/hooks/useProxyImperativeHandle.js

@@ -10,14 +10,21 @@ var fillProxy = function fillProxy(element, handler) {
   });
   return element;
 };
-export var useProxyImperativeHandle = function useProxyImperativeHandle(ref, init) {
+export var useProxyImperativeHandle = function useProxyImperativeHandle(ref, init, deps) {
   return useImperativeHandle(ref, function () {
     var refObj = init();
     var nativeElement = refObj.nativeElement;
+
+    // null guard: ref 尚未挂载时（SSR / 首次 render / Strict Mode 二次挂载）
+    // 返回 refObj 本身，避免 Proxy(null) 导致 Reflect.get 崩溃
+    if (!nativeElement) {
+      return refObj;
+    }
     if (typeof Proxy !== 'undefined') {
+      var refObjKeys = new Set(Object.keys(refObj));
       return new Proxy(nativeElement, {
         get: function get(obj, prop) {
-          if (refObj[prop]) {
+          if (refObjKeys.has(prop)) {
             return refObj[prop];
           }
           return Reflect.get(obj, prop);
@@ -27,5 +34,5 @@ export var useProxyImperativeHandle = function useProxyImperativeHandle(ref, ini
 
     // Fallback of IE
     return fillProxy(nativeElement, refObj);
-  });
+  }, deps);
 };

package/es/_util/hooks/useSyncState.d.ts

@@ -0,0 +1,3 @@
+type UseSyncStateProps<T> = readonly [() => T, (newValue: T) => void];
+export declare const useSyncState: <T>(initialValue: T) => UseSyncStateProps<T>;
+export {};

package/es/_util/hooks/useTimeoutLock.d.ts

@@ -0,0 +1 @@
+export declare function useTimeoutLock<State>(defaultState?: State): [(state: State) => void, () => State | null];

package/es/_util/hooks/useTimeoutLock.js

@@ -0,0 +1,26 @@
+import * as React from 'react';
+export function useTimeoutLock(defaultState) {
+  var frameRef = React.useRef(defaultState !== null && defaultState !== void 0 ? defaultState : null);
+  var timeoutRef = React.useRef(null);
+  function cleanUp() {
+    if (timeoutRef.current) {
+      clearTimeout(timeoutRef.current);
+      timeoutRef.current = null;
+    }
+  }
+  function setState(newState) {
+    frameRef.current = newState;
+    cleanUp();
+    timeoutRef.current = setTimeout(function () {
+      frameRef.current = null;
+      timeoutRef.current = null;
+    }, 100);
+  }
+  function getState() {
+    return frameRef.current;
+  }
+  React.useEffect(function () {
+    return cleanUp;
+  }, []);
+  return [setState, getState];
+}

package/es/_util/index.d.ts

@@ -0,0 +1,11 @@
+import type { TooltipProps } from 'antd';
+export type LabelTooltipType = TooltipProps | TooltipProps['title'];
+export declare function toTooltipProps(tooltip: LabelTooltipType): TooltipProps | null;
+export * from './getScroll';
+export * from './is';
+export * from './rcUtil';
+export * from './scrollbar';
+export * from './scrollTo';
+export * from './type';
+export * from './validate';
+export * from './warning';

package/{esm → es}/_util/index.js

@@ -7,4 +7,12 @@ export function toTooltipProps(tooltip) {
   return {
     title: tooltip
   };
-}
+}
+export * from "./getScroll";
+export * from "./is";
+export * from "./rcUtil";
+export * from "./scrollbar";
+export * from "./scrollTo";
+export * from "./type";
+export * from "./validate";
+export * from "./warning";

package/es/_util/is.d.ts

@@ -0,0 +1,5 @@
+export declare const isNonNullable: <T>(val: T) => val is NonNullable<T>;
+export declare const isNumber: (val: any) => val is number;
+export declare const isString: (val: any) => val is string;
+export declare const isPlainObject: <T extends object = object>(val: any) => val is T;
+export declare const isFunction: (val: any) => val is (...args: any[]) => any;

package/es/_util/is.js

@@ -0,0 +1,16 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+export var isNonNullable = function isNonNullable(val) {
+  return val !== undefined && val !== null;
+};
+export var isNumber = function isNumber(val) {
+  return typeof val === 'number' && !Number.isNaN(val);
+};
+export var isString = function isString(val) {
+  return typeof val === 'string';
+};
+export var isPlainObject = function isPlainObject(val) {
+  return val !== null && _typeof(val) === 'object';
+};
+export var isFunction = function isFunction(val) {
+  return typeof val === 'function';
+};

package/es/_util/rcUtil.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Local shim for `@rc-component/util`.
+ * Maps all needed functions to `rc-util` subpaths (React 17 compatible).
+ */
+export { default as useEvent } from 'rc-util/lib/hooks/useEvent';
+export { default as useLayoutEffect } from 'rc-util/lib/hooks/useLayoutEffect';
+export { default as useMemo } from 'rc-util/lib/hooks/useMemo';
+export { default as useMergedState } from 'rc-util/lib/hooks/useMergedState';
+export { default as useControlledState } from 'rc-util/lib/hooks/useMergedState';
+export { default as isEqual } from 'rc-util/lib/isEqual';
+export { default as KeyCode } from 'rc-util/lib/KeyCode';
+export { default as omit } from 'rc-util/lib/omit';
+export { default as pickAttrs } from 'rc-util/lib/pickAttrs';
+export { default as raf } from 'rc-util/lib/raf';
+export { default as get } from 'rc-util/lib/utils/get';
+export declare function toArray<T>(value: T | T[]): T[];
+export declare function mergeProps<T extends Record<string, any>>(...args: (Partial<T> | undefined)[]): T;