@wallarm-org/design-system 1.28.2-rc-fix-table-window-scroll-root.2 → 1.29.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wallarm-org/design-system",
-  "version": "1.28.2-rc-fix-table-window-scroll-root.2",
+  "version": "1.29.0",
   "description": "Core design system library with React components and Storybook documentation",
   "publishConfig": {
     "access": "public",

package/dist/components/Table/hooks/useWindowScrollRoot.d.ts

@@ -1,14 +0,0 @@
-import { type RefObject } from 'react';
-import { type ScrollRoot } from '../lib';
-/** The `virtualized='window'` scroll root, shared from the table shell to its body. */
-export declare const WindowScrollRootContext: import("react").Context<ScrollRoot | null>;
-/**
- * Resolves the scroll root of a `virtualized='window'` table once, for the
- * virtualizer, the edge detection and the prepend compensation alike.
- *
- * Starts on the window. At mount the body has no rows yet, so a pane that will
- * scroll does not overflow and stays on the window. While the root is the
- * window, a scroll of any ancestor of the table re-resolves it: a pane the user
- * scrolls overflows by then. An element root is final.
- */
-export declare const useWindowScrollRoot: (containerRef: RefObject<HTMLElement | null>) => ScrollRoot | null;

package/dist/components/Table/hooks/useWindowScrollRoot.js

@@ -1,35 +0,0 @@
-import { createContext, useLayoutEffect, useRef, useState } from "react";
-import { getScrollRoot, isWindowScrollRoot } from "../lib/index.js";
-const WindowScrollRootContext = createContext(null);
-const useWindowScrollRoot = (containerRef)=>{
-    const [scrollRoot, setScrollRoot] = useState(()=>"u" < typeof window ? null : window);
-    const scrollRootRef = useRef(scrollRoot);
-    useLayoutEffect(()=>{
-        const container = containerRef.current;
-        if (!container) return;
-        const resolve = ()=>{
-            const next = getScrollRoot(container);
-            if (next === scrollRootRef.current) return;
-            scrollRootRef.current = next;
-            setScrollRoot(next);
-        };
-        resolve();
-        const onScroll = (event)=>{
-            const { target } = event;
-            if (scrollRootRef.current && !isWindowScrollRoot(scrollRootRef.current)) return;
-            if (!(target instanceof Element) || target === container || !target.contains(container)) return;
-            resolve();
-        };
-        document.addEventListener('scroll', onScroll, {
-            capture: true,
-            passive: true
-        });
-        return ()=>document.removeEventListener('scroll', onScroll, {
-                capture: true
-            });
-    }, [
-        containerRef
-    ]);
-    return scrollRoot;
-};
-export { WindowScrollRootContext, useWindowScrollRoot };

package/dist/components/Table/lib/scrollRoot.d.ts

@@ -1,24 +0,0 @@
-export type ScrollRoot = HTMLElement | Window;
-export declare const isWindowScrollRoot: (root: ScrollRoot) => root is Window;
-/**
- * What a `virtualized='window'` table actually scrolls with: the nearest
- * ancestor that scrolls vertically, else the window. An app shell that scrolls
- * its content pane instead of the document (e.g. a micro-frontend host) keeps
- * `window.scrollY` at 0 forever, so tracking the window there never virtualizes
- * past the first screen and never reaches the end.
- *
- * `overflow-y` alone is not enough: a non-`visible` `overflow-x` (a plain
- * `overflow-x-hidden` layout wrapper) computes `overflow-y: visible` to `auto`
- * on a box that grows with its content and never scrolls. Only a box whose
- * content overflows it counts — so a pane that does not overflow yet resolves
- * to the window (`useWindowScrollRoot` re-resolves once an ancestor scrolls).
- */
-export declare const getScrollRoot: (el: Element | null) => ScrollRoot;
-export declare const getScrollMetrics: (root: ScrollRoot) => {
-    scrollTop: number;
-    clientHeight: number;
-    scrollHeight: number;
-};
-export declare const scrollRootBy: (root: ScrollRoot, delta: number) => void;
-/** `el`'s top in the root's scroll-content coordinates (the virtualizer's `scrollMargin`). */
-export declare const getOffsetTopInScrollRoot: (el: HTMLElement, root: ScrollRoot) => number;

package/dist/components/Table/lib/scrollRoot.js

@@ -1,22 +0,0 @@
-import { getDocumentOffsetTop } from "../TableBody/lib/getDocumentOffsetTop.js";
-const SCROLLABLE_OVERFLOW = /(auto|scroll|overlay)/;
-const isWindowScrollRoot = (root)=>root === window;
-const getScrollRoot = (el)=>{
-    for(let node = el?.parentElement; node && node !== document.body; node = node.parentElement)if (SCROLLABLE_OVERFLOW.test(getComputedStyle(node).overflowY) && node.scrollHeight > node.clientHeight) return node;
-    return window;
-};
-const getScrollMetrics = (root)=>isWindowScrollRoot(root) ? {
-        scrollTop: root.scrollY,
-        clientHeight: root.innerHeight,
-        scrollHeight: document.documentElement.scrollHeight
-    } : {
-        scrollTop: root.scrollTop,
-        clientHeight: root.clientHeight,
-        scrollHeight: root.scrollHeight
-    };
-const scrollRootBy = (root, delta)=>{
-    if (isWindowScrollRoot(root)) root.scrollBy(0, delta);
-    else root.scrollTop += delta;
-};
-const getOffsetTopInScrollRoot = (el, root)=>isWindowScrollRoot(root) ? getDocumentOffsetTop(el) : el.getBoundingClientRect().top - root.getBoundingClientRect().top - root.clientTop + root.scrollTop;
-export { getOffsetTopInScrollRoot, getScrollMetrics, getScrollRoot, isWindowScrollRoot, scrollRootBy };