@kanzo-tech/ui 0.0.1-alpha

package/README.md

@@ -0,0 +1,60 @@
+# @kanzo-tech/ui
+
+Kanzo's shared UI surface — **Ark UI** behaviour, **tailwind-variants** appearance, design tokens
+between them. The component set is adopted from [Shark UI](https://shark.vini.one) and re-branded to
+the Kanzo tokens.
+
+```tsx
+import "@kanzo-tech/ui/styles.css";
+import { Button, KanzoThemeProvider } from "@kanzo-tech/ui";
+```
+
+## What is in it
+
+- **`simples/`** — one component, one job: the adopted primitive set (inputs, overlays, menus,
+  navigation, data display) with a flat compound API — `DialogTrigger` and `DialogContent`, not
+  `Dialog.Trigger`.
+- **`composites/`** — assemblies of those that stay domain-free: the sidebar, the code editor, the
+  `Preferences` theme panel.
+- **`layouts/`** — the Shell and Section regions. Structure only, no appearance.
+
+Everything is exported flat from the root, so a component moving between layers is never a breaking
+change. The docs site lists the surface with a live example per component, and its Philosophy page
+says how the three layers divide and what has to be true before a component is added.
+
+## Subpaths
+
+The root barrel never statically imports an optional peer, because that would break
+`import { Button }` for everyone who did not install it. Anything that needs one lives on its own
+entry:
+
+| Entry | Peer |
+|---|---|
+| `@kanzo-tech/ui` | none beyond React and `lucide-react` |
+| `@kanzo-tech/ui/editor` | `@codemirror/*` |
+| `@kanzo-tech/ui/table` | `@tanstack/react-table` |
+| `@kanzo-tech/ui/analytics` | `@uwdata/vgplot`, `@uwdata/mosaic-*`, `@duckdb/duckdb-wasm` |
+
+## Theming
+
+`KanzoThemeProvider` writes the theme axes as `data-*` attributes on `<html>` — required, because
+Ark's overlays portal to `document.body`. `useKanzoTheme()` drives them, `themeScript()` prevents an
+SSR flash. Tokens and axes come from `@kanzo-tech/theme`.
+
+### Preference menus
+
+The editor is a **kit**, not one screen. `PreferencesColor`, `PreferencesDensity`,
+`PreferencesRadius` and the two font axes are one preference each, wired straight to
+`useKanzoTheme()`; `PreferencesField` / `PreferencesFieldSet` title a section of your own the same
+way; `PreferencesSections` draws whatever the packages a host installed contribute. None of them
+knows what it is mounted on — `PreferencesColor` lays its two cards out under a container query,
+never a window width.
+
+`Preferences` (and its `PreferencesRoot` / `Trigger` / `Panel` parts) is one **surface** over that
+kit: a non-modal drawer with a hotkey. A product with a real settings area drops the same sections
+into its own page instead, beside its own menu — no drawer, nothing to opt out of, no component to
+import for it. **Both are first-class**, and a section that ever needed to know which one it was on
+would be the design failing. The docs site shows the two side by side: `showcases/metadata-form` for
+the drawer, `showcases/settings` for the page.
+
+Admission rule: nothing domain-specific — no RDF, SHACL, fossil, graph or auth knowledge.

package/dist/analytics.d.ts

@@ -0,0 +1,36 @@
+export { MosaicProvider, useMosaic, useCrossfilter, useSelected } from './charts/mosaic-provider.js';
+export type { MosaicProviderProps, MosaicContextValue } from './charts/mosaic-provider.js';
+export { ChartRoot, useChartContext, useChartContextOptional } from './charts/chart-root.js';
+export type { ChartRootProps, ChartContextValue } from './charts/chart-root.js';
+export type { ChartConfig, ChartSeriesConfig, ChartSeriesEntry } from './charts/chart-config.js';
+export { chartSeriesColor } from './charts/chart-config.js';
+export { 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, ChartSphere, ChartGraticule, ChartFrame, ChartGridX, ChartGridY, ChartHexgrid, ChartRaw, } from './charts/chart-marks.js';
+export type { ChartMarkProps, ChartRawProps } from './charts/chart-marks.js';
+export { ChartIntervalX, ChartIntervalY, ChartIntervalXY, ChartToggleX, ChartToggleY, ChartToggleColor, ChartPickX, ChartPickY, ChartPickColor, ChartBrushX, ChartBrushY, ChartBrushXY, ChartNearestX, ChartNearestY, ChartRegion, ChartHighlight, ChartPanZoom, } from './charts/chart-interactors.js';
+export type { ChartInteractorProps, ChartHighlightProps, ChartPanZoomProps, } from './charts/chart-interactors.js';
+export { ChartAxisX, ChartAxisY, ChartFacetX, ChartFacetY } from './charts/chart-axes.js';
+export type { ChartAxisXProps, ChartAxisYProps, ChartFacetXProps, ChartFacetYProps, } from './charts/chart-axes.js';
+export { ChartFilter, ChartSearch, ChartSlider } from './charts/chart-inputs.js';
+export type { ChartFilterProps, ChartFilterOption, ChartSearchProps, ChartSliderProps, } from './charts/chart-inputs.js';
+export { useMosaicInput } from './charts/chart-inputs.js';
+export type { MosaicInputOptions, MosaicInputState } from './charts/chart-inputs.js';
+export { ChartLegend, ChartColorLegend } from './charts/chart-legend.js';
+export type { ChartLegendProps, ChartColorLegendProps } from './charts/chart-legend.js';
+export { ChartStat } from './charts/chart-stat.js';
+export type { ChartStatProps } from './charts/chart-stat.js';
+export { useChartQuery, Query } from './charts/use-chart-query.js';
+export type { ChartQueryOptions, ChartQueryResult, ChartQueryRow } from './charts/use-chart-query.js';
+export { chartDescriptor } from './charts/chart-spec.js';
+export type { ChartDescriptor, ChartCompile, ChartDirective, ChartMarkDirective, ChartInteractorDirective, ChartAttributeDirective, ChartRawDirective, ChartSpecContext, ChartSpecOptions, ChartMargin, ChartFacetOptions, ChartMarkSource, } from './charts/chart-spec.js';
+export { Coordinator, Selection, wasmConnector } from '@uwdata/mosaic-core';
+export { loadCSV, loadJSON, loadObjects, loadParquet, loadSpatial, loadExtension, } from '@uwdata/mosaic-sql';
+export { count, sum, avg, min, max, median, quantile, stddev, mode, bin, sql } from '@uwdata/vgplot';
+export type { ExprValue } from '@uwdata/mosaic-sql';
+export { axisX, axisY, axisFx, axisFy, gridFx, gridFy } from '@uwdata/vgplot';
+export { MosaicClient, makeClient, clausePoint, clausePoints, clauseInterval, clauseIntervals, clauseMatch, } from '@uwdata/mosaic-core';
+export type { SelectionClause } from '@uwdata/mosaic-core';
+export type { FilterExpr } from '@uwdata/mosaic-sql';
+export { column, fillColumn, numbers, type NumericArray } from './charts/arrow.js';
+export { IdSetClient } from './charts/id-set-client.js';
+export type { IdSetClientOptions } from './charts/id-set-client.js';
+//# sourceMappingURL=analytics.d.ts.map

package/dist/analytics.d.ts.map

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

package/dist/analytics.js

@@ -0,0 +1,155 @@
+import { MosaicProvider as a, useCrossfilter as e, useMosaic as C, useSelected as h } from "./charts/mosaic-provider.js";
+import { ChartRoot as i, useChartContext as l, useChartContextOptional as n } from "./charts/chart-root.js";
+import { chartSeriesColor as c } from "./charts/chart-config.js";
+import { ChartArea as u, ChartAreaX as m, ChartAreaY as Y, ChartArrow as X, ChartBarX as p, ChartBarY as d, ChartCell as f, ChartCellX as g, ChartCellY as S, ChartCircle as R, ChartContour as D, ChartDelaunayLink as k, ChartDelaunayMesh as y, ChartDenseLine as T, ChartDensity as v, ChartDensityX as F, ChartDensityY as I, ChartDot as L, ChartDotX as P, ChartDotY as M, ChartErrorbarX as b, ChartErrorbarY as A, ChartFrame as H, ChartGeo as V, ChartGraticule as B, ChartGridX as G, ChartGridY as q, ChartHeatmap as w, ChartHexagon as E, ChartHexbin as N, ChartHexgrid as O, ChartHull as Q, ChartImage as W, ChartLine as j, ChartLineX as J, ChartLineY as Z, ChartLink as z, ChartRaster as K, ChartRasterTile as U, ChartRaw as _, ChartRect as $, ChartRectX as rr, ChartRectY as tr, ChartRegressionY as ar, ChartRuleX as er, ChartRuleY as Cr, ChartSphere as hr, ChartSpike as or, ChartText as ir, ChartTextX as lr, ChartTextY as nr, ChartTickX as sr, ChartTickY as cr, ChartVector as xr, ChartVectorX as ur, ChartVectorY as mr, ChartVoronoi as Yr, ChartVoronoiMesh as Xr, ChartWaffleX as pr, ChartWaffleY as dr } from "./charts/chart-marks.js";
+import { ChartBrushX as gr, ChartBrushXY as Sr, ChartBrushY as Rr, ChartHighlight as Dr, ChartIntervalX as kr, ChartIntervalXY as yr, ChartIntervalY as Tr, ChartNearestX as vr, ChartNearestY as Fr, ChartPanZoom as Ir, ChartPickColor as Lr, ChartPickX as Pr, ChartPickY as Mr, ChartRegion as br, ChartToggleColor as Ar, ChartToggleX as Hr, ChartToggleY as Vr } from "./charts/chart-interactors.js";
+import { ChartAxisX as Gr, ChartAxisY as qr, ChartFacetX as wr, ChartFacetY as Er } from "./charts/chart-axes.js";
+import { ChartFilter as Or, ChartSearch as Qr, ChartSlider as Wr, useMosaicInput as jr } from "./charts/chart-inputs.js";
+import { ChartColorLegend as Zr, ChartLegend as zr } from "./charts/chart-legend.js";
+import { ChartStat as Ur } from "./charts/chart-stat.js";
+import { useChartQuery as $r } from "./charts/use-chart-query.js";
+import { chartDescriptor as tt } from "./charts/chart-spec.js";
+import { Coordinator as et, MosaicClient as Ct, Selection as ht, clauseInterval as ot, clauseIntervals as it, clauseMatch as lt, clausePoint as nt, clausePoints as st, makeClient as ct, wasmConnector as xt } from "@uwdata/mosaic-core";
+import { Query as mt, loadCSV as Yt, loadExtension as Xt, loadJSON as pt, loadObjects as dt, loadParquet as ft, loadSpatial as gt } from "@uwdata/mosaic-sql";
+import { avg as Rt, axisFx as Dt, axisFy as kt, axisX as yt, axisY as Tt, bin as vt, count as Ft, gridFx as It, gridFy as Lt, max as Pt, median as Mt, min as bt, mode as At, quantile as Ht, sql as Vt, stddev as Bt, sum as Gt } from "@uwdata/vgplot";
+import { column as wt, fillColumn as Et, numbers as Nt } from "./charts/arrow.js";
+import { IdSetClient as Qt } from "./charts/id-set-client.js";
+export {
+  u as ChartArea,
+  m as ChartAreaX,
+  Y as ChartAreaY,
+  X as ChartArrow,
+  Gr as ChartAxisX,
+  qr as ChartAxisY,
+  p as ChartBarX,
+  d as ChartBarY,
+  gr as ChartBrushX,
+  Sr as ChartBrushXY,
+  Rr as ChartBrushY,
+  f as ChartCell,
+  g as ChartCellX,
+  S as ChartCellY,
+  R as ChartCircle,
+  Zr as ChartColorLegend,
+  D as ChartContour,
+  k as ChartDelaunayLink,
+  y as ChartDelaunayMesh,
+  T as ChartDenseLine,
+  v as ChartDensity,
+  F as ChartDensityX,
+  I as ChartDensityY,
+  L as ChartDot,
+  P as ChartDotX,
+  M as ChartDotY,
+  b as ChartErrorbarX,
+  A as ChartErrorbarY,
+  wr as ChartFacetX,
+  Er as ChartFacetY,
+  Or as ChartFilter,
+  H as ChartFrame,
+  V as ChartGeo,
+  B as ChartGraticule,
+  G as ChartGridX,
+  q as ChartGridY,
+  w as ChartHeatmap,
+  E as ChartHexagon,
+  N as ChartHexbin,
+  O as ChartHexgrid,
+  Dr as ChartHighlight,
+  Q as ChartHull,
+  W as ChartImage,
+  kr as ChartIntervalX,
+  yr as ChartIntervalXY,
+  Tr as ChartIntervalY,
+  zr as ChartLegend,
+  j as ChartLine,
+  J as ChartLineX,
+  Z as ChartLineY,
+  z as ChartLink,
+  vr as ChartNearestX,
+  Fr as ChartNearestY,
+  Ir as ChartPanZoom,
+  Lr as ChartPickColor,
+  Pr as ChartPickX,
+  Mr as ChartPickY,
+  K as ChartRaster,
+  U as ChartRasterTile,
+  _ as ChartRaw,
+  $ as ChartRect,
+  rr as ChartRectX,
+  tr as ChartRectY,
+  br as ChartRegion,
+  ar as ChartRegressionY,
+  i as ChartRoot,
+  er as ChartRuleX,
+  Cr as ChartRuleY,
+  Qr as ChartSearch,
+  Wr as ChartSlider,
+  hr as ChartSphere,
+  or as ChartSpike,
+  Ur as ChartStat,
+  ir as ChartText,
+  lr as ChartTextX,
+  nr as ChartTextY,
+  sr as ChartTickX,
+  cr as ChartTickY,
+  Ar as ChartToggleColor,
+  Hr as ChartToggleX,
+  Vr as ChartToggleY,
+  xr as ChartVector,
+  ur as ChartVectorX,
+  mr as ChartVectorY,
+  Yr as ChartVoronoi,
+  Xr as ChartVoronoiMesh,
+  pr as ChartWaffleX,
+  dr as ChartWaffleY,
+  et as Coordinator,
+  Qt as IdSetClient,
+  Ct as MosaicClient,
+  a as MosaicProvider,
+  mt as Query,
+  ht as Selection,
+  Rt as avg,
+  Dt as axisFx,
+  kt as axisFy,
+  yt as axisX,
+  Tt as axisY,
+  vt as bin,
+  tt as chartDescriptor,
+  c as chartSeriesColor,
+  ot as clauseInterval,
+  it as clauseIntervals,
+  lt as clauseMatch,
+  nt as clausePoint,
+  st as clausePoints,
+  wt as column,
+  Ft as count,
+  Et as fillColumn,
+  It as gridFx,
+  Lt as gridFy,
+  Yt as loadCSV,
+  Xt as loadExtension,
+  pt as loadJSON,
+  dt as loadObjects,
+  ft as loadParquet,
+  gt as loadSpatial,
+  ct as makeClient,
+  Pt as max,
+  Mt as median,
+  bt as min,
+  At as mode,
+  Nt as numbers,
+  Ht as quantile,
+  Vt as sql,
+  Bt as stddev,
+  Gt as sum,
+  l as useChartContext,
+  n as useChartContextOptional,
+  $r as useChartQuery,
+  e as useCrossfilter,
+  C as useMosaic,
+  jr as useMosaicInput,
+  h as useSelected,
+  xt as wasmConnector
+};
+//# sourceMappingURL=analytics.js.map

package/dist/analytics.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"analytics.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;"}

package/dist/charts/arrow.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Reading one column out of whatever a Mosaic query handed back.
+ *
+ * The coordinator answers with an Arrow table, and Arrow only offers a typed column when the type
+ * allows one: `getChild` gives an array for an integer column and nothing usable for a
+ * dictionary-encoded string. Both shapes come back from ordinary queries — an `id` is the first, a
+ * `label` is the second — so a `queryResult` that assumes the typed path is a crash waiting for the
+ * first query that selects a string.
+ *
+ * This is the half of the client protocol the protocol itself does not give you. Declaring a query
+ * and publishing a clause is documented and small; turning the answer into values is where every
+ * call site independently writes `as { getChild(name: string): … }`, which is a cast asserting the
+ * shape rather than checking it.
+ */
+/** Every value in `field`, in row order. */
+export declare function column(data: unknown, field: string): unknown[];
+/** The same, coerced — Arrow hands back `BigInt` for some integer widths. */
+export declare function numbers(data: unknown, field: string): number[];
+/** A pre-sized destination `fillColumn` can write into. */
+export type NumericArray = Float32Array | Float64Array | Uint32Array | Uint16Array | Int32Array;
+/**
+ * One numeric column, written straight into a typed array the caller already owns.
+ *
+ * `numbers()` is the wrong tool once a result is large: `toArray()` already hands back a typed
+ * buffer, and `Array.from(...).map(Number)` turns it into two full-length boxed `number[]` on the
+ * way to a third array that was the actual destination. Three allocations to move nothing. This is
+ * the same pass with none of them — which is what lets a caller size once against its own limit and
+ * fill from the Arrow batches as they arrive.
+ *
+ * `stride` and `offset` are how interleaving is expressed: `x` at `(0, 2)` and `y` at `(1, 2)` fill
+ * one `[x0, y0, x1, y1, …]` buffer with no seam between them.
+ *
+ * Returns how many rows were written, which is `min(rows, capacity)` — a caller that sized against
+ * a `LIMIT` uses it to `subarray` down to what actually came back.
+ */
+export declare function fillColumn(data: unknown, field: string, into: NumericArray, offset?: number, stride?: number): number;
+//# sourceMappingURL=arrow.d.ts.map

package/dist/charts/arrow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arrow.d.ts","sourceRoot":"","sources":["../../src/charts/arrow.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAMH,4CAA4C;AAC5C,wBAAgB,MAAM,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,EAAE,CAI9D;AAED,6EAA6E;AAC7E,wBAAgB,OAAO,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAE9D;AAED,2DAA2D;AAC3D,MAAM,MAAM,YAAY,GAAG,YAAY,GAAG,YAAY,GAAG,WAAW,GAAG,WAAW,GAAG,UAAU,CAAC;AAEhG;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,UAAU,CACxB,IAAI,EAAE,OAAO,EACb,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,YAAY,EAClB,MAAM,SAAI,EACV,MAAM,SAAI,GACT,MAAM,CAiBR"}

package/dist/charts/arrow.js

@@ -0,0 +1,29 @@
+function b(r, n) {
+  var u;
+  const o = (u = r.getChild) == null ? void 0 : u.call(r, n);
+  return o ? Array.from(o.toArray()) : Array.from(r, (c) => c[n]);
+}
+function y(r, n) {
+  return b(r, n).map(Number);
+}
+function g(r, n, o, u = 0, c = 1) {
+  var h, f;
+  const i = Math.max(0, Math.ceil((o.length - u) / c)), t = (f = (h = r.getChild) == null ? void 0 : h.call(r, n)) == null ? void 0 : f.toArray();
+  if (t) {
+    const l = Math.min(t.length, i);
+    for (let m = 0; m < l; m++) o[u + m * c] = Number(t[m]);
+    return l;
+  }
+  let e = 0;
+  for (const l of r) {
+    if (e >= i) break;
+    o[u + e * c] = Number(l[n]), e++;
+  }
+  return e;
+}
+export {
+  b as column,
+  g as fillColumn,
+  y as numbers
+};
+//# sourceMappingURL=arrow.js.map

package/dist/charts/arrow.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"arrow.js","sources":["../../src/charts/arrow.ts"],"sourcesContent":["/**\n * Reading one column out of whatever a Mosaic query handed back.\n *\n * The coordinator answers with an Arrow table, and Arrow only offers a typed column when the type\n * allows one: `getChild` gives an array for an integer column and nothing usable for a\n * dictionary-encoded string. Both shapes come back from ordinary queries — an `id` is the first, a\n * `label` is the second — so a `queryResult` that assumes the typed path is a crash waiting for the\n * first query that selects a string.\n *\n * This is the half of the client protocol the protocol itself does not give you. Declaring a query\n * and publishing a clause is documented and small; turning the answer into values is where every\n * call site independently writes `as { getChild(name: string): … }`, which is a cast asserting the\n * shape rather than checking it.\n */\n\ninterface ArrowLike {\n  getChild?: (name: string) => { toArray(): ArrayLike<unknown> } | null;\n}\n\n/** Every value in `field`, in row order. */\nexport function column(data: unknown, field: string): unknown[] {\n  const child = (data as ArrowLike).getChild?.(field);\n  if (child) return Array.from(child.toArray());\n  return Array.from(data as Iterable<Record<string, unknown>>, (row) => row[field]);\n}\n\n/** The same, coerced — Arrow hands back `BigInt` for some integer widths. */\nexport function numbers(data: unknown, field: string): number[] {\n  return column(data, field).map(Number);\n}\n\n/** A pre-sized destination `fillColumn` can write into. */\nexport type NumericArray = Float32Array | Float64Array | Uint32Array | Uint16Array | Int32Array;\n\n/**\n * One numeric column, written straight into a typed array the caller already owns.\n *\n * `numbers()` is the wrong tool once a result is large: `toArray()` already hands back a typed\n * buffer, and `Array.from(...).map(Number)` turns it into two full-length boxed `number[]` on the\n * way to a third array that was the actual destination. Three allocations to move nothing. This is\n * the same pass with none of them — which is what lets a caller size once against its own limit and\n * fill from the Arrow batches as they arrive.\n *\n * `stride` and `offset` are how interleaving is expressed: `x` at `(0, 2)` and `y` at `(1, 2)` fill\n * one `[x0, y0, x1, y1, …]` buffer with no seam between them.\n *\n * Returns how many rows were written, which is `min(rows, capacity)` — a caller that sized against\n * a `LIMIT` uses it to `subarray` down to what actually came back.\n */\nexport function fillColumn(\n  data: unknown,\n  field: string,\n  into: NumericArray,\n  offset = 0,\n  stride = 1,\n): number {\n  const capacity = Math.max(0, Math.ceil((into.length - offset) / stride));\n  const values = (data as ArrowLike).getChild?.(field)?.toArray();\n  if (values) {\n    const n = Math.min(values.length, capacity);\n    // `Number` is identity on the numeric widths and the conversion on the BigInt ones; either way\n    // it reads an element rather than allocating one.\n    for (let i = 0; i < n; i++) into[offset + i * stride] = Number(values[i]);\n    return n;\n  }\n  let i = 0;\n  for (const row of data as Iterable<Record<string, unknown>>) {\n    if (i >= capacity) break;\n    into[offset + i * stride] = Number(row[field]);\n    i++;\n  }\n  return i;\n}\n"],"names":["column","data","field","_a","child","row","numbers","fillColumn","into","offset","stride","_b","capacity","values","n","i"],"mappings":"AAoBO,SAASA,EAAOC,GAAeC,GAA0B;AAAzD,MAAAC;AACL,QAAMC,KAASD,IAAAF,EAAmB,aAAnB,gBAAAE,EAAA,KAAAF,GAA8BC;AAC7C,SAAIE,IAAc,MAAM,KAAKA,EAAM,SAAS,IACrC,MAAM,KAAKH,GAA2C,CAACI,MAAQA,EAAIH,CAAK,CAAC;AAClF;AAGO,SAASI,EAAQL,GAAeC,GAAyB;AAC9D,SAAOF,EAAOC,GAAMC,CAAK,EAAE,IAAI,MAAM;AACvC;AAoBO,SAASK,EACdN,GACAC,GACAM,GACAC,IAAS,GACTC,IAAS,GACD;AAnCH,MAAAP,GAAAQ;AAoCL,QAAMC,IAAW,KAAK,IAAI,GAAG,KAAK,MAAMJ,EAAK,SAASC,KAAUC,CAAM,CAAC,GACjEG,KAAUF,KAAAR,IAAAF,EAAmB,aAAnB,gBAAAE,EAAA,KAAAF,GAA8BC,OAA9B,gBAAAS,EAAsC;AACtD,MAAIE,GAAQ;AACV,UAAMC,IAAI,KAAK,IAAID,EAAO,QAAQD,CAAQ;AAG1C,aAASG,IAAI,GAAGA,IAAID,GAAGC,IAAK,CAAAP,EAAKC,IAASM,IAAIL,CAAM,IAAI,OAAOG,EAAOE,CAAC,CAAC;AACxE,WAAOD;AAAA,EACT;AACA,MAAIC,IAAI;AACR,aAAWV,KAAOJ,GAA2C;AAC3D,QAAIc,KAAKH,EAAU;AACnB,IAAAJ,EAAKC,IAASM,IAAIL,CAAM,IAAI,OAAOL,EAAIH,CAAK,CAAC,GAC7Ca;AAAA,EACF;AACA,SAAOA;AACT;"}

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

@@ -0,0 +1,59 @@
+import { ChartDescriptor } from './chart-spec.js';
+/**
+ * Scale descriptors: the position scales (`x`/`y`) and the facet scales (`fx`/`fy`).
+ *
+ * They compile to plot **attributes** (`xTickRotate`, `fyGrid`…), not to vgplot's `axisX`/`axisFy`
+ * decorator marks — an attribute cannot become the mark a following interactor binds itself to.
+ * The subset here is what charts actually use; the rest goes through `ChartRoot`'s `attributes`.
+ */
+/** What every scale has, position or facet. */
+interface ChartScalePropsBase {
+    /** Axis label. `null` removes it. */
+    label?: string | null;
+    /** A tick count, an interval name, or explicit tick values. */
+    ticks?: unknown;
+    tickFormat?: unknown;
+    tickSize?: number;
+    tickRotate?: number;
+    grid?: boolean;
+    line?: boolean;
+    domain?: readonly unknown[];
+    reverse?: boolean;
+    inset?: number;
+    padding?: number;
+}
+interface ChartAxisPropsBase extends ChartScalePropsBase {
+    /** `"linear"`, `"log"`, `"band"`, `"utc"`… `null` disables the scale. */
+    scale?: string | null;
+    nice?: boolean | number;
+    zero?: boolean;
+    percent?: boolean;
+}
+export interface ChartAxisXProps extends ChartAxisPropsBase {
+    /** Which side the axis is drawn on; `null` hides it while keeping the scale. */
+    anchor?: "top" | "bottom" | null;
+}
+export interface ChartAxisYProps extends ChartAxisPropsBase {
+    /** Which side the axis is drawn on; `null` hides it while keeping the scale. */
+    anchor?: "left" | "right" | null;
+}
+export interface ChartFacetXProps extends ChartScalePropsBase {
+    /** Which side the facet axis is drawn on; `null` hides it while keeping the panels. */
+    anchor?: "top" | "bottom" | null;
+}
+export interface ChartFacetYProps extends ChartScalePropsBase {
+    /** Which side the facet axis is drawn on; `null` hides it while keeping the panels. */
+    anchor?: "left" | "right" | null;
+}
+export declare const ChartAxisX: ChartDescriptor<ChartAxisXProps>;
+export declare const ChartAxisY: ChartDescriptor<ChartAxisYProps>;
+/**
+ * Small multiples. Plot facets by the `fx` / `fy` channels of a mark — `<ChartBarY fx="region" />`
+ * splits the plot into one panel per region — and these two configure the resulting facet scale,
+ * exactly as `ChartAxisX` / `ChartAxisY` configure the position scales. Panel spacing, cross-panel
+ * grid and the shared facet label are plot-wide, so they live on `ChartRoot` instead.
+ */
+export declare const ChartFacetX: ChartDescriptor<ChartFacetXProps>;
+export declare const ChartFacetY: ChartDescriptor<ChartFacetYProps>;
+export {};
+//# sourceMappingURL=chart-axes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chart-axes.d.ts","sourceRoot":"","sources":["../../src/charts/chart-axes.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAiD,KAAK,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAEtG;;;;;;GAMG;AAEH,+CAA+C;AAC/C,UAAU,mBAAmB;IAC3B,qCAAqC;IACrC,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,+DAA+D;IAC/D,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,MAAM,CAAC,EAAE,SAAS,OAAO,EAAE,CAAC;IAC5B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,UAAU,kBAAmB,SAAQ,mBAAmB;IACtD,yEAAyE;IACzE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,IAAI,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;IACxB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,eAAgB,SAAQ,kBAAkB;IACzD,gFAAgF;IAChF,MAAM,CAAC,EAAE,KAAK,GAAG,QAAQ,GAAG,IAAI,CAAC;CAClC;AAED,MAAM,WAAW,eAAgB,SAAQ,kBAAkB;IACzD,gFAAgF;IAChF,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,GAAG,IAAI,CAAC;CAClC;AAED,MAAM,WAAW,gBAAiB,SAAQ,mBAAmB;IAC3D,uFAAuF;IACvF,MAAM,CAAC,EAAE,KAAK,GAAG,QAAQ,GAAG,IAAI,CAAC;CAClC;AAED,MAAM,WAAW,gBAAiB,SAAQ,mBAAmB;IAC3D,uFAAuF;IACvF,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,GAAG,IAAI,CAAC;CAClC;AA0CD,eAAO,MAAM,UAAU,EAA4C,eAAe,CAAC,eAAe,CAAC,CAAC;AACpG,eAAO,MAAM,UAAU,EAA4C,eAAe,CAAC,eAAe,CAAC,CAAC;AAEpG;;;;;GAKG;AACH,eAAO,MAAM,WAAW,EAA+C,eAAe,CAAC,gBAAgB,CAAC,CAAC;AACzG,eAAO,MAAM,WAAW,EAA+C,eAAe,CAAC,gBAAgB,CAAC,CAAC"}

package/dist/charts/chart-axes.js

@@ -0,0 +1,39 @@
+import { chartDescriptor as F } from "./chart-spec.js";
+const e = {
+  anchor: "Axis",
+  label: "Label",
+  ticks: "Ticks",
+  tickFormat: "TickFormat",
+  tickSize: "TickSize",
+  tickRotate: "TickRotate",
+  grid: "Grid",
+  line: "Line",
+  domain: "Domain",
+  reverse: "Reverse",
+  inset: "Inset",
+  padding: "Padding"
+}, a = {
+  ...e,
+  scale: "Scale",
+  nice: "Nice",
+  zero: "Zero",
+  percent: "Percent"
+};
+function t(n, o, s) {
+  return F(n, (h) => {
+    const i = [];
+    for (const [d, c] of Object.entries(h)) {
+      const r = s[d];
+      r === void 0 || c === void 0 || i.push({ kind: "attribute", name: `${o}${r}`, value: c });
+    }
+    return i;
+  });
+}
+const k = t("ChartAxisX", "x", a), u = t("ChartAxisY", "y", a), x = t("ChartFacetX", "fx", e), C = t("ChartFacetY", "fy", e);
+export {
+  k as ChartAxisX,
+  u as ChartAxisY,
+  x as ChartFacetX,
+  C as ChartFacetY
+};
+//# sourceMappingURL=chart-axes.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chart-axes.js","sources":["../../src/charts/chart-axes.tsx"],"sourcesContent":["import { chartDescriptor, type ChartAttributeDirective, type ChartDescriptor } from \"./chart-spec.js\";\n\n/**\n * Scale descriptors: the position scales (`x`/`y`) and the facet scales (`fx`/`fy`).\n *\n * They compile to plot **attributes** (`xTickRotate`, `fyGrid`…), not to vgplot's `axisX`/`axisFy`\n * decorator marks — an attribute cannot become the mark a following interactor binds itself to.\n * The subset here is what charts actually use; the rest goes through `ChartRoot`'s `attributes`.\n */\n\n/** What every scale has, position or facet. */\ninterface ChartScalePropsBase {\n  /** Axis label. `null` removes it. */\n  label?: string | null;\n  /** A tick count, an interval name, or explicit tick values. */\n  ticks?: unknown;\n  tickFormat?: unknown;\n  tickSize?: number;\n  tickRotate?: number;\n  grid?: boolean;\n  line?: boolean;\n  domain?: readonly unknown[];\n  reverse?: boolean;\n  inset?: number;\n  padding?: number;\n}\n\ninterface ChartAxisPropsBase extends ChartScalePropsBase {\n  /** `\"linear\"`, `\"log\"`, `\"band\"`, `\"utc\"`… `null` disables the scale. */\n  scale?: string | null;\n  nice?: boolean | number;\n  zero?: boolean;\n  percent?: boolean;\n}\n\nexport interface ChartAxisXProps extends ChartAxisPropsBase {\n  /** Which side the axis is drawn on; `null` hides it while keeping the scale. */\n  anchor?: \"top\" | \"bottom\" | null;\n}\n\nexport interface ChartAxisYProps extends ChartAxisPropsBase {\n  /** Which side the axis is drawn on; `null` hides it while keeping the scale. */\n  anchor?: \"left\" | \"right\" | null;\n}\n\nexport interface ChartFacetXProps extends ChartScalePropsBase {\n  /** Which side the facet axis is drawn on; `null` hides it while keeping the panels. */\n  anchor?: \"top\" | \"bottom\" | null;\n}\n\nexport interface ChartFacetYProps extends ChartScalePropsBase {\n  /** Which side the facet axis is drawn on; `null` hides it while keeping the panels. */\n  anchor?: \"left\" | \"right\" | null;\n}\n\n/** prop → attribute suffix; `anchor` is the odd one out, it is the axis attribute itself. */\nconst SCALE_SUFFIX: Record<string, string> = {\n  anchor: \"Axis\",\n  label: \"Label\",\n  ticks: \"Ticks\",\n  tickFormat: \"TickFormat\",\n  tickSize: \"TickSize\",\n  tickRotate: \"TickRotate\",\n  grid: \"Grid\",\n  line: \"Line\",\n  domain: \"Domain\",\n  reverse: \"Reverse\",\n  inset: \"Inset\",\n  padding: \"Padding\",\n};\n\n/** The position scales carry four attributes the facet scales have no equivalent for. */\nconst AXIS_SUFFIX: Record<string, string> = {\n  ...SCALE_SUFFIX,\n  scale: \"Scale\",\n  nice: \"Nice\",\n  zero: \"Zero\",\n  percent: \"Percent\",\n};\n\ntype ScaleProps = ChartScalePropsBase & { anchor?: string | null };\n\nfunction scale(displayName: string, prefix: string, suffixes: Record<string, string>): ChartDescriptor<ScaleProps> {\n  return chartDescriptor(displayName, (props) => {\n    const out: ChartAttributeDirective[] = [];\n    for (const [prop, value] of Object.entries(props)) {\n      const suffix = suffixes[prop];\n      // `undefined` means \"unspecified\"; `null` is a real value (hide the axis, drop the label).\n      if (suffix === undefined || value === undefined) continue;\n      out.push({ kind: \"attribute\", name: `${prefix}${suffix}`, value });\n    }\n    return out;\n  });\n}\n\nexport const ChartAxisX = scale(\"ChartAxisX\", \"x\", AXIS_SUFFIX) as ChartDescriptor<ChartAxisXProps>;\nexport const ChartAxisY = scale(\"ChartAxisY\", \"y\", AXIS_SUFFIX) as ChartDescriptor<ChartAxisYProps>;\n\n/**\n * Small multiples. Plot facets by the `fx` / `fy` channels of a mark — `<ChartBarY fx=\"region\" />`\n * splits the plot into one panel per region — and these two configure the resulting facet scale,\n * exactly as `ChartAxisX` / `ChartAxisY` configure the position scales. Panel spacing, cross-panel\n * grid and the shared facet label are plot-wide, so they live on `ChartRoot` instead.\n */\nexport const ChartFacetX = scale(\"ChartFacetX\", \"fx\", SCALE_SUFFIX) as ChartDescriptor<ChartFacetXProps>;\nexport const ChartFacetY = scale(\"ChartFacetY\", \"fy\", SCALE_SUFFIX) as ChartDescriptor<ChartFacetYProps>;\n"],"names":["SCALE_SUFFIX","AXIS_SUFFIX","scale","displayName","prefix","suffixes","chartDescriptor","props","out","prop","value","suffix","ChartAxisX","ChartAxisY","ChartFacetX","ChartFacetY"],"mappings":";AAwDA,MAAMA,IAAuC;AAAA,EAC3C,QAAQ;AAAA,EACR,OAAO;AAAA,EACP,OAAO;AAAA,EACP,YAAY;AAAA,EACZ,UAAU;AAAA,EACV,YAAY;AAAA,EACZ,MAAM;AAAA,EACN,MAAM;AAAA,EACN,QAAQ;AAAA,EACR,SAAS;AAAA,EACT,OAAO;AAAA,EACP,SAAS;AACX,GAGMC,IAAsC;AAAA,EAC1C,GAAGD;AAAA,EACH,OAAO;AAAA,EACP,MAAM;AAAA,EACN,MAAM;AAAA,EACN,SAAS;AACX;AAIA,SAASE,EAAMC,GAAqBC,GAAgBC,GAA+D;AACjH,SAAOC,EAAgBH,GAAa,CAACI,MAAU;AAC7C,UAAMC,IAAiC,CAAA;AACvC,eAAW,CAACC,GAAMC,CAAK,KAAK,OAAO,QAAQH,CAAK,GAAG;AACjD,YAAMI,IAASN,EAASI,CAAI;AAE5B,MAAIE,MAAW,UAAaD,MAAU,UACtCF,EAAI,KAAK,EAAE,MAAM,aAAa,MAAM,GAAGJ,CAAM,GAAGO,CAAM,IAAI,OAAAD,EAAA,CAAO;AAAA,IACnE;AACA,WAAOF;AAAA,EACT,CAAC;AACH;AAEO,MAAMI,IAAaV,EAAM,cAAc,KAAKD,CAAW,GACjDY,IAAaX,EAAM,cAAc,KAAKD,CAAW,GAQjDa,IAAcZ,EAAM,eAAe,MAAMF,CAAY,GACrDe,IAAcb,EAAM,eAAe,MAAMF,CAAY;"}

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

@@ -0,0 +1,52 @@
+import { ComponentType, ReactNode } from 'react';
+export interface ChartSeriesConfig {
+    /** Rendered by `ChartLegend` and used as the tooltip/legend name. Defaults to the key. */
+    label?: ReactNode;
+    /** `var(--chart-1)`, `--primary`, a hex or an `rgb()`. Tokens are resolved for the plot. */
+    color?: string;
+    /** An optional glyph for the legend row — the non-colour channel a swatch cannot carry alone. */
+    icon?: ComponentType<{
+        className?: string;
+    }>;
+}
+/** Series key → presentation. Feeds the plot's colour scale, `ChartLegend` and the tooltip. */
+export type ChartConfig = Record<string, ChartSeriesConfig>;
+export interface ChartSeriesEntry {
+    key: string;
+    label: ReactNode;
+    color: string;
+    icon?: ComponentType<{
+        className?: string;
+    }>;
+}
+/** A CSS custom property reference — the one colour form Observable Plot cannot parse. */
+export declare function isColorToken(value: string): boolean;
+/**
+ * Is this channel value a **colour**, or the name of a **column**?
+ *
+ * A different question from {@link isColorToken}, which asks only whether we have to resolve the
+ * value ourselves — and answering the second with the first was a bug: `fill="currentColor"` on a
+ * stacking mark was read as a series column, so the query grouped by a colour keyword and died with
+ * a binder error, silently, leaving the plot on its previous render.
+ *
+ * A column named exactly `red` would be read as a colour. That trade is deliberate: passing a
+ * colour is common, naming a column after one is not, and both mistakes are silent — so the tie
+ * goes to the frequent case.
+ */
+export declare function isColorValue(value: string): boolean;
+/** `var(--chart-1, red)` → `--chart-1`. */
+export declare function colorTokenName(value: string): string;
+/** The config in slot order; a series without a colour falls back to its scheme slot token. */
+export declare function chartSeriesEntries(config: ChartConfig): ChartSeriesEntry[];
+/** The colour a series wears — its own, or its scheme slot token. `undefined` if unknown. */
+export declare function chartSeriesColor(config: ChartConfig, key: string): string | undefined;
+/**
+ * The plot's colour scale. Pinning the domain to the config keys is what keeps a hue bound to an
+ * entity: without it vgplot orders the domain by the data, so filtering out a series repaints the
+ * survivors. `null` when the config is empty — no scale attributes are emitted.
+ */
+export declare function chartColorScale(config: ChartConfig): {
+    domain: string[];
+    range: string[];
+} | null;
+//# sourceMappingURL=chart-config.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chart-config.d.ts","sourceRoot":"","sources":["../../src/charts/chart-config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAGtD,MAAM,WAAW,iBAAiB;IAChC,0FAA0F;IAC1F,KAAK,CAAC,EAAE,SAAS,CAAC;IAClB,4FAA4F;IAC5F,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,iGAAiG;IACjG,IAAI,CAAC,EAAE,aAAa,CAAC;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAC9C;AAED,+FAA+F;AAC/F,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC;AAE5D,MAAM,WAAW,gBAAgB;IAC/B,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,SAAS,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,aAAa,CAAC;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAC9C;AAED,0FAA0F;AAC1F,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAEnD;AAcD;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAMnD;AAED,2CAA2C;AAC3C,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAKpD;AAED,+FAA+F;AAC/F,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,WAAW,GAAG,gBAAgB,EAAE,CAO1E;AAED,6FAA6F;AAC7F,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,WAAW,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAIrF;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,WAAW,GAAG;IAAE,MAAM,EAAE,MAAM,EAAE,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAA;CAAE,GAAG,IAAI,CAIjG"}

package/dist/charts/chart-config.js

@@ -0,0 +1,43 @@
+import { categoricalColor as o } from "../lib/token-color.js";
+function t(r) {
+  return r.startsWith("var(--") || r.startsWith("--");
+}
+const n = /^(?:rgba?|hsla?|hwb|lab|lch|oklab|oklch|color|color-mix|light-dark)\(/, i = /^#[0-9a-f]{3,8}$/, s = new Set(
+  "aliceblue antiquewhite aqua aquamarine azure beige bisque black blanchedalmond blue blueviolet brown burlywood cadetblue chartreuse chocolate coral cornflowerblue cornsilk crimson cyan darkblue darkcyan darkgoldenrod darkgray darkgreen darkgrey darkkhaki darkmagenta darkolivegreen darkorange darkorchid darkred darksalmon darkseagreen darkslateblue darkslategray darkslategrey darkturquoise darkviolet deeppink deepskyblue dimgray dimgrey dodgerblue firebrick floralwhite forestgreen fuchsia gainsboro ghostwhite gold goldenrod gray green greenyellow grey honeydew hotpink indianred indigo ivory khaki lavender lavenderblush lawngreen lemonchiffon lightblue lightcoral lightcyan lightgoldenrodyellow lightgray lightgreen lightgrey lightpink lightsalmon lightseagreen lightskyblue lightslategray lightslategrey lightsteelblue lightyellow lime limegreen linen magenta maroon mediumaquamarine mediumblue mediumorchid mediumpurple mediumseagreen mediumslateblue mediumspringgreen mediumturquoise mediumvioletred midnightblue mintcream mistyrose moccasin navajowhite navy oldlace olive olivedrab orange orangered orchid palegoldenrod palegreen paleturquoise palevioletred papayawhip peachpuff peru pink plum powderblue purple rebeccapurple red rosybrown royalblue saddlebrown salmon sandybrown seagreen seashell sienna silver skyblue slateblue slategray slategrey snow springgreen steelblue tan teal thistle tomato turquoise violet wheat white whitesmoke yellow yellowgreen".split(" ")
+);
+function g(r) {
+  const e = r.toLowerCase().trim();
+  return e === "none" || e === "currentcolor" || e === "transparent" || t(e) || e.startsWith("url(") || i.test(e) || n.test(e) ? !0 : s.has(e);
+}
+function c(r) {
+  if (!r.startsWith("var(")) return r.trim();
+  const e = r.slice(4, r.lastIndexOf(")")), l = e.indexOf(",");
+  return (l === -1 ? e : e.slice(0, l)).trim();
+}
+function d(r) {
+  return Object.entries(r).map(([e, l], a) => ({
+    key: e,
+    label: l.label ?? e,
+    color: l.color ?? o(a),
+    icon: l.icon
+  }));
+}
+function h(r, e) {
+  var a;
+  const l = Object.keys(r).indexOf(e);
+  if (l !== -1)
+    return ((a = r[e]) == null ? void 0 : a.color) ?? o(l);
+}
+function m(r) {
+  const e = d(r);
+  return e.length === 0 ? null : { domain: e.map((l) => l.key), range: e.map((l) => l.color) };
+}
+export {
+  m as chartColorScale,
+  h as chartSeriesColor,
+  d as chartSeriesEntries,
+  c as colorTokenName,
+  t as isColorToken,
+  g as isColorValue
+};
+//# sourceMappingURL=chart-config.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chart-config.js","sources":["../../src/charts/chart-config.ts"],"sourcesContent":["import type { ComponentType, ReactNode } from \"react\";\nimport { categoricalColor } from \"../lib/token-color.js\";\n\nexport interface ChartSeriesConfig {\n  /** Rendered by `ChartLegend` and used as the tooltip/legend name. Defaults to the key. */\n  label?: ReactNode;\n  /** `var(--chart-1)`, `--primary`, a hex or an `rgb()`. Tokens are resolved for the plot. */\n  color?: string;\n  /** An optional glyph for the legend row — the non-colour channel a swatch cannot carry alone. */\n  icon?: ComponentType<{ className?: string }>;\n}\n\n/** Series key → presentation. Feeds the plot's colour scale, `ChartLegend` and the tooltip. */\nexport type ChartConfig = Record<string, ChartSeriesConfig>;\n\nexport interface ChartSeriesEntry {\n  key: string;\n  label: ReactNode;\n  color: string;\n  icon?: ComponentType<{ className?: string }>;\n}\n\n/** A CSS custom property reference — the one colour form Observable Plot cannot parse. */\nexport function isColorToken(value: string): boolean {\n  return value.startsWith(\"var(--\") || value.startsWith(\"--\");\n}\n\nconst COLOR_FUNCTION = /^(?:rgba?|hsla?|hwb|lab|lch|oklab|oklch|color|color-mix|light-dark)\\(/;\nconst HEX = /^#[0-9a-f]{3,8}$/;\n\n/**\n * The CSS named colours, so the answer below does not depend on a DOM. Asking `CSS.supports` would\n * be shorter and is what Plot does, but jsdom ships `CSS` without `supports` — the test suite would\n * then disagree with the browser about `fill=\"red\"`, which is worse than carrying the list.\n */\nconst NAMED_COLORS = new Set(\n  (\"aliceblue antiquewhite aqua aquamarine azure beige bisque black blanchedalmond blue blueviolet brown burlywood cadetblue chartreuse chocolate coral cornflowerblue cornsilk crimson cyan darkblue darkcyan darkgoldenrod darkgray darkgreen darkgrey darkkhaki darkmagenta darkolivegreen darkorange darkorchid darkred darksalmon darkseagreen darkslateblue darkslategray darkslategrey darkturquoise darkviolet deeppink deepskyblue dimgray dimgrey dodgerblue firebrick floralwhite forestgreen fuchsia gainsboro ghostwhite gold goldenrod gray green greenyellow grey honeydew hotpink indianred indigo ivory khaki lavender lavenderblush lawngreen lemonchiffon lightblue lightcoral lightcyan lightgoldenrodyellow lightgray lightgreen lightgrey lightpink lightsalmon lightseagreen lightskyblue lightslategray lightslategrey lightsteelblue lightyellow lime limegreen linen magenta maroon mediumaquamarine mediumblue mediumorchid mediumpurple mediumseagreen mediumslateblue mediumspringgreen mediumturquoise mediumvioletred midnightblue mintcream mistyrose moccasin navajowhite navy oldlace olive olivedrab orange orangered orchid palegoldenrod palegreen paleturquoise palevioletred papayawhip peachpuff peru pink plum powderblue purple rebeccapurple red rosybrown royalblue saddlebrown salmon sandybrown seagreen seashell sienna silver skyblue slateblue slategray slategrey snow springgreen steelblue tan teal thistle tomato turquoise violet wheat white whitesmoke yellow yellowgreen\").split(\" \"),\n);\n\n/**\n * Is this channel value a **colour**, or the name of a **column**?\n *\n * A different question from {@link isColorToken}, which asks only whether we have to resolve the\n * value ourselves — and answering the second with the first was a bug: `fill=\"currentColor\"` on a\n * stacking mark was read as a series column, so the query grouped by a colour keyword and died with\n * a binder error, silently, leaving the plot on its previous render.\n *\n * A column named exactly `red` would be read as a colour. That trade is deliberate: passing a\n * colour is common, naming a column after one is not, and both mistakes are silent — so the tie\n * goes to the frequent case.\n */\nexport function isColorValue(value: string): boolean {\n  const v = value.toLowerCase().trim();\n  if (v === \"none\" || v === \"currentcolor\" || v === \"transparent\") return true;\n  if (isColorToken(v) || v.startsWith(\"url(\")) return true;\n  if (HEX.test(v) || COLOR_FUNCTION.test(v)) return true;\n  return NAMED_COLORS.has(v);\n}\n\n/** `var(--chart-1, red)` → `--chart-1`. */\nexport function colorTokenName(value: string): string {\n  if (!value.startsWith(\"var(\")) return value.trim();\n  const inner = value.slice(4, value.lastIndexOf(\")\"));\n  const comma = inner.indexOf(\",\");\n  return (comma === -1 ? inner : inner.slice(0, comma)).trim();\n}\n\n/** The config in slot order; a series without a colour falls back to its scheme slot token. */\nexport function chartSeriesEntries(config: ChartConfig): ChartSeriesEntry[] {\n  return Object.entries(config).map(([key, series], i) => ({\n    key,\n    label: series.label ?? key,\n    color: series.color ?? categoricalColor(i),\n    icon: series.icon,\n  }));\n}\n\n/** The colour a series wears — its own, or its scheme slot token. `undefined` if unknown. */\nexport function chartSeriesColor(config: ChartConfig, key: string): string | undefined {\n  const index = Object.keys(config).indexOf(key);\n  if (index === -1) return undefined;\n  return config[key]?.color ?? categoricalColor(index);\n}\n\n/**\n * The plot's colour scale. Pinning the domain to the config keys is what keeps a hue bound to an\n * entity: without it vgplot orders the domain by the data, so filtering out a series repaints the\n * survivors. `null` when the config is empty — no scale attributes are emitted.\n */\nexport function chartColorScale(config: ChartConfig): { domain: string[]; range: string[] } | null {\n  const entries = chartSeriesEntries(config);\n  if (entries.length === 0) return null;\n  return { domain: entries.map((e) => e.key), range: entries.map((e) => e.color) };\n}\n"],"names":["isColorToken","value","COLOR_FUNCTION","HEX","NAMED_COLORS","isColorValue","v","colorTokenName","inner","comma","chartSeriesEntries","config","key","series","i","categoricalColor","chartSeriesColor","index","_a","chartColorScale","entries","e"],"mappings":";AAuBO,SAASA,EAAaC,GAAwB;AACnD,SAAOA,EAAM,WAAW,QAAQ,KAAKA,EAAM,WAAW,IAAI;AAC5D;AAEA,MAAMC,IAAiB,yEACjBC,IAAM,oBAONC,IAAe,IAAI;AAAA,EACtB,g8CAAi8C,MAAM,GAAG;AAC78C;AAcO,SAASC,EAAaJ,GAAwB;AACnD,QAAMK,IAAIL,EAAM,YAAA,EAAc,KAAA;AAG9B,SAFIK,MAAM,UAAUA,MAAM,kBAAkBA,MAAM,iBAC9CN,EAAaM,CAAC,KAAKA,EAAE,WAAW,MAAM,KACtCH,EAAI,KAAKG,CAAC,KAAKJ,EAAe,KAAKI,CAAC,IAAU,KAC3CF,EAAa,IAAIE,CAAC;AAC3B;AAGO,SAASC,EAAeN,GAAuB;AACpD,MAAI,CAACA,EAAM,WAAW,MAAM,EAAG,QAAOA,EAAM,KAAA;AAC5C,QAAMO,IAAQP,EAAM,MAAM,GAAGA,EAAM,YAAY,GAAG,CAAC,GAC7CQ,IAAQD,EAAM,QAAQ,GAAG;AAC/B,UAAQC,MAAU,KAAKD,IAAQA,EAAM,MAAM,GAAGC,CAAK,GAAG,KAAA;AACxD;AAGO,SAASC,EAAmBC,GAAyC;AAC1E,SAAO,OAAO,QAAQA,CAAM,EAAE,IAAI,CAAC,CAACC,GAAKC,CAAM,GAAGC,OAAO;AAAA,IACvD,KAAAF;AAAA,IACA,OAAOC,EAAO,SAASD;AAAA,IACvB,OAAOC,EAAO,SAASE,EAAiBD,CAAC;AAAA,IACzC,MAAMD,EAAO;AAAA,EAAA,EACb;AACJ;AAGO,SAASG,EAAiBL,GAAqBC,GAAiC;;AACrF,QAAMK,IAAQ,OAAO,KAAKN,CAAM,EAAE,QAAQC,CAAG;AAC7C,MAAIK,MAAU;AACd,aAAOC,IAAAP,EAAOC,CAAG,MAAV,gBAAAM,EAAa,UAASH,EAAiBE,CAAK;AACrD;AAOO,SAASE,EAAgBR,GAAmE;AACjG,QAAMS,IAAUV,EAAmBC,CAAM;AACzC,SAAIS,EAAQ,WAAW,IAAU,OAC1B,EAAE,QAAQA,EAAQ,IAAI,CAACC,MAAMA,EAAE,GAAG,GAAG,OAAOD,EAAQ,IAAI,CAACC,MAAMA,EAAE,KAAK,EAAA;AAC/E;"}