exploreda 0.0.6 → 0.1.0

package/dist/chunk-NDF5LCST.js

@@ -0,0 +1,1088 @@
+import { Dialog, DialogContent, DialogHeader, DialogTitle, DialogDescription, Popover, PopoverTrigger, PopoverContent, Label, Input } from './chunk-MJPDJ5AS.js';
+import { cn, buildFieldProfile, TooltipProvider, Tooltip, TooltipTrigger, TooltipContent, useDataLayer, CalculationManager, getChartFields, getChartTitle, Button, calculationFunctions, ActionTooltip } from './chunk-JNO7OXCC.js';
+import { parseExpression } from './chunk-H5AVMMCE.js';
+import { createContext, useContext, useState, useRef, useCallback, useMemo, useEffect } from 'react';
+import * as TabsPrimitive from '@radix-ui/react-tabs';
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+import { ToggleLeft, CalendarDays, Type, Hash, CircleAlert, CheckCircle2 } from 'lucide-react';
+
+function Tabs({
+  className,
+  ...props
+}) {
+  return /* @__PURE__ */ jsx(
+    TabsPrimitive.Root,
+    {
+      "data-slot": "tabs",
+      className: cn("flex flex-col gap-2", className),
+      ...props
+    }
+  );
+}
+function TabsList({
+  className,
+  ...props
+}) {
+  return /* @__PURE__ */ jsx(
+    TabsPrimitive.List,
+    {
+      "data-slot": "tabs-list",
+      className: cn(
+        "bg-muted text-muted-foreground inline-flex h-9 w-fit items-center justify-center rounded-lg p-1",
+        className
+      ),
+      ...props
+    }
+  );
+}
+function TabsTrigger({
+  className,
+  ...props
+}) {
+  return /* @__PURE__ */ jsx(
+    TabsPrimitive.Trigger,
+    {
+      "data-slot": "tabs-trigger",
+      className: cn(
+        "data-[state=active]:bg-background data-[state=active]:text-foreground ring-ring/10 dark:ring-ring/20 dark:outline-ring/40 outline-ring/50 inline-flex items-center justify-center gap-2 rounded-md px-2 py-1 text-sm font-medium whitespace-nowrap transition-[color,box-shadow] focus-visible:ring-4 focus-visible:outline-1 disabled:pointer-events-none disabled:opacity-50 aria-invalid:focus-visible:ring-0 data-[state=active]:shadow-sm [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
+        className
+      ),
+      ...props
+    }
+  );
+}
+function TabsContent({
+  className,
+  ...props
+}) {
+  return /* @__PURE__ */ jsx(
+    TabsPrimitive.Content,
+    {
+      "data-slot": "tabs-content",
+      className: cn(
+        "ring-ring/10 dark:ring-ring/20 dark:outline-ring/40 outline-ring/50 flex-1 transition-[color,box-shadow] focus-visible:ring-4 focus-visible:outline-1 aria-invalid:focus-visible:ring-0",
+        className
+      ),
+      ...props
+    }
+  );
+}
+var typeLabels = {
+  numeric: "Number",
+  categorical: "Text",
+  datetime: "Date",
+  boolean: "Boolean"
+};
+var typeIcons = {
+  numeric: Hash,
+  categorical: Type,
+  datetime: CalendarDays,
+  boolean: ToggleLeft
+};
+var valueLabel = (value) => {
+  if (value == null || value === "") return "\u2014";
+  if (typeof value === "number") {
+    return new Intl.NumberFormat("en-US", { maximumFractionDigits: 3 }).format(
+      value
+    );
+  }
+  return String(value);
+};
+function resolveFieldProfile(name, profiles, getColumnData) {
+  const profile = profiles.find((item) => item.name === name);
+  if (profile) return profile;
+  const columnData = getColumnData(name);
+  return Object.keys(columnData).length ? buildFieldProfile(name, columnData) : void 0;
+}
+function dateRange(profile) {
+  if (profile.dataType !== "datetime") return void 0;
+  let first;
+  let last;
+  let firstTime = Infinity;
+  let lastTime = -Infinity;
+  for (const { value } of profile.categories?.distribution ?? []) {
+    const time = Date.parse(String(value));
+    if (!Number.isFinite(time)) continue;
+    if (time < firstTime) {
+      first = value;
+      firstTime = time;
+    }
+    if (time > lastTime) {
+      last = value;
+      lastTime = time;
+    }
+  }
+  if (first == null || last == null) return void 0;
+  const start = String(first);
+  const end = String(last);
+  return start === end ? start : `${start}\u2013${end}`;
+}
+function fieldMetadata(profile) {
+  const range = profile.statistics ? `${valueLabel(profile.statistics.min)}\u2013${valueLabel(profile.statistics.max)}` : dateRange(profile);
+  const sample = profile.categories?.topValues[0] ? valueLabel(profile.categories.topValues[0].value) : void 0;
+  return {
+    type: typeLabels[profile.dataType],
+    detail: range ?? (sample ? `e.g. ${sample}` : "No sample"),
+    detailLabel: range ? "Range" : "Sample",
+    nulls: `${profile.nullCount.toLocaleString()} null${profile.nullCount === 1 ? "" : "s"}`,
+    excluded: profile.excludedCount ? `${profile.excludedCount.toLocaleString()} not finite` : void 0
+  };
+}
+function FieldMetadata({
+  profile,
+  label,
+  compact = false,
+  showDetail = true,
+  className,
+  tooltipSide = "bottom"
+}) {
+  if (!profile) return /* @__PURE__ */ jsx("span", { className, children: label });
+  const metadata = fieldMetadata(profile);
+  const description = [
+    metadata.type,
+    metadata.detail,
+    metadata.nulls,
+    metadata.excluded
+  ].filter(Boolean).join("; ");
+  const TypeIcon = typeIcons[profile.dataType];
+  return /* @__PURE__ */ jsx(TooltipProvider, { children: /* @__PURE__ */ jsxs(Tooltip, { children: [
+    /* @__PURE__ */ jsx(TooltipTrigger, { asChild: true, children: /* @__PURE__ */ jsxs(
+      "span",
+      {
+        className: cn(
+          compact ? "inline-flex min-w-0 items-center gap-1" : "inline-flex min-w-0 items-baseline gap-1.5",
+          className
+        ),
+        "aria-label": `${label ?? profile.name}: ${description}`,
+        children: [
+          compact && /* @__PURE__ */ jsx(
+            TypeIcon,
+            {
+              className: "h-3.5 w-3.5 shrink-0 text-muted-foreground",
+              "aria-hidden": "true"
+            }
+          ),
+          label && /* @__PURE__ */ jsx("span", { className: "truncate font-medium", children: label }),
+          !compact && /* @__PURE__ */ jsxs("span", { className: "flex min-w-0 gap-1.5 text-[10px] text-muted-foreground", children: [
+            /* @__PURE__ */ jsx("span", { className: "shrink-0", children: metadata.type }),
+            showDetail && /* @__PURE__ */ jsx("span", { className: "truncate", children: metadata.detail }),
+            /* @__PURE__ */ jsx("span", { className: "shrink-0", children: metadata.nulls })
+          ] })
+        ]
+      }
+    ) }),
+    /* @__PURE__ */ jsxs(TooltipContent, { side: tooltipSide, align: "start", collisionPadding: 12, children: [
+      /* @__PURE__ */ jsx("p", { className: "mb-2 font-semibold", children: label ?? profile.name }),
+      /* @__PURE__ */ jsxs("dl", { className: "grid grid-cols-[auto_1fr] gap-x-3 gap-y-1 text-xs", children: [
+        /* @__PURE__ */ jsx("dt", { className: "text-muted-foreground", children: "Type" }),
+        /* @__PURE__ */ jsx("dd", { children: metadata.type }),
+        /* @__PURE__ */ jsx("dt", { className: "text-muted-foreground", children: metadata.detailLabel }),
+        /* @__PURE__ */ jsx("dd", { children: metadata.detail }),
+        /* @__PURE__ */ jsx("dt", { className: "text-muted-foreground", children: "Nulls" }),
+        /* @__PURE__ */ jsx("dd", { children: metadata.nulls }),
+        metadata.excluded && /* @__PURE__ */ jsxs(Fragment, { children: [
+          /* @__PURE__ */ jsx("dt", { className: "text-muted-foreground", children: "Excluded" }),
+          /* @__PURE__ */ jsx("dd", { children: metadata.excluded })
+        ] }),
+        /* @__PURE__ */ jsx("dt", { className: "text-muted-foreground", children: "Distinct" }),
+        /* @__PURE__ */ jsx("dd", { children: profile.uniqueCount.toLocaleString() })
+      ] })
+    ] })
+  ] }) });
+}
+function CalculationForm({
+  draft,
+  onChange,
+  fields,
+  calculatedFields,
+  editing,
+  nameLocked,
+  checking,
+  canApply,
+  dirty,
+  status,
+  preview,
+  trace,
+  impact,
+  onApply,
+  onDiscard,
+  onClose
+}) {
+  const fieldProfiles = useDataLayer((state) => state.fieldProfiles);
+  const getColumnData = useDataLayer((state) => state.getColumnData);
+  const input = useRef(null);
+  const [search, setSearch] = useState("");
+  const [tab, setTab] = useState(editing ? "chain" : "fields");
+  const insert = (text, selectStart = text.length, selectEnd = selectStart) => {
+    const start = input.current?.selectionStart ?? draft.expression.length;
+    const end = input.current?.selectionEnd ?? start;
+    onChange({
+      ...draft,
+      expression: draft.expression.slice(0, start) + text + draft.expression.slice(end)
+    });
+    requestAnimationFrame(() => {
+      input.current?.focus();
+      input.current?.setSelectionRange(start + selectStart, start + selectEnd);
+    });
+  };
+  const matches = fields.filter(
+    (field) => field.toLowerCase().includes(search.toLowerCase())
+  );
+  return /* @__PURE__ */ jsxs(
+    "form",
+    {
+      className: "eda-calc-form",
+      onSubmit: (event) => {
+        event.preventDefault();
+        if (canApply) onApply();
+      },
+      onKeyDown: (event) => {
+        if ((event.metaKey || event.ctrlKey) && event.key === "Enter") {
+          event.preventDefault();
+          if (canApply) onApply();
+        }
+      },
+      children: [
+        /* @__PURE__ */ jsxs("div", { className: "eda-calc-editor-grid", children: [
+          /* @__PURE__ */ jsxs("div", { className: "eda-calc-main", children: [
+            /* @__PURE__ */ jsxs(
+              "div",
+              {
+                className: nameLocked ? "eda-calc-name eda-calc-name-locked" : "eda-calc-name",
+                children: [
+                  /* @__PURE__ */ jsx(Label, { htmlFor: "calculation-name", children: "Field name" }),
+                  /* @__PURE__ */ jsx(
+                    Input,
+                    {
+                      id: "calculation-name",
+                      value: draft.name,
+                      readOnly: nameLocked,
+                      onChange: (event) => onChange({ ...draft, name: event.target.value }),
+                      placeholder: "e.g. Net sales"
+                    }
+                  ),
+                  nameLocked && /* @__PURE__ */ jsx("p", { className: "eda-calc-help", children: "This name is used by other calculations or views. Its formula can still change." })
+                ]
+              }
+            ),
+            /* @__PURE__ */ jsxs("div", { className: "eda-calc-section-heading", children: [
+              /* @__PURE__ */ jsx(Label, { htmlFor: "calculation-expression", children: "Formula" }),
+              /* @__PURE__ */ jsx("span", { children: "One result per source row \xB7 UTC dates" })
+            ] }),
+            /* @__PURE__ */ jsx(
+              "textarea",
+              {
+                ref: input,
+                id: "calculation-expression",
+                value: draft.expression,
+                spellCheck: false,
+                autoCapitalize: "off",
+                autoComplete: "off",
+                placeholder: 'e.g. ["Revenue"] - ["Cost"]',
+                onChange: (event) => onChange({ ...draft, expression: event.target.value }),
+                "aria-describedby": "calculation-syntax calculation-validation"
+              }
+            ),
+            /* @__PURE__ */ jsxs("div", { className: "eda-calc-formula-tools", children: [
+              /* @__PURE__ */ jsx("p", { id: "calculation-syntax", className: "eda-calc-help", children: 'Use ["Field name"] for a field and "text" for a literal.' }),
+              /* @__PURE__ */ jsx(
+                "button",
+                {
+                  type: "button",
+                  className: "eda-calc-text-button",
+                  onClick: () => setTab("functions"),
+                  children: "Function help"
+                }
+              )
+            ] }),
+            /* @__PURE__ */ jsx(
+              "div",
+              {
+                id: "calculation-validation",
+                className: "eda-calc-validation",
+                "aria-live": "polite",
+                "aria-busy": checking,
+                children: status
+              }
+            ),
+            preview
+          ] }),
+          /* @__PURE__ */ jsx("aside", { className: "eda-calc-aside", "aria-label": "Calculation tools", children: /* @__PURE__ */ jsxs(Tabs, { value: tab, onValueChange: setTab, children: [
+            /* @__PURE__ */ jsxs(TabsList, { className: "w-full", children: [
+              /* @__PURE__ */ jsx(TabsTrigger, { value: "chain", children: "Chain" }),
+              /* @__PURE__ */ jsx(TabsTrigger, { value: "fields", children: "Fields" }),
+              /* @__PURE__ */ jsx(TabsTrigger, { value: "functions", children: "Functions" })
+            ] }),
+            /* @__PURE__ */ jsx(TabsContent, { value: "chain", children: trace }),
+            /* @__PURE__ */ jsxs(TabsContent, { value: "fields", children: [
+              /* @__PURE__ */ jsx("p", { className: "eda-calc-help mb-3", children: "Insert at the cursor, or replace selected text." }),
+              /* @__PURE__ */ jsx(
+                Input,
+                {
+                  "aria-label": "Find a field",
+                  placeholder: "Find a field\u2026",
+                  value: search,
+                  onChange: (event) => setSearch(event.target.value)
+                }
+              ),
+              [true, false].map((calculated) => {
+                const group = matches.filter(
+                  (field) => calculatedFields.includes(field) === calculated
+                );
+                return group.length > 0 && /* @__PURE__ */ jsxs(
+                  "section",
+                  {
+                    className: "eda-calc-field-group",
+                    children: [
+                      /* @__PURE__ */ jsxs("h3", { children: [
+                        calculated ? "Calculated fields" : "Source fields",
+                        /* @__PURE__ */ jsx("span", { children: group.length })
+                      ] }),
+                      group.map((field) => /* @__PURE__ */ jsxs(
+                        "button",
+                        {
+                          type: "button",
+                          onClick: () => insert("[" + JSON.stringify(field) + "]"),
+                          children: [
+                            /* @__PURE__ */ jsx(
+                              "span",
+                              {
+                                className: calculated ? "eda-calc-symbol" : "text-muted-foreground",
+                                children: calculated ? "\u0192x" : "\xB7"
+                              }
+                            ),
+                            /* @__PURE__ */ jsx(
+                              FieldMetadata,
+                              {
+                                profile: resolveFieldProfile(
+                                  field,
+                                  fieldProfiles,
+                                  getColumnData
+                                ),
+                                label: field,
+                                compact: true,
+                                className: "min-w-0 flex-1"
+                              }
+                            ),
+                            /* @__PURE__ */ jsx(
+                              "span",
+                              {
+                                className: "ml-auto text-muted-foreground",
+                                "aria-hidden": "true",
+                                children: "+"
+                              }
+                            )
+                          ]
+                        },
+                        field
+                      ))
+                    ]
+                  },
+                  String(calculated)
+                );
+              }),
+              !matches.length && /* @__PURE__ */ jsxs("p", { className: "eda-calc-help mt-4", children: [
+                "No fields match \u201C",
+                search,
+                "\u201D."
+              ] })
+            ] }),
+            /* @__PURE__ */ jsxs(TabsContent, { value: "functions", children: [
+              /* @__PURE__ */ jsx("p", { className: "eda-calc-help mb-3", children: "Select a function to insert it. Replace the selected argument with a field or value." }),
+              /* @__PURE__ */ jsx("div", { className: "eda-calc-function-list", children: Object.values(calculationFunctions).map((fn) => /* @__PURE__ */ jsxs(
+                "button",
+                {
+                  type: "button",
+                  onClick: () => {
+                    const text = fn.syntax.replace(", \u2026", "");
+                    const start = text.indexOf("(") + 1;
+                    const end = text.indexOf(",", start);
+                    insert(text, start, end === -1 ? text.length - 1 : end);
+                  },
+                  children: [
+                    /* @__PURE__ */ jsx("code", { children: fn.syntax }),
+                    /* @__PURE__ */ jsx("span", { children: fn.description })
+                  ]
+                },
+                fn.syntax
+              )) }),
+              /* @__PURE__ */ jsxs("details", { className: "eda-calc-syntax-help", children: [
+                /* @__PURE__ */ jsx("summary", { children: "Operators and rules" }),
+                /* @__PURE__ */ jsx("p", { children: "Arithmetic: + \u2212 * / ^" }),
+                /* @__PURE__ */ jsx("p", { children: "Compare: == != > >= < <=" }),
+                /* @__PURE__ */ jsx("p", { children: "Logic: && (and), || (or), ! (not)" }),
+                /* @__PURE__ */ jsx("code", { children: "if x > 0 then x else 0" }),
+                /* @__PURE__ */ jsx("p", { children: "Guard missing values with x == null." }),
+                /* @__PURE__ */ jsx("p", { children: "Date components: year, month, day, quarter, week (ISO)." })
+              ] })
+            ] })
+          ] }) })
+        ] }),
+        /* @__PURE__ */ jsxs("footer", { className: "eda-calc-editor-footer", children: [
+          /* @__PURE__ */ jsxs("div", { className: "min-w-0", children: [
+            /* @__PURE__ */ jsx("p", { children: impact }),
+            /* @__PURE__ */ jsx("p", { className: "eda-calc-help", children: dirty ? "Draft only. Apply to update the analysis. Closing keeps your draft in this session." : "Active filters stay in place when you apply a change." })
+          ] }),
+          /* @__PURE__ */ jsxs("div", { className: "flex shrink-0 items-center gap-2", children: [
+            dirty && /* @__PURE__ */ jsx(Button, { type: "button", variant: "ghost", onClick: onDiscard, children: "Discard draft" }),
+            /* @__PURE__ */ jsx(Button, { type: "button", variant: "outline", onClick: onClose, children: "Close" }),
+            /* @__PURE__ */ jsxs(Button, { type: "submit", disabled: !canApply, children: [
+              editing ? "Apply changes" : "Create calculation",
+              /* @__PURE__ */ jsx("span", { className: "eda-calc-shortcut", "aria-hidden": "true", children: "\u2318/Ctrl \u21B5" })
+            ] })
+          ] })
+        ] })
+      ]
+    }
+  );
+}
+
+// src/components/calculations/calculationHelpers.ts
+function dependentCalculations(calculations, name) {
+  const names = /* @__PURE__ */ new Set([name]);
+  let added = true;
+  while (added) {
+    added = false;
+    for (const calc of calculations) {
+      if (!names.has(calc.resultColumnName) && calc.expression.dependencies.some((field) => names.has(field))) {
+        names.add(calc.resultColumnName);
+        added = true;
+      }
+    }
+  }
+  return calculations.filter(
+    (calc) => calc.resultColumnName !== name && names.has(calc.resultColumnName)
+  );
+}
+var numbers = new Intl.NumberFormat("en-US", { maximumFractionDigits: 6 });
+function calculationValue(value) {
+  if (value == null) return "Missing";
+  if (typeof value === "number") return numbers.format(value);
+  if (typeof value === "boolean") return value ? "true" : "false";
+  return value === "" ? '""' : value;
+}
+function CalculationPreview({
+  calculation,
+  manager,
+  savedManager,
+  data,
+  selectedRow,
+  onSelectRow,
+  changed
+}) {
+  const [errorsOnly, setErrorsOnly] = useState(false);
+  const [page, setPage] = useState(
+    () => Math.max(
+      0,
+      Math.floor(data.findIndex((row) => row.__ID === selectedRow) / 5)
+    )
+  );
+  const name = calculation.resultColumnName;
+  const values = manager.executeCalculation(calculation);
+  const errors = manager.getErrors(name);
+  const dependencies = calculation.expression.dependencies;
+  const definitions = manager.getCalculations();
+  const saved = savedManager.getCalculations().find((calc) => calc.resultColumnName === name);
+  const before = saved ? savedManager.executeCalculation(saved) : null;
+  const inputValues = dependencies.map((field) => {
+    const calc = definitions.find((item) => item.resultColumnName === field);
+    return calc ? manager.executeCalculation(calc) : null;
+  });
+  const rows = errorsOnly ? data.filter((row) => errors.has(row.__ID)) : data;
+  const currentPage = Math.min(
+    page,
+    Math.max(0, Math.ceil(rows.length / 5) - 1)
+  );
+  const start = currentPage * 5;
+  return /* @__PURE__ */ jsxs("section", { className: "eda-calc-preview", "aria-label": "Calculation preview", children: [
+    /* @__PURE__ */ jsxs("div", { className: "eda-calc-section-heading", children: [
+      /* @__PURE__ */ jsx("h3", { children: "Inputs \u2192 result" }),
+      /* @__PURE__ */ jsx("span", { children: changed ? "Draft preview" : "Saved values" })
+    ] }),
+    /* @__PURE__ */ jsxs("div", { className: "flex flex-wrap items-center justify-between gap-2 mb-3", children: [
+      /* @__PURE__ */ jsx("p", { className: "eda-calc-help", children: "All loaded rows, before chart filters. Select a row to follow its values through the chain." }),
+      errors.size > 0 && /* @__PURE__ */ jsxs("label", { className: "flex items-center gap-2 text-xs", children: [
+        /* @__PURE__ */ jsx(
+          "input",
+          {
+            type: "checkbox",
+            checked: errorsOnly,
+            onChange: (event) => {
+              setErrorsOnly(event.target.checked);
+              setPage(0);
+            }
+          }
+        ),
+        "Failed rows only"
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs("div", { className: "eda-calc-preview-scroll", children: [
+      /* @__PURE__ */ jsxs("table", { children: [
+        /* @__PURE__ */ jsx("thead", { children: /* @__PURE__ */ jsxs("tr", { children: [
+          /* @__PURE__ */ jsx("th", { children: "Row" }),
+          dependencies.map((field) => /* @__PURE__ */ jsxs("th", { children: [
+            definitions.some(
+              (calc) => calc.resultColumnName === field
+            ) && /* @__PURE__ */ jsx("span", { className: "eda-calc-symbol mr-1", children: "\u0192x" }),
+            field
+          ] }, field)),
+          changed && before && /* @__PURE__ */ jsx("th", { children: "Saved result" }),
+          /* @__PURE__ */ jsx("th", { children: changed ? "Draft result" : "Result" }),
+          /* @__PURE__ */ jsx("th", { children: "Status" })
+        ] }) }),
+        /* @__PURE__ */ jsx("tbody", { children: rows.slice(start, start + 5).map((row) => /* @__PURE__ */ jsxs("tr", { "data-selected": row.__ID === selectedRow, children: [
+          /* @__PURE__ */ jsx("td", { children: /* @__PURE__ */ jsx(
+            "button",
+            {
+              type: "button",
+              "aria-label": "Trace row " + (row.__ID + 1),
+              "aria-pressed": row.__ID === selectedRow,
+              onClick: () => onSelectRow(row.__ID),
+              children: row.__ID + 1
+            }
+          ) }),
+          dependencies.map((field, index) => /* @__PURE__ */ jsx("td", { children: calculationValue(
+            inputValues[index] ? inputValues[index].get(row.__ID) : row[field]
+          ) }, field)),
+          changed && before && /* @__PURE__ */ jsx("td", { className: "text-muted-foreground", children: calculationValue(before.get(row.__ID)) }),
+          /* @__PURE__ */ jsx("td", { className: "font-semibold", children: errors.has(row.__ID) ? "\u2014" : calculationValue(values.get(row.__ID)) }),
+          /* @__PURE__ */ jsx(
+            "td",
+            {
+              className: errors.has(row.__ID) ? "text-destructive" : "text-muted-foreground",
+              children: errors.get(row.__ID) ?? (values.get(row.__ID) == null ? "Missing value" : "Valid")
+            }
+          )
+        ] }, row.__ID)) })
+      ] }),
+      !rows.length && /* @__PURE__ */ jsx("p", { className: "p-4 text-sm text-muted-foreground", children: errorsOnly ? "No failed rows." : "No loaded rows." })
+    ] }),
+    /* @__PURE__ */ jsxs("div", { className: "flex items-center justify-between gap-3 mt-2 text-xs text-muted-foreground", children: [
+      /* @__PURE__ */ jsxs("span", { children: [
+        rows.length ? start + 1 : 0,
+        "\u2013",
+        Math.min(start + 5, rows.length),
+        " of",
+        " ",
+        rows.length.toLocaleString(),
+        " rows"
+      ] }),
+      /* @__PURE__ */ jsxs("div", { className: "flex gap-1", children: [
+        /* @__PURE__ */ jsx(
+          Button,
+          {
+            type: "button",
+            variant: "ghost",
+            size: "sm",
+            disabled: currentPage === 0,
+            onClick: () => setPage(currentPage - 1),
+            children: "Previous rows"
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          Button,
+          {
+            type: "button",
+            variant: "ghost",
+            size: "sm",
+            disabled: start + 5 >= rows.length,
+            onClick: () => setPage(currentPage + 1),
+            children: "Next rows"
+          }
+        )
+      ] })
+    ] })
+  ] });
+}
+function CalculationTrace({
+  calculations,
+  manager,
+  row,
+  root,
+  selected,
+  draftFields,
+  previewing,
+  onSelect
+}) {
+  const fieldProfiles = useDataLayer((state) => state.fieldProfiles);
+  const getColumnData = useDataLayer((state) => state.getColumnData);
+  const byName = new Map(
+    calculations.map((calc) => [calc.resultColumnName, calc])
+  );
+  const dependents = dependentCalculations(calculations, selected);
+  const node = (name, path) => {
+    if (path.has(name)) return null;
+    const calc = byName.get(name);
+    const value = calc ? manager.executeCalculation(calc).get(row.__ID) : row[name];
+    const error = calc && manager.getErrors(name).get(row.__ID);
+    const nextPath = /* @__PURE__ */ new Set([...path, name]);
+    return /* @__PURE__ */ jsxs("li", { children: [
+      calc ? /* @__PURE__ */ jsx(ActionTooltip, { content: calc.expression.rawInput, children: /* @__PURE__ */ jsxs(
+        "button",
+        {
+          type: "button",
+          className: "eda-calc-node",
+          "aria-pressed": name === selected,
+          onClick: () => onSelect(name),
+          children: [
+            /* @__PURE__ */ jsx("span", { className: "eda-calc-symbol", "aria-hidden": "true", children: "\u0192x" }),
+            /* @__PURE__ */ jsxs("span", { className: "min-w-0 flex-1", children: [
+              /* @__PURE__ */ jsx(
+                FieldMetadata,
+                {
+                  profile: resolveFieldProfile(
+                    name,
+                    fieldProfiles,
+                    getColumnData
+                  ),
+                  label: name,
+                  compact: true,
+                  className: "min-w-0"
+                }
+              ),
+              draftFields.includes(name) && /* @__PURE__ */ jsx("small", { className: "block text-xs font-normal text-muted-foreground", children: name === selected && previewing ? "Draft preview" : "Draft kept" })
+            ] }),
+            /* @__PURE__ */ jsx(ActionTooltip, { content: error || String(value ?? "Missing"), children: /* @__PURE__ */ jsx(
+              "span",
+              {
+                className: error ? "text-destructive" : "eda-calc-node-value",
+                children: error ? "Error" : calculationValue(value)
+              }
+            ) })
+          ]
+        }
+      ) }) : /* @__PURE__ */ jsxs("div", { className: "eda-calc-source", children: [
+        /* @__PURE__ */ jsx(
+          FieldMetadata,
+          {
+            profile: resolveFieldProfile(name, fieldProfiles, getColumnData),
+            label: name,
+            compact: true,
+            className: "min-w-0 flex-1"
+          }
+        ),
+        /* @__PURE__ */ jsx(ActionTooltip, { content: String(value ?? "Missing"), children: /* @__PURE__ */ jsx("span", { className: "eda-calc-node-value", children: calculationValue(value) }) })
+      ] }),
+      calc && calc.expression.dependencies.length > 0 && /* @__PURE__ */ jsx("ul", { children: calc.expression.dependencies.map((field) => node(field, nextPath)) })
+    ] }, name);
+  };
+  return /* @__PURE__ */ jsxs("div", { className: "eda-calc-trace", children: [
+    /* @__PURE__ */ jsxs("div", { className: "eda-calc-section-heading", children: [
+      /* @__PURE__ */ jsx("h3", { children: "How this value is made" }),
+      /* @__PURE__ */ jsxs("span", { children: [
+        "Row ",
+        row.__ID + 1
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx("p", { className: "eda-calc-help", children: "Follow the inputs below. Select a calculation to inspect or edit that step." }),
+    /* @__PURE__ */ jsx("ul", { className: "eda-calc-tree", "aria-label": "Calculation dependency chain", children: node(root, /* @__PURE__ */ new Set()) }),
+    root !== selected && /* @__PURE__ */ jsxs(
+      "button",
+      {
+        className: "eda-calc-text-button",
+        type: "button",
+        onClick: () => onSelect(root),
+        children: [
+          "Return to ",
+          root
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsxs("div", { className: "eda-calc-section-heading mt-6", children: [
+      /* @__PURE__ */ jsx("h3", { children: "Used by" }),
+      /* @__PURE__ */ jsxs("span", { children: [
+        dependents.length,
+        " calculations"
+      ] })
+    ] }),
+    dependents.length ? /* @__PURE__ */ jsx("div", { className: "eda-calc-link-list", children: dependents.map((calc) => /* @__PURE__ */ jsxs(
+      "button",
+      {
+        type: "button",
+        onClick: () => onSelect(calc.resultColumnName),
+        children: [
+          /* @__PURE__ */ jsx("span", { className: "eda-calc-symbol", children: "\u0192x" }),
+          calc.resultColumnName
+        ]
+      },
+      calc.resultColumnName
+    )) }) : /* @__PURE__ */ jsx("p", { className: "eda-calc-help", children: "No calculations depend on this field." })
+  ] });
+}
+var EditorContext = createContext(null);
+var useCalculationEditor = () => useContext(EditorContext);
+function CalculationEditorProvider({
+  children
+}) {
+  const data = useDataLayer((state) => state.data);
+  const calculations = useDataLayer((state) => state.calculations);
+  const savedManager = useDataLayer((state) => state.calculationManager);
+  const charts = useDataLayer((state) => state.charts);
+  const getColumnNames = useDataLayer((state) => state.getColumnNames);
+  const getFieldLabel = useDataLayer((state) => state.getFieldLabel);
+  const addCalculation = useDataLayer((state) => state.addCalculation);
+  const updateCalculation = useDataLayer((state) => state.updateCalculation);
+  const [visible, setVisible] = useState(false);
+  const [selected, setSelected] = useState();
+  const [root, setRoot] = useState();
+  const [rowId, setRowId] = useState(0);
+  const [drafts, setDrafts] = useState({});
+  const [preview, setPreview] = useState();
+  const [saveError, setSaveError] = useState("");
+  const [savedMessage, setSavedMessage] = useState("");
+  const returnFocus = useRef(null);
+  const open = useCallback(
+    (name, row, target) => {
+      returnFocus.current = target ?? document.activeElement;
+      setSelected(name);
+      setRoot(name);
+      setRowId(row ?? 0);
+      setSaveError("");
+      setSavedMessage("");
+      setVisible(true);
+    },
+    []
+  );
+  const editor = useMemo(() => ({ open }), [open]);
+  useEffect(() => {
+    setDrafts({});
+    setVisible(false);
+  }, [data]);
+  const key = selected ?? "";
+  const calculation = calculations.find(
+    (calc) => calc.resultColumnName === selected
+  );
+  const draft = Object.hasOwn(drafts, key) ? drafts[key] : {
+    name: calculation?.resultColumnName ?? "",
+    expression: calculation?.expression.rawInput ?? ""
+  };
+  const dirty = draft.name !== (calculation?.resultColumnName ?? "") || draft.expression !== (calculation?.expression.rawInput ?? "");
+  const previewKey = JSON.stringify([selected, draft.name, draft.expression]);
+  useEffect(() => {
+    if (!visible) return;
+    setPreview(void 0);
+    const timer = setTimeout(() => {
+      if (!draft.name.trim() || !draft.expression.trim()) {
+        setPreview({ key: previewKey });
+        return;
+      }
+      try {
+        const candidate = {
+          resultColumnName: draft.name.trim(),
+          expression: parseExpression(draft.expression)
+        };
+        const manager = new CalculationManager(data, [
+          ...calculations.filter((calc) => calc.resultColumnName !== selected),
+          candidate
+        ]);
+        manager.executeCalculation(candidate);
+        setPreview({ key: previewKey, manager, calculation: candidate });
+      } catch (error) {
+        setPreview({
+          key: previewKey,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }, 220);
+    return () => clearTimeout(timer);
+  }, [visible, previewKey, data, calculations]);
+  const current = preview?.key === previewKey ? preview : void 0;
+  const checking = !current && Boolean(draft.name.trim() && draft.expression.trim());
+  const dependents = dependentCalculations(
+    calculations,
+    selected ?? draft.name
+  );
+  const affected = /* @__PURE__ */ new Set([
+    selected ?? draft.name,
+    ...dependents.map((calc) => calc.resultColumnName)
+  ]);
+  const usedViews = charts.filter(
+    (chart) => [
+      ...getChartFields(chart),
+      ...chart.filters.map((filter) => filter.field),
+      chart.facet?.rowVariable,
+      chart.facet?.type === "grid" ? chart.facet.columnVariable : void 0
+    ].some((field) => field && affected.has(field))
+  );
+  const nameLocked = Boolean(
+    calculation && (dependents.length || usedViews.length)
+  );
+  const canApply = Boolean(dirty && current?.manager && current.calculation);
+  const errorCount = current?.manager?.getErrors(draft.name.trim()).size ?? 0;
+  const removeDraft = () => setDrafts((previous) => {
+    const next = { ...previous };
+    delete next[key];
+    return next;
+  });
+  const apply = async () => {
+    if (!canApply || !current?.calculation) return;
+    try {
+      if (selected) updateCalculation(selected, current.calculation);
+      else await addCalculation(current.calculation);
+      removeDraft();
+      const name = current.calculation.resultColumnName;
+      setSelected(name);
+      if (!root || root === selected) setRoot(name);
+      setSaveError("");
+      setSavedMessage(
+        "Applied. All dependent calculations and views are up to date."
+      );
+    } catch (error) {
+      setSaveError(error instanceof Error ? error.message : String(error));
+    }
+  };
+  const traceManager = current?.manager ?? savedManager;
+  const traceCalculations = traceManager.getCalculations();
+  const traceRoot = root === selected ? current?.calculation?.resultColumnName ?? root : root ?? current?.calculation?.resultColumnName;
+  const selectedRow = data.find((row) => row.__ID === rowId) ?? data[0];
+  const status = saveError || current?.error ? /* @__PURE__ */ jsxs("p", { role: "alert", className: "eda-calc-error", children: [
+    /* @__PURE__ */ jsx(CircleAlert, { "aria-hidden": "true", size: 16 }),
+    /* @__PURE__ */ jsx("span", { children: saveError || current?.error })
+  ] }) : checking ? /* @__PURE__ */ jsxs("p", { role: "status", children: [
+    "Checking formula against ",
+    data.length.toLocaleString(),
+    " loaded rows\u2026"
+  ] }) : current?.manager ? /* @__PURE__ */ jsxs(
+    "p",
+    {
+      role: "status",
+      className: errorCount ? "eda-calc-error" : "eda-calc-valid",
+      children: [
+        errorCount ? /* @__PURE__ */ jsx(CircleAlert, { size: 16, "aria-hidden": "true" }) : /* @__PURE__ */ jsx(CheckCircle2, { size: 16, "aria-hidden": "true" }),
+        /* @__PURE__ */ jsxs("span", { children: [
+          errorCount ? errorCount.toLocaleString() + " of " + data.length.toLocaleString() + " rows failed. Valid rows remain available." : "Valid for all " + data.length.toLocaleString() + " rows.",
+          savedMessage && " " + savedMessage
+        ] })
+      ]
+    }
+  ) : /* @__PURE__ */ jsx("p", { children: "Enter a field name and formula to preview results." });
+  return /* @__PURE__ */ jsxs(EditorContext.Provider, { value: editor, children: [
+    children,
+    /* @__PURE__ */ jsx(Dialog, { open: visible, onOpenChange: setVisible, children: /* @__PURE__ */ jsxs(
+      DialogContent,
+      {
+        className: "eda-calc-editor",
+        onCloseAutoFocus: (event) => {
+          event.preventDefault();
+          if (returnFocus.current?.isConnected) returnFocus.current.focus();
+        },
+        children: [
+          /* @__PURE__ */ jsxs(DialogHeader, { className: "eda-calc-editor-header", children: [
+            /* @__PURE__ */ jsxs(DialogTitle, { children: [
+              /* @__PURE__ */ jsx("span", { className: "eda-calc-symbol mr-2", children: "\u0192x" }),
+              selected ? "Inspect calculation" : "New calculation"
+            ] }),
+            /* @__PURE__ */ jsx(DialogDescription, { children: root ? "Following " + root + ". Preview a change before applying it to the analysis." : "Turn source fields into values you can reuse in any view." })
+          ] }),
+          /* @__PURE__ */ jsx(
+            CalculationForm,
+            {
+              draft,
+              onChange: (next) => {
+                setDrafts((previous) => ({ ...previous, [key]: next }));
+                setSaveError("");
+                setSavedMessage("");
+              },
+              fields: getColumnNames().filter((field) => field !== selected),
+              calculatedFields: calculations.map((calc) => calc.resultColumnName),
+              editing: Boolean(calculation),
+              nameLocked,
+              checking,
+              canApply,
+              dirty,
+              status,
+              impact: dependents.length + " dependent calculations \xB7 " + usedViews.length + " affected views",
+              onApply: apply,
+              onDiscard: () => {
+                removeDraft();
+                setSaveError("");
+                setSavedMessage("");
+              },
+              onClose: () => setVisible(false),
+              preview: current?.manager && current.calculation ? /* @__PURE__ */ jsx(
+                CalculationPreview,
+                {
+                  calculation: current.calculation,
+                  manager: current.manager,
+                  savedManager,
+                  data,
+                  selectedRow: selectedRow?.__ID ?? 0,
+                  onSelectRow: setRowId,
+                  changed: dirty
+                },
+                key
+              ) : /* @__PURE__ */ jsxs("div", { className: "eda-calc-preview-empty", children: [
+                /* @__PURE__ */ jsx("h3", { children: "See the result before you apply" }),
+                /* @__PURE__ */ jsx("p", { children: "Inputs, saved values, and draft results appear here once the formula is valid." })
+              ] }),
+              trace: /* @__PURE__ */ jsxs(Fragment, { children: [
+                dirty && !current?.manager && /* @__PURE__ */ jsx("p", { className: "eda-calc-help mb-3", children: "The chain shows saved values until this draft can be previewed." }),
+                traceRoot && selectedRow ? /* @__PURE__ */ jsx(
+                  CalculationTrace,
+                  {
+                    calculations: traceCalculations,
+                    manager: traceManager,
+                    row: selectedRow,
+                    root: traceRoot,
+                    selected: selected ?? draft.name,
+                    draftFields: Object.keys(drafts),
+                    previewing: Boolean(current?.manager),
+                    onSelect: (field) => {
+                      if (root && dependentCalculations(calculations, root).some(
+                        (calc) => calc.resultColumnName === field
+                      ))
+                        setRoot(field);
+                      setSelected(field);
+                      setSaveError("");
+                      setSavedMessage("");
+                    }
+                  }
+                ) : /* @__PURE__ */ jsx("p", { className: "eda-calc-help", children: "Add a formula to see how its fields connect." }),
+                usedViews.length > 0 && /* @__PURE__ */ jsxs("section", { className: "mt-6", children: [
+                  /* @__PURE__ */ jsx("h3", { className: "text-sm font-medium", children: "Used in views" }),
+                  /* @__PURE__ */ jsx("ul", { className: "eda-calc-view-list", children: usedViews.map((chart) => /* @__PURE__ */ jsx("li", { children: getChartTitle(chart, getFieldLabel) }, chart.id)) })
+                ] })
+              ] })
+            },
+            key
+          )
+        ]
+      }
+    ) })
+  ] });
+}
+function CalculatedFieldBadge({
+  field,
+  showName = false,
+  rowId = 0,
+  children,
+  hoverOpen = true,
+  side = "bottom"
+}) {
+  const calculations = useDataLayer((state) => state.calculations) ?? [];
+  const manager = useDataLayer((state) => state.calculationManager);
+  const data = useDataLayer((state) => state.data);
+  const fieldProfiles = useDataLayer((state) => state.fieldProfiles);
+  const getColumnData = useDataLayer((state) => state.getColumnData);
+  const editor = useCalculationEditor();
+  const calc = calculations.find((item) => item.resultColumnName === field);
+  const [open, setOpen] = useState(false);
+  const pinned = useRef(false);
+  const restoreFocus = useRef(false);
+  const timer = useRef(void 0);
+  const trigger = useRef(null);
+  const cancelTimer = () => clearTimeout(timer.current);
+  useEffect(() => () => clearTimeout(timer.current), []);
+  if (!calc || !editor) return /* @__PURE__ */ jsx(Fragment, { children });
+  const leave = () => {
+    cancelTimer();
+    if (!pinned.current) timer.current = setTimeout(() => setOpen(false), 180);
+  };
+  const errors = open ? manager.getErrors(field) : /* @__PURE__ */ new Map();
+  const value = open ? manager.executeCalculation(calc).get(rowId) : void 0;
+  const profile = open ? resolveFieldProfile(field, fieldProfiles, getColumnData) : void 0;
+  return /* @__PURE__ */ jsxs(
+    Popover,
+    {
+      open,
+      onOpenChange: (next) => {
+        setOpen(next);
+        if (!next) pinned.current = false;
+      },
+      children: [
+        /* @__PURE__ */ jsx(PopoverTrigger, { asChild: true, children: /* @__PURE__ */ jsx(
+          "button",
+          {
+            ref: trigger,
+            type: "button",
+            className: children !== void 0 ? "eda-calc-cell" : "eda-calc-badge",
+            "aria-label": "Inspect " + field + " calculation" + (children !== void 0 ? ", row " + (rowId + 1) : ""),
+            onPointerEnter: (event) => {
+              if (!hoverOpen || event.pointerType === "touch" || event.buttons)
+                return;
+              cancelTimer();
+              timer.current = setTimeout(() => setOpen(true), 250);
+            },
+            onPointerLeave: leave,
+            onClick: (event) => {
+              event.preventDefault();
+              event.stopPropagation();
+              cancelTimer();
+              pinned.current = true;
+              restoreFocus.current = true;
+              setOpen(true);
+            },
+            children: children !== void 0 ? children : /* @__PURE__ */ jsxs(Fragment, { children: [
+              /* @__PURE__ */ jsx("span", { className: "eda-calc-symbol", "aria-hidden": "true", children: "\u0192x" }),
+              showName && /* @__PURE__ */ jsx("span", { children: field })
+            ] })
+          }
+        ) }),
+        /* @__PURE__ */ jsxs(
+          PopoverContent,
+          {
+            className: "eda-calc-peek",
+            align: "start",
+            side,
+            collisionPadding: 12,
+            onPointerEnter: cancelTimer,
+            onPointerLeave: leave,
+            onOpenAutoFocus: (event) => {
+              if (!pinned.current) event.preventDefault();
+            },
+            onCloseAutoFocus: (event) => {
+              event.preventDefault();
+              if (restoreFocus.current) trigger.current?.focus();
+              restoreFocus.current = false;
+            },
+            children: [
+              /* @__PURE__ */ jsxs("div", { className: "eda-calc-section-heading", children: [
+                /* @__PURE__ */ jsx(FieldMetadata, { profile, label: field, compact: true }),
+                /* @__PURE__ */ jsx("span", { children: "Calculated field" })
+              ] }),
+              /* @__PURE__ */ jsx("pre", { children: calc.expression.rawInput }),
+              /* @__PURE__ */ jsxs("p", { className: "eda-calc-help", children: [
+                "Uses",
+                " ",
+                calc.expression.dependencies.length ? calc.expression.dependencies.join(", ") : "constant values",
+                "."
+              ] }),
+              /* @__PURE__ */ jsxs("div", { className: "eda-calc-peek-result", children: [
+                /* @__PURE__ */ jsxs("span", { children: [
+                  "Row ",
+                  rowId + 1
+                ] }),
+                /* @__PURE__ */ jsx("strong", { children: errors.get(rowId) ?? calculationValue(value) })
+              ] }),
+              /* @__PURE__ */ jsxs("p", { className: "eda-calc-help", children: [
+                errors.size ? errors.size.toLocaleString() + " of " + data.length.toLocaleString() + " rows failed" : "All " + data.length.toLocaleString() + " rows valid",
+                " ",
+                "\xB7 ",
+                dependentCalculations(calculations, field).length,
+                " dependent calculations"
+              ] }),
+              /* @__PURE__ */ jsx(
+                Button,
+                {
+                  type: "button",
+                  className: "mt-4 w-full",
+                  onClick: () => {
+                    setOpen(false);
+                    pinned.current = false;
+                    restoreFocus.current = false;
+                    editor.open(field, rowId, trigger.current);
+                  },
+                  children: "Inspect chain & edit"
+                }
+              )
+            ]
+          }
+        )
+      ]
+    }
+  );
+}
+
+export { CalculatedFieldBadge, CalculationEditorProvider, FieldMetadata, Tabs, TabsContent, TabsList, TabsTrigger, dependentCalculations, resolveFieldProfile, useCalculationEditor };
+//# sourceMappingURL=chunk-NDF5LCST.js.map
+//# sourceMappingURL=chunk-NDF5LCST.js.map