@kanzo-tech/ui 0.0.1-alpha

package/dist/charts/chart-interactors.d.ts

@@ -0,0 +1,75 @@
+import { Selection } from '@uwdata/mosaic-core';
+import { ChartDescriptor } from './chart-spec.js';
+/**
+ * The interactor vocabulary. Inert descriptors, like the marks.
+ *
+ * vgplot binds an interactor to the **last mark added before it**, so order inside `ChartRoot` is
+ * semantic: put the interactor after the mark it should drive.
+ */
+export interface ChartInteractorProps {
+    /** Where the interaction publishes. Defaults to `ChartRoot`'s `as` — the selection that root owns. */
+    as?: Selection | null;
+    /** Any other vgplot interactor option (`peers`, `brush`, `pixelSize`, `empty`…). */
+    [option: string]: unknown;
+}
+export declare const ChartIntervalX: ChartDescriptor<ChartInteractorProps>;
+export declare const ChartIntervalY: ChartDescriptor<ChartInteractorProps>;
+export declare const ChartIntervalXY: ChartDescriptor<ChartInteractorProps>;
+export declare const ChartToggleX: ChartDescriptor<ChartInteractorProps>;
+export declare const ChartToggleY: ChartDescriptor<ChartInteractorProps>;
+export declare const ChartToggleColor: ChartDescriptor<ChartInteractorProps>;
+export declare const ChartNearestX: ChartDescriptor<ChartInteractorProps>;
+export declare const ChartNearestY: ChartDescriptor<ChartInteractorProps>;
+export declare const ChartRegion: ChartDescriptor<ChartInteractorProps>;
+export interface ChartHighlightProps {
+    /**
+     * The selection to highlight by — vgplot spells this `by`, not `as`. Defaults to `ChartRoot`'s
+     * own selection, which is the only value guaranteed to be safe; see below before overriding it.
+     */
+    by?: Selection | null;
+    /** The channels applied to the de-emphasised marks (`opacity`, `fill`, `stroke`…). */
+    [channel: string]: unknown;
+}
+/**
+ * Dims the marks outside `by` instead of publishing a selection — it reads, it does not write.
+ *
+ * **`by` is not a filter.** The highlight appends `by`'s predicate to the mark's own query as an
+ * extra output column, and on an aggregating mark that query has a `GROUP BY` — so a predicate
+ * naming a column the plot does not group by is a DuckDB binder error. Mosaic swallows it and the
+ * plot keeps its previous render, silently. Leaving `by` off is what keeps that impossible: the
+ * root's own selection can only hold clauses its own interactors published, over its own columns.
+ * `ChartRoot` warns in development when an explicit `by` gives that away.
+ */
+export declare const ChartHighlight: ChartDescriptor<ChartHighlightProps>;
+/**
+ * Clearer aliases for the two ways of selecting, because vgplot's own pair mixes criteria:
+ * `toggle` names the gesture, `interval` names the result. Both spellings work, and the vgplot names
+ * stay so anyone reading Mosaic's documentation lands on the same component.
+ *
+ * This block used to claim "the docs teach these". They did not — a measurement found zero mentions
+ * of any `Pick`/`Brush` name across every `.mdx`, while both spellings ran side by side in examples
+ * and one showcase, sometimes in the same file. The pairing is now a table under
+ * "Interactors" in `charts.mdx`. If you add an alias here, teach it there in the same commit.
+ *
+ * **Pick** is discrete: click a bar, get `region IN (…)`. Needs a categorical/band scale.
+ * **Brush** is continuous: drag the axis, get `latency BETWEEN lo AND hi`. Needs a scale with a
+ * "between" — brushing a band scale throws inside Mosaic, which `ChartRoot` warns about.
+ */
+export declare const ChartPickX: ChartDescriptor<ChartInteractorProps>;
+export declare const ChartPickY: ChartDescriptor<ChartInteractorProps>;
+export declare const ChartPickColor: ChartDescriptor<ChartInteractorProps>;
+export declare const ChartBrushX: ChartDescriptor<ChartInteractorProps>;
+export declare const ChartBrushY: ChartDescriptor<ChartInteractorProps>;
+export declare const ChartBrushXY: ChartDescriptor<ChartInteractorProps>;
+export interface ChartPanZoomProps {
+    /** Restrict panning/zooming to an axis, or bind the resulting domain to a `Selection`/`Param`. */
+    x?: unknown;
+    y?: unknown;
+    zoom?: boolean;
+    panx?: boolean;
+    pany?: boolean;
+    [option: string]: unknown;
+}
+/** Pan and zoom the plot's scales. Carries no selection — it rewrites the domains in place. */
+export declare const ChartPanZoom: ChartDescriptor<ChartPanZoomProps>;
+//# sourceMappingURL=chart-interactors.d.ts.map

package/dist/charts/chart-interactors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chart-interactors.d.ts","sourceRoot":"","sources":["../../src/charts/chart-interactors.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,EAAmB,KAAK,eAAe,EAAiC,MAAM,iBAAiB,CAAC;AAEvG;;;;;GAKG;AAEH,MAAM,WAAW,oBAAoB;IACnC,sGAAsG;IACtG,EAAE,CAAC,EAAE,SAAS,GAAG,IAAI,CAAC;IACtB,oFAAoF;IACpF,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC;CAC3B;AASD,eAAO,MAAM,cAAc,uCAA4C,CAAC;AACxE,eAAO,MAAM,cAAc,uCAA4C,CAAC;AACxE,eAAO,MAAM,eAAe,uCAA8C,CAAC;AAC3E,eAAO,MAAM,YAAY,uCAAwC,CAAC;AAClE,eAAO,MAAM,YAAY,uCAAwC,CAAC;AAClE,eAAO,MAAM,gBAAgB,uCAAgD,CAAC;AAC9E,eAAO,MAAM,aAAa,uCAA0C,CAAC;AACrE,eAAO,MAAM,aAAa,uCAA0C,CAAC;AACrE,eAAO,MAAM,WAAW,uCAAsC,CAAC;AAE/D,MAAM,WAAW,mBAAmB;IAClC;;;OAGG;IACH,EAAE,CAAC,EAAE,SAAS,GAAG,IAAI,CAAC;IACtB,sFAAsF;IACtF,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC;CAC5B;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,cAAc,sCAGzB,CAAC;AAEH;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,UAAU,uCAAe,CAAC;AACvC,eAAO,MAAM,UAAU,uCAAe,CAAC;AACvC,eAAO,MAAM,cAAc,uCAAmB,CAAC;AAC/C,eAAO,MAAM,WAAW,uCAAiB,CAAC;AAC1C,eAAO,MAAM,WAAW,uCAAiB,CAAC;AAC1C,eAAO,MAAM,YAAY,uCAAkB,CAAC;AAE5C,MAAM,WAAW,iBAAiB;IAChC,kGAAkG;IAClG,CAAC,CAAC,EAAE,OAAO,CAAC;IACZ,CAAC,CAAC,EAAE,OAAO,CAAC;IACZ,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC;CAC3B;AAED,+FAA+F;AAC/F,eAAO,MAAM,YAAY,oCAItB,CAAC"}

package/dist/charts/chart-interactors.js

@@ -0,0 +1,35 @@
+import { chartDescriptor as e } from "./chart-spec.js";
+function t(r, a) {
+  return e(r, (o, n) => {
+    const { as: h, ...s } = o;
+    return { kind: "interactor", interactor: a, options: { ...s, as: h === void 0 ? n.as : h } };
+  });
+}
+const c = t("ChartIntervalX", "intervalX"), i = t("ChartIntervalY", "intervalY"), C = t("ChartIntervalXY", "intervalXY"), g = t("ChartToggleX", "toggleX"), l = t("ChartToggleY", "toggleY"), X = t("ChartToggleColor", "toggleColor"), v = t("ChartNearestX", "nearestX"), p = t("ChartNearestY", "nearestY"), u = t("ChartRegion", "region"), k = e("ChartHighlight", (r, a) => {
+  const { by: o, ...n } = r;
+  return { kind: "interactor", interactor: "highlight", options: { ...n, by: o === void 0 ? a.as : o } };
+}), I = g, T = l, d = X, m = c, P = i, N = C, B = e("ChartPanZoom", (r) => ({
+  kind: "interactor",
+  interactor: "panZoom",
+  options: { ...r }
+}));
+export {
+  m as ChartBrushX,
+  N as ChartBrushXY,
+  P as ChartBrushY,
+  k as ChartHighlight,
+  c as ChartIntervalX,
+  C as ChartIntervalXY,
+  i as ChartIntervalY,
+  v as ChartNearestX,
+  p as ChartNearestY,
+  B as ChartPanZoom,
+  d as ChartPickColor,
+  I as ChartPickX,
+  T as ChartPickY,
+  u as ChartRegion,
+  X as ChartToggleColor,
+  g as ChartToggleX,
+  l as ChartToggleY
+};
+//# sourceMappingURL=chart-interactors.js.map

package/dist/charts/chart-interactors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"chart-interactors.js","sources":["../../src/charts/chart-interactors.tsx"],"sourcesContent":["import type { Selection } from \"@uwdata/mosaic-core\";\nimport { chartDescriptor, type ChartDescriptor, type ChartInteractorDirective } from \"./chart-spec.js\";\n\n/**\n * The interactor vocabulary. Inert descriptors, like the marks.\n *\n * vgplot binds an interactor to the **last mark added before it**, so order inside `ChartRoot` is\n * semantic: put the interactor after the mark it should drive.\n */\n\nexport interface ChartInteractorProps {\n  /** Where the interaction publishes. Defaults to `ChartRoot`'s `as` — the selection that root owns. */\n  as?: Selection | null;\n  /** Any other vgplot interactor option (`peers`, `brush`, `pixelSize`, `empty`…). */\n  [option: string]: unknown;\n}\n\nfunction interactor(displayName: string, type: string): ChartDescriptor<ChartInteractorProps> {\n  return chartDescriptor<ChartInteractorProps>(displayName, (props, ctx): ChartInteractorDirective => {\n    const { as, ...rest } = props;\n    return { kind: \"interactor\", interactor: type, options: { ...rest, as: as === undefined ? ctx.as : as } };\n  });\n}\n\nexport const ChartIntervalX = interactor(\"ChartIntervalX\", \"intervalX\");\nexport const ChartIntervalY = interactor(\"ChartIntervalY\", \"intervalY\");\nexport const ChartIntervalXY = interactor(\"ChartIntervalXY\", \"intervalXY\");\nexport const ChartToggleX = interactor(\"ChartToggleX\", \"toggleX\");\nexport const ChartToggleY = interactor(\"ChartToggleY\", \"toggleY\");\nexport const ChartToggleColor = interactor(\"ChartToggleColor\", \"toggleColor\");\nexport const ChartNearestX = interactor(\"ChartNearestX\", \"nearestX\");\nexport const ChartNearestY = interactor(\"ChartNearestY\", \"nearestY\");\nexport const ChartRegion = interactor(\"ChartRegion\", \"region\");\n\nexport interface ChartHighlightProps {\n  /**\n   * The selection to highlight by — vgplot spells this `by`, not `as`. Defaults to `ChartRoot`'s\n   * own selection, which is the only value guaranteed to be safe; see below before overriding it.\n   */\n  by?: Selection | null;\n  /** The channels applied to the de-emphasised marks (`opacity`, `fill`, `stroke`…). */\n  [channel: string]: unknown;\n}\n\n/**\n * Dims the marks outside `by` instead of publishing a selection — it reads, it does not write.\n *\n * **`by` is not a filter.** The highlight appends `by`'s predicate to the mark's own query as an\n * extra output column, and on an aggregating mark that query has a `GROUP BY` — so a predicate\n * naming a column the plot does not group by is a DuckDB binder error. Mosaic swallows it and the\n * plot keeps its previous render, silently. Leaving `by` off is what keeps that impossible: the\n * root's own selection can only hold clauses its own interactors published, over its own columns.\n * `ChartRoot` warns in development when an explicit `by` gives that away.\n */\nexport const ChartHighlight = chartDescriptor<ChartHighlightProps>(\"ChartHighlight\", (props, ctx) => {\n  const { by, ...channels } = props;\n  return { kind: \"interactor\", interactor: \"highlight\", options: { ...channels, by: by === undefined ? ctx.as : by } };\n});\n\n/**\n * Clearer aliases for the two ways of selecting, because vgplot's own pair mixes criteria:\n * `toggle` names the gesture, `interval` names the result. Both spellings work, and the vgplot names\n * stay so anyone reading Mosaic's documentation lands on the same component.\n *\n * This block used to claim \"the docs teach these\". They did not — a measurement found zero mentions\n * of any `Pick`/`Brush` name across every `.mdx`, while both spellings ran side by side in examples\n * and one showcase, sometimes in the same file. The pairing is now a table under\n * \"Interactors\" in `charts.mdx`. If you add an alias here, teach it there in the same commit.\n *\n * **Pick** is discrete: click a bar, get `region IN (…)`. Needs a categorical/band scale.\n * **Brush** is continuous: drag the axis, get `latency BETWEEN lo AND hi`. Needs a scale with a\n * \"between\" — brushing a band scale throws inside Mosaic, which `ChartRoot` warns about.\n */\nexport const ChartPickX = ChartToggleX;\nexport const ChartPickY = ChartToggleY;\nexport const ChartPickColor = ChartToggleColor;\nexport const ChartBrushX = ChartIntervalX;\nexport const ChartBrushY = ChartIntervalY;\nexport const ChartBrushXY = ChartIntervalXY;\n\nexport interface ChartPanZoomProps {\n  /** Restrict panning/zooming to an axis, or bind the resulting domain to a `Selection`/`Param`. */\n  x?: unknown;\n  y?: unknown;\n  zoom?: boolean;\n  panx?: boolean;\n  pany?: boolean;\n  [option: string]: unknown;\n}\n\n/** Pan and zoom the plot's scales. Carries no selection — it rewrites the domains in place. */\nexport const ChartPanZoom = chartDescriptor<ChartPanZoomProps>(\"ChartPanZoom\", (props) => ({\n  kind: \"interactor\",\n  interactor: \"panZoom\",\n  options: { ...props },\n}));\n"],"names":["interactor","displayName","type","chartDescriptor","props","ctx","as","rest","ChartIntervalX","ChartIntervalY","ChartIntervalXY","ChartToggleX","ChartToggleY","ChartToggleColor","ChartNearestX","ChartNearestY","ChartRegion","ChartHighlight","by","channels","ChartPickX","ChartPickY","ChartPickColor","ChartBrushX","ChartBrushY","ChartBrushXY","ChartPanZoom"],"mappings":";AAiBA,SAASA,EAAWC,GAAqBC,GAAqD;AAC5F,SAAOC,EAAsCF,GAAa,CAACG,GAAOC,MAAkC;AAClG,UAAM,EAAE,IAAAC,GAAI,GAAGC,EAAA,IAASH;AACxB,WAAO,EAAE,MAAM,cAAc,YAAYF,GAAM,SAAS,EAAE,GAAGK,GAAM,IAAID,MAAO,SAAYD,EAAI,KAAKC,IAAG;AAAA,EACxG,CAAC;AACH;AAEO,MAAME,IAAiBR,EAAW,kBAAkB,WAAW,GACzDS,IAAiBT,EAAW,kBAAkB,WAAW,GACzDU,IAAkBV,EAAW,mBAAmB,YAAY,GAC5DW,IAAeX,EAAW,gBAAgB,SAAS,GACnDY,IAAeZ,EAAW,gBAAgB,SAAS,GACnDa,IAAmBb,EAAW,oBAAoB,aAAa,GAC/Dc,IAAgBd,EAAW,iBAAiB,UAAU,GACtDe,IAAgBf,EAAW,iBAAiB,UAAU,GACtDgB,IAAchB,EAAW,eAAe,QAAQ,GAsBhDiB,IAAiBd,EAAqC,kBAAkB,CAACC,GAAOC,MAAQ;AACnG,QAAM,EAAE,IAAAa,GAAI,GAAGC,EAAA,IAAaf;AAC5B,SAAO,EAAE,MAAM,cAAc,YAAY,aAAa,SAAS,EAAE,GAAGe,GAAU,IAAID,MAAO,SAAYb,EAAI,KAAKa,IAAG;AACnH,CAAC,GAgBYE,IAAaT,GACbU,IAAaT,GACbU,IAAiBT,GACjBU,IAAcf,GACdgB,IAAcf,GACdgB,IAAef,GAafgB,IAAevB,EAAmC,gBAAgB,CAACC,OAAW;AAAA,EACzF,MAAM;AAAA,EACN,YAAY;AAAA,EACZ,SAAS,EAAE,GAAGA,EAAA;AAChB,EAAE;"}

package/dist/charts/chart-legend.d.ts

@@ -0,0 +1,38 @@
+import { default as React } from 'react';
+import { ark } from '@ark-ui/react/factory';
+import { Selection } from '@uwdata/mosaic-core';
+import { ChartConfig } from './chart-config.js';
+export interface ChartLegendProps extends React.ComponentProps<typeof ark.ul> {
+    /** Series config. Defaults to the surrounding `<ChartRoot>`'s. */
+    config?: ChartConfig;
+    /** Standalone shorthand: labels in slot order, the i-th on its scheme slot. */
+    series?: readonly string[];
+}
+/**
+ * The identity key for a multi-series chart — our DOM, not vgplot's. Colour is never the only
+ * channel (dataviz): the label text carries identity and the swatch is `aria-hidden`.
+ */
+export declare function ChartLegend(props: ChartLegendProps): React.JSX.Element;
+export interface ChartColorLegendProps {
+    /**
+     * Where a swatch click publishes. Defaults to `ChartRoot`'s `as`, which makes the legend a
+     * filter; pass `null` for a static key.
+     */
+    as?: Selection | null;
+    /** The column the swatches map to, when it cannot be inferred from the channel. */
+    field?: string;
+    /**
+     * Which scale the swatches read. `color` is the usual one; `opacity` and `symbol` legend a plot
+     * that encodes its series on those channels instead — a scatter keyed by shape, say.
+     */
+    channel?: "color" | "opacity" | "symbol";
+    /** Any other vgplot legend option (`label`, `columns`, `tickSize`, `width`…). */
+    [option: string]: unknown;
+}
+/**
+ * vgplot's own colour legend — a descriptor, drawn inside the plot element and **interactive**:
+ * clicking a swatch toggles that series into the selection. Use `ChartLegend` when you want our
+ * DOM and the config's labels and icons; use this one when you want click-to-filter.
+ */
+export declare const ChartColorLegend: import('./chart-spec.js').ChartDescriptor<ChartColorLegendProps>;
+//# sourceMappingURL=chart-legend.d.ts.map

package/dist/charts/chart-legend.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chart-legend.d.ts","sourceRoot":"","sources":["../../src/charts/chart-legend.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,EAAE,GAAG,EAAE,MAAM,uBAAuB,CAAC;AAC5C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAGrD,OAAO,EAAsB,KAAK,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAKzE,MAAM,WAAW,gBAAiB,SAAQ,KAAK,CAAC,cAAc,CAAC,OAAO,GAAG,CAAC,EAAE,CAAC;IAC3E,kEAAkE;IAClE,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,+EAA+E;IAC/E,MAAM,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC5B;AAMD;;;GAGG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,gBAAgB,qBA8BlD;AAED,MAAM,WAAW,qBAAqB;IACpC;;;OAGG;IACH,EAAE,CAAC,EAAE,SAAS,GAAG,IAAI,CAAC;IACtB,mFAAmF;IACnF,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;OAGG;IACH,OAAO,CAAC,EAAE,OAAO,GAAG,SAAS,GAAG,QAAQ,CAAC;IACzC,iFAAiF;IACjF,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC;CAC3B;AAED;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,kEAW3B,CAAC"}

package/dist/charts/chart-legend.js

@@ -0,0 +1,49 @@
+"use client";
+import { jsx as o, jsxs as g } from "react/jsx-runtime";
+import { ark as m } from "@ark-ui/react/factory";
+import { cn as h } from "../lib/cn.js";
+import { Swatch as u } from "../simples/swatch.js";
+import { chartSeriesEntries as x } from "./chart-config.js";
+import { useChartContextOptional as C } from "./chart-root.js";
+import { chartDescriptor as k } from "./chart-spec.js";
+import { categoricalColor as N } from "../lib/token-color.js";
+function L(r) {
+  return Object.fromEntries(r.map((t, e) => [t, { color: N(e) }]));
+}
+function b(r) {
+  const { config: t, series: e, className: s, slot: a, ...l } = r, n = C(), p = t ?? (e ? L(e) : n == null ? void 0 : n.config) ?? {};
+  return /* @__PURE__ */ o(
+    m.ul,
+    {
+      className: h("flex flex-wrap items-center gap-x-4 gap-y-1", s),
+      ...l,
+      "data-slot": a ?? "chart-legend",
+      children: x(p).map(({ key: d, label: f, color: i, icon: c }) => /* @__PURE__ */ g(
+        m.li,
+        {
+          className: "flex items-center gap-1.5 text-muted-foreground text-xs",
+          "data-slot": "chart-legend-item",
+          children: [
+            c ? /* @__PURE__ */ o("span", { "aria-hidden": !0, className: "shrink-0", style: { color: i }, children: /* @__PURE__ */ o(c, { className: "size-3" }) }) : /* @__PURE__ */ o(u, { color: i, size: "xs" }),
+            f
+          ]
+        },
+        d
+      ))
+    }
+  );
+}
+const D = k("ChartColorLegend", (r, t) => {
+  const { as: e, channel: s = "color", ...a } = r;
+  return {
+    kind: "mark",
+    mark: `${s}Legend`,
+    source: null,
+    options: { ...a, as: e === void 0 ? t.as : e }
+  };
+});
+export {
+  D as ChartColorLegend,
+  b as ChartLegend
+};
+//# sourceMappingURL=chart-legend.js.map

package/dist/charts/chart-legend.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"chart-legend.js","sources":["../../src/charts/chart-legend.tsx"],"sourcesContent":["\"use client\";\n\nimport type React from \"react\";\nimport { ark } from \"@ark-ui/react/factory\";\nimport type { Selection } from \"@uwdata/mosaic-core\";\nimport { cn } from \"../lib/cn.js\";\nimport { Swatch } from \"../simples/swatch.js\";\nimport { chartSeriesEntries, type ChartConfig } from \"./chart-config.js\";\nimport { useChartContextOptional } from \"./chart-root.js\";\nimport { chartDescriptor } from \"./chart-spec.js\";\nimport { categoricalColor } from \"../lib/token-color.js\";\n\nexport interface ChartLegendProps extends React.ComponentProps<typeof ark.ul> {\n  /** Series config. Defaults to the surrounding `<ChartRoot>`'s. */\n  config?: ChartConfig;\n  /** Standalone shorthand: labels in slot order, the i-th on its scheme slot. */\n  series?: readonly string[];\n}\n\nfunction seriesConfig(series: readonly string[]): ChartConfig {\n  return Object.fromEntries(series.map((label, i) => [label, { color: categoricalColor(i) }]));\n}\n\n/**\n * The identity key for a multi-series chart — our DOM, not vgplot's. Colour is never the only\n * channel (dataviz): the label text carries identity and the swatch is `aria-hidden`.\n */\nexport function ChartLegend(props: ChartLegendProps) {\n  const { config, series, className, slot, ...rest } = props;\n  const chart = useChartContextOptional();\n  const resolved = config ?? (series ? seriesConfig(series) : chart?.config) ?? {};\n\n  return (\n    <ark.ul\n      className={cn(\"flex flex-wrap items-center gap-x-4 gap-y-1\", className)}\n      {...rest}\n      data-slot={slot ?? \"chart-legend\"}\n    >\n      {chartSeriesEntries(resolved).map(({ key, label, color, icon: Icon }) => (\n        <ark.li\n          className=\"flex items-center gap-1.5 text-muted-foreground text-xs\"\n          data-slot=\"chart-legend-item\"\n          key={key}\n        >\n          {/* The swatch colour is data, not a variant — the sanctioned inline-style case. */}\n          {Icon ? (\n            <span aria-hidden className=\"shrink-0\" style={{ color }}>\n              <Icon className=\"size-3\" />\n            </span>\n          ) : (\n            <Swatch color={color} size=\"xs\" />\n          )}\n          {label}\n        </ark.li>\n      ))}\n    </ark.ul>\n  );\n}\n\nexport interface ChartColorLegendProps {\n  /**\n   * Where a swatch click publishes. Defaults to `ChartRoot`'s `as`, which makes the legend a\n   * filter; pass `null` for a static key.\n   */\n  as?: Selection | null;\n  /** The column the swatches map to, when it cannot be inferred from the channel. */\n  field?: string;\n  /**\n   * Which scale the swatches read. `color` is the usual one; `opacity` and `symbol` legend a plot\n   * that encodes its series on those channels instead — a scatter keyed by shape, say.\n   */\n  channel?: \"color\" | \"opacity\" | \"symbol\";\n  /** Any other vgplot legend option (`label`, `columns`, `tickSize`, `width`…). */\n  [option: string]: unknown;\n}\n\n/**\n * vgplot's own colour legend — a descriptor, drawn inside the plot element and **interactive**:\n * clicking a swatch toggles that series into the selection. Use `ChartLegend` when you want our\n * DOM and the config's labels and icons; use this one when you want click-to-filter.\n */\nexport const ChartColorLegend = chartDescriptor<ChartColorLegendProps>(\"ChartColorLegend\", (props, ctx) => {\n  const { as, channel = \"color\", ...rest } = props;\n  // A `mark` with `source: null`, not a directive kind of its own. That is the decorator path the\n  // compiler already has for `frame` / `gridX` / `gridY` — options in, no data — and\n  // `colorLegend` / `opacityLegend` / `symbolLegend` are vgplot directives like any other.\n  return {\n    kind: \"mark\",\n    mark: `${channel}Legend`,\n    source: null,\n    options: { ...rest, as: as === undefined ? ctx.as : as },\n  };\n});\n"],"names":[],"mappings":";;;;;;;;;AAmBA;AACE;AACF;AAMO;AACL;AAIA;AACE;AAAK;AAAJ;AACuE;AAClE;AACe;AAGjB;AAAK;AAAJ;AACW;AACA;AAIT;AAKiC;AAEjC;AAAA;AAAA;AAVI;AAYR;AAAA;AAGP;AAwBO;AACL;AAIA;AAAO;AACC;AACU;AACR;AAC4C;AAExD;;;;;"}

package/dist/charts/chart-marks.d.ts

@@ -0,0 +1,124 @@
+import { Selection } from '@uwdata/mosaic-core';
+import { ChartDescriptor } from './chart-spec.js';
+/**
+ * The mark vocabulary. Every component here renders `null` — `ChartRoot` reads the `__chart`
+ * static off the element type and compiles it. `"use client"` is load-bearing even though nothing
+ * here uses a hook: a server-rendered descriptor would collapse to `null` before `ChartRoot`
+ * ever sees it.
+ */
+export interface ChartMarkProps {
+    /**
+     * The selection this mark filters by. Defaults to `ChartRoot`'s; `null` draws the full relation
+     * — the dimmed background layer of a crossfilter pair.
+     */
+    filterBy?: Selection | null;
+    /**
+     * A different relation for this mark alone. The root's `table` is the default, which is right
+     * until a plot needs two — a node-link view draws nodes from one relation and edges from
+     * another, and both still filter by the same selection.
+     */
+    table?: string;
+    /** Literal rows instead of the root's table. */
+    data?: readonly unknown[];
+    /** Positions a rule/tick without a table: `at={0}` is the zero line. */
+    at?: unknown;
+    /** Observable Plot's per-mark hover tooltip. */
+    tip?: boolean;
+    x?: unknown;
+    y?: unknown;
+    z?: unknown;
+    r?: unknown;
+    /** Facet the plot horizontally by this column — one panel per distinct value. */
+    fx?: unknown;
+    /** Facet the plot vertically by this column. */
+    fy?: unknown;
+    /** A column name, or a colour — `var(--chart-1)` / `--primary` tokens are resolved for Plot. */
+    fill?: unknown;
+    /** A column name, or a colour; tokens are resolved the same way. */
+    stroke?: unknown;
+    opacity?: unknown;
+    fillOpacity?: unknown;
+    strokeOpacity?: unknown;
+    strokeWidth?: unknown;
+    sort?: unknown;
+    reverse?: boolean;
+    limit?: number;
+    inset?: number;
+    /** Any other vgplot / Observable Plot mark option. */
+    [option: string]: unknown;
+}
+export declare const ChartBarY: ChartDescriptor<ChartMarkProps>;
+export declare const ChartBarX: ChartDescriptor<ChartMarkProps>;
+export declare const ChartWaffleY: ChartDescriptor<ChartMarkProps>;
+export declare const ChartWaffleX: ChartDescriptor<ChartMarkProps>;
+export declare const ChartLine: ChartDescriptor<ChartMarkProps>;
+export declare const ChartLineY: ChartDescriptor<ChartMarkProps>;
+export declare const ChartLineX: ChartDescriptor<ChartMarkProps>;
+export declare const ChartArea: ChartDescriptor<ChartMarkProps>;
+export declare const ChartAreaY: ChartDescriptor<ChartMarkProps>;
+export declare const ChartAreaX: ChartDescriptor<ChartMarkProps>;
+export declare const ChartDot: ChartDescriptor<ChartMarkProps>;
+export declare const ChartDotX: ChartDescriptor<ChartMarkProps>;
+export declare const ChartDotY: ChartDescriptor<ChartMarkProps>;
+export declare const ChartCircle: ChartDescriptor<ChartMarkProps>;
+export declare const ChartHexagon: ChartDescriptor<ChartMarkProps>;
+export declare const ChartImage: ChartDescriptor<ChartMarkProps>;
+export declare const ChartRect: ChartDescriptor<ChartMarkProps>;
+export declare const ChartRectY: ChartDescriptor<ChartMarkProps>;
+export declare const ChartRectX: ChartDescriptor<ChartMarkProps>;
+export declare const ChartCell: ChartDescriptor<ChartMarkProps>;
+export declare const ChartCellX: ChartDescriptor<ChartMarkProps>;
+export declare const ChartCellY: ChartDescriptor<ChartMarkProps>;
+export declare const ChartRuleY: ChartDescriptor<ChartMarkProps>;
+export declare const ChartRuleX: ChartDescriptor<ChartMarkProps>;
+export declare const ChartTickX: ChartDescriptor<ChartMarkProps>;
+export declare const ChartTickY: ChartDescriptor<ChartMarkProps>;
+export declare const ChartText: ChartDescriptor<ChartMarkProps>;
+export declare const ChartTextX: ChartDescriptor<ChartMarkProps>;
+export declare const ChartTextY: ChartDescriptor<ChartMarkProps>;
+export declare const ChartVector: ChartDescriptor<ChartMarkProps>;
+export declare const ChartVectorX: ChartDescriptor<ChartMarkProps>;
+export declare const ChartVectorY: ChartDescriptor<ChartMarkProps>;
+export declare const ChartSpike: ChartDescriptor<ChartMarkProps>;
+export declare const ChartArrow: ChartDescriptor<ChartMarkProps>;
+export declare const ChartLink: ChartDescriptor<ChartMarkProps>;
+export declare const ChartHeatmap: ChartDescriptor<ChartMarkProps>;
+export declare const ChartRaster: ChartDescriptor<ChartMarkProps>;
+export declare const ChartRasterTile: ChartDescriptor<ChartMarkProps>;
+export declare const ChartContour: ChartDescriptor<ChartMarkProps>;
+export declare const ChartDenseLine: ChartDescriptor<ChartMarkProps>;
+export declare const ChartDensity: ChartDescriptor<ChartMarkProps>;
+export declare const ChartDensityY: ChartDescriptor<ChartMarkProps>;
+export declare const ChartDensityX: ChartDescriptor<ChartMarkProps>;
+export declare const ChartHexbin: ChartDescriptor<ChartMarkProps>;
+export declare const ChartRegressionY: ChartDescriptor<ChartMarkProps>;
+export declare const ChartErrorbarY: ChartDescriptor<ChartMarkProps>;
+export declare const ChartErrorbarX: ChartDescriptor<ChartMarkProps>;
+export declare const ChartVoronoi: ChartDescriptor<ChartMarkProps>;
+export declare const ChartVoronoiMesh: ChartDescriptor<ChartMarkProps>;
+export declare const ChartDelaunayLink: ChartDescriptor<ChartMarkProps>;
+export declare const ChartDelaunayMesh: ChartDescriptor<ChartMarkProps>;
+export declare const ChartHull: ChartDescriptor<ChartMarkProps>;
+export declare const ChartGeo: ChartDescriptor<ChartMarkProps>;
+export declare const ChartFrame: ChartDescriptor<ChartMarkProps>;
+export declare const ChartGridX: ChartDescriptor<ChartMarkProps>;
+export declare const ChartGridY: ChartDescriptor<ChartMarkProps>;
+export declare const ChartHexgrid: ChartDescriptor<ChartMarkProps>;
+export declare const ChartSphere: ChartDescriptor<ChartMarkProps>;
+export declare const ChartGraticule: ChartDescriptor<ChartMarkProps>;
+export interface ChartRawProps {
+    /** A `vg.*` directive, or several — `vg.axisFx({ anchor: "top" })`. */
+    spec: unknown;
+}
+/**
+ * The escape hatch. The wrappers above cover vgplot's mark vocabulary, but not its ~250 attributes
+ * nor the `axisX`/`axisFy` decorator marks the axis descriptors deliberately compile away from.
+ * Anything unwrapped goes in here, in source order, with the same interactor-binding semantics as
+ * a wrapped mark:
+ *
+ * ```tsx
+ * <ChartRaw spec={vg.axisFy({ anchor: "right", tickRotate: 45 })} />
+ * ```
+ */
+export declare const ChartRaw: ChartDescriptor<ChartRawProps>;
+//# sourceMappingURL=chart-marks.d.ts.map

package/dist/charts/chart-marks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chart-marks.d.ts","sourceRoot":"","sources":["../../src/charts/chart-marks.tsx"],"names":[],"mappings":"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"}

package/dist/charts/chart-marks.js

@@ -0,0 +1,109 @@
+import { isColorValue as s, isColorToken as i } from "./chart-config.js";
+import { chartDescriptor as c } from "./chart-spec.js";
+const l = ["fill", "stroke"], u = /* @__PURE__ */ new Set([
+  "barY",
+  "barX",
+  "areaY",
+  "areaX",
+  "area",
+  "rectY",
+  "rectX",
+  "rect",
+  "waffleY",
+  "waffleX"
+]);
+function Y(r, e, n) {
+  if (n) return null;
+  if (r.data !== void 0) return { kind: "values", values: r.data };
+  if (r.at !== void 0) return { kind: "values", values: Array.isArray(r.at) ? r.at : [r.at] };
+  const o = r.table ?? e.table;
+  return o === void 0 ? { kind: "values", values: [{}] } : {
+    kind: "table",
+    table: o,
+    filterBy: r.filterBy === void 0 ? e.filterBy : r.filterBy
+  };
+}
+function X(r, e, n, o) {
+  const a = { ...e };
+  if (delete a.filterBy, delete a.data, delete a.at, delete a.table, u.has(r) && !("z" in a)) {
+    const C = [a.fill, a.stroke].find(
+      (h) => typeof h == "string" && !s(h)
+    );
+    C !== void 0 && (a.z = C);
+  }
+  for (const C of l) {
+    const h = a[C];
+    typeof h == "string" && i(h) && (a[C] = n.resolveColor(h));
+  }
+  return { kind: "mark", mark: r, source: Y(e, n, o), options: a };
+}
+function t(r, e, n = !1) {
+  return c(r, (o, a) => X(e, o, a, n));
+}
+const k = t("ChartBarY", "barY"), y = t("ChartBarX", "barX"), D = t("ChartWaffleY", "waffleY"), R = t("ChartWaffleX", "waffleX"), v = t("ChartLine", "line"), b = t("ChartLineY", "lineY"), g = t("ChartLineX", "lineX"), m = t("ChartArea", "area"), x = t("ChartAreaY", "areaY"), L = t("ChartAreaX", "areaX"), A = t("ChartDot", "dot"), T = t("ChartDotX", "dotX"), w = t("ChartDotY", "dotY"), H = t("ChartCircle", "circle"), V = t("ChartHexagon", "hexagon"), B = t("ChartImage", "image"), G = t("ChartRect", "rect"), S = t("ChartRectY", "rectY"), M = t("ChartRectX", "rectX"), E = t("ChartCell", "cell"), W = t("ChartCellX", "cellX"), I = t("ChartCellY", "cellY"), N = t("ChartRuleY", "ruleY"), z = t("ChartRuleX", "ruleX"), F = t("ChartTickX", "tickX"), K = t("ChartTickY", "tickY"), O = t("ChartText", "text"), _ = t("ChartTextX", "textX"), j = t("ChartTextY", "textY"), q = t("ChartVector", "vector"), J = t("ChartVectorX", "vectorX"), P = t("ChartVectorY", "vectorY"), Q = t("ChartSpike", "spike"), U = t("ChartArrow", "arrow"), Z = t("ChartLink", "link"), $ = t("ChartHeatmap", "heatmap"), p = t("ChartRaster", "raster"), tt = t("ChartRasterTile", "rasterTile"), rt = t("ChartContour", "contour"), at = t("ChartDenseLine", "denseLine"), et = t("ChartDensity", "density"), nt = t("ChartDensityY", "densityY"), ot = t("ChartDensityX", "densityX"), ht = t("ChartHexbin", "hexbin"), Ct = t("ChartRegressionY", "regressionY"), ct = t("ChartErrorbarY", "errorbarY"), st = t("ChartErrorbarX", "errorbarX"), it = t("ChartVoronoi", "voronoi"), lt = t("ChartVoronoiMesh", "voronoiMesh"), ut = t("ChartDelaunayLink", "delaunayLink"), Yt = t("ChartDelaunayMesh", "delaunayMesh"), Xt = t("ChartHull", "hull"), ft = t("ChartGeo", "geo"), dt = t("ChartFrame", "frame", !0), kt = t("ChartGridX", "gridX", !0), yt = t("ChartGridY", "gridY", !0), Dt = t("ChartHexgrid", "hexgrid", !0), Rt = t("ChartSphere", "sphere", !0), vt = t("ChartGraticule", "graticule", !0), bt = c(
+  "ChartRaw",
+  (r) => Array.isArray(r.spec) ? r.spec.map((e) => ({ kind: "raw", value: e })) : { kind: "raw", value: r.spec }
+);
+export {
+  m as ChartArea,
+  L as ChartAreaX,
+  x as ChartAreaY,
+  U as ChartArrow,
+  y as ChartBarX,
+  k as ChartBarY,
+  E as ChartCell,
+  W as ChartCellX,
+  I as ChartCellY,
+  H as ChartCircle,
+  rt as ChartContour,
+  ut as ChartDelaunayLink,
+  Yt as ChartDelaunayMesh,
+  at as ChartDenseLine,
+  et as ChartDensity,
+  ot as ChartDensityX,
+  nt as ChartDensityY,
+  A as ChartDot,
+  T as ChartDotX,
+  w as ChartDotY,
+  st as ChartErrorbarX,
+  ct as ChartErrorbarY,
+  dt as ChartFrame,
+  ft as ChartGeo,
+  vt as ChartGraticule,
+  kt as ChartGridX,
+  yt as ChartGridY,
+  $ as ChartHeatmap,
+  V as ChartHexagon,
+  ht as ChartHexbin,
+  Dt as ChartHexgrid,
+  Xt as ChartHull,
+  B as ChartImage,
+  v as ChartLine,
+  g as ChartLineX,
+  b as ChartLineY,
+  Z as ChartLink,
+  p as ChartRaster,
+  tt as ChartRasterTile,
+  bt as ChartRaw,
+  G as ChartRect,
+  M as ChartRectX,
+  S as ChartRectY,
+  Ct as ChartRegressionY,
+  z as ChartRuleX,
+  N as ChartRuleY,
+  Rt as ChartSphere,
+  Q as ChartSpike,
+  O as ChartText,
+  _ as ChartTextX,
+  j as ChartTextY,
+  F as ChartTickX,
+  K as ChartTickY,
+  q as ChartVector,
+  J as ChartVectorX,
+  P as ChartVectorY,
+  it as ChartVoronoi,
+  lt as ChartVoronoiMesh,
+  R as ChartWaffleX,
+  D as ChartWaffleY
+};
+//# sourceMappingURL=chart-marks.js.map

package/dist/charts/chart-marks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"chart-marks.js","sources":["../../src/charts/chart-marks.tsx"],"sourcesContent":["import type { Selection } from \"@uwdata/mosaic-core\";\nimport { isColorToken, isColorValue } from \"./chart-config.js\";\nimport {\n  chartDescriptor,\n  type ChartDescriptor,\n  type ChartMarkDirective,\n  type ChartMarkSource,\n  type ChartSpecContext,\n} from \"./chart-spec.js\";\n\n/**\n * The mark vocabulary. Every component here renders `null` — `ChartRoot` reads the `__chart`\n * static off the element type and compiles it. `\"use client\"` is load-bearing even though nothing\n * here uses a hook: a server-rendered descriptor would collapse to `null` before `ChartRoot`\n * ever sees it.\n */\n\nexport interface ChartMarkProps {\n  /**\n   * The selection this mark filters by. Defaults to `ChartRoot`'s; `null` draws the full relation\n   * — the dimmed background layer of a crossfilter pair.\n   */\n  filterBy?: Selection | null;\n  /**\n   * A different relation for this mark alone. The root's `table` is the default, which is right\n   * until a plot needs two — a node-link view draws nodes from one relation and edges from\n   * another, and both still filter by the same selection.\n   */\n  table?: string;\n  /** Literal rows instead of the root's table. */\n  data?: readonly unknown[];\n  /** Positions a rule/tick without a table: `at={0}` is the zero line. */\n  at?: unknown;\n  /** Observable Plot's per-mark hover tooltip. */\n  tip?: boolean;\n  x?: unknown;\n  y?: unknown;\n  z?: unknown;\n  r?: unknown;\n  /** Facet the plot horizontally by this column — one panel per distinct value. */\n  fx?: unknown;\n  /** Facet the plot vertically by this column. */\n  fy?: unknown;\n  /** A column name, or a colour — `var(--chart-1)` / `--primary` tokens are resolved for Plot. */\n  fill?: unknown;\n  /** A column name, or a colour; tokens are resolved the same way. */\n  stroke?: unknown;\n  opacity?: unknown;\n  fillOpacity?: unknown;\n  strokeOpacity?: unknown;\n  strokeWidth?: unknown;\n  sort?: unknown;\n  reverse?: boolean;\n  limit?: number;\n  inset?: number;\n  /** Any other vgplot / Observable Plot mark option. */\n  [option: string]: unknown;\n}\n\n/** Only these two channels can hold a colour; everything else keeps its column name. */\nconst COLOR_CHANNELS = [\"fill\", \"stroke\"] as const;\n\n/**\n * Marks that stack, and therefore need a series key.\n *\n * In Observable Plot `z` defaults to `fill`, so a stacked bar coloured by a column just works.\n * Through Mosaic it does not: the fill arrives as `{ value, scale: \"color\" }`, `maybeZ` cannot\n * pull a series name out of that object, and `stackY` silently stacks every row on the previous\n * one — a chart that renders, looks plausible and is wrong, which is worse than one that throws.\n * So we restore Plot's own default: a column-valued `fill`/`stroke` becomes `z` unless the caller\n * set one. `z={null}` opts out (Plot's own way of saying \"do not group\").\n */\nconst STACKING_MARKS = new Set([\n  \"barY\", \"barX\", \"areaY\", \"areaX\", \"area\", \"rectY\", \"rectX\", \"rect\", \"waffleY\", \"waffleX\",\n]);\n\nfunction markSource(props: ChartMarkProps, ctx: ChartSpecContext, decorator: boolean): ChartMarkSource {\n  if (decorator) return null;\n  if (props.data !== undefined) return { kind: \"values\", values: props.data };\n  if (props.at !== undefined) return { kind: \"values\", values: Array.isArray(props.at) ? props.at : [props.at] };\n  const table = props.table ?? ctx.table;\n  if (table === undefined) return { kind: \"values\", values: [{}] };\n  return {\n    kind: \"table\",\n    table,\n    filterBy: props.filterBy === undefined ? ctx.filterBy : props.filterBy,\n  };\n}\n\nfunction markDirective(mark: string, props: ChartMarkProps, ctx: ChartSpecContext, decorator: boolean): ChartMarkDirective {\n  const channels: Record<string, unknown> = { ...props };\n  // `filterBy` / `data` / `at` are our sugar; they choose the source, they are never mark options.\n  delete channels.filterBy;\n  delete channels.data;\n  delete channels.at;\n  delete channels.table;\n  // Read the series key before the colour channels are resolved to `rgb(...)` strings.\n  if (STACKING_MARKS.has(mark) && !(\"z\" in channels)) {\n    const series = [channels.fill, channels.stroke].find(\n      (v) => typeof v === \"string\" && !isColorValue(v),\n    );\n    if (series !== undefined) channels.z = series;\n  }\n  for (const channel of COLOR_CHANNELS) {\n    const value = channels[channel];\n    // `fill=\"host\"` is the *column* host; only a token reference is a colour we must resolve.\n    if (typeof value === \"string\" && isColorToken(value)) channels[channel] = ctx.resolveColor(value);\n  }\n  return { kind: \"mark\", mark, source: markSource(props, ctx, decorator), options: channels };\n}\n\nfunction mark(displayName: string, type: string, decorator = false): ChartDescriptor<ChartMarkProps> {\n  return chartDescriptor<ChartMarkProps>(displayName, (props, ctx) => markDirective(type, props, ctx, decorator));\n}\n\nexport const ChartBarY = mark(\"ChartBarY\", \"barY\");\nexport const ChartBarX = mark(\"ChartBarX\", \"barX\");\nexport const ChartWaffleY = mark(\"ChartWaffleY\", \"waffleY\");\nexport const ChartWaffleX = mark(\"ChartWaffleX\", \"waffleX\");\n\nexport const ChartLine = mark(\"ChartLine\", \"line\");\nexport const ChartLineY = mark(\"ChartLineY\", \"lineY\");\nexport const ChartLineX = mark(\"ChartLineX\", \"lineX\");\nexport const ChartArea = mark(\"ChartArea\", \"area\");\nexport const ChartAreaY = mark(\"ChartAreaY\", \"areaY\");\nexport const ChartAreaX = mark(\"ChartAreaX\", \"areaX\");\n\nexport const ChartDot = mark(\"ChartDot\", \"dot\");\nexport const ChartDotX = mark(\"ChartDotX\", \"dotX\");\nexport const ChartDotY = mark(\"ChartDotY\", \"dotY\");\nexport const ChartCircle = mark(\"ChartCircle\", \"circle\");\nexport const ChartHexagon = mark(\"ChartHexagon\", \"hexagon\");\nexport const ChartImage = mark(\"ChartImage\", \"image\");\n\nexport const ChartRect = mark(\"ChartRect\", \"rect\");\nexport const ChartRectY = mark(\"ChartRectY\", \"rectY\");\nexport const ChartRectX = mark(\"ChartRectX\", \"rectX\");\nexport const ChartCell = mark(\"ChartCell\", \"cell\");\nexport const ChartCellX = mark(\"ChartCellX\", \"cellX\");\nexport const ChartCellY = mark(\"ChartCellY\", \"cellY\");\n\nexport const ChartRuleY = mark(\"ChartRuleY\", \"ruleY\");\nexport const ChartRuleX = mark(\"ChartRuleX\", \"ruleX\");\nexport const ChartTickX = mark(\"ChartTickX\", \"tickX\");\nexport const ChartTickY = mark(\"ChartTickY\", \"tickY\");\nexport const ChartText = mark(\"ChartText\", \"text\");\nexport const ChartTextX = mark(\"ChartTextX\", \"textX\");\nexport const ChartTextY = mark(\"ChartTextY\", \"textY\");\n\nexport const ChartVector = mark(\"ChartVector\", \"vector\");\n// vgplot 0.29.2 builds this one with the mark type `vectoX`, which Observable Plot has no\n// function for. Wrapped for symmetry; use `<ChartVector>` until upstream fixes the typo.\nexport const ChartVectorX = mark(\"ChartVectorX\", \"vectorX\");\nexport const ChartVectorY = mark(\"ChartVectorY\", \"vectorY\");\nexport const ChartSpike = mark(\"ChartSpike\", \"spike\");\nexport const ChartArrow = mark(\"ChartArrow\", \"arrow\");\nexport const ChartLink = mark(\"ChartLink\", \"link\");\n\nexport const ChartHeatmap = mark(\"ChartHeatmap\", \"heatmap\");\nexport const ChartRaster = mark(\"ChartRaster\", \"raster\");\nexport const ChartRasterTile = mark(\"ChartRasterTile\", \"rasterTile\");\nexport const ChartContour = mark(\"ChartContour\", \"contour\");\nexport const ChartDenseLine = mark(\"ChartDenseLine\", \"denseLine\");\nexport const ChartDensity = mark(\"ChartDensity\", \"density\");\nexport const ChartDensityY = mark(\"ChartDensityY\", \"densityY\");\nexport const ChartDensityX = mark(\"ChartDensityX\", \"densityX\");\nexport const ChartHexbin = mark(\"ChartHexbin\", \"hexbin\");\nexport const ChartRegressionY = mark(\"ChartRegressionY\", \"regressionY\");\nexport const ChartErrorbarY = mark(\"ChartErrorbarY\", \"errorbarY\");\nexport const ChartErrorbarX = mark(\"ChartErrorbarX\", \"errorbarX\");\n\nexport const ChartVoronoi = mark(\"ChartVoronoi\", \"voronoi\");\nexport const ChartVoronoiMesh = mark(\"ChartVoronoiMesh\", \"voronoiMesh\");\nexport const ChartDelaunayLink = mark(\"ChartDelaunayLink\", \"delaunayLink\");\nexport const ChartDelaunayMesh = mark(\"ChartDelaunayMesh\", \"delaunayMesh\");\nexport const ChartHull = mark(\"ChartHull\", \"hull\");\nexport const ChartGeo = mark(\"ChartGeo\", \"geo\");\n\n// Decorators: they draw the frame, not the data, so vgplot gives them options and no source.\nexport const ChartFrame = mark(\"ChartFrame\", \"frame\", true);\nexport const ChartGridX = mark(\"ChartGridX\", \"gridX\", true);\nexport const ChartGridY = mark(\"ChartGridY\", \"gridY\", true);\nexport const ChartHexgrid = mark(\"ChartHexgrid\", \"hexgrid\", true);\nexport const ChartSphere = mark(\"ChartSphere\", \"sphere\", true);\nexport const ChartGraticule = mark(\"ChartGraticule\", \"graticule\", true);\n\nexport interface ChartRawProps {\n  /** A `vg.*` directive, or several — `vg.axisFx({ anchor: \"top\" })`. */\n  spec: unknown;\n}\n\n/**\n * The escape hatch. The wrappers above cover vgplot's mark vocabulary, but not its ~250 attributes\n * nor the `axisX`/`axisFy` decorator marks the axis descriptors deliberately compile away from.\n * Anything unwrapped goes in here, in source order, with the same interactor-binding semantics as\n * a wrapped mark:\n *\n * ```tsx\n * <ChartRaw spec={vg.axisFy({ anchor: \"right\", tickRotate: 45 })} />\n * ```\n */\nexport const ChartRaw = chartDescriptor<ChartRawProps>(\"ChartRaw\", (props) =>\n  Array.isArray(props.spec)\n    ? props.spec.map((value: unknown) => ({ kind: \"raw\" as const, value }))\n    : { kind: \"raw\", value: props.spec },\n);\n"],"names":["COLOR_CHANNELS","STACKING_MARKS","markSource","props","ctx","decorator","table","markDirective","mark","channels","series","v","isColorValue","channel","value","isColorToken","displayName","type","chartDescriptor","ChartBarY","ChartBarX","ChartWaffleY","ChartWaffleX","ChartLine","ChartLineY","ChartLineX","ChartArea","ChartAreaY","ChartAreaX","ChartDot","ChartDotX","ChartDotY","ChartCircle","ChartHexagon","ChartImage","ChartRect","ChartRectY","ChartRectX","ChartCell","ChartCellX","ChartCellY","ChartRuleY","ChartRuleX","ChartTickX","ChartTickY","ChartText","ChartTextX","ChartTextY","ChartVector","ChartVectorX","ChartVectorY","ChartSpike","ChartArrow","ChartLink","ChartHeatmap","ChartRaster","ChartRasterTile","ChartContour","ChartDenseLine","ChartDensity","ChartDensityY","ChartDensityX","ChartHexbin","ChartRegressionY","ChartErrorbarY","ChartErrorbarX","ChartVoronoi","ChartVoronoiMesh","ChartDelaunayLink","ChartDelaunayMesh","ChartHull","ChartGeo","ChartFrame","ChartGridX","ChartGridY","ChartHexgrid","ChartSphere","ChartGraticule","ChartRaw"],"mappings":";;AA4DA,MAAMA,IAAiB,CAAC,QAAQ,QAAQ,GAYlCC,wBAAqB,IAAI;AAAA,EAC7B;AAAA,EAAQ;AAAA,EAAQ;AAAA,EAAS;AAAA,EAAS;AAAA,EAAQ;AAAA,EAAS;AAAA,EAAS;AAAA,EAAQ;AAAA,EAAW;AACjF,CAAC;AAED,SAASC,EAAWC,GAAuBC,GAAuBC,GAAqC;AACrG,MAAIA,EAAW,QAAO;AACtB,MAAIF,EAAM,SAAS,OAAW,QAAO,EAAE,MAAM,UAAU,QAAQA,EAAM,KAAA;AACrE,MAAIA,EAAM,OAAO,eAAkB,EAAE,MAAM,UAAU,QAAQ,MAAM,QAAQA,EAAM,EAAE,IAAIA,EAAM,KAAK,CAACA,EAAM,EAAE,EAAA;AAC3G,QAAMG,IAAQH,EAAM,SAASC,EAAI;AACjC,SAAIE,MAAU,SAAkB,EAAE,MAAM,UAAU,QAAQ,CAAC,CAAA,CAAE,EAAA,IACtD;AAAA,IACL,MAAM;AAAA,IACN,OAAAA;AAAA,IACA,UAAUH,EAAM,aAAa,SAAYC,EAAI,WAAWD,EAAM;AAAA,EAAA;AAElE;AAEA,SAASI,EAAcC,GAAcL,GAAuBC,GAAuBC,GAAwC;AACzH,QAAMI,IAAoC,EAAE,GAAGN,EAAA;AAO/C,MALA,OAAOM,EAAS,UAChB,OAAOA,EAAS,MAChB,OAAOA,EAAS,IAChB,OAAOA,EAAS,OAEZR,EAAe,IAAIO,CAAI,KAAK,EAAE,OAAOC,IAAW;AAClD,UAAMC,IAAS,CAACD,EAAS,MAAMA,EAAS,MAAM,EAAE;AAAA,MAC9C,CAACE,MAAM,OAAOA,KAAM,YAAY,CAACC,EAAaD,CAAC;AAAA,IAAA;AAEjD,IAAID,MAAW,WAAWD,EAAS,IAAIC;AAAA,EACzC;AACA,aAAWG,KAAWb,GAAgB;AACpC,UAAMc,IAAQL,EAASI,CAAO;AAE9B,IAAI,OAAOC,KAAU,YAAYC,EAAaD,CAAK,MAAGL,EAASI,CAAO,IAAIT,EAAI,aAAaU,CAAK;AAAA,EAClG;AACA,SAAO,EAAE,MAAM,QAAQ,MAAAN,GAAM,QAAQN,EAAWC,GAAOC,GAAKC,CAAS,GAAG,SAASI,EAAA;AACnF;AAEA,SAASD,EAAKQ,GAAqBC,GAAcZ,IAAY,IAAwC;AACnG,SAAOa,EAAgCF,GAAa,CAACb,GAAOC,MAAQG,EAAcU,GAAMd,GAAOC,GAAKC,CAAS,CAAC;AAChH;AAEO,MAAMc,IAAYX,EAAK,aAAa,MAAM,GACpCY,IAAYZ,EAAK,aAAa,MAAM,GACpCa,IAAeb,EAAK,gBAAgB,SAAS,GAC7Cc,IAAed,EAAK,gBAAgB,SAAS,GAE7Ce,IAAYf,EAAK,aAAa,MAAM,GACpCgB,IAAahB,EAAK,cAAc,OAAO,GACvCiB,IAAajB,EAAK,cAAc,OAAO,GACvCkB,IAAYlB,EAAK,aAAa,MAAM,GACpCmB,IAAanB,EAAK,cAAc,OAAO,GACvCoB,IAAapB,EAAK,cAAc,OAAO,GAEvCqB,IAAWrB,EAAK,YAAY,KAAK,GACjCsB,IAAYtB,EAAK,aAAa,MAAM,GACpCuB,IAAYvB,EAAK,aAAa,MAAM,GACpCwB,IAAcxB,EAAK,eAAe,QAAQ,GAC1CyB,IAAezB,EAAK,gBAAgB,SAAS,GAC7C0B,IAAa1B,EAAK,cAAc,OAAO,GAEvC2B,IAAY3B,EAAK,aAAa,MAAM,GACpC4B,IAAa5B,EAAK,cAAc,OAAO,GACvC6B,IAAa7B,EAAK,cAAc,OAAO,GACvC8B,IAAY9B,EAAK,aAAa,MAAM,GACpC+B,IAAa/B,EAAK,cAAc,OAAO,GACvCgC,IAAahC,EAAK,cAAc,OAAO,GAEvCiC,IAAajC,EAAK,cAAc,OAAO,GACvCkC,IAAalC,EAAK,cAAc,OAAO,GACvCmC,IAAanC,EAAK,cAAc,OAAO,GACvCoC,IAAapC,EAAK,cAAc,OAAO,GACvCqC,IAAYrC,EAAK,aAAa,MAAM,GACpCsC,IAAatC,EAAK,cAAc,OAAO,GACvCuC,IAAavC,EAAK,cAAc,OAAO,GAEvCwC,IAAcxC,EAAK,eAAe,QAAQ,GAG1CyC,IAAezC,EAAK,gBAAgB,SAAS,GAC7C0C,IAAe1C,EAAK,gBAAgB,SAAS,GAC7C2C,IAAa3C,EAAK,cAAc,OAAO,GACvC4C,IAAa5C,EAAK,cAAc,OAAO,GACvC6C,IAAY7C,EAAK,aAAa,MAAM,GAEpC8C,IAAe9C,EAAK,gBAAgB,SAAS,GAC7C+C,IAAc/C,EAAK,eAAe,QAAQ,GAC1CgD,KAAkBhD,EAAK,mBAAmB,YAAY,GACtDiD,KAAejD,EAAK,gBAAgB,SAAS,GAC7CkD,KAAiBlD,EAAK,kBAAkB,WAAW,GACnDmD,KAAenD,EAAK,gBAAgB,SAAS,GAC7CoD,KAAgBpD,EAAK,iBAAiB,UAAU,GAChDqD,KAAgBrD,EAAK,iBAAiB,UAAU,GAChDsD,KAActD,EAAK,eAAe,QAAQ,GAC1CuD,KAAmBvD,EAAK,oBAAoB,aAAa,GACzDwD,KAAiBxD,EAAK,kBAAkB,WAAW,GACnDyD,KAAiBzD,EAAK,kBAAkB,WAAW,GAEnD0D,KAAe1D,EAAK,gBAAgB,SAAS,GAC7C2D,KAAmB3D,EAAK,oBAAoB,aAAa,GACzD4D,KAAoB5D,EAAK,qBAAqB,cAAc,GAC5D6D,KAAoB7D,EAAK,qBAAqB,cAAc,GAC5D8D,KAAY9D,EAAK,aAAa,MAAM,GACpC+D,KAAW/D,EAAK,YAAY,KAAK,GAGjCgE,KAAahE,EAAK,cAAc,SAAS,EAAI,GAC7CiE,KAAajE,EAAK,cAAc,SAAS,EAAI,GAC7CkE,KAAalE,EAAK,cAAc,SAAS,EAAI,GAC7CmE,KAAenE,EAAK,gBAAgB,WAAW,EAAI,GACnDoE,KAAcpE,EAAK,eAAe,UAAU,EAAI,GAChDqE,KAAiBrE,EAAK,kBAAkB,aAAa,EAAI,GAiBzDsE,KAAW5D;AAAA,EAA+B;AAAA,EAAY,CAACf,MAClE,MAAM,QAAQA,EAAM,IAAI,IACpBA,EAAM,KAAK,IAAI,CAACW,OAAoB,EAAE,MAAM,OAAgB,OAAAA,EAAA,EAAQ,IACpE,EAAE,MAAM,OAAO,OAAOX,EAAM,KAAA;AAClC;"}

package/dist/charts/chart-root.d.ts

@@ -0,0 +1,90 @@
+import { ReactNode, default as React } from 'react';
+import { ark } from '@ark-ui/react/factory';
+import { Selection, Coordinator } from '@uwdata/mosaic-core';
+import { ChartConfig } from './chart-config.js';
+import { ChartFacetOptions, ChartMargin } from './chart-spec.js';
+export interface ChartContextValue {
+    /** The active Mosaic coordinator, for a consumer that queries alongside the plot. */
+    coordinator: Coordinator;
+    config: ChartConfig;
+    table?: string;
+    /** What the marks filter by; `null` = the full relation. */
+    filterBy: Selection | null;
+    /** Where the interactors publish. */
+    as: Selection;
+    /**
+     * The series colour, normalised to `rgb(...)` so it is safe for both CSS and Plot. `undefined`
+     * for a key the config does not name.
+     *
+     * Normalising is what makes it dual-purpose and is also what makes it a **snapshot**: the answer
+     * is read off the DOM when you call it, and nothing re-calls it when the theme or the scheme
+     * changes. `ChartLegend` deliberately does not use this — its only sink is a `style`, so it
+     * passes `var(--chart-N)` through and lets the browser follow the theme for free. Take the same
+     * route for anything that only ends up in CSS; pair this with `useThemeTick` when you need the
+     * literal, which is to say when you are handing it to Plot.
+     */
+    color: (key: string) => string | undefined;
+    /** The chart's locale number formatter — one vocabulary for axes, legend and tooltip. */
+    formatNumber: (value: number, options?: Intl.NumberFormatOptions) => string;
+}
+/**
+ * The chart context — config, selections, coordinator, and the `color` / `formatNumber` helpers
+ * that keep a series' identity in one place. Throws outside a `<ChartRoot>`.
+ *
+ * Available to DOM parts (`ChartLegend`, a custom tooltip, a readout). **Not** to descriptors:
+ * `ChartRoot` reads their props off the element before React renders them, so a mark cannot pull
+ * anything out of context — pass the value down from the component that owns the `<ChartRoot>`.
+ */
+export declare function useChartContext(): ChartContextValue;
+/** The chart context, or `null` — for parts that also work standalone, like `ChartLegend`. */
+export declare function useChartContextOptional(): ChartContextValue | null;
+export interface ChartRootProps extends Omit<React.ComponentProps<typeof ark.div>, "children">, ChartFacetOptions {
+    /** The relation registered in the coordinator. Omit it when every mark carries its own `data`. */
+    table?: string;
+    /** What the marks filter by. Defaults to the `<MosaicProvider>` crossfilter; `null` = unfiltered. */
+    filterBy?: Selection | null;
+    /**
+     * Where the child interactors publish, and what `ChartHighlight` reads back. Defaults to a
+     * selection this root owns, relayed into the provider — see the note on `ChartRoot`. Pass one and
+     * you own its wiring: nothing is relayed for you, though the provider's `reset()` still clears it.
+     */
+    as?: Selection;
+    /** Series key → `{ label, color, icon }`. A non-empty config pins the plot's colour scale. */
+    config?: ChartConfig;
+    /** Plot height in px; the width is measured from the container. Default 200. */
+    height?: number;
+    margin?: number | ChartMargin;
+    aspectRatio?: number;
+    /**
+     * Raw `vg.*` directives for anything the layer does not wrap. Applied last, so they win.
+     * Keep the array referentially stable — a new array rebuilds the plot.
+     */
+    attributes?: readonly unknown[];
+    /** BCP-47 tag for `formatNumber`. Defaults to the runtime locale. */
+    locale?: string;
+    /** Default options for `formatNumber` — the chart's number vocabulary in one place. */
+    numberFormat?: Intl.NumberFormatOptions;
+    /** Descriptors (marks, interactors, axes) plus real DOM parts such as `ChartLegend`. */
+    children?: ReactNode;
+    /** Class for the plot host itself, inside the root. */
+    plotClassName?: string;
+}
+/**
+ * Why every chart owns a selection instead of sharing the page's.
+ *
+ * `ChartHighlight` does not filter — it asks the mark's **own** query which rows are selected, by
+ * appending the predicate as an extra output column: `q._groupby.length ? q.select({__: pred})`.
+ * On an aggregating mark that query has a `GROUP BY`, so a predicate naming a column this plot does
+ * not group by is `Binder Error: column "provider" must appear in the GROUP BY clause`. The query
+ * dies, vgplot swallows it, and **the plot keeps its previous render** — no error, no empty state,
+ * nothing but a console line. It costs hours to find, because the symptom looks like a broken
+ * crossfilter three components away.
+ *
+ * A page-wide publish target guarantees that failure the moment a second chart filters by a second
+ * column. So each root publishes into a union of its own: those clauses, by construction, name only
+ * columns this plot's own interactors could produce — which are the columns its marks group by. The
+ * clauses are relayed on into the provider (`selected` → `crossfilter`) with `source` and `clients`
+ * intact, so every other chart filters exactly as before and this one still does not filter itself.
+ */
+export declare function ChartRoot(props: ChartRootProps): React.JSX.Element;
+//# sourceMappingURL=chart-root.d.ts.map

package/dist/charts/chart-root.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chart-root.d.ts","sourceRoot":"","sources":["../../src/charts/chart-root.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAmE,KAAK,SAAS,EAAY,MAAM,OAAO,CAAC;AAClH,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,EAAE,GAAG,EAAE,MAAM,uBAAuB,CAAC;AAC5C,OAAO,EAAE,SAAS,EAAE,KAAK,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAGlE,OAAO,EAAmE,KAAK,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACtH,OAAO,EAML,KAAK,iBAAiB,EACtB,KAAK,WAAW,EAEjB,MAAM,iBAAiB,CAAC;AA+BzB,MAAM,WAAW,iBAAiB;IAChC,qFAAqF;IACrF,WAAW,EAAE,WAAW,CAAC;IACzB,MAAM,EAAE,WAAW,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,4DAA4D;IAC5D,QAAQ,EAAE,SAAS,GAAG,IAAI,CAAC;IAC3B,qCAAqC;IACrC,EAAE,EAAE,SAAS,CAAC;IACd;;;;;;;;;;OAUG;IACH,KAAK,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAC;IAC3C,yFAAyF;IACzF,YAAY,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,IAAI,CAAC,mBAAmB,KAAK,MAAM,CAAC;CAC7E;AAID;;;;;;;GAOG;AACH,wBAAgB,eAAe,IAAI,iBAAiB,CAInD;AAED,8FAA8F;AAC9F,wBAAgB,uBAAuB,IAAI,iBAAiB,GAAG,IAAI,CAElE;AAED,MAAM,WAAW,cACf,SAAQ,IAAI,CAAC,KAAK,CAAC,cAAc,CAAC,OAAO,GAAG,CAAC,GAAG,CAAC,EAAE,UAAU,CAAC,EAC5D,iBAAiB;IACnB,kGAAkG;IAClG,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,qGAAqG;IACrG,QAAQ,CAAC,EAAE,SAAS,GAAG,IAAI,CAAC;IAC5B;;;;OAIG;IACH,EAAE,CAAC,EAAE,SAAS,CAAC;IACf,8FAA8F;IAC9F,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,gFAAgF;IAChF,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,GAAG,WAAW,CAAC;IAC9B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;OAGG;IACH,UAAU,CAAC,EAAE,SAAS,OAAO,EAAE,CAAC;IAChC,qEAAqE;IACrE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,uFAAuF;IACvF,YAAY,CAAC,EAAE,IAAI,CAAC,mBAAmB,CAAC;IACxC,wFAAwF;IACxF,QAAQ,CAAC,EAAE,SAAS,CAAC;IACrB,uDAAuD;IACvD,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAID;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,cAAc,qBAkI9C"}