exploreda 0.0.5 → 0.1.0

package/dist/chunk-JNO7OXCC.js

@@ -0,0 +1,2171 @@
+import { getChartDefinition, chartRegistry } from './chunk-TLLRW6S3.js';
+import { parseExpression } from './chunk-H5AVMMCE.js';
+import crossfilter from 'crossfilter2';
+import isEqual from 'react-fast-compare';
+import { utcFormat } from 'd3-time-format';
+import { createContext, useRef, useEffect, useContext } from 'react';
+import { useStore, createStore } from 'zustand';
+import { jsx, jsxs } from 'react/jsx-runtime';
+import { clsx } from 'clsx';
+import { twMerge } from 'tailwind-merge';
+import * as TooltipPrimitive from '@radix-ui/react-tooltip';
+import { Slot } from '@radix-ui/react-slot';
+import { cva } from 'class-variance-authority';
+
+// src/lib/categories.ts
+var categoryValue = (value) => value ?? null;
+var categoryKey = (value) => {
+  if (value == null) return JSON.stringify(["missing"]);
+  if (typeof value === "number" && !Number.isFinite(value)) {
+    return JSON.stringify(["number", String(value)]);
+  }
+  return JSON.stringify([typeof value, value]);
+};
+function categoryEqual(left, right) {
+  return left == null && right == null || left === right || typeof left === "number" && typeof right === "number" && Number.isNaN(left) && Number.isNaN(right);
+}
+function categoryIncludes(values, value) {
+  return values.includes(value) || value == null && values.some((item) => item == null);
+}
+function categoryLabel(value) {
+  if (value == null) return "(missing)";
+  if (typeof value === "string" && (!value.trim() || !Number.isNaN(Number(value)) || /^(true|false|null|undefined|NaN|Other categories|\(missing\))$/.test(
+    value
+  ) || value.startsWith('"')))
+    return JSON.stringify(value);
+  return String(value);
+}
+
+// src/lib/dateTime.ts
+function dateTimestamp(value) {
+  return Date.parse(
+    /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?$/.test(value) ? `${value}Z` : value
+  );
+}
+
+// src/lib/fieldSettings.ts
+var validTypes = /* @__PURE__ */ new Set([
+  "numeric",
+  "categorical",
+  "datetime",
+  "boolean"
+]);
+var validFormats = /* @__PURE__ */ new Set([
+  "auto",
+  "number",
+  "currency",
+  "percent",
+  "date",
+  "datetime"
+]);
+function getFieldSettingsError(settings) {
+  if (settings.type && !validTypes.has(settings.type)) {
+    return "Choose a valid field type.";
+  }
+  if (settings.format && !validFormats.has(settings.format)) {
+    return "Choose a valid display format.";
+  }
+  if (settings.precision !== void 0 && (!Number.isInteger(settings.precision) || settings.precision < 0 || settings.precision > 20)) {
+    return "Precision must be a whole number from 0 to 20.";
+  }
+  if (settings.currency !== void 0 && !/^[A-Z]{3}$/.test(settings.currency)) {
+    return "Currency must be a three-letter code, such as USD.";
+  }
+  if (settings.datePreset !== void 0 && !["iso", "month-day-year", "day-month-year"].includes(settings.datePreset)) {
+    return "Choose a valid date input preset.";
+  }
+  if (settings.nullTokens !== void 0 && settings.nullTokens.some((token) => typeof token !== "string")) {
+    return "Null tokens must be text values.";
+  }
+  return void 0;
+}
+function validCalendarDate(year, month, day) {
+  const timestamp = Date.UTC(year, month - 1, day);
+  const date = new Date(timestamp);
+  return Number.isFinite(timestamp) && date.getUTCFullYear() === year && date.getUTCMonth() === month - 1 && date.getUTCDate() === day;
+}
+function parseDate(value, preset = "iso") {
+  const text = value.trim();
+  if (preset === "month-day-year" || preset === "day-month-year") {
+    const match = text.match(/^(\d{1,2})[/-](\d{1,2})[/-](\d{4})$/);
+    if (match) {
+      const [, first, second, yearText2] = match;
+      const year = Number(yearText2);
+      const month = preset === "month-day-year" ? Number(first) : Number(second);
+      const day = preset === "month-day-year" ? Number(second) : Number(first);
+      const parsed = Date.UTC(year, month - 1, day);
+      if (validCalendarDate(year, month, day)) {
+        return parsed;
+      }
+    }
+    return NaN;
+  }
+  const isoMatch = text.match(
+    /^(\d{4})-(\d{2})-(\d{2})(?:T(\d{2}):(\d{2})(?::(\d{2})(?:\.(\d+))?)?(Z|[+-]\d{2}:\d{2})?)?$/
+  );
+  if (!isoMatch) return NaN;
+  const [, yearText, monthText, dayText] = isoMatch;
+  if (!validCalendarDate(
+    Number(yearText),
+    Number(monthText),
+    Number(dayText)
+  )) {
+    return NaN;
+  }
+  return dateTimestamp(text);
+}
+function convertFieldValue(raw, type, settings = {}) {
+  if (raw == null) {
+    return { value: void 0 };
+  }
+  const text = typeof raw === "string" ? raw.trim() : String(raw);
+  if (settings.nullTokens?.some((token) => token === text)) {
+    return { value: void 0 };
+  }
+  if (type !== "categorical" && text === "") {
+    return { value: void 0 };
+  }
+  switch (type) {
+    case "categorical":
+      return { value: raw };
+    case "numeric": {
+      const value = typeof raw === "number" ? raw : Number(text);
+      return Number.isFinite(value) ? { value } : { value: void 0, error: "Not a finite number" };
+    }
+    case "boolean":
+      if (raw === true || raw === false) {
+        return { value: raw };
+      }
+      if (text.toLowerCase() === "true") {
+        return { value: true };
+      }
+      if (text.toLowerCase() === "false") {
+        return { value: false };
+      }
+      return { value: void 0, error: "Expected true or false" };
+    case "datetime": {
+      const timestamp = parseDate(text, settings.datePreset);
+      return Number.isFinite(timestamp) ? { value: new Date(timestamp).toISOString() } : { value: void 0, error: "Invalid date" };
+    }
+  }
+}
+function getFieldLabel(field, settings = {}) {
+  const label = settings.label?.trim() || field;
+  return settings.unit ? `${label} (${settings.unit})` : label;
+}
+function hasFieldDisplayFormat(settings = {}) {
+  return Boolean(
+    settings.format && settings.format !== "auto" || settings.precision !== void 0 || settings.unit
+  );
+}
+function formatFieldValue(field, value, settings = {}) {
+  if (value == null) {
+    return "\u2014";
+  }
+  if (typeof value === "boolean") {
+    return value ? "Yes" : "No";
+  }
+  if (typeof value === "string" && value.trim() === "") {
+    return "\u2014";
+  }
+  const format = settings.format ?? "auto";
+  if (format === "date" || format === "datetime") {
+    const date = typeof value === "number" ? new Date(value) : new Date(String(value));
+    if (Number.isFinite(date.getTime())) {
+      const options = {
+        timeZone: "UTC",
+        dateStyle: "medium"
+      };
+      if (format === "datetime") options.timeStyle = "short";
+      const text = new Intl.DateTimeFormat("en-US", options).format(date);
+      return settings.unit ? `${text} ${settings.unit}` : text;
+    }
+    return String(value);
+  }
+  const numberValue = format === "number" || format === "currency" || format === "percent" || typeof value === "number" && format === "auto" ? Number(value) : NaN;
+  if (Number.isFinite(numberValue)) {
+    const precision = Number.isInteger(settings.precision) && settings.precision !== void 0 && settings.precision >= 0 && settings.precision <= 20 ? settings.precision : void 0;
+    const options = {
+      maximumFractionDigits: precision ?? 3,
+      minimumFractionDigits: precision
+    };
+    if (format === "currency") {
+      options.style = "currency";
+      options.currency = /^[A-Z]{3}$/.test(settings.currency ?? "") ? settings.currency : "USD";
+    } else if (format === "percent") {
+      options.style = "percent";
+    }
+    const text = new Intl.NumberFormat("en-US", options).format(numberValue);
+    return settings.unit ? `${text} ${settings.unit}` : text;
+  }
+  return String(value);
+}
+function applyFieldSettings(rows, fieldSettings, inferredTypes) {
+  return rows.map((row) => {
+    const next = { ...row };
+    Object.entries(fieldSettings).forEach(([field, settings]) => {
+      if (!settings.type && !(settings.nullTokens && settings.nullTokens.length > 0) && !settings.datePreset) {
+        return;
+      }
+      const type = settings.type ?? inferredTypes[field];
+      if (!type || !(field in row)) {
+        return;
+      }
+      next[field] = convertFieldValue(
+        row[field],
+        type,
+        settings
+      ).value;
+    });
+    return next;
+  });
+}
+function buildConversionPreview(field, rows, settings = {}, inferredType) {
+  const effectiveType = settings.type ?? inferredType;
+  const examples = [];
+  const failures = [];
+  let validCount = 0;
+  let missingCount = 0;
+  rows.forEach((row, rowIndex) => {
+    const raw = row[field];
+    const converts = settings.type !== void 0 || Boolean(settings.datePreset) || Boolean(settings.nullTokens?.length);
+    const result = converts ? convertFieldValue(raw, effectiveType, settings) : { value: raw };
+    if (result.error) {
+      failures.push({ row: rowIndex, raw, reason: result.error });
+    } else if (raw == null || result.value == null) {
+      missingCount += 1;
+    } else {
+      validCount += 1;
+    }
+    if (examples.length < 8 && (raw != null || result.error)) {
+      examples.push({ row: rowIndex, raw, value: result.value });
+    }
+  });
+  return {
+    field,
+    inferredType,
+    effectiveType,
+    totalCount: rows.length,
+    validCount,
+    missingCount,
+    failedCount: failures.length,
+    examples,
+    failures
+  };
+}
+
+// src/components/charts/chartAccessibility.ts
+var chartNames = {
+  row: "Row chart",
+  bar: "Bar chart",
+  scatter: "Scatter plot",
+  line: "Line chart",
+  boxplot: "Box plot",
+  "3d-scatter": "3D scatter plot",
+  pivot: "Pivot table",
+  "data-table": "Data table",
+  summary: "Summary table",
+  "color-legend": "Color legend",
+  markdown: "Markdown note"
+};
+function getChartTitle(settings, getFieldLabel2 = (field) => field) {
+  const title = settings.title.trim();
+  if (settings.type === "color-legend" && settings.fields.length === 1 && (!title || settings.title === "Color Legend")) {
+    return getFieldLabel2(settings.fields[0]);
+  }
+  if (title) {
+    return title;
+  }
+  const field = settings.type === "bar" || settings.type === "row" || settings.type === "boxplot" ? settings.field : settings.type === "scatter" || settings.type === "3d-scatter" ? settings.yField : settings.type === "line" && settings.seriesField.length === 1 ? settings.seriesField[0] : void 0;
+  if (!field) {
+    return getChartDefinition(settings.type).name;
+  }
+  const label = field === "__ID" ? "Row sequence" : getFieldLabel2(field);
+  if (settings.type === "bar") {
+    return `Distribution of ${label}`;
+  }
+  if (settings.type === "row") {
+    return `Rows by ${label}`;
+  }
+  return `${getChartDefinition(settings.type).name} \xB7 ${label}`;
+}
+function getChartFields(settings) {
+  const fields = (() => {
+    switch (settings.type) {
+      case "line":
+        return [settings.xField, ...settings.seriesField];
+      case "scatter":
+        return [settings.xField, settings.yField, settings.colorField];
+      case "3d-scatter":
+        return [
+          settings.xField,
+          settings.yField,
+          settings.zField,
+          settings.colorField,
+          settings.sizeField
+        ];
+      case "pivot":
+        return [
+          ...settings.rowFields,
+          settings.columnField,
+          ...settings.valueFields.map((field) => field.field)
+        ];
+      case "data-table":
+        return settings.columns.map((column) => column.field);
+      case "color-legend":
+        return settings.fields;
+      default:
+        return [settings.field, settings.colorField];
+    }
+  })();
+  return Array.from(
+    new Set(fields.filter((field) => Boolean(field)))
+  );
+}
+function getChartAxisFields(settings) {
+  switch (settings.type) {
+    case "bar":
+      return { x: settings.field };
+    case "row":
+      return { y: settings.field };
+    case "scatter":
+      return { x: settings.xField, y: settings.yField };
+    case "line":
+      return {
+        x: settings.xField,
+        y: settings.seriesField.length === 1 ? settings.seriesField[0] : void 0
+      };
+    case "boxplot":
+      return { y: settings.field };
+    case "3d-scatter":
+      return { x: settings.xField, y: settings.yField };
+    default:
+      return {};
+  }
+}
+function getChartAxisLabel(field, local, getFieldLabel2 = (value) => value) {
+  return local || (field === "__ID" ? "Row sequence" : field ? getFieldLabel2(field) : "");
+}
+function getChartSummary(settings, getFieldLabel2 = (field) => field) {
+  const name = chartNames[settings.type] ?? "Chart";
+  if (settings.type === "summary") {
+    return `${name} of all data columns.`;
+  }
+  if (settings.type === "markdown") {
+    return `${name}.`;
+  }
+  const fields = getChartFields(settings);
+  return fields.length ? `${name} showing ${fields.map(getFieldLabel2).join(", ")}.` : `${name} with no data fields selected.`;
+}
+var CrossfilterWrapper = class {
+  ref;
+  nonce = 0;
+  charts = /* @__PURE__ */ new Map();
+  idFunction;
+  // assume this gets set after creation
+  fieldGetter = () => ({});
+  constructor(data, idFunction) {
+    this.ref = crossfilter(data);
+    this.idFunction = idFunction;
+  }
+  setFieldGetter(fieldGetter) {
+    this.fieldGetter = fieldGetter;
+  }
+  updateChart(chart) {
+    const existing = this.charts.get(chart.id);
+    if (!existing) {
+      this.addChart(chart);
+      return;
+    }
+    if (!isEqual(existing.chart, chart)) this.updateChartFilters(chart);
+    existing.chart = chart;
+  }
+  updateChartFilters(chart) {
+    const filterFunc = this.getFilterFunction(chart);
+    const foundChart = this.charts.get(chart.id);
+    const dimension = foundChart?.dimension;
+    if (!dimension) {
+      return;
+    }
+    dimension.filterFunction(filterFunc);
+  }
+  addChart(chart) {
+    const dimension = this.ref.dimension(this.idFunction);
+    const chartDimension = {
+      dimension,
+      chart,
+      group: dimension.group()
+    };
+    this.charts.set(chart.id, chartDimension);
+    this.updateChartFilters(chart);
+  }
+  removeChart(chart) {
+    const savedChart = this.charts.get(chart.id);
+    if (!savedChart) {
+      throw new Error(`Chart ${chart.id} not found`);
+    }
+    savedChart.dimension.filterAll();
+    savedChart.group.dispose();
+    savedChart.dimension.dispose();
+    this.charts.delete(chart.id);
+  }
+  removeAllCharts() {
+    for (const chart of this.charts.values()) {
+      chart.dimension.filterAll();
+      chart.group.dispose();
+      chart.dimension.dispose();
+    }
+    this.charts.clear();
+  }
+  getFilterFunction(chart) {
+    const definition = getChartDefinition(chart.type);
+    return definition.getFilterFunction(chart, this.fieldGetter);
+  }
+  getFilteredRowCount() {
+    return this.ref.allFiltered().length;
+  }
+  getFilteredRowIds() {
+    return this.ref.allFiltered().map(this.idFunction);
+  }
+  getAllData() {
+    const data = {};
+    const commonNonce = ++this.nonce;
+    for (const chart of this.charts.values()) {
+      data[chart.chart.id] = {
+        items: chart.group.all(),
+        nonce: commonNonce
+      };
+    }
+    return data;
+  }
+};
+function numericValue(value) {
+  if (value == null || value === "") throw new Error("Missing numeric value");
+  if (typeof value !== "number" && typeof value !== "string" || typeof value === "string" && !value.trim() || !Number.isFinite(Number(value))) {
+    throw new Error(`Invalid numeric value: ${String(value)}`);
+  }
+  return Number(value);
+}
+function dateValue(value) {
+  const date = value instanceof Date ? value : new Date(dateTimestamp(String(value)));
+  if (!Number.isFinite(date.getTime())) {
+    throw new Error(`Invalid date: ${String(value)}`);
+  }
+  return date;
+}
+var calculationFunctions = {
+  sum: {
+    description: "Add values within this row.",
+    syntax: "sum(x, y, \u2026)",
+    minArgs: 1,
+    evaluate: (...values) => values.reduce((sum, value) => sum + numericValue(value), 0)
+  },
+  avg: {
+    description: "Average values within this row, not across rows.",
+    syntax: "avg(x, y, \u2026)",
+    minArgs: 1,
+    evaluate: (...values) => values.reduce((sum, value) => sum + numericValue(value), 0) / values.length
+  },
+  min: {
+    description: "Return the smallest supplied value.",
+    syntax: "min(x, y, \u2026)",
+    minArgs: 1,
+    evaluate: (...values) => Math.min(...values.map(numericValue))
+  },
+  max: {
+    description: "Return the largest supplied value.",
+    syntax: "max(x, y, \u2026)",
+    minArgs: 1,
+    evaluate: (...values) => Math.max(...values.map(numericValue))
+  },
+  count: {
+    description: "Count supplied arguments, including missing values.",
+    syntax: "count(x, y, \u2026)",
+    minArgs: 0,
+    evaluate: (...values) => values.length
+  },
+  formatdate: {
+    description: "Format a UTC date. Use %Y-%m for a month label.",
+    syntax: 'formatDate(date, "%Y-%m-%d")',
+    minArgs: 2,
+    maxArgs: 2,
+    evaluate: (value, format) => utcFormat(String(format))(dateValue(value))
+  },
+  extractdatecomponent: {
+    description: "Extract a UTC year, month, day, quarter, or ISO week.",
+    syntax: 'extractDateComponent(date, "year")',
+    minArgs: 2,
+    maxArgs: 2,
+    evaluate: (value, component) => {
+      const date = dateValue(value);
+      switch (component) {
+        case "year":
+          return date.getUTCFullYear();
+        case "month":
+          return date.getUTCMonth() + 1;
+        case "day":
+          return date.getUTCDate();
+        case "quarter":
+          return Math.floor(date.getUTCMonth() / 3) + 1;
+        case "week":
+          return Number(utcFormat("%V")(date));
+        default:
+          throw new Error(`Unknown date component: ${String(component)}`);
+      }
+    }
+  }
+};
+function getFunction(name, argumentCount) {
+  const key = name.toLowerCase();
+  const fn = Object.hasOwn(calculationFunctions, key) ? calculationFunctions[key] : void 0;
+  if (!fn) throw new Error(`Unknown function: ${name}`);
+  if (argumentCount < fn.minArgs || fn.maxArgs !== void 0 && argumentCount > fn.maxArgs) {
+    throw new Error(`Invalid arguments. Use ${fn.syntax}`);
+  }
+  return fn;
+}
+
+// src/lib/calculations/engine/Calculator.ts
+function validateExpression(expression, fields) {
+  for (const field of expression.dependencies) {
+    if (!fields.includes(field)) throw new Error(`Unknown field: ${field}`);
+  }
+  switch (expression.type) {
+    case "function":
+      getFunction(expression.functionName, expression.arguments.length);
+      expression.arguments.forEach((arg) => validateExpression(arg, fields));
+      break;
+    case "basic":
+      validateExpression(expression.left, fields);
+      validateExpression(expression.right, fields);
+      break;
+    case "unary":
+      validateExpression(expression.operand, fields);
+      break;
+    case "ternary":
+      validateExpression(expression.condition, fields);
+      validateExpression(expression.trueBranch, fields);
+      validateExpression(expression.falseBranch, fields);
+  }
+}
+var Calculator = class {
+  constructor(context, steps) {
+    this.context = context;
+    this.steps = steps;
+  }
+  depth = 0;
+  evaluate(expression) {
+    try {
+      return { success: true, value: this.value(expression) };
+    } catch (error) {
+      return {
+        success: false,
+        value: null,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  value(expression) {
+    const depth = this.depth++;
+    const label = expression.type === "literal" ? expression.dependencies[0] ?? String(expression.value) : expression.type === "function" ? expression.functionName : expression.type === "ternary" ? "conditional" : expression.operator;
+    try {
+      const result = this.evaluateValue(expression);
+      if (typeof result === "number" && !Number.isFinite(result)) {
+        throw new Error("Calculation produced a non-finite number");
+      }
+      this.steps?.push({ id: expression.id, depth, label, value: result });
+      return result;
+    } catch (error) {
+      this.steps?.push({
+        id: expression.id,
+        depth,
+        label,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    } finally {
+      this.depth--;
+    }
+  }
+  evaluateValue(expression) {
+    switch (expression.type) {
+      case "literal": {
+        const field = expression.dependencies[0];
+        if (field === void 0) return expression.value;
+        if (!this.context.variables.has(field))
+          throw new Error(`Undefined variable: ${field}`);
+        return this.context.variables.get(field);
+      }
+      case "function":
+        return getFunction(
+          expression.functionName,
+          expression.arguments.length
+        ).evaluate(...expression.arguments.map((arg) => this.value(arg)));
+      case "ternary":
+        if (!expression.condition || !expression.trueBranch || !expression.falseBranch) {
+          throw new Error("Invalid ternary expression: missing branches");
+        }
+        return this.value(
+          this.value(expression.condition) ? expression.trueBranch : expression.falseBranch
+        );
+      case "unary": {
+        if (!expression.operand)
+          throw new Error("Invalid unary expression: missing operand");
+        const value = this.value(expression.operand);
+        switch (expression.operator) {
+          case "!":
+            return !value;
+          case "-":
+            return -numericValue(value);
+          case "+":
+            return numericValue(value);
+          default:
+            throw new Error(`Unknown unary operator: ${expression.operator}`);
+        }
+      }
+      case "basic": {
+        if (!expression.left || !expression.right)
+          throw new Error("Invalid basic expression: missing operands");
+        const left = this.value(expression.left);
+        if (expression.operator === "&&")
+          return Boolean(left) && Boolean(this.value(expression.right));
+        if (expression.operator === "||")
+          return Boolean(left) || Boolean(this.value(expression.right));
+        const right = this.value(expression.right);
+        if (expression.operator === "==")
+          return left == null ? right == null : left === right;
+        if (expression.operator === "!=")
+          return left == null ? right != null : left !== right;
+        const a = numericValue(left);
+        const b = numericValue(right);
+        switch (expression.operator) {
+          case "+":
+            return a + b;
+          case "-":
+            return a - b;
+          case "*":
+            return a * b;
+          case "/":
+            if (b === 0) throw new Error("Division by zero");
+            return a / b;
+          case "^":
+            return a ** b;
+          case ">":
+            return a > b;
+          case ">=":
+            return a >= b;
+          case "<":
+            return a < b;
+          case "<=":
+            return a <= b;
+          default:
+            throw new Error(`Unknown operator: ${expression.operator}`);
+        }
+      }
+      default:
+        throw new Error("Unknown expression type");
+    }
+  }
+};
+
+// src/lib/calculations/CalculationState.ts
+var CalculationManager = class {
+  constructor(data, calculations = []) {
+    this.data = data;
+    this.setCalculations(calculations);
+  }
+  calculations = [];
+  results = /* @__PURE__ */ new Map();
+  errors = /* @__PURE__ */ new Map();
+  setCalculations(calculations) {
+    const sourceFields = new Set(this.data.flatMap((row) => Object.keys(row)));
+    const names = calculations.map((calc) => calc.resultColumnName);
+    for (const name of names) {
+      if (!name.trim()) throw new Error("Enter a result column name");
+      if (sourceFields.has(name) || names.filter((other) => other === name).length > 1) {
+        throw new Error(`Field already exists: ${name}`);
+      }
+    }
+    const fields = [...sourceFields, ...names];
+    const visiting = /* @__PURE__ */ new Set();
+    const visited = /* @__PURE__ */ new Set();
+    const visit = (calc) => {
+      const name = calc.resultColumnName;
+      if (visiting.has(name)) throw new Error(`Circular calculation: ${name}`);
+      if (visited.has(name)) return;
+      visiting.add(name);
+      validateExpression(calc.expression, fields);
+      for (const field of calc.expression.dependencies) {
+        const dependency = calculations.find(
+          (item) => item.resultColumnName === field
+        );
+        if (dependency) visit(dependency);
+      }
+      visiting.delete(name);
+      visited.add(name);
+    };
+    calculations.forEach(visit);
+    const affected = /* @__PURE__ */ new Set([
+      ...this.calculations.map((calc) => calc.resultColumnName),
+      ...names
+    ]);
+    this.calculations = [...calculations];
+    this.results.clear();
+    this.errors.clear();
+    return affected;
+  }
+  addCalculation(calculation) {
+    return this.setCalculations([...this.calculations, calculation]);
+  }
+  updateCalculation(name, calculation) {
+    if (!this.calculations.some((calc) => calc.resultColumnName === name)) {
+      throw new Error(`Unknown calculation: ${name}`);
+    }
+    return this.setCalculations(
+      this.calculations.map(
+        (calc) => calc.resultColumnName === name ? calculation : calc
+      )
+    );
+  }
+  removeCalculation(name) {
+    return this.setCalculations(
+      this.calculations.filter((calc) => calc.resultColumnName !== name)
+    );
+  }
+  getCalculations() {
+    return [...this.calculations];
+  }
+  getErrors(name) {
+    const calculation = this.calculations.find(
+      (calc) => calc.resultColumnName === name
+    );
+    if (calculation) this.executeCalculation(calculation);
+    return this.errors.get(name) ?? /* @__PURE__ */ new Map();
+  }
+  traceRow(name, rowId) {
+    const calc = this.calculations.find(
+      (item) => item.resultColumnName === name
+    );
+    const row = this.data.find((item) => item.__ID === rowId);
+    if (!calc || !row) return void 0;
+    const dependencies = calc.expression.dependencies.flatMap((field) => {
+      const trace = this.traceRow(field, rowId);
+      return trace ? [trace] : [];
+    });
+    const variables = new Map(Object.entries(row));
+    for (const field of calc.expression.dependencies) {
+      const dependency = dependencies.find((item) => item.field === field);
+      if (dependency) variables.set(field, dependency.value);
+    }
+    const steps = [];
+    const result = new Calculator(
+      { data: this.data, variables },
+      steps
+    ).evaluate(calc.expression);
+    return {
+      field: name,
+      expression: calc.expression.rawInput,
+      value: result.success && !(result.value instanceof Date) ? result.value ?? void 0 : void 0,
+      error: result.error,
+      steps,
+      inputs: calc.expression.dependencies.map((field) => ({
+        field,
+        value: variables.get(field)
+      })),
+      dependencies
+    };
+  }
+  executeCalculation(calculation) {
+    const name = calculation.resultColumnName;
+    const cached = this.results.get(name);
+    if (cached) return cached;
+    for (const field of calculation.expression.dependencies) {
+      const dependency = this.calculations.find(
+        (calc) => calc.resultColumnName === field
+      );
+      if (dependency) this.executeCalculation(dependency);
+    }
+    const values = /* @__PURE__ */ new Map();
+    const errors = /* @__PURE__ */ new Map();
+    for (const row of this.data) {
+      const variables = new Map(Object.entries(row));
+      for (const field of calculation.expression.dependencies) {
+        const results = this.results.get(field);
+        variables.set(field, results ? results.get(row.__ID) : row[field]);
+      }
+      const result = new Calculator({ data: this.data, variables }).evaluate(
+        calculation.expression
+      );
+      values.set(
+        row.__ID,
+        result.success && !(result.value instanceof Date) ? result.value ?? void 0 : void 0
+      );
+      if (!result.success)
+        errors.set(row.__ID, result.error ?? "Calculation failed");
+    }
+    this.results.set(name, values);
+    this.errors.set(name, errors);
+    return values;
+  }
+};
+
+// src/lib/numeric.ts
+function isMissingValue(value) {
+  return value === void 0 || value === null || typeof value === "string" && value.trim() === "";
+}
+function isNumberLike(value) {
+  if (typeof value === "number") return true;
+  if (typeof value !== "string" || value.trim() === "") return false;
+  return value.trim() === "NaN" || !Number.isNaN(Number(value));
+}
+function numericExclusionReason(value) {
+  if (value === void 0 || value === null || value === "") {
+    return "Missing value";
+  }
+  if (typeof value === "boolean") return "Boolean values are not numeric";
+  if (typeof value === "string" && value.trim() === "") return "Blank value";
+  return Number.isFinite(Number(value)) ? void 0 : "Not a finite number";
+}
+function finiteNumber(value) {
+  if (numericExclusionReason(value) !== void 0) return void 0;
+  return Number(value);
+}
+function finiteNumbers(values) {
+  const numbers = [];
+  for (const value of values) {
+    const number = finiteNumber(value);
+    if (number !== void 0) numbers.push(number);
+  }
+  return numbers;
+}
+
+// src/components/SummaryTable/utils/dataTypeDetection.ts
+function detectColumnType(columnData) {
+  const values = Object.values(columnData);
+  const nonNullValues = values.filter((v) => !isMissingValue(v));
+  if (nonNullValues.length === 0) {
+    return "categorical";
+  }
+  const booleanValues = /* @__PURE__ */ new Set(["true", "false", true, false]);
+  if (nonNullValues.every((v) => booleanValues.has(v))) {
+    return "boolean";
+  }
+  if (nonNullValues.every(isNumberLike)) {
+    return "numeric";
+  }
+  if (nonNullValues.every((v) => !isNaN(Date.parse(String(v))))) {
+    return "datetime";
+  }
+  return "categorical";
+}
+
+// src/components/SummaryTable/utils/statisticsCalculator.ts
+var DISTRIBUTION_BINS = 24;
+function binValues(sorted, min, max, binCount = DISTRIBUTION_BINS) {
+  if (sorted.length === 0 || !Number.isFinite(min) || !Number.isFinite(max)) {
+    return [];
+  }
+  if (min === max) return [sorted.length];
+  if (max - min + 1 < binCount && sorted.every(Number.isInteger)) {
+    binCount = max - min + 1;
+    const bins2 = new Array(binCount).fill(0);
+    for (const value of sorted) bins2[value - min] += 1;
+    return bins2;
+  }
+  const bins = new Array(binCount).fill(0);
+  const width = (max - min) / binCount;
+  for (const value of sorted) {
+    if (!Number.isFinite(value)) continue;
+    const index = Math.min(binCount - 1, Math.floor((value - min) / width));
+    bins[index] += 1;
+  }
+  return bins;
+}
+function calculateColumnStatistics(columnData, dataType) {
+  const values = Object.values(columnData);
+  const totalCount = values.length;
+  const nullCount = values.filter((v) => v == null).length;
+  const nonNullValues = values.filter((v) => v != null);
+  const uniqueValues = new Set(nonNullValues);
+  const uniqueCount = uniqueValues.size;
+  if (dataType === "numeric") {
+    const missingCount = values.filter(isMissingValue).length;
+    const numericValues = finiteNumbers(values);
+    const numericBase = {
+      dataType,
+      totalCount,
+      uniqueCount,
+      nullCount: missingCount,
+      excludedCount: totalCount - missingCount - numericValues.length
+    };
+    if (numericValues.length === 0) {
+      return numericBase;
+    }
+    const sorted = [...numericValues].sort((a, b) => a - b);
+    const min = sorted.at(0);
+    const max = sorted.at(-1);
+    if (min === void 0 || max === void 0) {
+      return numericBase;
+    }
+    const sum = numericValues.reduce((a, b) => a + b, 0);
+    const mean = sum / numericValues.length;
+    const lower = sorted[Math.floor((sorted.length - 1) / 2)];
+    const upper = sorted[Math.floor(sorted.length / 2)];
+    if (lower === void 0 || upper === void 0) {
+      return numericBase;
+    }
+    const median = (lower + upper) / 2;
+    const squaredDiffs = numericValues.map((v) => Math.pow(v - mean, 2));
+    const variance = squaredDiffs.reduce((a, b) => a + b, 0) / numericValues.length;
+    const stdDev = Math.sqrt(variance);
+    return {
+      ...numericBase,
+      statistics: {
+        min,
+        max,
+        mean,
+        median,
+        stdDev,
+        bins: binValues(sorted, min, max)
+      }
+    };
+  } else {
+    const counts = /* @__PURE__ */ new Map();
+    nonNullValues.forEach(
+      (value) => counts.set(value, (counts.get(value) ?? 0) + 1)
+    );
+    const distribution = [...counts].map(([value, count]) => ({
+      value,
+      count
+    }));
+    const topValues = [...distribution].sort((a, b) => b.count - a.count).slice(0, 5);
+    return {
+      dataType,
+      totalCount,
+      uniqueCount,
+      nullCount,
+      categories: {
+        topValues,
+        distribution
+      }
+    };
+  }
+}
+
+// src/lib/fieldProfiles.ts
+function buildFieldProfile(name, columnData, typeOverride) {
+  return {
+    name,
+    ...calculateColumnStatistics(
+      columnData,
+      typeOverride ?? detectColumnType(columnData)
+    )
+  };
+}
+function emptyFieldProfile(profile) {
+  return {
+    name: profile.name,
+    dataType: profile.dataType,
+    totalCount: 0,
+    uniqueCount: 0,
+    nullCount: 0,
+    statistics: void 0,
+    categories: profile.categories ? { topValues: [], distribution: [] } : void 0
+  };
+}
+function buildFieldProfiles(rows, typeOverrides2 = {}) {
+  const fields = /* @__PURE__ */ new Set();
+  for (const row of rows) {
+    Object.keys(row).filter((field) => field !== "__ID").forEach((field) => fields.add(field));
+  }
+  return Array.from(fields, (name) => {
+    const columnData = {};
+    rows.forEach((row, index) => {
+      columnData[index] = row[name];
+    });
+    return buildFieldProfile(name, columnData, typeOverrides2[name]);
+  });
+}
+
+// src/lib/aggregates.ts
+function displayAggregateValue(value) {
+  if (value === void 0) {
+    return "undefined";
+  }
+  if (value === null) {
+    return "null";
+  }
+  if (typeof value === "string") {
+    return JSON.stringify(value);
+  }
+  return String(value);
+}
+function numericInputs(values) {
+  const inputs = [];
+  const exclusions = [];
+  values.forEach((value, index) => {
+    const reason = numericExclusionReason(value);
+    if (reason) {
+      exclusions.push({ index, reason });
+    } else {
+      inputs.push({ value: Number(value), index });
+    }
+  });
+  return { inputs, exclusions };
+}
+function aggregateValues(aggregation, values) {
+  if (aggregation === "count") {
+    return {
+      value: values.length,
+      included: new Set(values.map((_, index) => index)),
+      exclusions: []
+    };
+  }
+  const { inputs, exclusions } = numericInputs(values);
+  if (inputs.length === 0) {
+    return { value: void 0, included: /* @__PURE__ */ new Set(), exclusions };
+  }
+  const total = inputs.reduce((sum, input) => sum + input.value, 0);
+  return {
+    value: aggregation === "sum" ? total : total / inputs.length,
+    included: new Set(inputs.map((input) => input.index)),
+    exclusions
+  };
+}
+function calculateGroupedAggregate(rows, spec, rawInputs = {}, exclusionReasons = {}) {
+  if (spec.aggregation !== "count" && !spec.measureField) {
+    throw new Error(`${spec.aggregation} requires a measure field`);
+  }
+  const groups = /* @__PURE__ */ new Map();
+  rows.forEach((row) => {
+    const value = categoryValue(row[spec.groupField]);
+    const key = categoryKey(value);
+    const group = groups.get(key);
+    if (group) {
+      group.push(row);
+    } else {
+      groups.set(key, [row]);
+    }
+  });
+  const resultRows = Array.from(groups, ([key, group]) => {
+    const values = group.map(
+      (row) => spec.measureField ? row[spec.measureField] : void 0
+    );
+    const result = aggregateValues(spec.aggregation, values);
+    const exclusionByIndex = new Map(
+      result.exclusions.map((exclusion) => [exclusion.index, exclusion.reason])
+    );
+    return {
+      id: `${spec.id}:${key}`,
+      groupValue: categoryValue(group[0]?.[spec.groupField]),
+      groupLabel: categoryLabel(categoryValue(group[0]?.[spec.groupField])),
+      value: result.value,
+      rowCount: group.length,
+      contributors: group.map((row, index) => ({
+        sourceId: row.__ID,
+        input: values[index],
+        rawInput: rawInputs[row.__ID],
+        included: result.included.has(index),
+        exclusionReason: result.included.has(index) ? void 0 : exclusionReasons[row.__ID] ?? exclusionByIndex.get(index)
+      }))
+    };
+  });
+  return { spec, rows: resultRows, sourceRowCount: rows.length };
+}
+
+// src/utils/compactChartLayouts.ts
+function overlaps(a, b) {
+  return a.x < b.x + b.w && b.x < a.x + a.w && a.y < b.y + b.h && b.y < a.y + a.h;
+}
+function compactChartLayouts(items) {
+  const order = items.map((item, index) => ({ item, index })).sort(
+    (a, b) => a.item.layout.y - b.item.layout.y || a.item.layout.x - b.item.layout.x
+  );
+  const placed = [];
+  const result = [...items];
+  for (const { item, index } of order) {
+    const layout = { ...item.layout };
+    while (layout.y > 0 && !placed.some((other) => overlaps(other, { ...layout, y: layout.y - 1 }))) {
+      layout.y -= 1;
+    }
+    placed.push(layout);
+    result[index] = layout.y === item.layout.y ? item : { ...item, layout };
+  }
+  return result;
+}
+
+// src/providers/lib/dataLayerState.ts
+function initializeData(data) {
+  const dataWithIds = data.map((row, index) => ({
+    ...row,
+    __ID: index
+  }));
+  const emptyColumn = dataWithIds.reduce(
+    (acc, row) => {
+      acc[row.__ID] = void 0;
+      return acc;
+    },
+    {}
+  );
+  return { dataWithIds, emptyColumn };
+}
+function typeOverrides(settings) {
+  return Object.fromEntries(
+    Object.entries(settings).filter(([, value]) => value.type).map(([field, value]) => [field, value.type])
+  );
+}
+function validateFieldSettings(settings) {
+  for (const [field, value] of Object.entries(settings)) {
+    const error = getFieldSettingsError(value);
+    if (error) {
+      throw new Error(`Invalid settings for ${field}: ${error}`);
+    }
+  }
+}
+var toVector3 = ({ x, y, z }) => ({
+  x,
+  y,
+  z,
+  toArray: () => [x, y, z],
+  clone: () => toVector3({ x, y, z })
+});
+function toRuntimeChart(chart) {
+  if (chart.type !== "3d-scatter") {
+    return chart;
+  }
+  return {
+    ...chart,
+    cameraPosition: toVector3(chart.cameraPosition),
+    cameraTarget: toVector3(chart.cameraTarget)
+  };
+}
+function toSavedChart(chart) {
+  if (chart.type !== "3d-scatter") {
+    return chart;
+  }
+  return {
+    ...chart,
+    cameraPosition: {
+      x: chart.cameraPosition.x,
+      y: chart.cameraPosition.y,
+      z: chart.cameraPosition.z
+    },
+    cameraTarget: {
+      x: chart.cameraTarget.x,
+      y: chart.cameraTarget.y,
+      z: chart.cameraTarget.z
+    }
+  };
+}
+function toRuntimeCalculations(calculations) {
+  return calculations.map(({ resultColumnName, expression }) => ({
+    resultColumnName,
+    expression: parseExpression(expression)
+  }));
+}
+function toSavedCalculations(calculations) {
+  return calculations.map(({ resultColumnName, expression }) => ({
+    resultColumnName,
+    expression: expression.rawInput
+  }));
+}
+function validateAggregateState(aggregates, charts, fieldNames) {
+  const ids = /* @__PURE__ */ new Set();
+  const availableFields = fieldNames ? new Set(fieldNames) : void 0;
+  for (const aggregate of aggregates) {
+    if (!aggregate.id || !aggregate.name.trim() || !aggregate.groupField.trim() || !["count", "sum", "average"].includes(aggregate.aggregation) || aggregate.aggregation !== "count" && !aggregate.measureField?.trim()) {
+      throw new Error("Invalid grouped summary definition");
+    }
+    if (availableFields && !availableFields.has(aggregate.groupField)) {
+      throw new Error(
+        `Grouped summary ${aggregate.name} references missing group field ${aggregate.groupField}`
+      );
+    }
+    if (availableFields && aggregate.measureField && !availableFields.has(aggregate.measureField)) {
+      throw new Error(
+        `Grouped summary ${aggregate.name} references missing measure field ${aggregate.measureField}`
+      );
+    }
+    if (ids.has(aggregate.id)) {
+      throw new Error(`Duplicate grouped summary id: ${aggregate.id}`);
+    }
+    ids.add(aggregate.id);
+  }
+  for (const chart of charts) {
+    const aggregateId = chart.aggregateId;
+    if (aggregateId !== void 0 && (typeof aggregateId !== "string" || !ids.has(aggregateId))) {
+      throw new Error(
+        `Chart references missing grouped summary: ${String(aggregateId)}`
+      );
+    }
+  }
+}
+function getDefaultRowsSettings(fields, calculationNames = []) {
+  const allFields = [
+    ...fields,
+    ...calculationNames.filter((field) => !fields.includes(field))
+  ];
+  return {
+    columns: allFields.map((field) => ({ id: field, field })),
+    sortDirection: "asc",
+    filters: [],
+    globalSearch: ""
+  };
+}
+function getSavedStateFingerprint(savedData) {
+  return JSON.stringify(
+    {
+      ...savedData,
+      metadata: {
+        ...savedData.metadata,
+        modifiedAt: ""
+      }
+    },
+    (_key, value) => {
+      if (value === void 0) {
+        return { __exploreda_fingerprint: "undefined" };
+      }
+      if (typeof value === "number" && !Number.isFinite(value)) {
+        return {
+          __exploreda_fingerprint: Number.isNaN(value) ? "NaN" : value === Infinity ? "Infinity" : "-Infinity"
+        };
+      }
+      return value;
+    }
+  );
+}
+function getDataAndCrossfilterWrapper(data, fieldGetter, charts) {
+  const { dataWithIds, emptyColumn } = initializeData(data);
+  const newCrossFilter = new CrossfilterWrapper(
+    dataWithIds,
+    (d) => d.__ID
+  );
+  if (fieldGetter) {
+    newCrossFilter.setFieldGetter(fieldGetter);
+  }
+  return {
+    data: dataWithIds,
+    emptyColumn,
+    crossfilterWrapper: newCrossFilter,
+    charts: [],
+    colorScales: [],
+    calculationManager: new CalculationManager(dataWithIds),
+    calculations: []
+  };
+}
+function createDefaultWorkspaceCharts(fieldProfiles) {
+  if (fieldProfiles.length === 0) {
+    return [];
+  }
+  const summary = chartRegistry.has("summary") ? getChartDefinition("summary").createDefaultSettings({
+    x: 0,
+    y: 0,
+    w: 5,
+    h: 6
+  }) : void 0;
+  const table = chartRegistry.has("data-table") ? getChartDefinition("data-table").createDefaultSettings({
+    x: 5,
+    y: 0,
+    w: 7,
+    h: 6
+  }) : void 0;
+  if (table?.type === "data-table") {
+    table.columns = fieldProfiles.map(({ name }) => ({
+      id: name,
+      field: name
+    }));
+  }
+  return [summary, table].filter(
+    (item) => Boolean(item)
+  );
+}
+var getInitialStoreState = (initProps) => {
+  const rawData = initProps?.data ?? [];
+  const fieldSettings = initProps?.savedData?.fieldSettings ?? {};
+  validateFieldSettings(fieldSettings);
+  const inferredTypes = Object.fromEntries(
+    buildFieldProfiles(rawData, typeOverrides(fieldSettings)).map((profile) => [
+      profile.name,
+      profile.dataType
+    ])
+  );
+  const runtimeData = applyFieldSettings(rawData, fieldSettings, inferredTypes);
+  const {
+    data: initData,
+    emptyColumn: initialEmptyColumn,
+    crossfilterWrapper,
+    calculationManager: ogCalculationManager
+  } = getDataAndCrossfilterWrapper(runtimeData);
+  const fieldProfiles = buildFieldProfiles(
+    runtimeData,
+    typeOverrides(fieldSettings)
+  );
+  if (!crossfilterWrapper || !initData || !ogCalculationManager) {
+    throw new Error(
+      "Data, crossfilterWrapper, or calculationManager not found"
+    );
+  }
+  if (initProps?.savedData) {
+    const savedData = initProps.savedData;
+    ogCalculationManager.setCalculations(
+      toRuntimeCalculations(savedData.calculations)
+    );
+    const newCalculations = ogCalculationManager.getCalculations();
+    validateAggregateState(savedData.aggregates ?? [], savedData.charts, [
+      ...fieldProfiles.map((profile) => profile.name),
+      ...newCalculations.map((calculation) => calculation.resultColumnName)
+    ]);
+    const restoredColorScales = savedData.colorScales.map(
+      (scale) => {
+        if (scale.type === "categorical") {
+          return {
+            ...scale,
+            mapping: new Map(scale.mapping)
+          };
+        }
+        return scale;
+      }
+    );
+    return {
+      rawData,
+      data: initData,
+      fieldProfiles,
+      emptyColumn: initialEmptyColumn,
+      crossfilterWrapper,
+      calculationManager: ogCalculationManager,
+      calculations: newCalculations,
+      charts: savedData.charts.map(toRuntimeChart),
+      colorScales: restoredColorScales,
+      gridSettings: savedData.gridSettings,
+      rowsSettings: savedData.rowsSettings ?? getDefaultRowsSettings(
+        fieldProfiles.map((profile) => profile.name),
+        newCalculations.map((calculation) => calculation.resultColumnName)
+      ),
+      metadata: savedData.metadata,
+      columnCache: {},
+      calcColumnCache: {},
+      nonce: 0,
+      fileName: void 0,
+      fieldSettings,
+      aggregates: savedData.aggregates ?? []
+    };
+  }
+  return {
+    rawData,
+    data: initData,
+    fieldProfiles,
+    emptyColumn: initialEmptyColumn,
+    crossfilterWrapper,
+    calculationManager: ogCalculationManager,
+    calculations: [],
+    charts: initProps?.charts ?? createDefaultWorkspaceCharts(fieldProfiles),
+    colorScales: [],
+    gridSettings: {
+      columnCount: 12,
+      rowHeight: 100,
+      containerPadding: 10,
+      showBackgroundMarkers: true
+    },
+    rowsSettings: getDefaultRowsSettings(
+      fieldProfiles.map((profile) => profile.name)
+    ),
+    metadata: {
+      name: "Untitled",
+      version: 1,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      modifiedAt: (/* @__PURE__ */ new Date()).toISOString()
+    },
+    columnCache: {},
+    calcColumnCache: {},
+    nonce: 0,
+    fileName: void 0,
+    fieldSettings,
+    aggregates: []
+  };
+};
+var createDataLayerStore = (initProps) => {
+  const initialState = getInitialStoreState(initProps);
+  const { crossfilterWrapper } = initialState;
+  if (!crossfilterWrapper) {
+    throw new Error("crossfilterWrapper not found in initial state");
+  }
+  const store = createStore()((set, get) => ({
+    ...initialState,
+    liveItems: {},
+    filterReset: 0,
+    setData: (rawData, fileName, useDefaults = true) => {
+      const inferredTypes = Object.fromEntries(
+        buildFieldProfiles(rawData, typeOverrides({})).map((profile) => [
+          profile.name,
+          profile.dataType
+        ])
+      );
+      const runtimeData = applyFieldSettings(rawData, {}, inferredTypes);
+      const {
+        data: newData,
+        emptyColumn: newEmptyColumn,
+        crossfilterWrapper: newCrossfilter,
+        calculationManager: newCalculationManager
+      } = getDataAndCrossfilterWrapper(runtimeData, get().getColumnData);
+      const fieldProfiles = buildFieldProfiles(runtimeData, typeOverrides({}));
+      if (!newData || !newEmptyColumn || !newCrossfilter || !newCalculationManager) {
+        throw new Error("Failed to reset data layer");
+      }
+      const charts = useDefaults ? createDefaultWorkspaceCharts(fieldProfiles) : [];
+      charts.forEach((chart) => newCrossfilter.addChart(chart));
+      set({
+        rawData,
+        data: newData,
+        fieldProfiles,
+        emptyColumn: newEmptyColumn,
+        fileName,
+        crossfilterWrapper: newCrossfilter,
+        calculationManager: newCalculationManager,
+        calculations: [],
+        charts,
+        colorScales: [],
+        rowsSettings: getDefaultRowsSettings(
+          fieldProfiles.map((profile) => profile.name)
+        ),
+        liveItems: newCrossfilter.getAllData(),
+        columnCache: {},
+        calcColumnCache: {},
+        fieldSettings: {},
+        aggregates: [],
+        nonce: get().nonce + 1,
+        filterReset: get().filterReset + 1
+      });
+    },
+    updateFieldSettings: (field, updates) => {
+      const current = get().fieldSettings[field] ?? {};
+      const nextFieldSettings = { ...current, ...updates };
+      const settingsError = getFieldSettingsError(nextFieldSettings);
+      if (settingsError) {
+        throw new Error(settingsError);
+      }
+      const nextFieldSettingsMap = { ...get().fieldSettings };
+      if (Object.keys(nextFieldSettings).length === 0) {
+        delete nextFieldSettingsMap[field];
+      } else {
+        nextFieldSettingsMap[field] = nextFieldSettings;
+      }
+      const typeChanged = current.type !== nextFieldSettings.type || current.datePreset !== nextFieldSettings.datePreset || JSON.stringify(current.nullTokens?.filter(Boolean) ?? []) !== JSON.stringify(nextFieldSettings.nullTokens?.filter(Boolean) ?? []);
+      if (!typeChanged) {
+        set((state) => ({
+          fieldSettings: nextFieldSettingsMap,
+          nonce: state.nonce + 1
+        }));
+        return;
+      }
+      const inferredTypes = Object.fromEntries(
+        buildFieldProfiles(
+          get().rawData,
+          typeOverrides(nextFieldSettingsMap)
+        ).map((profile) => [profile.name, profile.dataType])
+      );
+      const runtimeRows = applyFieldSettings(
+        get().rawData,
+        nextFieldSettingsMap,
+        inferredTypes
+      );
+      const nextData = initializeData(runtimeRows);
+      const nextCrossfilter = new CrossfilterWrapper(
+        nextData.dataWithIds,
+        (row) => row.__ID
+      );
+      const nextCharts = get().charts.map((chart) => ({
+        ...chart,
+        filters: chart.filters.filter((filter) => filter.field !== field),
+        facet: typeChanged && (chart.facet.rowVariable === field || chart.facet.type === "grid" && chart.facet.columnVariable === field) ? { ...chart.facet, visibleFacetIds: void 0 } : chart.facet
+      }));
+      nextCharts.forEach((chart) => nextCrossfilter.addChart(chart));
+      const nextManager = new CalculationManager(
+        nextData.dataWithIds,
+        get().calculations
+      );
+      set((state) => ({
+        fieldSettings: nextFieldSettingsMap,
+        data: nextData.dataWithIds,
+        emptyColumn: nextData.emptyColumn,
+        fieldProfiles: buildFieldProfiles(
+          runtimeRows,
+          typeOverrides(nextFieldSettingsMap)
+        ),
+        crossfilterWrapper: nextCrossfilter,
+        calculationManager: nextManager,
+        charts: nextCharts,
+        rowsSettings: {
+          ...state.rowsSettings,
+          filters: state.rowsSettings.filters.filter(
+            (filter) => filter.field !== field
+          )
+        },
+        columnCache: {},
+        calcColumnCache: {},
+        liveItems: {},
+        nonce: state.nonce + 1,
+        filterReset: state.filterReset + 1
+      }));
+      nextCrossfilter.setFieldGetter(get().getColumnData);
+      nextCharts.forEach((chart) => nextCrossfilter.updateChartFilters(chart));
+      set({ liveItems: nextCrossfilter.getAllData() });
+    },
+    getFieldLabel: (field) => getFieldLabel(field, get().fieldSettings[field]),
+    formatFieldValue: (field, value) => formatFieldValue(field, value, get().fieldSettings[field]),
+    getFieldConversionPreview: (field, previewSettings) => {
+      const rawRows = get().rawData;
+      const rawProfile = buildFieldProfiles(rawRows).find(
+        (profile) => profile.name === field
+      );
+      return buildConversionPreview(
+        field,
+        rawRows,
+        previewSettings ?? get().fieldSettings[field],
+        rawProfile?.dataType ?? "categorical"
+      );
+    },
+    addAggregate: (spec) => {
+      if (!spec.name.trim() || !spec.groupField.trim()) {
+        throw new Error("Bar aggregates need a name and group field");
+      }
+      if (spec.aggregation !== "count" && !spec.measureField?.trim()) {
+        throw new Error(`${spec.aggregation} requires a measure field`);
+      }
+      validateAggregateState(
+        [{ ...spec, id: "new" }],
+        [],
+        get().getColumnNames()
+      );
+      const aggregate = { ...spec, id: crypto.randomUUID() };
+      set((state) => ({
+        aggregates: [...state.aggregates, aggregate],
+        nonce: state.nonce + 1
+      }));
+      return aggregate;
+    },
+    updateAggregate: (id, updates) => {
+      const current = get().aggregates.find((aggregate) => aggregate.id === id);
+      if (!current) {
+        throw new Error("Grouped summary was not found");
+      }
+      const next = { ...current, ...updates };
+      if (!next.name.trim() || !next.groupField.trim()) {
+        throw new Error("Bar aggregates need a name and group field");
+      }
+      if (next.aggregation !== "count" && !next.measureField?.trim()) {
+        throw new Error(`${next.aggregation} requires a measure field`);
+      }
+      validateAggregateState([next], [], get().getColumnNames());
+      set((state) => ({
+        aggregates: state.aggregates.map(
+          (aggregate) => aggregate.id === id ? next : aggregate
+        ),
+        nonce: state.nonce + 1
+      }));
+    },
+    removeAggregate: (id) => {
+      const aggregate = get().aggregates.find((item) => item.id === id);
+      if (!aggregate) {
+        return;
+      }
+      if (get().charts.some(
+        (chart) => chart.aggregateId === id
+      )) {
+        throw new Error(
+          `Remove charts using ${aggregate.name} before deleting the grouped summary`
+        );
+      }
+      set((state) => ({
+        aggregates: state.aggregates.filter((item) => item.id !== id),
+        nonce: state.nonce + 1
+      }));
+    },
+    getAggregate: (id) => get().aggregates.find((item) => item.id === id),
+    getAggregateResult: (id, sourceIds) => {
+      const spec = get().aggregates.find((item) => item.id === id);
+      if (!spec) {
+        return void 0;
+      }
+      const ids = sourceIds ?? get().crossfilterWrapper.getFilteredRowIds();
+      const groupData = get().getColumnData(spec.groupField);
+      const measureData = spec.measureField ? get().getColumnData(spec.measureField) : void 0;
+      const rawRows = get().rawData;
+      const rawInputs = {};
+      const exclusionReasons = {};
+      const calculationField = get().calculations.some(
+        (calculation) => calculation.resultColumnName === spec.measureField
+      );
+      const measureProfile = get().fieldProfiles.find(
+        (profile) => profile.name === spec.measureField
+      );
+      const measureSettings = spec.measureField ? get().fieldSettings[spec.measureField] ?? {} : {};
+      const rows = ids.map((sourceId) => ({
+        __ID: sourceId,
+        [spec.groupField]: groupData[sourceId],
+        ...spec.measureField ? {
+          [spec.measureField]: measureData?.[sourceId]
+        } : {}
+      }));
+      if (spec.measureField) {
+        ids.forEach((sourceId) => {
+          const rawValue = rawRows[sourceId]?.[spec.measureField];
+          if (!calculationField) {
+            rawInputs[sourceId] = rawValue;
+            const conversion = convertFieldValue(
+              rawValue,
+              measureSettings.type ?? measureProfile?.dataType ?? "categorical",
+              measureSettings
+            );
+            if (conversion.error) {
+              exclusionReasons[sourceId] = `Conversion failed: ${conversion.error}`;
+            }
+          }
+        });
+      }
+      return calculateGroupedAggregate(rows, spec, rawInputs, exclusionReasons);
+    },
+    addChart: (chartSettings) => {
+      const { crossfilterWrapper: crossfilterWrapper2 } = get();
+      const newChart = {
+        ...chartSettings,
+        id: crypto.randomUUID()
+      };
+      crossfilterWrapper2.addChart(newChart);
+      set((state) => ({
+        charts: [...state.charts, newChart],
+        liveItems: crossfilterWrapper2.getAllData()
+      }));
+    },
+    removeChart: (chart) => {
+      const { crossfilterWrapper: crossfilterWrapper2 } = get();
+      crossfilterWrapper2.removeChart(chart);
+      set((state) => ({
+        charts: compactChartLayouts(
+          state.charts.filter((ogChart) => ogChart.id !== chart.id)
+        ),
+        liveItems: crossfilterWrapper2.getAllData()
+      }));
+    },
+    removeAllCharts: () => {
+      const { crossfilterWrapper: crossfilterWrapper2 } = get();
+      crossfilterWrapper2.removeAllCharts();
+      set({ charts: [], liveItems: crossfilterWrapper2.getAllData() });
+    },
+    updateChart: (id, settings) => {
+      const { crossfilterWrapper: crossfilterWrapper2 } = get();
+      const chart = get().charts.find((chart2) => chart2.id === id);
+      if (!chart) {
+        return;
+      }
+      const updatedChart = { ...chart, ...settings, id };
+      crossfilterWrapper2.updateChart(updatedChart);
+      set((state) => ({
+        charts: state.charts.map(
+          (chart2) => chart2.id === id ? updatedChart : chart2
+        ),
+        liveItems: crossfilterWrapper2.getAllData()
+      }));
+    },
+    updateChartLayouts: (layouts) => {
+      set((state) => ({
+        charts: state.charts.map((chart) => {
+          const layout = layouts[chart.id];
+          return layout ? { ...chart, layout } : chart;
+        })
+      }));
+    },
+    addColorScale: (scale) => {
+      const newScale = {
+        ...scale,
+        id: crypto.randomUUID()
+      };
+      set((state) => ({
+        colorScales: [...state.colorScales, newScale]
+      }));
+      return newScale;
+    },
+    removeColorScale: (id) => {
+      set((state) => ({
+        colorScales: state.colorScales.filter((scale) => scale.id !== id)
+      }));
+    },
+    updateColorScale: (id, updates) => {
+      set((state) => ({
+        colorScales: state.colorScales.map(
+          (scale) => scale.id === id ? { ...scale, ...updates } : scale
+        )
+      }));
+    },
+    clearAllFilters: () => {
+      const { charts, crossfilterWrapper: crossfilterWrapper2 } = get();
+      const newCharts = charts.map((chart) => ({
+        ...chart,
+        filters: [],
+        ...chart.type === "data-table" ? { globalSearch: "" } : {}
+      }));
+      for (const chart of newCharts) {
+        crossfilterWrapper2.updateChart(chart);
+      }
+      set((state) => ({
+        charts: newCharts,
+        rowsSettings: {
+          ...state.rowsSettings,
+          filters: [],
+          globalSearch: ""
+        },
+        liveItems: crossfilterWrapper2.getAllData(),
+        filterReset: state.filterReset + 1
+      }));
+    },
+    clearFilter: (chart) => {
+      const { updateChart } = get();
+      updateChart(chart.id, { filters: [] });
+    },
+    getLiveItems: (chart) => {
+      const { liveItems } = get();
+      const liveItemsForChart = liveItems[chart.id] ?? void 0;
+      return liveItemsForChart;
+    },
+    getColumnNames() {
+      const { fieldProfiles, calculations } = get();
+      const baseColumns = fieldProfiles.map((profile) => profile.name);
+      const calcFields = calculations.map((calc) => calc.resultColumnName);
+      return [...baseColumns, ...calcFields];
+    },
+    getColumnData(field) {
+      const {
+        columnCache,
+        data,
+        calcColumnCache,
+        calculations,
+        emptyColumn,
+        calculationManager
+      } = get();
+      if (!field) {
+        return emptyColumn;
+      }
+      if (Object.hasOwn(columnCache, field)) {
+        return columnCache[field];
+      }
+      const calculation = calculations.find(
+        (calc) => calc.resultColumnName === field
+      );
+      if (calculation) {
+        if (Object.hasOwn(calcColumnCache, field)) {
+          return calcColumnCache[field];
+        }
+        const resultMap = calculationManager.executeCalculation(calculation);
+        const columnData2 = {};
+        resultMap.forEach((value, key) => {
+          columnData2[key] = value;
+        });
+        Object.defineProperty(calcColumnCache, field, {
+          value: columnData2,
+          enumerable: true,
+          configurable: true
+        });
+        return columnData2;
+      }
+      if (!data.some((row) => field in row)) {
+        return emptyColumn;
+      }
+      const columnData = {};
+      data.forEach((row) => {
+        columnData[row.__ID] = row[field];
+      });
+      Object.defineProperty(columnCache, field, {
+        value: columnData,
+        enumerable: true,
+        configurable: true
+      });
+      return columnData;
+    },
+    // Calculation management
+    addCalculation: async (calculation) => {
+      get().calculationManager.addCalculation(calculation);
+      refreshCalculations();
+      return calculation;
+    },
+    removeCalculation: (name) => {
+      assertUnusedCalculation(name);
+      get().calculationManager.removeCalculation(name);
+      refreshCalculations();
+    },
+    updateCalculation: (name, calculation) => {
+      if (name !== calculation.resultColumnName) {
+        assertUnusedCalculation(name);
+      }
+      get().calculationManager.updateCalculation(name, calculation);
+      refreshCalculations();
+    },
+    updateGridSettings: (settings) => {
+      set((state) => ({
+        gridSettings: {
+          ...state.gridSettings,
+          ...settings
+        }
+      }));
+    },
+    updateRowsSettings: (settings) => {
+      set((state) => ({
+        rowsSettings: { ...state.rowsSettings, ...settings }
+      }));
+    },
+    // Save/Restore functionality
+    saveToStructure: () => {
+      const state = get();
+      const serializedColorScales = state.colorScales.map((scale) => {
+        if (scale.type === "categorical") {
+          return {
+            ...scale,
+            mapping: Array.from(scale.mapping.entries())
+          };
+        }
+        return scale;
+      });
+      return {
+        charts: state.charts.map(toSavedChart),
+        calculations: toSavedCalculations(state.calculations),
+        gridSettings: state.gridSettings,
+        metadata: {
+          ...state.metadata,
+          modifiedAt: (/* @__PURE__ */ new Date()).toISOString()
+        },
+        colorScales: serializedColorScales,
+        rowsSettings: state.rowsSettings,
+        fieldSettings: state.fieldSettings,
+        aggregates: state.aggregates
+      };
+    },
+    restoreFromStructure: (savedData) => {
+      const data = get().rawData;
+      get().restoreAnalysisFromStructure({
+        format: "exploreda-analysis",
+        version: 1,
+        data,
+        settings: savedData
+      });
+    },
+    saveAnalysisToStructure: () => {
+      const state = get();
+      return {
+        format: "exploreda-analysis",
+        version: 1,
+        data: state.rawData,
+        settings: state.saveToStructure()
+      };
+    },
+    restoreAnalysisFromStructure: (savedData) => {
+      const rawData = savedData.data;
+      const fieldSettings = savedData.settings.fieldSettings ?? {};
+      validateFieldSettings(fieldSettings);
+      const inferredTypes = Object.fromEntries(
+        buildFieldProfiles(rawData, typeOverrides(fieldSettings)).map(
+          (profile) => [profile.name, profile.dataType]
+        )
+      );
+      const runtimeData = applyFieldSettings(
+        rawData,
+        fieldSettings,
+        inferredTypes
+      );
+      const next = getDataAndCrossfilterWrapper(runtimeData);
+      const nextData = next.data;
+      const nextCrossfilter = next.crossfilterWrapper;
+      const nextEmptyColumn = next.emptyColumn;
+      if (!nextData || !nextCrossfilter || !nextEmptyColumn || !next.calculationManager) {
+        throw new Error("Failed to restore analysis rows");
+      }
+      const calculations = toRuntimeCalculations(
+        savedData.settings.calculations
+      );
+      const calculationManager = new CalculationManager(nextData, calculations);
+      const fieldProfiles = buildFieldProfiles(
+        runtimeData,
+        typeOverrides(fieldSettings)
+      );
+      validateAggregateState(
+        savedData.settings.aggregates ?? [],
+        savedData.settings.charts,
+        [
+          ...fieldProfiles.map((profile) => profile.name),
+          ...calculations.map((calculation) => calculation.resultColumnName)
+        ]
+      );
+      const charts = savedData.settings.charts.map(toRuntimeChart);
+      const fieldGetter = (field) => {
+        const calculation = calculations.find(
+          (item) => item.resultColumnName === field
+        );
+        if (calculation) {
+          const values = {};
+          calculationManager.executeCalculation(calculation).forEach((value, id) => values[id] = value);
+          return values;
+        }
+        if (!nextData.some((row) => field in row)) {
+          return nextEmptyColumn;
+        }
+        return Object.fromEntries(
+          nextData.map((row) => [row.__ID, row[field]])
+        );
+      };
+      nextCrossfilter.setFieldGetter(fieldGetter);
+      charts.forEach((chart) => nextCrossfilter.addChart(chart));
+      const colorScales = savedData.settings.colorScales.map(
+        (scale) => scale.type === "categorical" ? { ...scale, mapping: new Map(scale.mapping) } : scale
+      );
+      set((state) => ({
+        rawData,
+        data: nextData,
+        fieldProfiles,
+        emptyColumn: nextEmptyColumn,
+        fileName: void 0,
+        crossfilterWrapper: nextCrossfilter,
+        calculationManager,
+        calculations: calculationManager.getCalculations(),
+        charts,
+        colorScales,
+        gridSettings: savedData.settings.gridSettings,
+        rowsSettings: savedData.settings.rowsSettings ?? getDefaultRowsSettings(
+          fieldProfiles.map((profile) => profile.name),
+          calculations.map((calculation) => calculation.resultColumnName)
+        ),
+        metadata: savedData.settings.metadata,
+        liveItems: nextCrossfilter.getAllData(),
+        columnCache: {},
+        calcColumnCache: {},
+        nonce: state.nonce + 1,
+        filterReset: state.filterReset + 1,
+        fieldSettings,
+        aggregates: savedData.settings.aggregates ?? []
+      }));
+      nextCrossfilter.setFieldGetter(get().getColumnData);
+    }
+  }));
+  function assertUnusedCalculation(name) {
+    const { charts, aggregates } = store.getState();
+    if (aggregates.some(
+      (aggregate) => aggregate.groupField === name || aggregate.measureField === name
+    )) {
+      throw new Error(
+        `Remove ${name} from its grouped summaries before renaming or deleting it`
+      );
+    }
+    if (charts.some(
+      (chart) => getChartFields(chart).includes(name) || chart.filters.some((filter) => filter.field === name) || chart.facet.rowVariable === name || chart.facet.type === "grid" && chart.facet.columnVariable === name
+    )) {
+      throw new Error(
+        `Remove ${name} from its charts and colors before renaming or deleting it`
+      );
+    }
+  }
+  function refreshCalculations() {
+    const { calculationManager, crossfilterWrapper: crossfilterWrapper2, charts } = store.getState();
+    const previousCalculations = store.getState().calculations;
+    const calculations = calculationManager.getCalculations();
+    const previousNames = new Set(
+      previousCalculations.map((calculation) => calculation.resultColumnName)
+    );
+    const nextNames = new Set(
+      calculations.map((calculation) => calculation.resultColumnName)
+    );
+    const addedNames = calculations.map((calculation) => calculation.resultColumnName).filter((name) => !previousNames.has(name));
+    store.setState((state) => ({
+      calculations,
+      calcColumnCache: {},
+      rowsSettings: {
+        ...state.rowsSettings,
+        columns: [
+          ...state.rowsSettings.columns.filter(
+            (column) => !previousNames.has(column.field) || nextNames.has(column.field)
+          ),
+          ...addedNames.filter(
+            (name) => !state.rowsSettings.columns.some(
+              (column) => column.field === name
+            )
+          ).map((name) => ({ id: name, field: name }))
+        ]
+      }
+    }));
+    charts.forEach((chart) => crossfilterWrapper2.updateChartFilters(chart));
+    store.setState((state) => ({
+      liveItems: crossfilterWrapper2.getAllData(),
+      nonce: state.nonce + 1
+    }));
+  }
+  crossfilterWrapper.setFieldGetter(store.getState().getColumnData);
+  store.getState().charts.forEach((chart) => {
+    crossfilterWrapper.addChart(chart);
+  });
+  store.setState({ liveItems: crossfilterWrapper.getAllData() });
+  return store;
+};
+var DataLayerContext = createContext(null);
+function DataLayerProvider({
+  children,
+  ...props
+}) {
+  const storeRef = useRef(null);
+  const propsRef = useRef(props);
+  const onStateChangeRef = useRef(props.onStateChange);
+  const suppressStateChangeRef = useRef(false);
+  const savedStateFingerprintRef = useRef(void 0);
+  onStateChangeRef.current = props.onStateChange;
+  const nextData = props.data;
+  const nextSavedData = props.savedData;
+  if (!storeRef.current) {
+    storeRef.current = createDataLayerStore(props);
+  }
+  useEffect(() => {
+    const store = storeRef.current;
+    const previousProps = propsRef.current;
+    const dataChanged = previousProps.data !== nextData;
+    const savedDataChanged = previousProps.savedData !== nextSavedData;
+    suppressStateChangeRef.current = true;
+    try {
+      if (dataChanged) {
+        store.getState().setData(nextData ?? [], void 0, !nextSavedData);
+        if (nextSavedData) {
+          store.getState().restoreFromStructure(nextSavedData);
+        }
+      } else if (savedDataChanged) {
+        if (nextSavedData) {
+          store.getState().restoreFromStructure(nextSavedData);
+        } else {
+          store.getState().setData(store.getState().rawData);
+        }
+      }
+    } finally {
+      suppressStateChangeRef.current = false;
+      savedStateFingerprintRef.current = getSavedStateFingerprint(
+        store.getState().saveToStructure()
+      );
+    }
+    propsRef.current = { data: nextData, savedData: nextSavedData };
+  }, [nextData, nextSavedData]);
+  useEffect(() => {
+    const store = storeRef.current;
+    savedStateFingerprintRef.current = getSavedStateFingerprint(
+      store.getState().saveToStructure()
+    );
+    return store.subscribe((state) => {
+      const savedData = state.saveToStructure();
+      const nextFingerprint = getSavedStateFingerprint(savedData);
+      if (nextFingerprint === savedStateFingerprintRef.current) {
+        return;
+      }
+      savedStateFingerprintRef.current = nextFingerprint;
+      if (!suppressStateChangeRef.current) {
+        onStateChangeRef.current?.(savedData);
+      }
+    });
+  }, []);
+  return /* @__PURE__ */ jsx(DataLayerContext.Provider, { value: storeRef.current, children });
+}
+function useDataLayer(selector) {
+  const store = useContext(DataLayerContext);
+  if (!store) {
+    throw new Error("Missing DataLayerContext.Provider in the tree");
+  }
+  return useStore(store, selector);
+}
+function cn(...inputs) {
+  return twMerge(clsx(inputs));
+}
+function TooltipProvider({
+  delayDuration = 140,
+  ...props
+}) {
+  return /* @__PURE__ */ jsx(
+    TooltipPrimitive.Provider,
+    {
+      "data-slot": "tooltip-provider",
+      delayDuration,
+      ...props
+    }
+  );
+}
+function Tooltip({
+  ...props
+}) {
+  return /* @__PURE__ */ jsx(TooltipPrimitive.Root, { "data-slot": "tooltip", ...props });
+}
+function TooltipTrigger({
+  ...props
+}) {
+  return /* @__PURE__ */ jsx(TooltipPrimitive.Trigger, { "data-slot": "tooltip-trigger", ...props });
+}
+function TooltipContent({
+  className,
+  sideOffset = 4,
+  children,
+  ...props
+}) {
+  return /* @__PURE__ */ jsx(TooltipPrimitive.Portal, { children: /* @__PURE__ */ jsx(
+    TooltipPrimitive.Content,
+    {
+      "data-slot": "tooltip-content",
+      sideOffset,
+      className: cn("eda-soft-tooltip z-50", className),
+      ...props,
+      children
+    }
+  ) });
+}
+function ActionTooltip({
+  children,
+  content
+}) {
+  return /* @__PURE__ */ jsx(TooltipProvider, { children: /* @__PURE__ */ jsxs(Tooltip, { children: [
+    /* @__PURE__ */ jsx(TooltipTrigger, { asChild: true, children }),
+    /* @__PURE__ */ jsx(TooltipContent, { children: content })
+  ] }) });
+}
+var buttonVariants = cva(
+  "inline-flex items-center justify-center gap-2 whitespace-nowrap rounded-md text-sm font-medium transition-[color,box-shadow] disabled:pointer-events-none disabled:opacity-50 [&_svg]:pointer-events-none [&_svg:not([class*='size-'])]:size-4 [&_svg]:shrink-0 ring-ring/10 dark:ring-ring/20 dark:outline-ring/40 outline-ring/50 focus-visible:ring-4 focus-visible:outline-1 aria-invalid:focus-visible:ring-0",
+  {
+    variants: {
+      variant: {
+        default: "bg-primary text-primary-foreground shadow-sm hover:bg-primary/90",
+        destructive: "bg-destructive text-destructive-foreground shadow-xs hover:bg-destructive/90",
+        outline: "border border-input bg-background shadow-xs hover:bg-accent hover:text-accent-foreground",
+        secondary: "bg-secondary text-secondary-foreground shadow-xs hover:bg-secondary/80",
+        ghost: "hover:bg-accent hover:text-accent-foreground",
+        link: "text-primary underline-offset-4 hover:underline"
+      },
+      size: {
+        default: "h-9 px-4 py-2 has-[>svg]:px-3",
+        sm: "h-8 rounded-md px-3 has-[>svg]:px-2.5",
+        lg: "h-10 rounded-md px-6 has-[>svg]:px-4",
+        icon: "size-9"
+      }
+    },
+    defaultVariants: {
+      variant: "default",
+      size: "default"
+    }
+  }
+);
+function Button({
+  className,
+  variant,
+  size,
+  asChild = false,
+  tooltip,
+  ...props
+}) {
+  const Comp = asChild ? Slot : "button";
+  const button = /* @__PURE__ */ jsx(
+    Comp,
+    {
+      "data-slot": "button",
+      className: cn(buttonVariants({ variant, size, className })),
+      ...props
+    }
+  );
+  return tooltip ? /* @__PURE__ */ jsx(ActionTooltip, { content: tooltip, children: button }) : button;
+}
+
+export { ActionTooltip, Button, CalculationManager, DISTRIBUTION_BINS, DataLayerProvider, Tooltip, TooltipContent, TooltipProvider, TooltipTrigger, binValues, buildConversionPreview, buildFieldProfile, buttonVariants, calculateGroupedAggregate, calculationFunctions, categoryEqual, categoryIncludes, categoryKey, categoryLabel, categoryValue, cn, convertFieldValue, dateTimestamp, detectColumnType, displayAggregateValue, emptyFieldProfile, finiteNumber, finiteNumbers, formatFieldValue, getChartAxisFields, getChartAxisLabel, getChartFields, getChartSummary, getChartTitle, getFieldLabel, getFieldSettingsError, hasFieldDisplayFormat, initializeData, isMissingValue, isNumberLike, numericInputs, useDataLayer };
+//# sourceMappingURL=chunk-JNO7OXCC.js.map
+//# sourceMappingURL=chunk-JNO7OXCC.js.map