web-mojo 2.1.175 → 2.1.244

package/dist/chunks/{FilePreviewView-Crpalaos.js → FilePreviewView-CCngMe-J.js}

@@ -1,8 +1,8 @@
-import { M as Model, C as Collection, T as ToastService, G as GroupList, c as UserList } from "./User-DI3U4oRV.js";
-import { r as rest, V as View, d as dataFormatter, M as Mustache } from "./WebApp-B2r2EDj7.js";
-import { P as Page } from "./Page-tbcVc_Wl.js";
-import Dialog from "./Dialog-eoLNdg-d.js";
-import { F as FormView } from "./FormView-fUbbKQQU.js";
+import { M as Model, C as Collection, T as ToastService, G as GroupList, c as UserList } from "./User-DzR9RPjg.js";
+import { r as rest, V as View, d as dataFormatter, M as Mustache } from "./WebApp-CR6b7HZz.js";
+import { P as Page } from "./Page-CouRTtLr.js";
+import Dialog from "./Dialog-DWDn0XUt.js";
+import { F as FormView } from "./FormView-GxoZ1H6P.js";
 class S3Bucket extends Model {
   constructor(data = {}) {
     super(data, {
@@ -3079,6 +3079,7 @@ class TableRow extends ListViewItem {
     this.contextMenu = options.contextMenu || null;
     this.batchActions = options.batchActions || null;
     this.tableView = options.tableView || options.listView || null;
+    this.editingCells = /* @__PURE__ */ new Set();
     this.template = this.buildRowTemplate();
   }
   /**
@@ -3115,13 +3116,17 @@ class TableRow extends ListViewItem {
     this.columns.forEach((column) => {
       const cellClass = column.class || column.className || "";
       const responsiveClasses = this.getResponsiveClasses(column.visibility);
-      const combinedClasses = [cellClass, responsiveClasses].filter((c) => c).join(" ");
+      const editableClass = column.editable ? "editable-cell" : "";
+      const combinedClasses = [cellClass, responsiveClasses, editableClass].filter((c) => c).join(" ");
       const cellContent = this.buildCellTemplate(column);
-      if (!column.action && this.tableView.rowAction) {
-        column.action = this.tableView.rowAction;
+      let cellAction = column.action;
+      if (!cellAction && column.editable) {
+        cellAction = "edit-cell";
+      } else if (!cellAction && this.tableView.rowAction) {
+        cellAction = this.tableView.rowAction;
       }
-      if (column.action) {
-        template += `<td class="${combinedClasses}" data-action="${column.action}" data-column="${column.key}">${cellContent}</td>`;
+      if (cellAction) {
+        template += `<td class="${combinedClasses}" data-action="${cellAction}" data-column="${column.key}">${cellContent}</td>`;
       } else {
         template += `<td class="${combinedClasses}" data-column="${column.key}">${cellContent}</td>`;
       }
@@ -3151,6 +3156,9 @@ class TableRow extends ListViewItem {
     if (column.template) {
       return column.template;
     }
+    if (column.editable) {
+      return `<span class="cell-content" data-field="${column.key}">{{{${path}}}}</span>`;
+    }
     return `{{{${path}}}}`;
   }
   /**
@@ -3281,11 +3289,22 @@ class TableRow extends ListViewItem {
       this.element.setAttribute("data-id", id);
     }
   }
+  /**
+   * Handle edit cell action
+   */
+  async onActionEditCell(event, element) {
+    event.stopPropagation();
+    const columnKey = element.getAttribute("data-column");
+    const column = this.columns.find((col) => col.key === columnKey);
+    if (!column || !column.editable) return;
+    if (this.editingCells.has(columnKey)) return;
+    await this.enterEditMode(columnKey, column, element);
+  }
   /**
    * Handle row click action
    */
   async onActionRowClick(event, element) {
-    if (event.target.closest(".btn-group") || event.target.closest(".dropdown")) {
+    if (event.target.closest(".btn-group") || event.target.closest(".dropdown") || event.target.closest(".cell-editor")) {
       return;
     }
     this.emit("row:click", {
@@ -3358,6 +3377,265 @@ class TableRow extends ListViewItem {
       });
     }
   }
+  /**
+   * Enter edit mode for a cell
+   */
+  async enterEditMode(columnKey, column, cellElement) {
+    const contentSpan = cellElement.querySelector(".cell-content");
+    if (!contentSpan) return;
+    this.editingCells.add(columnKey);
+    const currentValue = this.model.get ? this.model.get(columnKey) : this.model[columnKey];
+    const editor = this.createCellEditor(column, currentValue);
+    const originalContent = contentSpan.innerHTML;
+    contentSpan.style.display = "none";
+    const editorContainer = document.createElement("div");
+    editorContainer.className = "cell-editor";
+    editorContainer.innerHTML = editor;
+    cellElement.appendChild(editorContainer);
+    const input = editorContainer.querySelector("input, select, .form-check-input");
+    if (input) {
+      input.focus();
+      if (input.type === "text" || input.type === "textarea") {
+        input.select();
+      }
+    }
+    editorContainer.dataset.originalContent = originalContent;
+    editorContainer.dataset.columnKey = columnKey;
+    this.setupEditorEvents(editorContainer, columnKey, column);
+    this.emit("cell:edit", {
+      row: this,
+      model: this.model,
+      column: columnKey,
+      originalValue: currentValue
+    });
+  }
+  /**
+   * Create cell editor HTML based on column configuration
+   */
+  createCellEditor(column, currentValue) {
+    const options = column.editableOptions || {};
+    switch (options.type) {
+      case "select":
+        return this.createSelectEditor(options, currentValue);
+      case "switch":
+      case "checkbox":
+        return this.createSwitchEditor(options, currentValue);
+      case "textarea":
+        return this.createTextareaEditor(options, currentValue);
+      default:
+        return this.createTextEditor(options, currentValue);
+    }
+  }
+  /**
+   * Create text input editor
+   */
+  createTextEditor(options, currentValue) {
+    const placeholder = options.placeholder || "";
+    const inputType = options.inputType || "text";
+    return `
+      <div class="d-flex gap-1 align-items-center">
+        <input type="${inputType}" 
+               class="form-control form-control-sm cell-input" 
+               value="${this.escapeHtml(currentValue || "")}"
+               placeholder="${placeholder}">
+        <button type="button" class="btn btn-sm btn-success cell-save" title="Save">
+          <i class="bi bi-check"></i>
+        </button>
+        <button type="button" class="btn btn-sm btn-outline-secondary cell-cancel" title="Cancel">
+          <i class="bi bi-x"></i>
+        </button>
+      </div>
+    `;
+  }
+  /**
+   * Create textarea editor
+   */
+  createTextareaEditor(options, currentValue) {
+    const placeholder = options.placeholder || "";
+    const rows = options.rows || 2;
+    return `
+      <div class="d-flex gap-1">
+        <textarea class="form-control form-control-sm cell-input" 
+                  rows="${rows}"
+                  placeholder="${placeholder}">${this.escapeHtml(currentValue || "")}</textarea>
+        <div class="d-flex flex-column gap-1">
+          <button type="button" class="btn btn-sm btn-success cell-save" title="Save">
+            <i class="bi bi-check"></i>
+          </button>
+          <button type="button" class="btn btn-sm btn-outline-secondary cell-cancel" title="Cancel">
+            <i class="bi bi-x"></i>
+          </button>
+        </div>
+      </div>
+    `;
+  }
+  /**
+   * Create select dropdown editor
+   */
+  createSelectEditor(options, currentValue) {
+    const optionsArray = options.options || [];
+    let optionsHtml = "";
+    optionsArray.forEach((option) => {
+      if (typeof option === "string") {
+        const selected = option === currentValue ? "selected" : "";
+        optionsHtml += `<option value="${option}" ${selected}>${option}</option>`;
+      } else if (typeof option === "object" && option.value !== void 0) {
+        const selected = option.value === currentValue ? "selected" : "";
+        optionsHtml += `<option value="${option.value}" ${selected}>${option.label || option.value}</option>`;
+      }
+    });
+    return `
+      <div class="d-flex gap-1 align-items-center">
+        <select class="form-select form-select-sm cell-input">
+          ${optionsHtml}
+        </select>
+        <button type="button" class="btn btn-sm btn-success cell-save" title="Save">
+          <i class="bi bi-check"></i>
+        </button>
+        <button type="button" class="btn btn-sm btn-outline-secondary cell-cancel" title="Cancel">
+          <i class="bi bi-x"></i>
+        </button>
+      </div>
+    `;
+  }
+  /**
+   * Create switch/checkbox editor
+   */
+  createSwitchEditor(options, currentValue) {
+    const checked = currentValue ? "checked" : "";
+    const switchType = options.type === "switch" ? "form-switch" : "";
+    return `
+      <div class="d-flex gap-2 align-items-center">
+        <div class="form-check ${switchType}">
+          <input class="form-check-input cell-input" type="checkbox" ${checked}>
+        </div>
+        <div class="d-flex gap-1">
+          <button type="button" class="btn btn-sm btn-success cell-save" title="Save">
+            <i class="bi bi-check"></i>
+          </button>
+          <button type="button" class="btn btn-sm btn-outline-secondary cell-cancel" title="Cancel">
+            <i class="bi bi-x"></i>
+          </button>
+        </div>
+      </div>
+    `;
+  }
+  /**
+   * Setup event listeners for cell editor
+   */
+  setupEditorEvents(editorContainer, columnKey, column) {
+    const input = editorContainer.querySelector(".cell-input");
+    const saveBtn = editorContainer.querySelector(".cell-save");
+    const cancelBtn = editorContainer.querySelector(".cell-cancel");
+    if (input && (input.type === "text" || input.type === "email" || input.type === "number")) {
+      input.addEventListener("keydown", (e) => {
+        if (e.key === "Enter") {
+          e.preventDefault();
+          this.saveCellEdit(editorContainer, columnKey, column);
+        } else if (e.key === "Escape") {
+          e.preventDefault();
+          this.cancelCellEdit(editorContainer, columnKey);
+        }
+      });
+    }
+    if (input && (input.type === "checkbox" || input.tagName === "SELECT") && column.autoSave !== false) {
+      input.addEventListener("change", () => {
+        this.saveCellEdit(editorContainer, columnKey, column);
+      });
+    }
+    saveBtn?.addEventListener("click", () => {
+      this.saveCellEdit(editorContainer, columnKey, column);
+    });
+    cancelBtn?.addEventListener("click", () => {
+      this.cancelCellEdit(editorContainer, columnKey);
+    });
+  }
+  /**
+   * Save cell edit
+   */
+  async saveCellEdit(editorContainer, columnKey, column) {
+    const input = editorContainer.querySelector(".cell-input");
+    if (!input) return;
+    let newValue;
+    if (input.type === "checkbox") {
+      newValue = input.checked;
+    } else if (input.tagName === "SELECT") {
+      newValue = input.value;
+    } else {
+      newValue = input.value;
+    }
+    const oldValue = this.model.get ? this.model.get(columnKey) : this.model[columnKey];
+    try {
+      if (this.model.save) {
+        await this.model.save({ [columnKey]: newValue });
+      } else {
+        this.model[columnKey] = newValue;
+      }
+      this.exitEditMode(editorContainer, columnKey, newValue);
+      this.emit("cell:save", {
+        row: this,
+        model: this.model,
+        column: columnKey,
+        oldValue,
+        newValue
+      });
+    } catch (error) {
+      console.error("Failed to save cell edit:", error);
+      this.emit("cell:save:error", {
+        row: this,
+        model: this.model,
+        column: columnKey,
+        oldValue,
+        newValue,
+        error
+      });
+      editorContainer.classList.add("saving-error");
+      setTimeout(() => editorContainer.classList.remove("saving-error"), 3e3);
+    }
+  }
+  /**
+   * Cancel cell edit
+   */
+  cancelCellEdit(editorContainer, columnKey) {
+    const originalContent = editorContainer.dataset.originalContent;
+    this.exitEditMode(editorContainer, columnKey, null, originalContent);
+    this.emit("cell:cancel", {
+      row: this,
+      model: this.model,
+      column: columnKey
+    });
+  }
+  /**
+   * Exit edit mode and restore content
+   */
+  exitEditMode(editorContainer, columnKey, newValue = null, originalContent = null) {
+    const cellElement = editorContainer.closest("td");
+    const contentSpan = cellElement.querySelector(".cell-content");
+    if (contentSpan) {
+      if (newValue !== null) {
+        const column = this.columns.find((col) => col.key === columnKey);
+        let displayValue = newValue;
+        if (column && column.formatter && typeof column.formatter === "string") {
+          displayValue = dataFormatter.pipe(newValue, column.formatter);
+        }
+        contentSpan.innerHTML = this.escapeHtml(displayValue);
+      } else if (originalContent) {
+        contentSpan.innerHTML = originalContent;
+      }
+      contentSpan.style.display = "";
+    }
+    editorContainer.remove();
+    this.editingCells.delete(columnKey);
+  }
+  /**
+   * Escape HTML for safe display
+   */
+  escapeHtml(text) {
+    if (text === null || text === void 0) return "";
+    const div = document.createElement("div");
+    div.textContent = text;
+    return div.innerHTML;
+  }
   /**
    * Override select to handle table-specific selection UI
    */
@@ -3391,6 +3669,7 @@ class TableView extends ListView {
       ...options
     };
     super(tableOptions);
+    this.isFullscreen = false;
     this.columns = options.columns || [];
     this.actions = options.actions || null;
     this.contextMenu = options.contextMenu || null;
@@ -3434,7 +3713,20 @@ class TableView extends ListView {
     this.searchPlaceholder = options.searchPlaceholder || "Search...";
     this.initializeColumns();
     this.extractColumnFilters();
+    this.footerTotalColumns = this.columns.filter((col) => col.footer_total === true);
+    this.hasFooterTotals = this.footerTotalColumns.length > 0;
     this.template = this.buildTableTemplate();
+    this.setupCollectionListeners();
+  }
+  /**
+   * Setup collection event listeners for totals updates
+   */
+  setupCollectionListeners() {
+    if (this.hasFooterTotals && this.collection) {
+      this.collection.on("reset add remove change", () => {
+        this.updateFooterTotals();
+      });
+    }
   }
   /**
    * Initialize column configuration
@@ -3463,6 +3755,80 @@ class TableView extends ListView {
     }
     return `d-none d-${visibility}-table-cell`;
   }
+  /**
+   * Extract column key and formatter from combined key (e.g., "sales_amount|currency")
+   */
+  parseColumnKey(key) {
+    const parts = key.split("|");
+    return {
+      fieldKey: parts[0],
+      formatter: parts[1] || null
+    };
+  }
+  /**
+   * Update footer totals in the DOM without full re-render
+   */
+  updateFooterTotals() {
+    if (!this.hasFooterTotals || !this.element) return;
+    const totals = this.calculateFooterTotals();
+    console.log("Updating footer totals in DOM:", totals);
+    let totalColumnIndex = 0;
+    this.columns.forEach((column) => {
+      if (column.footer_total) {
+        const safeKey = `col_${totalColumnIndex}`;
+        const cell = this.element.querySelector(`[data-total-column="${safeKey}"]`);
+        if (cell && totals[safeKey]) {
+          const formatter = this.parseColumnKey(column.key).formatter || column.formatter;
+          let displayValue;
+          if (formatter && typeof formatter === "string") {
+            displayValue = this.formatValue(totals[safeKey].value, formatter);
+          } else {
+            displayValue = totals[safeKey].value;
+          }
+          cell.textContent = displayValue;
+        }
+        totalColumnIndex++;
+      }
+    });
+  }
+  /**
+   * Format a value using DataFormatter
+   */
+  formatValue(value, formatter) {
+    try {
+      return dataFormatter.pipe(value, formatter);
+    } catch (e) {
+      console.warn("Error formatting value:", e);
+      return value;
+    }
+  }
+  /**
+   * Calculate totals for footer columns
+   */
+  calculateFooterTotals() {
+    if (!this.hasFooterTotals || !this.collection || this.collection.length === 0) {
+      return {};
+    }
+    const totals = {};
+    this.footerTotalColumns.forEach((column, totalColumnIndex) => {
+      const { fieldKey, formatter } = this.parseColumnKey(column.key);
+      let sum = 0;
+      this.collection.forEach((model) => {
+        const value = model.get ? model.get(fieldKey) : model[fieldKey];
+        const numValue = parseFloat(value) || 0;
+        sum += numValue;
+      });
+      console.log(`Footer total for ${column.key}: ${sum} (from ${this.collection.length} items)`);
+      const safeKey = `col_${totalColumnIndex}`;
+      totals[safeKey] = {
+        value: sum,
+        formatter: formatter || column.formatter,
+        fieldKey,
+        originalKey: column.key
+      };
+    });
+    return totals;
+  }
   /**
    * Extract filters from column configuration
    */
@@ -3474,14 +3840,6 @@ class TableView extends ListView {
       }
     });
   }
-  /**
-   * Override getTemplateData to provide dynamic values for Mustache
-   */
-  getTemplateData() {
-    const data = super.getTemplateData();
-    data.searchValue = this.getActiveFilters().search || "";
-    return data;
-  }
   isSelectable() {
     return this.batchActions && this.batchActions.length > 0 && this.selectionMode == "multiple";
   }
@@ -3514,6 +3872,7 @@ class TableView extends ListView {
               <table class="${this.buildTableClasses()}">
                 ${this.buildTableHeaderTemplate()}
                 <tbody data-container="items"></tbody>
+                ${this.hasFooterTotals ? this.buildTableFooterTemplate() : ""}
               </table>
             {{/isEmpty}}
           {{/loading}}
@@ -3568,6 +3927,15 @@ class TableView extends ListView {
         <i class="bi bi-arrow-clockwise"></i>
       </button>
     `);
+    if (this.isFullscreenSupported()) {
+      buttons.push(`
+        <button class="btn btn-sm btn-outline-secondary btn-fullscreen"
+                data-action="toggle-fullscreen"
+                title="Toggle Fullscreen">
+          <i class="bi bi-fullscreen"></i>
+        </button>
+      `);
+    }
     if (this.options.showAdd) {
       buttons.push(`
         <button class="btn btn-sm btn-success btn-add"
@@ -3850,6 +4218,47 @@ class TableView extends ListView {
       </thead>
     `;
   }
+  /**
+   * Build table footer template with totals
+   */
+  buildTableFooterTemplate() {
+    let footerCells = "";
+    if (this.isSelectable()) {
+      footerCells += "<td></td>";
+    }
+    let totalColumnIndex = 0;
+    this.columns.forEach((column, index) => {
+      const responsiveClasses = this.getResponsiveClasses(column.visibility);
+      if (column.footer_total) {
+        const safeKey = `col_${totalColumnIndex}`;
+        const formatter = this.parseColumnKey(column.key).formatter || column.formatter;
+        let cellContent;
+        if (formatter && typeof formatter === "string") {
+          cellContent = `{{{footerTotals.${safeKey}.value|${formatter}}}}`;
+        } else {
+          cellContent = `{{footerTotals.${safeKey}.value}}`;
+        }
+        footerCells += `<td class="table-footer-total ${responsiveClasses}" data-total-column="${safeKey}">${cellContent}</td>`;
+        totalColumnIndex++;
+      } else if (index === 0) {
+        footerCells += `<td class="table-footer-label ${responsiveClasses}"><strong>Totals</strong></td>`;
+      } else {
+        footerCells += `<td class="${responsiveClasses}"></td>`;
+      }
+    });
+    if (this.actions) {
+      footerCells += "<td></td>";
+    } else if (this.contextMenu) {
+      footerCells += "<td></td>";
+    }
+    return `
+      <tfoot>
+        <tr class="table-totals-row">
+          ${footerCells}
+        </tr>
+      </tfoot>
+    `;
+  }
   /**
    * Build batch actions panel
    */
@@ -3986,6 +4395,9 @@ class TableView extends ListView {
     itemView.on("row:view", this._onRowView.bind(this));
     itemView.on("row:edit", this._onRowEdit.bind(this));
     itemView.on("row:delete", this._onRowDelete.bind(this));
+    itemView.on("cell:edit", this._onCellEdit.bind(this));
+    itemView.on("cell:save", this._onCellSave.bind(this));
+    itemView.on("cell:cancel", this._onCellCancel.bind(this));
     return itemView;
   }
   /**
@@ -4165,6 +4577,140 @@ class TableView extends ListView {
       this.collection.remove(event.model);
     }
   }
+  /**
+   * Handle cell edit event
+   */
+  _onCellEdit(event) {
+    this.emit("cell:edit", event);
+  }
+  /**
+   * Handle cell save event
+   */
+  async _onCellSave(event) {
+    this.emit("cell:save", event);
+  }
+  /**
+   * Handle cell cancel event
+   */
+  _onCellCancel(event) {
+    this.emit("cell:cancel", event);
+  }
+  /**
+   * Check if fullscreen is supported by the browser
+   */
+  isFullscreenSupported() {
+    return !!(document.fullscreenEnabled || document.mozFullScreenEnabled || document.webkitFullscreenEnabled || document.msFullscreenEnabled);
+  }
+  /**
+   * Handle toggle fullscreen action
+   */
+  async onActionToggleFullscreen(event, element) {
+    if (this.isFullscreen) {
+      await this.exitFullscreen();
+    } else {
+      await this.enterFullscreen();
+    }
+  }
+  /**
+   * Enter fullscreen mode
+   */
+  async enterFullscreen() {
+    try {
+      if (this.element.requestFullscreen) {
+        await this.element.requestFullscreen();
+      } else if (this.element.mozRequestFullScreen) {
+        await this.element.mozRequestFullScreen();
+      } else if (this.element.webkitRequestFullscreen) {
+        await this.element.webkitRequestFullscreen();
+      } else if (this.element.msRequestFullscreen) {
+        await this.element.msRequestFullscreen();
+      }
+      this.isFullscreen = true;
+      this.element.classList.add("table-fullscreen");
+      this.updateFullscreenButton();
+      this.setupFullscreenListeners();
+      this.emit("table:fullscreen:enter");
+    } catch (error) {
+      console.warn("Could not enter fullscreen:", error);
+    }
+  }
+  /**
+   * Exit fullscreen mode
+   */
+  async exitFullscreen() {
+    try {
+      if (document.exitFullscreen) {
+        await document.exitFullscreen();
+      } else if (document.mozCancelFullScreen) {
+        await document.mozCancelFullScreen();
+      } else if (document.webkitExitFullscreen) {
+        await document.webkitExitFullscreen();
+      } else if (document.msExitFullscreen) {
+        await document.msExitFullscreen();
+      }
+      this.isFullscreen = false;
+      this.element.classList.remove("table-fullscreen");
+      this.updateFullscreenButton();
+      this.emit("table:fullscreen:exit");
+    } catch (error) {
+      console.warn("Could not exit fullscreen:", error);
+    }
+  }
+  /**
+   * Update fullscreen button icon and title
+   */
+  updateFullscreenButton() {
+    const button = this.element?.querySelector(".btn-fullscreen");
+    const icon = button?.querySelector("i");
+    if (button && icon) {
+      if (this.isFullscreen) {
+        icon.className = "bi bi-fullscreen-exit";
+        button.title = "Exit Fullscreen";
+      } else {
+        icon.className = "bi bi-fullscreen";
+        button.title = "Enter Fullscreen";
+      }
+    }
+  }
+  /**
+   * Setup fullscreen event listeners
+   */
+  setupFullscreenListeners() {
+    if (this._fullscreenHandler) return;
+    const handleFullscreenChange = () => {
+      const isCurrentlyFullscreen = !!(document.fullscreenElement || document.mozFullScreenElement || document.webkitFullscreenElement || document.msFullscreenElement);
+      if (!isCurrentlyFullscreen && this.isFullscreen) {
+        this.isFullscreen = false;
+        this.element.classList.remove("table-fullscreen");
+        this.updateFullscreenButton();
+        this.emit("table:fullscreen:exit");
+      }
+    };
+    document.addEventListener("fullscreenchange", handleFullscreenChange);
+    document.addEventListener("mozfullscreenchange", handleFullscreenChange);
+    document.addEventListener("webkitfullscreenchange", handleFullscreenChange);
+    document.addEventListener("msfullscreenchange", handleFullscreenChange);
+    this._fullscreenHandler = handleFullscreenChange;
+  }
+  /**
+   * Cleanup fullscreen listeners
+   */
+  cleanupFullscreenListeners() {
+    if (this._fullscreenHandler) {
+      document.removeEventListener("fullscreenchange", this._fullscreenHandler);
+      document.removeEventListener("mozfullscreenchange", this._fullscreenHandler);
+      document.removeEventListener("webkitfullscreenchange", this._fullscreenHandler);
+      document.removeEventListener("msfullscreenchange", this._fullscreenHandler);
+      this._fullscreenHandler = null;
+    }
+  }
+  /**
+   * Override destroy to cleanup fullscreen listeners
+   */
+  destroy() {
+    this.cleanupFullscreenListeners();
+    super.destroy();
+  }
   /**
    * Handle refresh action
    */
@@ -4410,11 +4956,23 @@ class TableView extends ListView {
     }
     this.updateBatchActionsPanel();
   }
+  /**
+   * Override render to set data properties before rendering
+   */
+  async render(force, container) {
+    this.searchValue = this.getActiveFilters().search || "";
+    this.footerTotals = this.calculateFooterTotals();
+    console.log("Setting footerTotals before render:", this.footerTotals);
+    return super.render(force, container);
+  }
   /**
    * Override onAfterRender to update pagination info
    */
   async onAfterRender() {
     await super.onAfterRender();
+    if (this.hasFooterTotals) {
+      this.updateFooterTotals();
+    }
     if (this.paginated && this.collection) {
       const total = this.collection.meta?.count || this.collection.length();
       const start = this.collection.params?.start || 0;
@@ -5962,4 +6520,4 @@ export {
   IncidentEventList as y,
   IncidentEventForms as z
 };
-//# sourceMappingURL=FilePreviewView-Crpalaos.js.map
+//# sourceMappingURL=FilePreviewView-CCngMe-J.js.map