exploreda 0.0.5 → 0.1.0

package/dist/chunk-EGMFQSGK.js

@@ -0,0 +1,909 @@
+import { DEFAULT_CHART_SETTINGS } from './chunk-CJQQFNEY.js';
+import { FieldSelector, ComboBox } from './chunk-SFV5LZPD.js';
+import { useGetLiveIds } from './chunk-ZD64SCZB.js';
+import { applyFilter } from './chunk-YXPAWUXO.js';
+import { useColumnNames, multi_select_default } from './chunk-SWLNKY6R.js';
+import { Dialog, DialogContent, DialogHeader, DialogTitle, DialogDescription, Label } from './chunk-MJPDJ5AS.js';
+import { useDataLayer, categoryIncludes, getChartSummary, categoryKey, cn, ActionTooltip, hasFieldDisplayFormat, categoryValue, categoryLabel, categoryEqual, numericInputs } from './chunk-JNO7OXCC.js';
+import { Table, Filter } from 'lucide-react';
+import { useMemo, useState, useRef, useEffect, useCallback } from 'react';
+import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
+
+// src/components/charts/PivotTable/utils/calculations.ts
+var numericAggregations = /* @__PURE__ */ new Set([
+  "sum",
+  "avg",
+  "min",
+  "max",
+  "median",
+  "stddev",
+  "variance"
+]);
+function aggregate(name, values) {
+  const includedIndexes = /* @__PURE__ */ new Set();
+  const numeric = numericAggregations.has(name) ? numericInputs(values) : { inputs: [], exclusions: [] };
+  numeric.inputs.forEach(({ index }) => includedIndexes.add(index));
+  if (name === "count") {
+    values.forEach((_, index) => includedIndexes.add(index));
+    return { value: values.length, includedIndexes, numericExclusions: [] };
+  }
+  if (name === "countUnique") {
+    values.forEach((_, index) => includedIndexes.add(index));
+    return {
+      value: new Set(values).size,
+      includedIndexes,
+      numericExclusions: []
+    };
+  }
+  if (name === "mode") {
+    values.forEach((_, index) => includedIndexes.add(index));
+    const counts = /* @__PURE__ */ new Map();
+    values.forEach((value2) => {
+      const key = value2 ?? null;
+      counts.set(key, (counts.get(key) || 0) + 1);
+    });
+    let maxCount = 0;
+    let value = void 0;
+    counts.forEach((count, candidate) => {
+      if (count > maxCount) {
+        maxCount = count;
+        value = candidate === null ? void 0 : candidate;
+      }
+    });
+    return { value, includedIndexes, numericExclusions: [] };
+  }
+  if (name === "singleValue") {
+    if (values.length === 0) {
+      return { value: void 0, includedIndexes, numericExclusions: [] };
+    }
+    const uniqueValues = new Set(values.map((value) => categoryKey(value)));
+    if (uniqueValues.size !== 1) {
+      throw new Error("Multiple values found when single value expected");
+    }
+    values.forEach((_, index) => includedIndexes.add(index));
+    return { value: values[0], includedIndexes, numericExclusions: [] };
+  }
+  if (!numericAggregations.has(name)) {
+    throw new Error(`Unsupported aggregation: ${name}`);
+  }
+  const numbers = numeric.inputs.map(({ value }) => value);
+  if (numbers.length === 0) {
+    return {
+      value: void 0,
+      includedIndexes,
+      numericExclusions: numeric.exclusions
+    };
+  }
+  if (name === "sum") {
+    return {
+      value: numbers.reduce((sum, value) => sum + value, 0),
+      includedIndexes,
+      numericExclusions: numeric.exclusions
+    };
+  }
+  if (name === "avg") {
+    return {
+      value: numbers.reduce((sum, value) => sum + value, 0) / numbers.length,
+      includedIndexes,
+      numericExclusions: numeric.exclusions
+    };
+  }
+  if (name === "min") {
+    return {
+      value: Math.min(...numbers),
+      includedIndexes,
+      numericExclusions: numeric.exclusions
+    };
+  }
+  if (name === "max") {
+    return {
+      value: Math.max(...numbers),
+      includedIndexes,
+      numericExclusions: numeric.exclusions
+    };
+  }
+  if (name === "median") {
+    const sorted = [...numbers].sort((a, b) => a - b);
+    const mid = Math.floor(sorted.length / 2);
+    return {
+      value: sorted.length % 2 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2,
+      includedIndexes,
+      numericExclusions: numeric.exclusions
+    };
+  }
+  const average = numbers.reduce((sum, value) => sum + value, 0) / numbers.length;
+  const squareDiffs = numbers.map((value) => (value - average) ** 2);
+  const variance = squareDiffs.reduce((sum, value) => sum + value, 0) / squareDiffs.length;
+  return {
+    value: name === "stddev" ? Math.sqrt(variance) : variance,
+    includedIndexes,
+    numericExclusions: numeric.exclusions
+  };
+}
+function generateHeaders(data, field) {
+  if (!field) {
+    return [];
+  }
+  const uniqueValues = /* @__PURE__ */ new Map();
+  data.forEach((row) => {
+    const value = categoryValue(row[field]);
+    const key = categoryKey(value);
+    if (!uniqueValues.has(key)) {
+      uniqueValues.set(key, value);
+    }
+  });
+  return Array.from(uniqueValues.values()).sort((left, right) => categoryKey(left).localeCompare(categoryKey(right))).map((value) => ({
+    label: categoryLabel(value),
+    field,
+    value,
+    children: [],
+    span: 1,
+    depth: 0
+  }));
+}
+function makeContributors(rows, groupingKeys, valueField, result) {
+  const exclusionByIndex = new Map(
+    result.numericExclusions.map((exclusion) => [
+      exclusion.index,
+      exclusion.reason
+    ])
+  );
+  const contributors = rows.map((row, index) => ({
+    sourceId: row.__ID,
+    groupingKeys,
+    input: row[valueField],
+    included: result.includedIndexes.has(index),
+    exclusionReason: exclusionByIndex.get(index)
+  }));
+  return {
+    contributors,
+    numericExclusions: result.numericExclusions.map(({ index, reason }) => ({
+      sourceId: rows[index]?.__ID,
+      value: rows[index]?.[valueField],
+      reason
+    }))
+  };
+}
+function generateCell(rows, groupingKeys, columnField, columnValue, isTotal, valueField) {
+  const values = rows.map((row) => row[valueField.field]);
+  let result;
+  let error;
+  try {
+    result = aggregate(valueField.aggregation, values);
+  } catch (caught) {
+    result = {
+      value: void 0,
+      includedIndexes: /* @__PURE__ */ new Set(),
+      numericExclusions: []
+    };
+    error = caught instanceof Error ? caught.message : "Aggregation failed";
+  }
+  const { contributors, numericExclusions } = makeContributors(
+    rows,
+    groupingKeys,
+    valueField.field,
+    result
+  );
+  const status = error ? "error" : rows.length === 0 ? "empty" : result.numericExclusions.length > 0 && result.includedIndexes.size === 0 ? "invalid" : "ok";
+  return {
+    key: {
+      columnField,
+      columnValue,
+      valueField: valueField.field,
+      isTotal
+    },
+    value: result.value,
+    rawValue: result.value,
+    aggregation: valueField.aggregation,
+    status,
+    error,
+    contributors,
+    numericExclusions
+  };
+}
+function generateCells(rowData, columnHeaders, rowKeys, hasColumnField, valueFields) {
+  const cells = [];
+  const headers = hasColumnField ? columnHeaders : [{ field: "total", value: "total" }];
+  headers.forEach((header) => {
+    const columnData = hasColumnField ? rowData.filter(
+      (row) => categoryEqual(categoryValue(row[header.field]), header.value)
+    ) : rowData;
+    const groupingKeys = !hasColumnField ? rowKeys : [...rowKeys, { field: header.field, value: header.value }];
+    valueFields.forEach((valueField) => {
+      cells.push(
+        generateCell(
+          columnData,
+          groupingKeys,
+          hasColumnField ? header.field : "total",
+          header.value,
+          !hasColumnField,
+          valueField
+        )
+      );
+    });
+  });
+  return cells;
+}
+function generateRows(data, rowFields, columnField, valueFields) {
+  const rows = [];
+  const columnHeaders = generateHeaders(data, columnField);
+  const rowGroups = /* @__PURE__ */ new Map();
+  data.forEach((item) => {
+    const keyString = JSON.stringify(
+      rowFields.map((field) => categoryKey(categoryValue(item[field])))
+    );
+    if (!rowGroups.has(keyString)) {
+      rowGroups.set(keyString, []);
+    }
+    rowGroups.get(keyString).push(item);
+  });
+  rowGroups.forEach((groupData) => {
+    const keys = rowFields.map((field) => ({
+      field,
+      value: categoryValue(groupData[0][field])
+    }));
+    const headers = keys.map((key, index) => ({
+      label: categoryLabel(key.value),
+      field: key.field,
+      value: key.value,
+      span: 1,
+      depth: index
+    }));
+    rows.push({
+      keys,
+      headers,
+      cells: generateCells(
+        groupData,
+        columnHeaders,
+        keys,
+        Boolean(columnField),
+        valueFields
+      )
+    });
+  });
+  return rows;
+}
+function calculatePivotData(data, settings) {
+  return {
+    headers: generateHeaders(data, settings.columnField),
+    rows: generateRows(
+      data,
+      settings.rowFields,
+      settings.columnField,
+      settings.valueFields
+    )
+  };
+}
+function displayValue(value) {
+  if (value === void 0 || value === null || value === "") {
+    return "Missing";
+  }
+  if (typeof value === "number") {
+    return String(value);
+  }
+  if (typeof value === "string") {
+    return JSON.stringify(value);
+  }
+  return String(value);
+}
+function displayExactValue(value) {
+  if (value === void 0) {
+    return "undefined";
+  }
+  if (value === null) {
+    return "null";
+  }
+  if (typeof value === "string") {
+    return JSON.stringify(value);
+  }
+  return String(value);
+}
+function displayCellValue(cell) {
+  if (cell.status === "empty") {
+    return "No rows";
+  }
+  if (cell.status === "error") {
+    return "Conflict";
+  }
+  if (cell.status === "invalid") {
+    return "No valid numbers";
+  }
+  return displayValue(cell.value);
+}
+function cellName(cell, rowHeaders) {
+  const rowLabel = rowHeaders.map((header) => header.label).join(" / ");
+  const columnLabel = cell.key.isTotal ? "Total" : displayValue(cell.key.columnValue);
+  return [rowLabel, columnLabel, cell.key.valueField].filter(Boolean).join(" \xB7 ");
+}
+function PivotTable({ settings, height, facetIds }) {
+  const getColumnData = useDataLayer((state) => state.getColumnData);
+  const getFieldLabel = useDataLayer((state) => state.getFieldLabel);
+  const formatFieldValue = useDataLayer((state) => state.formatFieldValue);
+  const fieldSettings = useDataLayer((state) => state.fieldSettings);
+  const updateChart = useDataLayer((state) => state.updateChart);
+  const allLiveIds = useGetLiveIds(settings);
+  const pivotData = useMemo(() => {
+    const liveIds = facetIds ? allLiveIds.filter((id) => facetIds.includes(id)) : allLiveIds;
+    const allFields = /* @__PURE__ */ new Set([
+      ...settings.rowFields,
+      settings.columnField,
+      ...settings.valueFields.map((f) => f.field)
+    ]);
+    const fieldData = {};
+    allFields.forEach((field) => {
+      fieldData[field] = getColumnData(field);
+    });
+    const data = liveIds.map((id) => {
+      const row = {
+        __ID: id
+      };
+      allFields.forEach((field) => {
+        row[field] = fieldData[field]?.[id];
+      });
+      return row;
+    });
+    return calculatePivotData(data, settings);
+  }, [facetIds, allLiveIds, settings, getColumnData]);
+  const [selectedCell, setSelectedCell] = useState(null);
+  const lastTrigger = useRef(null);
+  const [contributorPage, setContributorPage] = useState(0);
+  useEffect(() => {
+    setSelectedCell(null);
+  }, [pivotData, settings]);
+  useEffect(() => {
+    setContributorPage(0);
+  }, [selectedCell]);
+  const handleFilterClick = useCallback(
+    (field, value) => {
+      const currentFilters = settings.filters || [];
+      const existingFilterIndex = currentFilters.findIndex(
+        (f) => f.type === "value" && f.field === field && categoryIncludes(f.values, value)
+      );
+      let newFilters;
+      if (existingFilterIndex >= 0) {
+        newFilters = [
+          ...currentFilters.slice(0, existingFilterIndex),
+          ...currentFilters.slice(existingFilterIndex + 1)
+        ];
+      } else {
+        const newFilter = {
+          type: "value",
+          field,
+          values: [value]
+        };
+        newFilters = [...currentFilters, newFilter];
+      }
+      updateChart(settings.id, {
+        ...settings,
+        filters: newFilters
+      });
+    },
+    [settings, updateChart]
+  );
+  const isValueFiltered = useCallback(
+    (field, value) => {
+      const currentFilters = settings.filters || [];
+      const fieldFilters = currentFilters.filter((f) => f.field === field);
+      if (fieldFilters.length === 0) {
+        return false;
+      }
+      return fieldFilters.some((filter) => applyFilter(value, filter));
+    },
+    [settings.filters]
+  );
+  const isCellFiltered = useCallback(
+    (rowHeaders, cellKey) => {
+      const currentFilters = settings.filters || [];
+      if (currentFilters.length === 0) {
+        return false;
+      }
+      const rowFieldFilters = rowHeaders.map((header) => {
+        const fieldFilters = currentFilters.filter(
+          (f) => f.field === header.field
+        );
+        return {
+          header,
+          filters: fieldFilters
+        };
+      });
+      const hasRowFilters = rowFieldFilters.some((rf) => rf.filters.length > 0);
+      const rowMatches = !hasRowFilters || rowFieldFilters.every(
+        ({ header, filters }) => filters.length === 0 || filters.some((filter) => applyFilter(header.value, filter))
+      );
+      const columnFilters = currentFilters.filter(
+        (f) => !cellKey.isTotal && f.field === cellKey.columnField
+      );
+      const hasColumnFilters = columnFilters.length > 0;
+      const columnMatches = !hasColumnFilters || columnFilters.some(
+        (filter) => applyFilter(cellKey.columnValue, filter)
+      );
+      return rowMatches && columnMatches;
+    },
+    [settings.filters]
+  );
+  const filterButton = (header) => /* @__PURE__ */ jsxs(
+    "button",
+    {
+      type: "button",
+      className: "eda-pivot-filter",
+      "aria-label": `Filter ${header.field} by ${header.label}`,
+      "aria-pressed": isValueFiltered(header.field, header.value),
+      onClick: () => handleFilterClick(header.field, header.value),
+      children: [
+        /* @__PURE__ */ jsx("span", { children: hasFieldDisplayFormat(fieldSettings[header.field]) ? formatFieldValue?.(header.field, header.value) ?? header.label : header.label }),
+        /* @__PURE__ */ jsx(Filter, { "aria-hidden": "true" })
+      ]
+    }
+  );
+  const valueLabel = (field, aggregation, label) => label || `${getFieldLabel?.(field) ?? field} (${aggregation})`;
+  const displayPivotCell = (cell) => {
+    if (cell.status !== "ok") return displayCellValue(cell);
+    return hasFieldDisplayFormat(fieldSettings[cell.key.valueField]) ? formatFieldValue?.(cell.key.valueField, cell.value) ?? displayCellValue(cell) : displayCellValue(cell);
+  };
+  const selectedCellName = selectedCell ? cellName(selectedCell.cell, selectedCell.rowHeaders) : "";
+  const valueColumnCount = settings.valueFields.length * (settings.columnField ? pivotData.headers.length : 1);
+  const contributorPageSize = 50;
+  const contributorCount = selectedCell?.cell.contributors.length ?? 0;
+  const contributorPageCount = Math.max(
+    1,
+    Math.ceil(contributorCount / contributorPageSize)
+  );
+  const contributorStart = contributorPage * contributorPageSize;
+  const visibleContributors = selectedCell?.cell.contributors.slice(
+    contributorStart,
+    contributorStart + contributorPageSize
+  ) ?? [];
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: "w-full min-h-0 overflow-auto",
+      style: { height },
+      tabIndex: 0,
+      "aria-label": "Pivot table, scroll to see more",
+      children: [
+        /* @__PURE__ */ jsxs(
+          "table",
+          {
+            className: "eda-pivot-table",
+            style: {
+              minWidth: settings.rowFields.length * 140 + valueColumnCount * 112
+            },
+            children: [
+              /* @__PURE__ */ jsx("caption", { className: "sr-only", children: getChartSummary(settings) }),
+              /* @__PURE__ */ jsxs("colgroup", { children: [
+                settings.rowFields.map((field) => /* @__PURE__ */ jsx("col", { style: { width: 140 } }, field)),
+                Array.from({ length: valueColumnCount }, (_, index) => /* @__PURE__ */ jsx("col", {}, index))
+              ] }),
+              /* @__PURE__ */ jsxs("thead", { className: "sticky top-0 z-30", children: [
+                /* @__PURE__ */ jsxs("tr", { children: [
+                  settings.rowFields.map((field, index) => /* @__PURE__ */ jsx(
+                    "th",
+                    {
+                      scope: "col",
+                      rowSpan: settings.columnField ? 2 : 1,
+                      className: "eda-pivot-row-label",
+                      style: { left: index * 140, zIndex: 20 - index },
+                      children: getFieldLabel?.(field) ?? field
+                    },
+                    field
+                  )),
+                  settings.columnField ? pivotData.headers.map((header) => /* @__PURE__ */ jsx(
+                    "th",
+                    {
+                      scope: "colgroup",
+                      colSpan: settings.valueFields.length,
+                      children: filterButton(header)
+                    },
+                    `${header.field}-${categoryKey(header.value)}`
+                  )) : settings.valueFields.map((valueField) => /* @__PURE__ */ jsx("th", { scope: "col", children: valueLabel(
+                    valueField.field,
+                    valueField.aggregation,
+                    valueField.label
+                  ) }, valueField.field))
+                ] }),
+                settings.columnField && /* @__PURE__ */ jsx("tr", { children: pivotData.headers.flatMap(
+                  (header) => settings.valueFields.map((valueField) => /* @__PURE__ */ jsx(
+                    "th",
+                    {
+                      scope: "col",
+                      children: valueLabel(
+                        valueField.field,
+                        valueField.aggregation,
+                        valueField.label
+                      )
+                    },
+                    `${header.field}-${categoryKey(header.value)}-${valueField.field}`
+                  ))
+                ) })
+              ] }),
+              /* @__PURE__ */ jsxs("tbody", { children: [
+                pivotData.rows.map((row) => /* @__PURE__ */ jsxs(
+                  "tr",
+                  {
+                    children: [
+                      row.headers.map((header, index) => /* @__PURE__ */ jsx(
+                        "th",
+                        {
+                          scope: "row",
+                          className: "eda-pivot-row-label",
+                          style: { left: index * 140, zIndex: 10 - index },
+                          children: filterButton(header)
+                        },
+                        `${header.field}-${categoryKey(header.value)}`
+                      )),
+                      row.cells.map((cell) => /* @__PURE__ */ jsx(
+                        "td",
+                        {
+                          className: cn(
+                            isCellFiltered(row.headers, cell.key) && "is-selected"
+                          ),
+                          children: /* @__PURE__ */ jsxs("div", { className: "flex items-center justify-end gap-2", children: [
+                            /* @__PURE__ */ jsx(
+                              ActionTooltip,
+                              {
+                                content: cell.error ?? cellName(cell, row.headers),
+                                children: /* @__PURE__ */ jsx("span", { tabIndex: cell.error ? 0 : void 0, children: displayPivotCell(cell) })
+                              }
+                            ),
+                            /* @__PURE__ */ jsx(
+                              "button",
+                              {
+                                type: "button",
+                                className: "rounded px-1 text-[10px] text-muted-foreground underline-offset-2 hover:underline focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring",
+                                "aria-haspopup": "dialog",
+                                "aria-label": `Inspect ${cellName(cell, row.headers)}`,
+                                onClick: (event) => {
+                                  lastTrigger.current = event.currentTarget;
+                                  setSelectedCell({ cell, rowHeaders: row.headers });
+                                },
+                                children: "Inspect"
+                              }
+                            )
+                          ] })
+                        },
+                        `${cell.key.isTotal ? "total" : cell.key.columnField}-${categoryKey(cell.key.columnValue)}-${cell.key.valueField}`
+                      ))
+                    ]
+                  },
+                  JSON.stringify(
+                    row.keys.map((key) => [key.field, categoryKey(key.value)])
+                  )
+                )),
+                pivotData.rows.length === 0 && /* @__PURE__ */ jsx("tr", { children: /* @__PURE__ */ jsx(
+                  "td",
+                  {
+                    colSpan: settings.rowFields.length + valueColumnCount,
+                    className: "text-muted-foreground",
+                    children: "No matching rows"
+                  }
+                ) })
+              ] })
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          Dialog,
+          {
+            open: selectedCell !== null,
+            onOpenChange: (open) => {
+              if (!open) {
+                setSelectedCell(null);
+                window.setTimeout(() => lastTrigger.current?.focus(), 0);
+              }
+            },
+            children: /* @__PURE__ */ jsx(DialogContent, { className: "max-h-[80vh] max-w-3xl overflow-y-auto", children: selectedCell && /* @__PURE__ */ jsxs(Fragment, { children: [
+              /* @__PURE__ */ jsxs(DialogHeader, { children: [
+                /* @__PURE__ */ jsxs(DialogTitle, { children: [
+                  "Inspect ",
+                  selectedCellName
+                ] }),
+                /* @__PURE__ */ jsx(DialogDescription, { children: "This cell uses the current filtered rows and the same aggregation as the table." })
+              ] }),
+              /* @__PURE__ */ jsxs("div", { className: "grid gap-2 text-sm sm:grid-cols-3", children: [
+                /* @__PURE__ */ jsxs("div", { children: [
+                  /* @__PURE__ */ jsx("div", { className: "text-muted-foreground", children: "Aggregation" }),
+                  /* @__PURE__ */ jsx("div", { children: selectedCell.cell.aggregation })
+                ] }),
+                /* @__PURE__ */ jsxs("div", { children: [
+                  /* @__PURE__ */ jsx("div", { className: "text-muted-foreground", children: "Result" }),
+                  /* @__PURE__ */ jsx("div", { children: displayPivotCell(selectedCell.cell) })
+                ] }),
+                /* @__PURE__ */ jsxs("div", { children: [
+                  /* @__PURE__ */ jsx("div", { className: "text-muted-foreground", children: "Contributors" }),
+                  /* @__PURE__ */ jsx("div", { children: selectedCell.cell.contributors.length })
+                ] })
+              ] }),
+              selectedCell.cell.error && /* @__PURE__ */ jsxs(
+                "p",
+                {
+                  role: "alert",
+                  className: "rounded border border-destructive/50 p-2 text-sm text-destructive",
+                  children: [
+                    selectedCell.cell.error,
+                    ". The other pivot cells remain available."
+                  ]
+                }
+              ),
+              selectedCell.cell.numericExclusions.length > 0 && /* @__PURE__ */ jsxs("p", { className: "text-sm text-muted-foreground", children: [
+                selectedCell.cell.numericExclusions.length,
+                " numeric value(s) excluded; the result uses the",
+                " ",
+                selectedCell.cell.contributors.filter(
+                  (contributor) => contributor.included
+                ).length,
+                " ",
+                "valid value(s)."
+              ] }),
+              /* @__PURE__ */ jsxs("div", { className: "overflow-auto rounded border", children: [
+                /* @__PURE__ */ jsxs("table", { className: "w-full text-left text-sm", children: [
+                  /* @__PURE__ */ jsx("caption", { className: "sr-only", children: "Pivot cell contributors" }),
+                  /* @__PURE__ */ jsx("thead", { className: "bg-muted", children: /* @__PURE__ */ jsxs("tr", { children: [
+                    /* @__PURE__ */ jsx("th", { className: "p-2", scope: "col", children: "Source row ID (zero-based)" }),
+                    /* @__PURE__ */ jsx("th", { className: "p-2", scope: "col", children: "Grouping keys" }),
+                    /* @__PURE__ */ jsx("th", { className: "p-2", scope: "col", children: "Input" }),
+                    /* @__PURE__ */ jsx("th", { className: "p-2", scope: "col", children: "Used" })
+                  ] }) }),
+                  /* @__PURE__ */ jsx("tbody", { children: visibleContributors.map((contributor, index) => /* @__PURE__ */ jsxs(
+                    "tr",
+                    {
+                      className: "border-t",
+                      children: [
+                        /* @__PURE__ */ jsx("td", { className: "p-2", children: contributor.sourceId ?? "Unknown" }),
+                        /* @__PURE__ */ jsx("td", { className: "p-2", children: contributor.groupingKeys.map(
+                          (key) => `${key.field}=${displayValue(key.value)}`
+                        ).join(", ") }),
+                        /* @__PURE__ */ jsx("td", { className: "p-2", children: displayExactValue(contributor.input) }),
+                        /* @__PURE__ */ jsx("td", { className: "p-2", children: contributor.included ? "Yes" : contributor.exclusionReason || "No" })
+                      ]
+                    },
+                    `${contributor.sourceId ?? "unknown"}-${index}`
+                  )) })
+                ] }),
+                contributorCount === 0 && /* @__PURE__ */ jsx("p", { className: "p-3 text-sm text-muted-foreground", children: "No rows match this cell." })
+              ] }),
+              /* @__PURE__ */ jsxs("div", { className: "flex items-center justify-between gap-3 text-sm text-muted-foreground", children: [
+                /* @__PURE__ */ jsxs("span", { children: [
+                  "Showing ",
+                  contributorCount === 0 ? 0 : contributorStart + 1,
+                  "\u2013",
+                  Math.min(
+                    contributorStart + contributorPageSize,
+                    contributorCount
+                  ),
+                  " ",
+                  "of ",
+                  contributorCount,
+                  " source rows"
+                ] }),
+                /* @__PURE__ */ jsxs("div", { className: "flex gap-2", children: [
+                  /* @__PURE__ */ jsx(
+                    "button",
+                    {
+                      type: "button",
+                      className: "rounded border px-2 py-1 disabled:cursor-not-allowed disabled:opacity-50",
+                      disabled: contributorPage === 0,
+                      onClick: () => setContributorPage((page) => page - 1),
+                      children: "Previous"
+                    }
+                  ),
+                  /* @__PURE__ */ jsx(
+                    "button",
+                    {
+                      type: "button",
+                      className: "rounded border px-2 py-1 disabled:cursor-not-allowed disabled:opacity-50",
+                      disabled: contributorPage >= contributorPageCount - 1,
+                      onClick: () => setContributorPage((page) => page + 1),
+                      children: "Next"
+                    }
+                  )
+                ] })
+              ] })
+            ] }) })
+          }
+        )
+      ]
+    }
+  );
+}
+var AGGREGATION_OPTIONS = [
+  { label: "Sum", value: "sum" },
+  { label: "Count", value: "count" },
+  { label: "Average", value: "avg" },
+  { label: "Min", value: "min" },
+  { label: "Max", value: "max" },
+  { label: "Median", value: "median" },
+  { label: "Mode", value: "mode" },
+  { label: "StdDev", value: "stddev" },
+  { label: "Variance", value: "variance" },
+  { label: "Count Unique", value: "countUnique" },
+  { label: "Single Value", value: "singleValue" }
+];
+function PivotTableSettingsPanel({
+  settings,
+  onSettingsChange
+}) {
+  const availableFields = useColumnNames();
+  const fieldOptions = availableFields.map((f) => ({
+    label: f,
+    value: f
+  }));
+  return /* @__PURE__ */ jsxs("div", { className: "space-y-4", children: [
+    /* @__PURE__ */ jsxs("div", { className: "space-y-2", children: [
+      /* @__PURE__ */ jsx(Label, { children: "Row Fields" }),
+      /* @__PURE__ */ jsx("div", { className: "max-w-[400px]", children: /* @__PURE__ */ jsx(
+        multi_select_default,
+        {
+          options: fieldOptions,
+          value: settings.rowFields.map((f) => ({
+            label: f,
+            value: f
+          })),
+          onChange: (values) => onSettingsChange({
+            ...settings,
+            rowFields: values.map((v) => v.value)
+          })
+        }
+      ) })
+    ] }),
+    /* @__PURE__ */ jsx("div", { className: "space-y-2", children: /* @__PURE__ */ jsx("div", { className: "max-w-[400px]", children: /* @__PURE__ */ jsx(
+      FieldSelector,
+      {
+        label: "Column Field",
+        value: settings.columnField,
+        onChange: (value) => onSettingsChange({ ...settings, columnField: value })
+      }
+    ) }) }),
+    /* @__PURE__ */ jsxs("div", { className: "space-y-2", children: [
+      /* @__PURE__ */ jsx(Label, { children: "Value Fields" }),
+      /* @__PURE__ */ jsxs("div", { className: "max-w-[400px] space-y-2", children: [
+        settings.valueFields.map((valueField, index) => /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2", children: [
+          /* @__PURE__ */ jsx("div", { className: "flex-1", children: /* @__PURE__ */ jsx(
+            ComboBox,
+            {
+              options: fieldOptions,
+              value: fieldOptions.find((f) => f.value === valueField.field),
+              onChange: (option) => {
+                const newValueFields = [...settings.valueFields];
+                newValueFields[index] = {
+                  ...valueField,
+                  field: option?.value || valueField.field
+                };
+                onSettingsChange({
+                  ...settings,
+                  valueFields: newValueFields
+                });
+              },
+              optionToString: (option) => option.label
+            }
+          ) }),
+          /* @__PURE__ */ jsx("div", { className: "flex-1", children: /* @__PURE__ */ jsx(
+            ComboBox,
+            {
+              options: AGGREGATION_OPTIONS,
+              value: AGGREGATION_OPTIONS.find(
+                (o) => o.value === valueField.aggregation
+              ),
+              onChange: (option) => {
+                if (!option) {
+                  return;
+                }
+                const newValueFields = [...settings.valueFields];
+                newValueFields[index] = {
+                  ...valueField,
+                  aggregation: option.value
+                };
+                onSettingsChange({
+                  ...settings,
+                  valueFields: newValueFields
+                });
+              },
+              optionToString: (option) => option.label
+            }
+          ) }),
+          /* @__PURE__ */ jsx(
+            "button",
+            {
+              className: "p-2 hover:bg-accent rounded",
+              onClick: () => {
+                const newValueFields = settings.valueFields.filter(
+                  (_, i) => i !== index
+                );
+                onSettingsChange({
+                  ...settings,
+                  valueFields: newValueFields
+                });
+              },
+              children: "\xD7"
+            }
+          )
+        ] }, index)),
+        /* @__PURE__ */ jsx(
+          "button",
+          {
+            className: "text-sm text-primary hover:text-primary/80",
+            onClick: () => {
+              const field = availableFields[0];
+              if (!field) {
+                return;
+              }
+              onSettingsChange({
+                ...settings,
+                valueFields: [
+                  ...settings.valueFields,
+                  {
+                    field,
+                    aggregation: "count"
+                  }
+                ]
+              });
+            },
+            children: "+ Add Value Field"
+          }
+        )
+      ] })
+    ] })
+  ] });
+}
+
+// src/components/charts/PivotTable/definition.ts
+var VALID_AGGREGATIONS = /* @__PURE__ */ new Set([
+  "sum",
+  "count",
+  "avg",
+  "min",
+  "max",
+  "median",
+  "mode",
+  "stddev",
+  "variance",
+  "countUnique",
+  "singleValue"
+]);
+var pivotTableDefinition = {
+  type: "pivot",
+  name: "Pivot Table",
+  description: "Interactive pivot table for data analysis",
+  icon: Table,
+  component: PivotTable,
+  settingsPanel: PivotTableSettingsPanel,
+  createDefaultSettings: (layout) => ({
+    ...DEFAULT_CHART_SETTINGS,
+    id: crypto.randomUUID(),
+    type: "pivot",
+    title: "Pivot Table",
+    layout,
+    margin: { top: 0, right: 0, bottom: 0, left: 0 },
+    rowFields: [],
+    columnField: "",
+    valueFields: [],
+    filters: []
+  }),
+  validateSettings: (settings) => {
+    const rowFields = Array.isArray(settings.rowFields) && settings.rowFields.every(
+      (field) => typeof field === "string" && field.trim().length > 0
+    );
+    const columnField = typeof settings.columnField === "string" && (settings.columnField === "" || settings.columnField.trim().length > 0);
+    const valueFields = Array.isArray(settings.valueFields) && settings.valueFields.length > 0 && settings.valueFields.every(
+      (valueField) => typeof valueField.field === "string" && valueField.field.trim().length > 0 && VALID_AGGREGATIONS.has(valueField.aggregation)
+    );
+    return rowFields && columnField && valueFields && new Set(settings.rowFields).size === settings.rowFields.length && (!settings.columnField || !settings.rowFields.includes(settings.columnField));
+  },
+  getFilterFunction: (settings, fieldGetter) => {
+    const fields = [...settings.rowFields, settings.columnField];
+    const filters = settings.filters.filter(
+      (filter) => filter.type === "value" && fields.includes(filter.field)
+    );
+    const activeFields = [...new Set(filters.map((filter) => filter.field))];
+    const groups = activeFields.map((field) => ({
+      data: fieldGetter(field),
+      filters: filters.filter((filter) => filter.field === field)
+    }));
+    return (id) => groups.every(
+      (group) => group.filters.some((filter) => applyFilter(group.data[id], filter))
+    );
+  }
+};
+
+export { pivotTableDefinition };
+//# sourceMappingURL=chunk-EGMFQSGK.js.map
+//# sourceMappingURL=chunk-EGMFQSGK.js.map