@slithy/react-grid-gallery 0.1.1 → 0.2.0

package/dist/index.d.ts

@@ -22,8 +22,12 @@ type GridLayoutRow<T> = {
     height: number;
 };
 type GridRow<T> = {
+    rowIndex: number;
+    startIndex: number;
     items: Array<{
         item: GalleryItem<T>;
+        itemIndex: number;
+        colIndex: number;
         width: number;
         height: number;
         loaded: boolean;
@@ -42,6 +46,7 @@ type VirtualWindow = {
 declare function useGridGallery<T>(items: GalleryItem<T>[], options: GridOptions, scrollContainerRef?: ScrollContainerRef): {
     containerRef: RefObject<HTMLDivElement | null>;
     rows: GridRow<T>[];
+    totalRows: number;
     cellWidth: number;
     cellHeight: number;
     gap: number;

package/dist/index.js

@@ -1,10 +1,11 @@
 // src/computeGridLayout.ts
 function computeGridLayout(items, columns, cellWidth, cellHeight) {
-  if (items.length === 0 || columns <= 0 || cellWidth <= 0) return [];
+  if (items.length === 0 || !Number.isFinite(columns) || !Number.isFinite(cellWidth) || !Number.isFinite(cellHeight) || columns <= 0 || cellWidth <= 0 || cellHeight < 0) return [];
+  const columnCount = Math.max(1, Math.floor(columns));
   const rows = [];
-  for (let i = 0; i < items.length; i += columns) {
+  for (let i = 0; i < items.length; i += columnCount) {
     rows.push({
-      items: items.slice(i, i + columns),
+      items: items.slice(i, i + columnCount),
       width: cellWidth,
       height: cellHeight
     });
@@ -67,13 +68,19 @@ function useVirtualWindow(containerRef, enabled, scrollContainerRef) {
 }
 
 // src/useGridGallery.ts
+function finitePositive(value, fallback) {
+  return Number.isFinite(value) && value > 0 ? value : fallback;
+}
+function finiteNonNegative(value, fallback = 0) {
+  return Number.isFinite(value) && value >= 0 ? value : fallback;
+}
 function useGridGallery(items, options, scrollContainerRef) {
   const containerRef = useRef2(null);
   const [containerWidth, setContainerWidth] = useState2(0);
   const [focusedIndex, setFocusedIndex] = useState2(0);
   const pendingFocusRef = useRef2(null);
   const loadedSet = useRef2(/* @__PURE__ */ new Set());
-  const [loadedVersion, setLoadedVersion] = useState2(0);
+  const [loadedTick, setLoadedTick] = useState2(0);
   const virtualRange = useVirtualWindow(containerRef, options.virtualize === true, scrollContainerRef);
   useEffect2(() => {
     const observer = new ResizeObserver((entries) => {
@@ -87,49 +94,83 @@ function useGridGallery(items, options, scrollContainerRef) {
   const onLoad = useCallback((key) => {
     if (!loadedSet.current.has(key)) {
       loadedSet.current.add(key);
-      setLoadedVersion((v) => v + 1);
+      setLoadedTick((v) => v + 1);
     }
   }, []);
   const onError = useCallback((_key) => {
   }, []);
+  const rawColumns = typeof options.columns === "function" ? options.columns(containerWidth) : options.columns;
   const resolvedColumns = Math.max(
     1,
-    Math.round(typeof options.columns === "function" ? options.columns(containerWidth) : options.columns)
+    Math.round(finitePositive(rawColumns, 1))
   );
-  const resolvedGap = typeof options.gap === "function" ? options.gap(containerWidth) : options.gap ?? 0;
-  const resolvedAspectRatio = typeof options.aspectRatio === "function" ? options.aspectRatio(containerWidth) : options.aspectRatio ?? 1;
-  const cellWidth = containerWidth > 0 ? Math.floor((containerWidth - resolvedGap * (resolvedColumns - 1)) / resolvedColumns) : 0;
+  const rawGap = typeof options.gap === "function" ? options.gap(containerWidth) : options.gap ?? 0;
+  const resolvedGap = finiteNonNegative(rawGap);
+  const rawAspectRatio = typeof options.aspectRatio === "function" ? options.aspectRatio(containerWidth) : options.aspectRatio ?? 1;
+  const resolvedAspectRatio = finitePositive(rawAspectRatio, 1);
+  const cellWidth = containerWidth > 0 ? Math.max(0, Math.floor((containerWidth - resolvedGap * (resolvedColumns - 1)) / resolvedColumns)) : 0;
   const cellHeight = cellWidth > 0 ? Math.round(cellWidth / resolvedAspectRatio) : 0;
-  const rows = useMemo(() => {
-    if (cellWidth === 0) return [];
-    const layoutRows = computeGridLayout(items, resolvedColumns, cellWidth, cellHeight);
-    return layoutRows.map((row) => ({
-      height: row.height,
-      items: row.items.map((item) => ({
-        item,
-        width: row.width,
-        height: row.height,
-        loaded: loadedSet.current.has(item.key)
-      }))
-    }));
-  }, [items, resolvedColumns, cellWidth, cellHeight, loadedVersion]);
+  const hasLayout = cellWidth > 0 && cellHeight >= 0 && items.length > 0;
+  const totalRows = hasLayout ? Math.ceil(items.length / resolvedColumns) : 0;
   const rowStride = cellHeight + resolvedGap;
   let virtualWindow = null;
-  if (options.virtualize && virtualRange !== null && rows.length > 0) {
-    const totalRows = rows.length;
+  if (options.virtualize && virtualRange !== null && totalRows > 0 && rowStride > 0) {
     const overscan = options.overscan ?? cellHeight * 4;
     const visibleTop = virtualRange.top - overscan;
     const visibleBottom = virtualRange.bottom + overscan;
-    let firstIndex = Math.max(0, Math.floor(visibleTop / rowStride));
-    let lastIndex = Math.min(totalRows - 1, Math.ceil(visibleBottom / rowStride) - 1);
+    const maxRowIndex = totalRows - 1;
+    const firstIndex = Math.min(maxRowIndex, Math.max(0, Math.floor(visibleTop / rowStride)));
+    let lastIndex = Math.min(maxRowIndex, Math.max(0, Math.ceil(visibleBottom / rowStride) - 1));
     if (firstIndex > lastIndex) {
-      firstIndex = 0;
-      lastIndex = totalRows - 1;
+      lastIndex = firstIndex;
     }
     const topSpacerHeight = firstIndex * rowStride;
     const bottomSpacerHeight = (totalRows - 1 - lastIndex) * rowStride;
     virtualWindow = { firstIndex, lastIndex, topSpacerHeight, bottomSpacerHeight };
   }
+  const rows = useMemo(() => {
+    if (!hasLayout) return [];
+    if (!options.virtualize) {
+      const layoutRows = computeGridLayout(items, resolvedColumns, cellWidth, cellHeight);
+      return layoutRows.map((row, rowIndex) => {
+        const startIndex = rowIndex * resolvedColumns;
+        return {
+          rowIndex,
+          startIndex,
+          height: row.height,
+          items: row.items.map((item, colIndex) => ({
+            item,
+            itemIndex: startIndex + colIndex,
+            colIndex,
+            width: row.width,
+            height: row.height,
+            loaded: loadedSet.current.has(item.key)
+          }))
+        };
+      });
+    }
+    if (virtualWindow === null) return [];
+    const renderRows = [];
+    for (let rowIndex = virtualWindow.firstIndex; rowIndex <= virtualWindow.lastIndex; rowIndex++) {
+      const startIndex = rowIndex * resolvedColumns;
+      const endIndex = Math.min(startIndex + resolvedColumns, items.length);
+      const rowItems = items.slice(startIndex, endIndex);
+      renderRows.push({
+        rowIndex,
+        startIndex,
+        height: cellHeight,
+        items: rowItems.map((item, colIndex) => ({
+          item,
+          itemIndex: startIndex + colIndex,
+          colIndex,
+          width: cellWidth,
+          height: cellHeight,
+          loaded: loadedSet.current.has(item.key)
+        }))
+      });
+    }
+    return renderRows;
+  }, [cellHeight, cellWidth, hasLayout, items, options.virtualize, resolvedColumns, virtualWindow, loadedTick]);
   const isControlled = options.focusedIndex !== void 0;
   const padding = options.padding ?? 0;
   function scrollToRow(rowIndex) {
@@ -223,6 +264,7 @@ function useGridGallery(items, options, scrollContainerRef) {
   return {
     containerRef,
     rows,
+    totalRows,
     cellWidth,
     cellHeight,
     gap: resolvedGap,
@@ -239,14 +281,11 @@ function useGridGallery(items, options, scrollContainerRef) {
 // src/GridGallery.tsx
 import { jsx, jsxs } from "react/jsx-runtime";
 function GridGallery({ items, renderItem, scrollContainerRef, ...options }) {
-  const { containerRef, rows, cellHeight, gap, columns, onLoad, onError, virtualWindow, focusedIndex, handleItemFocus, handleItemKeyDown } = useGridGallery(
+  const { containerRef, rows, totalRows, cellHeight, gap, columns, onLoad, onError, virtualWindow, focusedIndex, handleItemFocus, handleItemKeyDown } = useGridGallery(
     items,
     options,
     scrollContainerRef
   );
-  const firstIndex = virtualWindow?.firstIndex ?? 0;
-  const lastIndex = virtualWindow?.lastIndex ?? rows.length - 1;
-  const visibleRows = virtualWindow ? rows.slice(firstIndex, lastIndex + 1) : rows;
   const padding = options.padding ?? 0;
   const navigable = options.navigable === true;
   return /* @__PURE__ */ jsxs(
@@ -254,18 +293,16 @@ function GridGallery({ items, renderItem, scrollContainerRef, ...options }) {
     {
       ref: containerRef,
       style: { display: "flex", flexDirection: "column", gap: `${gap}px`, padding: padding > 0 ? `${padding}px` : void 0 },
-      ...navigable ? { role: "grid", "aria-rowcount": rows.length, "aria-colcount": columns } : {},
+      ...navigable ? { role: "grid", "aria-rowcount": totalRows, "aria-colcount": columns } : {},
       children: [
         virtualWindow && virtualWindow.topSpacerHeight > 0 && /* @__PURE__ */ jsx("div", { style: { height: virtualWindow.topSpacerHeight, contain: "layout" } }),
-        visibleRows.map((row, i) => {
-          const rowIndex = firstIndex + i;
+        rows.map((row) => {
           return /* @__PURE__ */ jsx(
             "div",
             {
               style: { display: "grid", gridTemplateColumns: `repeat(${columns}, 1fr)`, gap: `${gap}px`, contain: "layout" },
-              ...navigable ? { role: "row", "aria-rowindex": rowIndex + 1 } : {},
-              children: row.items.map(({ item, loaded }, colIdx) => {
-                const itemIndex = rowIndex * columns + colIdx;
+              ...navigable ? { role: "row", "aria-rowindex": row.rowIndex + 1 } : {},
+              children: row.items.map(({ item, itemIndex, colIndex, loaded }) => {
                 const focused = navigable && focusedIndex === itemIndex;
                 return /* @__PURE__ */ jsx(
                   "div",
@@ -273,7 +310,7 @@ function GridGallery({ items, renderItem, scrollContainerRef, ...options }) {
                     style: { height: `${cellHeight}px` },
                     ...navigable ? {
                       role: "gridcell",
-                      "aria-colindex": colIdx + 1,
+                      "aria-colindex": colIndex + 1,
                       tabIndex: focused ? 0 : -1,
                       "data-grid-index": itemIndex,
                       onKeyDown: (e) => handleItemKeyDown(itemIndex, e),
@@ -292,7 +329,7 @@ function GridGallery({ items, renderItem, scrollContainerRef, ...options }) {
                 );
               })
             },
-            rowIndex
+            row.rowIndex
           );
         }),
         virtualWindow && virtualWindow.bottomSpacerHeight > 0 && /* @__PURE__ */ jsx("div", { style: { height: virtualWindow.bottomSpacerHeight, contain: "layout" } })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@slithy/react-grid-gallery",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "React grid gallery component.",
   "type": "module",
   "exports": {
@@ -28,13 +28,16 @@
     "tsup": "^8",
     "typescript": "^5",
     "vitest": "^4.1.2",
-    "@slithy/tsconfig": "0.0.0",
-    "@slithy/eslint-config": "0.0.0"
+    "@slithy/eslint-config": "0.0.0",
+    "@slithy/tsconfig": "0.0.0"
   },
   "repository": {
     "type": "git",
     "url": "https://github.com/mjcampagna/react-grid-gallery"
   },
+  "publishConfig": {
+    "access": "public"
+  },
   "author": "mjcampagna",
   "license": "MIT",
   "scripts": {