@vuu-ui/vuu-utils 3.3.17 → 3.4.1

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "3.3.17",
+  "version": "3.4.1",
   "author": "heswell",
   "main": "./src/index.js",
   "license": "Apache-2.0",
@@ -15,14 +15,14 @@
   },
   "devDependencies": {
     "@dnd-kit/react": "^0.1.21",
-    "@vuu-ui/vuu-data-types": "3.3.17",
-    "@vuu-ui/vuu-table-types": "3.3.17",
-    "@vuu-ui/vuu-filter-types": "3.3.17",
-    "@vuu-ui/vuu-protocol-types": "3.3.17"
+    "@vuu-ui/vuu-data-types": "3.4.1",
+    "@vuu-ui/vuu-table-types": "3.4.1",
+    "@vuu-ui/vuu-filter-types": "3.4.1",
+    "@vuu-ui/vuu-protocol-types": "3.4.1"
   },
   "peerDependencies": {
     "@internationalized/date": "^3.0.0",
-    "@vuu-ui/vuu-filter-parser": "3.3.17",
+    "@vuu-ui/vuu-filter-parser": "3.4.1",
     "clsx": "^2.0.0",
     "react": "^19.2.3",
     "react-dom": "^19.2.3"

package/src/html-utils.js

@@ -81,6 +81,40 @@ function getScrollbarSize() {
     }
     return size;
 }
+const DEFAULT_MAX_SCROLL_HEIGHT = 33000000;
+const MAX_PROBE_HEIGHT = 2 ** 26;
+const maxScrollHeightByDevicePixelRatio = new Map();
+function getMaxScrollHeight(doc = globalThis.document) {
+    if (doc?.body === void 0 || null === doc.body) return DEFAULT_MAX_SCROLL_HEIGHT;
+    const devicePixelRatio = doc.defaultView?.devicePixelRatio ?? 1;
+    const cachedValue = maxScrollHeightByDevicePixelRatio.get(devicePixelRatio);
+    if (void 0 !== cachedValue) return cachedValue;
+    const outer = doc.createElement("div");
+    outer.style.cssText = "position:absolute;top:-200px;left:-200px;width:50px;height:50px;overflow:scroll;visibility:hidden;";
+    const inner = doc.createElement("div");
+    inner.style.width = "1px";
+    outer.appendChild(inner);
+    doc.body.appendChild(outer);
+    const isHonoured = (height)=>{
+        inner.style.height = `${height}px`;
+        return outer.scrollHeight >= height - 1;
+    };
+    let lo = 0;
+    let hi = MAX_PROBE_HEIGHT;
+    while(hi - lo > 1){
+        const mid = Math.floor((lo + hi) / 2);
+        if (isHonoured(mid)) lo = mid;
+        else hi = mid;
+    }
+    inner.style.height = `${lo}px`;
+    const maxScrollHeight = Math.min(lo, outer.scrollHeight);
+    outer.remove();
+    if (maxScrollHeight > 0) {
+        maxScrollHeightByDevicePixelRatio.set(devicePixelRatio, maxScrollHeight);
+        return maxScrollHeight;
+    }
+    return DEFAULT_MAX_SCROLL_HEIGHT;
+}
 const dispatchMouseEvent = (el, type)=>{
     const evt = new MouseEvent(type, {
         view: window,
@@ -105,4 +139,4 @@ const dispatchCustomEvent = (el, type)=>{
     });
     el.dispatchEvent(evt);
 };
-export { createEl, dispatchCustomEvent, dispatchKeyboardEvent, dispatchMouseEvent, focusFirstFocusableElement, getClosest, getClosestIndexItem, getElementByDataIndex, getElementDataIndex, getFocusableElement, getScrollbarSize, hasOpenOptionList, isDateInput, isInputElement, isSelectableElement, queryClosest };
+export { DEFAULT_MAX_SCROLL_HEIGHT, createEl, dispatchCustomEvent, dispatchKeyboardEvent, dispatchMouseEvent, focusFirstFocusableElement, getClosest, getClosestIndexItem, getElementByDataIndex, getElementDataIndex, getFocusableElement, getMaxScrollHeight, getScrollbarSize, hasOpenOptionList, isDateInput, isInputElement, isSelectableElement, queryClosest };

package/src/useResizeObserver.js

@@ -29,7 +29,7 @@ const getTargetSize = (element, size, dimension)=>{
             return 0;
     }
 };
-const resizeObserver = new ResizeObserver((entries)=>{
+const resizeObserver = "u" < typeof ResizeObserver ? void 0 : new ResizeObserver((entries)=>{
     for (const entry of entries){
         const { target, borderBoxSize, contentBoxSize } = entry;
         const observedTarget = observedMap.get(target);
@@ -81,7 +81,7 @@ function useResizeObserver(ref, dimensions, onResize, reportInitialSize = false)
             if (observedTarget) {
                 const measurements = measure(target);
                 observedTarget.measurements = measurements;
-                resizeObserver.observe(target);
+                resizeObserver?.observe(target);
                 if (reportInitialSize) onResize(measurements);
             } else console.log("%cuseResizeObserver an target expected to be under observation wa snot found. This warrants investigation", "font-weight:bold; color:red;");
         }
@@ -93,7 +93,7 @@ function useResizeObserver(ref, dimensions, onResize, reportInitialSize = false)
         }
         return ()=>{
             if (target && observedMap.has(target)) {
-                resizeObserver.unobserve(target);
+                resizeObserver?.unobserve(target);
                 observedMap.delete(target);
             }
         };

package/types/filters/filter-utils.d.ts

@@ -51,7 +51,8 @@ export declare const stripFilterFromColumns: (columns: RuntimeColumnDescriptor[]
     allowColumnHeaderMenu?: false;
     colHeaderContentRenderer?: string;
     colHeaderLabelRenderer?: string;
-    exportFormatter?: (value: unknown) => string;
+    exportable?: boolean;
+    exportFormatter?: (value: unknown, row: import("@vuu-ui/vuu-table-types").RowAccessor) => string;
     getIcon?: (row: import("@vuu-ui/vuu-table-types").DataRow) => string | undefined;
     groupable?: boolean;
     hidden?: boolean;

package/types/html-utils.d.ts

@@ -13,6 +13,22 @@ export declare const isInputElement: (el: HTMLElement | EventTarget | null) => e
 export declare const isDateInput: (el: HTMLElement | EventTarget | null) => el is HTMLInputElement;
 export declare const hasOpenOptionList: (el: HTMLElement | EventTarget | null) => boolean | undefined;
 export declare function getScrollbarSize(): number;
+/**
+ * Used when the max scroll height cannot be measured, e.g. outside a browser.
+ */
+export declare const DEFAULT_MAX_SCROLL_HEIGHT = 33000000;
+/**
+ * Measure the largest scrollHeight (in CSS pixels) the browser supports for a
+ * scrollable element. Engines have an internal layout limit, which shrinks in
+ * CSS pixels as browser zoom increases, e.g.
+ *   Chromium/WebKit: ~33.5M at 100%, ~11.18M at 300%
+ *   Firefox:         ~17.9M at 100%, ~5.97M at 300%
+ * Chromium/WebKit clamp heights above the limit, Firefox ignores them entirely,
+ * so a single oversized probe cannot be used. Instead we binary search for the
+ * largest height that is honoured. Browser zoom changes devicePixelRatio, so
+ * results are cached per ratio.
+ */
+export declare function getMaxScrollHeight(doc?: Document | undefined): number;
 export type MouseEventTypes = "dblclick" | "click";
 export type KeyboardEventTypes = "keydown" | "keypress" | "keyup";
 export declare const dispatchMouseEvent: (el: HTMLElement, type: MouseEventTypes) => void;