@chalabi/svelte-sheets 2.0.3 → 2.0.5

package/dist/Sheet.svelte

@@ -131,11 +131,23 @@ $: {
         currentValue = "";
     }
 }
+function getDefaultColWidth() {
+    const w = config.defaultColWidth;
+    if (typeof w === "string") {
+        return Number(w.replace("px", "")) || 50;
+    }
+    return Number(w) || 50;
+}
 function getColumnsWidth(i) {
-    var _a, _b, _c;
-    return Number(typeof ((_a = columns[i]) === null || _a === void 0 ? void 0 : _a.width) == "string"
-        ? (_b = columns[i]) === null || _b === void 0 ? void 0 : _b.width.replace("px", "")
-        : ((_c = columns[i]) === null || _c === void 0 ? void 0 : _c.width) || config.defaultColWidth);
+    var _a;
+    const colWidth = (_a = columns[i]) === null || _a === void 0 ? void 0 : _a.width;
+    if (colWidth !== undefined && colWidth !== null) {
+        if (typeof colWidth === "string") {
+            return Number(colWidth.replace("px", "")) || getDefaultColWidth();
+        }
+        return Number(colWidth) || getDefaultColWidth();
+    }
+    return getDefaultColWidth();
 }
 function getRowHeight(i) {
     var _a, _b, _c, _d;
@@ -180,45 +192,58 @@ export function onInputChange(value, row, column) {
 }
 function refresh(data, viewport_height, viewport_width) {
     return __awaiter(this, void 0, void 0, function* () {
+        if (!viewport)
+            return;
         const { scrollTop, scrollLeft } = viewport;
         yield tick(); // wait until the DOM is up to date
+        const defaultHeight = 24;
+        const defaultWidth = getDefaultColWidth();
+        // Safety limits to prevent infinite loops
+        const maxRowsToRender = Math.max(data.length, Math.ceil((viewport_height + bottom_buffer * 2) / defaultHeight) + 10, 100);
+        const maxColsToRender = Math.max(columns.length, Math.ceil((viewport_width + right_buffer * 2) / defaultWidth) + 10, 50);
         let content_height = top - scrollTop - bottom_buffer;
         let content_width = left - scrollLeft - left_buffer;
         // vertical
         let y = startY;
-        while (content_height < viewport_height) {
+        while (content_height < viewport_height && y < maxRowsToRender) {
             let row = rowElements[y - startY];
             if (!row) {
                 endY = y + 1;
                 yield tick(); // render the newly visible row
                 row = rowElements[y - startY];
+                // If still no row after tick, break to prevent infinite loop
+                if (!row)
+                    break;
             }
             const row_height = (height_map[y] = getRowHeight(y));
             content_height += row_height;
             y += 1;
         }
-        endY = y;
+        endY = Math.max(y, 1);
         let remaining = data.length - endY;
-        average_height = (top + content_height) / endY;
-        bottom = remaining * average_height;
+        average_height = endY > 0 ? (top + content_height) / endY : defaultHeight;
+        bottom = remaining * (average_height || defaultHeight);
         height_map.length = data.length;
         // horizontal
         let x = startX;
-        while (content_width < viewport_width) {
+        while (content_width < viewport_width && x < maxColsToRender) {
             let col = colElements[x - startX];
             if (!col) {
                 endX = x + 1;
                 yield tick(); // render the newly visible col
                 col = colElements[x - startX];
+                // If still no col after tick, break to prevent infinite loop
+                if (!col)
+                    break;
             }
             const col_width = (width_map[x] = getColumnsWidth(x));
             content_width += col_width;
             x += 1;
         }
-        endX = x;
+        endX = Math.max(x, 1);
         let remains = columns.length - endX;
-        average_width = (left + content_width) / endX;
-        right = remains * average_width;
+        average_width = endX > 0 ? (left + content_width) / endX : defaultWidth;
+        right = remains * (average_width || defaultWidth);
         width_map.length = columns.length;
     });
 }
@@ -229,6 +254,9 @@ let scrollTop;
 $: (function scrollX() {
     if (scrollLeft === undefined || !colElements)
         return;
+    // Ensure we have valid dimensions to work with
+    const totalCols = Math.max(columns.length, endX, 1);
+    const defaultWidth = getDefaultColWidth();
     // if (!scrollLeft) ;
     // horizontal scrolling
     for (let v = 0; v < colElements.length; v += 1) {
@@ -236,8 +264,8 @@ $: (function scrollX() {
     }
     let c = 0;
     let x = 0;
-    while (true) {
-        const col_width = width_map[c] || average_width;
+    while (c < totalCols) {
+        const col_width = width_map[c] || average_width || defaultWidth;
         if (x + col_width > scrollLeft - left_buffer) {
             startX = c;
             left = x;
@@ -246,31 +274,40 @@ $: (function scrollX() {
         x += col_width;
         c += 1;
     }
-    while (true) {
-        x += width_map[c] || average_width;
+    // Safety: ensure we found a valid startX
+    if (c >= totalCols) {
+        startX = Math.max(0, totalCols - 1);
+        left = x;
+    }
+    while (c < totalCols + Math.ceil((viewport_width + right_buffer) / defaultWidth)) {
+        const w = width_map[c] || average_width || defaultWidth;
+        x += w;
         c += 1;
         if (x > scrollLeft + viewport_width + right_buffer)
             break;
     }
-    endX = c;
+    endX = Math.max(c, 1);
     const remaining = endX > columns.length
-        ? (viewport_width + right_buffer) / 24
+        ? (viewport_width + right_buffer) / defaultWidth
         : columns.length - endX;
-    average_width = x / endX;
+    average_width = endX > 0 ? x / endX : defaultWidth;
     // while (c < columns.length) width_map[c++] = average_width;
-    right = remaining * average_width;
+    right = remaining * (average_width || defaultWidth);
 })();
 $: (function scrollY() {
     if (scrollTop === undefined || !rowElements)
         return;
+    // Ensure we have valid dimensions to work with
+    const totalRows = Math.max(data.length, endY, 1);
+    const defaultHeight = 24;
     // vertical scrolling
     for (let v = 0; v < rowElements.length; v += 1) {
         height_map[startY + v] = getRowHeight(startY + v);
     }
     let r = 0;
     let y = 0;
-    while (true) {
-        const row_height = height_map[r] || average_height;
+    while (r < totalRows) {
+        const row_height = height_map[r] || average_height || defaultHeight;
         if (y + row_height > scrollTop - top_buffer) {
             startY = r;
             top = y;
@@ -279,19 +316,25 @@ $: (function scrollY() {
         y += row_height;
         r += 1;
     }
-    while (true) {
-        y += height_map[r] || average_height;
+    // Safety: ensure we found a valid startY
+    if (r >= totalRows) {
+        startY = Math.max(0, totalRows - 1);
+        top = y;
+    }
+    while (r < totalRows + Math.ceil((viewport_height + bottom_buffer) / defaultHeight)) {
+        const h = height_map[r] || average_height || defaultHeight;
+        y += h;
         r += 1;
         if (y > scrollTop + viewport_height + bottom_buffer)
             break;
     }
-    endY = r;
+    endY = Math.max(r, 1);
     const remaining = endY > data.length
-        ? (viewport_height + bottom_buffer) / 24
+        ? (viewport_height + bottom_buffer) / defaultHeight
         : data.length - endY;
-    average_height = y / endY;
+    average_height = endY > 0 ? y / endY : defaultHeight;
     // while (r < data.length) height_map[r++] = average_height;
-    bottom = remaining * average_height;
+    bottom = remaining * (average_height || defaultHeight);
 })();
 function handle_scroll(e) {
     scrollTop = viewport.scrollTop;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chalabi/svelte-sheets",
-  "version": "2.0.3",
+  "version": "2.0.5",
   "description": "Run your excel sheet in the browser!",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",