@jmruthers/pace-core 0.5.97 → 0.5.99

package/dist/{DataTable-FB22ES46.js → DataTable-VSJWLCVT.js}

@@ -33,6 +33,7 @@ import {
   createHierarchicalStructure,
   defaultDataTableFeatures,
   exportToCSV,
+  exportToCSVWithTableRows,
   generateCSVContent,
   getAriaSortValue,
   getCellRenderer,
@@ -53,7 +54,7 @@ import {
   sortHierarchicalDataWithSorting,
   validateHierarchicalData,
   validatePaginationConfig
-} from "./chunk-QX5I62KP.js";
+} from "./chunk-D7CZVI3K.js";
 import "./chunk-2KLAOD4M.js";
 import "./chunk-S63MFSY6.js";
 import "./chunk-Q7APDV6H.js";
@@ -130,6 +131,7 @@ export {
   defaultDataTableFeatures,
   determinePaginationMode,
   exportToCSV,
+  exportToCSVWithTableRows,
   generateCSVContent,
   getAriaSortValue,
   getCellRenderer,
@@ -155,4 +157,4 @@ export {
   validateHierarchicalData,
   validatePaginationConfig
 };
-//# sourceMappingURL=DataTable-FB22ES46.js.map
+//# sourceMappingURL=DataTable-VSJWLCVT.js.map

package/dist/{chunk-UBPRDNPY.js → chunk-2PWJ6NFH.js}

@@ -25,7 +25,7 @@ import {
   SelectSeparator,
   SelectTrigger,
   SelectValue
-} from "./chunk-QX5I62KP.js";
+} from "./chunk-D7CZVI3K.js";
 import {
   isPermitted,
   isSuperAdmin
@@ -4799,4 +4799,4 @@ export {
   EventLogoCompact,
   EventLogoLarge
 };
-//# sourceMappingURL=chunk-UBPRDNPY.js.map
+//# sourceMappingURL=chunk-2PWJ6NFH.js.map

package/dist/{chunk-QX5I62KP.js → chunk-D7CZVI3K.js}

@@ -8916,31 +8916,60 @@ function ImportModal({ isOpen, onClose, onImport, config = {} }) {
 import { Fragment as Fragment3, jsx as jsx19 } from "react/jsx-runtime";
 function mapCSVToTableColumns(csvData, columns) {
   const columnMap = /* @__PURE__ */ new Map();
+  console.log("[mapCSVToTableColumns] Building column map from", columns.length, "column definitions");
   columns.forEach((col) => {
     const fieldName = col.editAccessorKey || col.accessorKey || col.id;
     const header = typeof col.header === "string" ? col.header : "";
     if (fieldName && header) {
       columnMap.set(header.toLowerCase(), fieldName);
+      console.log(`[mapCSVToTableColumns] Mapped "${header}" -> "${fieldName}"`);
       const colId = col.id || col.accessorKey;
       if (colId && colId !== header && colId !== fieldName) {
         columnMap.set(colId.toLowerCase(), fieldName);
+        console.log(`[mapCSVToTableColumns] Also mapped "${colId}" -> "${fieldName}"`);
       }
       if (col.editAccessorKey && header) {
         const idColumnHeader = `${header} (ID)`;
         columnMap.set(idColumnHeader.toLowerCase(), col.editAccessorKey);
+        console.log(`[mapCSVToTableColumns] Mapped ID column "${idColumnHeader}" -> "${col.editAccessorKey}"`);
         columnMap.set(col.editAccessorKey.toLowerCase(), col.editAccessorKey);
+        console.log(`[mapCSVToTableColumns] Also mapped "${col.editAccessorKey}" -> "${col.editAccessorKey}"`);
       }
+    } else {
+      console.warn("[mapCSVToTableColumns] Skipping column with missing fieldName or header:", col);
     }
   });
-  return csvData.map((row) => {
+  if (csvData.length === 0) {
+    console.warn("[mapCSVToTableColumns] No CSV data to map");
+    return [];
+  }
+  const csvHeaders = Object.keys(csvData[0]);
+  console.log("[mapCSVToTableColumns] CSV headers found:", csvHeaders);
+  console.log("[mapCSVToTableColumns] Column map size:", columnMap.size);
+  const mappedData = csvData.map((row, index) => {
     const mappedRow = {};
     Object.keys(row).forEach((csvHeader) => {
       const csvHeaderLower = csvHeader.toLowerCase();
-      const fieldName = columnMap.get(csvHeaderLower) || csvHeaderLower;
-      mappedRow[fieldName] = row[csvHeader];
+      const fieldName = columnMap.get(csvHeaderLower);
+      if (fieldName) {
+        mappedRow[fieldName] = row[csvHeader];
+        if (index === 0) {
+          console.log(`[mapCSVToTableColumns] Row 0: "${csvHeader}" -> "${fieldName}"`);
+        }
+      } else {
+        mappedRow[csvHeaderLower] = row[csvHeader];
+        if (index === 0) {
+          console.warn(`[mapCSVToTableColumns] No mapping found for "${csvHeader}", using as-is`);
+        }
+      }
     });
     return mappedRow;
   });
+  console.log("[mapCSVToTableColumns] Mapped", mappedData.length, "rows");
+  if (mappedData.length > 0) {
+    console.log("[mapCSVToTableColumns] First mapped row keys:", Object.keys(mappedData[0]));
+  }
+  return mappedData;
 }
 function DataTableModals({
   showImportModal,
@@ -8967,10 +8996,30 @@ function DataTableModals({
       isOpen: showImportModal,
       onClose: onCloseImportModal,
       onImport: async (rawData) => {
-        const mappedData = columns ? mapCSVToTableColumns(rawData, columns) : rawData;
-        const result = onImport(mappedData);
-        if (result && typeof result.then === "function") {
-          await result;
+        try {
+          let mappedData;
+          if (columns && columns.length > 0) {
+            console.log("[DataTableModals] Mapping CSV data with", columns.length, "column definitions");
+            console.log("[DataTableModals] Raw CSV headers:", rawData.length > 0 ? Object.keys(rawData[0]) : []);
+            mappedData = mapCSVToTableColumns(rawData, columns);
+            console.log("[DataTableModals] Mapped data sample:", mappedData.length > 0 ? mappedData[0] : null);
+          } else {
+            console.warn("[DataTableModals] No columns provided for mapping, using raw data");
+            mappedData = rawData;
+          }
+          if (!onImport) {
+            console.error("[DataTableModals] onImport callback is not provided");
+            throw new Error("Import handler is not configured. Please provide an onImport callback.");
+          }
+          console.log("[DataTableModals] Calling onImport with", mappedData.length, "rows");
+          const result = onImport(mappedData);
+          if (result && typeof result.then === "function") {
+            await result;
+          }
+          console.log("[DataTableModals] Import completed successfully");
+        } catch (error) {
+          console.error("[DataTableModals] Import error:", error);
+          throw error;
         }
       },
       config: importModalConfig
@@ -10274,6 +10323,76 @@ function generateCSVContent(data, columns, options = {}) {
   const csvContent = includeHeaders ? [headers.join(","), ...csvData].join("\n") : csvData.join("\n");
   return csvContent;
 }
+async function exportToCSVWithTableRows(tableRows, columns, columnIdToTableColumn, filename = "download.csv", options = {}) {
+  const logger = createLogger("ExportUtils");
+  return new Promise((resolve, reject) => {
+    try {
+      if (typeof window === "undefined") {
+        throw new Error("CSV export is only available in browser environments");
+      }
+      if (!tableRows || tableRows.length === 0) {
+        throw new Error("No data to export");
+      }
+      if (!columns || columns.length === 0) {
+        throw new Error("No columns defined for export");
+      }
+      const headers = columns.map((col) => {
+        const headerValue = col.header || col.id || "Column";
+        return escapeCSVValue(headerValue, options.sanitizeForSecurity !== false);
+      });
+      const csvData = tableRows.map((tableRow) => {
+        return columns.map((col) => {
+          let value;
+          if (col.isIdColumn && col.accessorKey) {
+            value = tableRow.original[col.accessorKey];
+          } else if (col.id && columnIdToTableColumn.has(col.id)) {
+            try {
+              value = tableRow.getValue(col.id);
+            } catch (error) {
+              if (col.accessorFn) {
+                try {
+                  value = col.accessorFn(tableRow.original);
+                } catch (accessorError) {
+                  console.warn("Error evaluating accessorFn for column:", col.id || col.header, accessorError);
+                  value = void 0;
+                }
+              } else {
+                const key = col.accessorKey || col.id;
+                value = key ? tableRow.original[key] : void 0;
+              }
+            }
+          } else {
+            const key = col.accessorKey || col.id;
+            value = key ? tableRow.original[key] : void 0;
+          }
+          if (options.locale && (typeof value === "number" || value instanceof Date || typeof value === "boolean")) {
+            value = formatLocaleValue(value, options.locale);
+          }
+          return escapeCSVValue(value, options.sanitizeForSecurity !== false);
+        }).join(",");
+      });
+      const csvContent = [headers.join(","), ...csvData].join("\n");
+      const blob = new Blob([csvContent], { type: "text/csv;charset=utf-8;" });
+      const link = document.createElement("a");
+      const url = URL.createObjectURL(blob);
+      link.setAttribute("href", url);
+      link.setAttribute("download", filename);
+      link.style.display = "none";
+      link.onclick = () => {
+        setTimeout(() => {
+          URL.revokeObjectURL(url);
+          resolve();
+        }, 100);
+      };
+      document.body.appendChild(link);
+      link.click();
+      document.body.removeChild(link);
+    } catch (error) {
+      logger.error("Failed to export data to CSV:", error);
+      reject(error);
+    }
+  });
+}
 function exportToCSV(data, columns, filename = "download.csv", options = {}) {
   const logger = createLogger("ExportUtils");
   return new Promise((resolve, reject) => {
@@ -11716,33 +11835,38 @@ function DataTableInternal({
                 onImportClick: () => stateActions.setImportModal(true),
                 onExport: secureHandlers.onExport || (async () => {
                   try {
-                    const currentData = table.getFilteredRowModel().rows.map((row) => row.original);
+                    const tableRows = table.getFilteredRowModel().rows;
                     const tableColumns = table.getAllColumns();
                     const visibleTableColumns = tableColumns.filter((col) => {
                       const isSystemColumn = col.id === "select" || col.id === "actions";
                       return !isSystemColumn && col.getIsVisible();
                     });
                     const visibleColumns2 = [];
+                    const columnIdToTableColumn = /* @__PURE__ */ new Map();
                     visibleTableColumns.forEach((tableCol) => {
                       const originalCol = columns.find((col) => {
                         const colId = col.id || col.accessorKey;
                         return colId && String(colId) === tableCol.id;
                       });
                       if (!originalCol) return;
+                      columnIdToTableColumn.set(tableCol.id, tableCol);
                       const hasAccessorFn = "accessorFn" in originalCol && originalCol.accessorFn;
                       const editAccessorKey = originalCol.editAccessorKey;
+                      const displayHeader = typeof originalCol.header === "string" ? originalCol.header : originalCol.accessorKey || tableCol.id || "Column";
                       visibleColumns2.push({
                         ...originalCol,
-                        header: typeof originalCol.header === "string" ? originalCol.header : originalCol.accessorKey || tableCol.id || "Column",
-                        // Preserve accessorFn if present (for computed/reference fields)
-                        // accessorFn is part of ColumnDef from TanStack Table
+                        header: displayHeader,
+                        // Store table column ID for getValue() lookup
+                        id: tableCol.id,
+                        // Preserve accessorFn if present (will use getValue() if available)
                         accessorFn: hasAccessorFn ? originalCol.accessorFn : void 0
                       });
                       if (hasAccessorFn && editAccessorKey) {
+                        const idHeader = `${displayHeader} (ID)`;
                         visibleColumns2.push({
                           id: editAccessorKey,
                           accessorKey: editAccessorKey,
-                          header: `${originalCol.header || "ID"} (ID)`,
+                          header: idHeader,
                           isIdColumn: true,
                           editAccessorKey
                         });
@@ -11750,7 +11874,7 @@ function DataTableInternal({
                     });
                     const timestamp = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
                     const filename = title ? `${title.replace(/[^a-z0-9]/gi, "_").toLowerCase()}_${timestamp}.csv` : `data_export_${timestamp}.csv`;
-                    await exportToCSV(currentData, visibleColumns2, filename);
+                    await exportToCSVWithTableRows(tableRows, visibleColumns2, columnIdToTableColumn, filename);
                     toast({
                       title: "Export Successful",
                       description: `Data exported to ${filename}`,
@@ -11934,10 +12058,35 @@ function DataTableInternal({
         onCloseImportModal: () => stateActions.setImportModal(false),
         onImport: async (data2) => {
           if (onImport) {
-            const result = onImport(data2);
-            if (result && typeof result.then === "function") {
-              await result;
+            try {
+              console.log("[DataTableCore] onImport called with", data2.length, "rows");
+              const result = onImport(data2);
+              if (result && typeof result.then === "function") {
+                await result;
+              }
+              console.log("[DataTableCore] onImport completed successfully");
+              toast({
+                title: "Import Successful",
+                description: `Successfully imported ${data2.length} ${data2.length === 1 ? "row" : "rows"}`,
+                variant: "default"
+              });
+            } catch (error) {
+              console.error("[DataTableCore] Import error:", error);
+              toast({
+                title: "Import Failed",
+                description: error instanceof Error ? error.message : "Failed to import data",
+                variant: "destructive"
+              });
+              return;
             }
+          } else {
+            console.error("[DataTableCore] onImport handler not provided");
+            toast({
+              title: "Import Not Configured",
+              description: "Import functionality requires an onImport handler to be provided.",
+              variant: "destructive"
+            });
+            return;
           }
           stateActions.setImportModal(false);
         },
@@ -12160,6 +12309,7 @@ export {
   isHierarchicalSortableColumn,
   getHierarchicalSortConfig,
   generateCSVContent,
+  exportToCSVWithTableRows,
   exportToCSV,
   defaultDataTableFeatures,
   normalizeDataTableFeatures,
@@ -12194,4 +12344,4 @@ lodash/lodash.js:
    * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
    *)
 */
-//# sourceMappingURL=chunk-QX5I62KP.js.map
+//# sourceMappingURL=chunk-D7CZVI3K.js.map