@pond-ts/charts 0.41.0 → 0.43.0

package/CHANGELOG.md

@@ -3,12 +3,14 @@
 All notable changes to this project are documented here.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
-The `@pond-ts` packages — `pond-ts`, `@pond-ts/react`, `@pond-ts/charts`, and
-`@pond-ts/fit` — release together under a single `v*` tag, so this file covers
-them all. Pre-1.0: minor bumps may include new features and type-level changes;
-patch bumps are strictly additive.
-
-[Unreleased]: https://github.com/pjm17971/pond-ts/compare/v0.41.0...HEAD
+The `@pond-ts` packages — `pond-ts`, `@pond-ts/react`, `@pond-ts/charts`,
+`@pond-ts/fit`, and `@pond-ts/financial` — release together under a single `v*`
+tag, so this file covers them all. Pre-1.0: minor bumps may include new features
+and type-level changes; patch bumps are strictly additive.
+
+[Unreleased]: https://github.com/pjm17971/pond-ts/compare/v0.43.0...HEAD
+[0.43.0]: https://github.com/pjm17971/pond-ts/compare/v0.42.0...v0.43.0
+[0.42.0]: https://github.com/pjm17971/pond-ts/compare/v0.41.0...v0.42.0
 [0.41.0]: https://github.com/pjm17971/pond-ts/compare/v0.40.0...v0.41.0
 [0.40.0]: https://github.com/pjm17971/pond-ts/compare/v0.39.0...v0.40.0
 [0.39.0]: https://github.com/pjm17971/pond-ts/compare/v0.38.0...v0.39.0
@@ -39,6 +41,155 @@ patch bumps are strictly additive.
 
 ## [Unreleased]
 
+## [0.43.0] — 2026-07-11
+
+The **categorical x-axis** release: a first-class ordinal band scale (ticker /
+account / expiry on x — the transpose view of a time series), plus the charts
+**interaction** wave that landed after v0.42.0 was cut — the region cursor and
+its drag-to-select gesture, per-bin band colour, and annotation edges that snap
+to session boundaries.
+
+### Added
+
+- **`@pond-ts/charts`: a first-class categorical x-axis.** `<BarChart
+categories={[{ label, value }]}>` draws one bar per category on an ordinal
+  **band scale** (the transpose view's "columns on x" — ticker / account / zone
+  on x). The container infers `xKind:'category'` and builds a `scaleBand` over the
+  labels; `<CategoryAxis>` ticks once per category. Colour per category via
+  `binColors`; selection reports the category name. **Negative** category values
+  draw below the baseline (the P&L / delta case) — a single-series category bar
+  honours its sign. New exports `scaleBand` / `ScaleBand`, `CategoryAxis`,
+  `categoryStack` / `CategoryDatum`. Additive — a new x-kind alongside time /
+  value; existing charts are unchanged. First slice of the categorical-axis RFC
+  (`docs/rfcs/categorical-axis.md`, Phase 1).
+- **`@pond-ts/charts`: `transposeRow`** — read one **row** of a wide `TimeSeries`
+  **across** into `{ label, value }[]` for `<BarChart categories>`: the schema's
+  numeric columns (a `pivotByGroup` output's per-group columns, a term
+  structure's per-expiry columns) become the categories at one instant. Pick the
+  row with `at` (`'last'` — the head/live row — by default; `'first'`, an index,
+  or `{ time }`); bound / order the set with `columns`.
+- **`@pond-ts/charts`: stable per-column selection identity.** `SelectInfo` gains
+  an optional **`mark`** — a stable per-mark identity within a layer. A categorical
+  bar reports its **column name** as `mark`, and a controlled `selected` echo /
+  the highlight match key on `(id, mark)`, so a pinned selection survives a column
+  reorder (the slot index doesn't; the name does). Additive — `mark` is
+  `undefined` for a time / value bar (whose sample `key` is already its identity).
+  Plus a category-axis **label policy**: a dense axis thins (keeps every k-th) and
+  ellipsis-truncates its labels so they stay legible while every bar draws.
+- **`@pond-ts/charts`: region cursor (`cursor="region"`).** A shaded **band**
+  highlights the bucket under the pointer, bucketed by a new **`cursorSequence`**
+  prop — a `Sequence` (`Sequence.every('15m')`, `Sequence.calendar('week')`)
+  realized over the view, or a `BoundedSequence` (a `TradingCalendar`'s
+  `sessionSequence()` / `barSequence()`) used as-is. The band maps through the x
+  scale, so on a trading-time axis the closed part of a bucket collapses (crops
+  to live sessions). Time-axis only (a no-op on a value axis). (#409, #413)
+- **`@pond-ts/charts`: draggable region cursor → one-shot select.** Opt-in
+  **`onRegionSelect?: (range: TimeRange) => void`** makes the region cursor
+  draggable: the band extends bucket by bucket and fires **once** on release
+  with the selected `[start, end)` `TimeRange` (the cursor doesn't keep it —
+  typical use is to zoom the view). With **no `cursorSequence`** it degenerates
+  to a hover **line** + **freeform** drag. **`regionSelectModifier="shift"`**
+  resolves the gesture conflict with `panZoom` (plain drag pans, shift-drag
+  selects); omitted, a region-drag preempts pan. (#416)
+- **`@pond-ts/charts`: `binColors` — per-bin colour for single-series bars.**
+  `<BarChart binColors={[...]}>` colours each bar/band segment individually (one
+  colour per bin, in order), the single-series analog of the stacked `colors`
+  prop — used by the category axis (colour per category) and any single-series
+  band chart. (#408)
+- **`@pond-ts/charts`: annotation edges snap to session boundaries.** When a
+  `<ChartContainer>` carries a trading calendar (disjoint x axis), dragging a
+  `<Region>` edge (or creating one) snaps to the nearest **session boundary**
+  rather than raw wall-clock, so a drawn span aligns with real market sessions.
+  (#410)
+
+### Fixed
+
+- **`@pond-ts/charts`: region body-move no longer distorts across a session
+  boundary.** On a trading-time (discontinuous) axis, dragging a `<Region>`
+  annotation by its body now translates it rigidly in pixel space, so the box
+  keeps its width as it crosses a collapsed gap (it previously applied one
+  value-delta to both edges, which stretched the box in the different
+  rate-contexts either side of a session boundary). No-op on a continuous axis.
+  (#405)
+
+## [0.42.0] — 2026-07-10
+
+The **trading-calendar** release: a new `@pond-ts/financial` package (its first
+publish) and a discontinuous **trading-time x axis** in `@pond-ts/charts` that
+collapses closed-market time (weekends, holidays, overnight, lunch breaks).
+
+### Added
+
+- **`@pond-ts/financial` — new package (first release).** A calendar/analytics
+  layer on `pond-ts` (peer dep; ESM, no React; `@js-temporal/polyfill` for
+  DST-correct session generation):
+  - **`TradingCalendar`** — `fromSessions` (explicit schedule) and `fromRules`
+    (weekmask / holidays / early-closes / breaks, DST-correct via Temporal);
+    query surface (`sessionOn`, `sessionContaining`, `isOpen`, `sessionsInRange`,
+    `nextSession`, `previousSession`).
+  - **Bucketing seam** — `sessionSequence()` / `barSequence(period)` return a
+    `BoundedSequence` that flows straight through `aggregate` / `materialize`,
+    so every bucket is a real trading session/bar (no weekend/holiday buckets,
+    no bucket spanning a closure). Zero core edits.
+  - **`tagSessions(series, { column?, stamped? })`** — appends a session-id
+    column (`number | undefined`) for `partitionBy` so stateful ops don't bridge
+    a session boundary. `stamped: 'close'` bins a bar stamped at its close into
+    the closing session (`(open, close]`) for OHLC feeds.
+  - **`DiscontinuityProvider`** — the d3fc-style 5-method provider
+    (`clampUp`/`clampDown`/`distance`/`offset`/`copy` + optional `boundaries`);
+    `identityDiscontinuity`, `weekendSkip` (bundled reference), and
+    `segmentDiscontinuity(segments, { spacing })`.
+  - **`TradingCalendar.discontinuities({ range?, spacing?, period? })`** — the
+    chart-ready provider; `spacing: 'proportional'` (default, true-time) or
+    `'uniform'` (equal-width per session/bar, the TradingView ordinal look).
+- **`@pond-ts/charts`: trading-time x axis.** Pass a `@pond-ts/financial`
+  provider (structurally — charts never imports that package) to collapse
+  closed-market gaps:
+  - **`ChartContainer` `discontinuities` prop** (low-level) and **`calendar` +
+    `spacing` props** (high-level sugar; `calendar` is a structural
+    `TradingCalendarLike`, `spacing` defaults to proportional).
+  - **`scaleTradingTime`** — a d3-scale-shaped discontinuous time scale; ticks
+    coarsen to a **calendar grain** (week/month/quarter/year starts) with
+    date/year labels, and **session dividers** draw at the collapse points
+    (`theme.axis.sessionDivider`), aligned with the labels.
+  - `Charts/TradingTimeAxis` stories (weekend/holiday/half-day/intraday,
+    continuous-vs-trading, daily-months, proportional-vs-uniform).
+- **`@pond-ts/charts`: first-class histograms.** `<BarChart>` gains **stacking**
+  — a group-by dimension → stacked segments, from a wide series (`columns`), a
+  `Map<group, TimeSeries>` (the `partitionBy().aggregate().toMap()` shape), or a
+  `byColumn` `bins` array; per-group colour via `colors` or theme roles — and an
+  **`orientation`** prop (`'vertical'` default | `'horizontal'`, bars grow right
+  with the bins on a y band axis). New readers `stacksFromGroups` /
+  `stacksFromColumns` / `stacksFromBins` plus `StackedBarSeries` / `BinRecord` /
+  `Orientation` types. All data generation composes from existing operators
+  (`aggregate` / `byColumn` / `partitionBy`); no core changes. Guide: How-to
+  guides → Histograms. (#401)
+- **`@pond-ts/charts`:** selection now has a stable series identity. `SelectInfo`
+  carries an `id`, and `BarChart` / `ScatterChart` take an optional `id` prop —
+  the series identity used for selection + hover. An `id` **gates interactivity**:
+  a layer is selectable/hoverable only when given one (a layer with no `id`
+  renders and reads out but can't be selected). A dev-warning fires when
+  `selected`/`onSelect` is wired but no layer carries an `id`. First slice of the
+  selection RFC (`docs/rfcs/selection.md`, Amendments 2–3).
+- **`pond-ts`: `bin(W, 'minMaxFirstLast')`** — the four-channel M4 downsampling
+  reducer (per-bin min/max/first/last, validity-aware, chunked-delegating); the
+  foundation for the charts decimator wave.
+- **`pond-ts`: `binBy`** — key-domain bucketed reduction (the M4 gappy-data
+  decimation path).
+
+### Changed
+
+- **BREAKING (`@pond-ts/charts`):** `SelectInfo` gained a required `id` field
+  (`{ id, key, value, color, label }`) — `id` is the selection identity, `key` /
+  `value` are now click provenance. Code that constructs a `SelectInfo` by hand
+  must add `id`, and selection equality/dedup now keys on `id`, not the sample
+  `begin`.
+- **BREAKING (`@pond-ts/charts`):** `BarChart` / `ScatterChart` selection now
+  requires an explicit `id` prop — the previous implicit `as ?? column` selection
+  identity is gone. A selectable bar/scatter layer must add `id` (e.g.
+  `<BarChart series={s} column="v" id="v" />`); without it the layer is
+  display-only.
+
 ## [0.41.0] — 2026-07-06
 
 ### Added

package/dist/BarChart.d.ts

@@ -1,42 +1,123 @@
 import { ValueSeries } from 'pond-ts';
 import type { SeriesSchema, TimeSeries, ValueSeriesSchema } from 'pond-ts';
+import { type BinRecord, type CategoryDatum } from './data.js';
+import { type Orientation } from './bars.js';
 export interface BarChartProps<S extends SeriesSchema = SeriesSchema, VS extends ValueSeriesSchema = ValueSeriesSchema> {
     /**
-     * The source series. **Interval / timeRange-keyed** `TimeSeries` is the primary
-     * form — each event's key `[begin, end]` is a bar's x-span. A **point-keyed**
-     * (`time`) series is supported too: each bar's width is derived from neighbour
-     * spacing (see {@link barsFromTimeSeries}). A **`ValueSeries`**
-     * (`series.byValue('dist')`) bars against its value axis — also point-keyed, so
-     * the same neighbour-spacing span applies (see {@link barsFromValueSeries}); the
-     * container infers the x-kind from the data, no axis-type prop (mirrors the
-     * other layers).
+     * The source series. Provide **exactly one** of `series` or `bins`.
      *
-     * **Live charts:** `series.byValue(…)` mints a *fresh* projection each call, so
-     * an inline `series={s.byValue('dist')}` re-registers this layer every render —
-     * on a frequently re-rendering chart, memoize the projection (`useMemo`).
+     * - A **`TimeSeries`** (interval / timeRange-keyed is the primary form — each
+     *   event's key `[begin, end]` is a bar's x-span; a point-keyed series derives
+     *   its width from neighbour spacing) → single-series bars via `column`, or
+     *   stacked bars from a **wide** series via `columns`.
+     * - A **`ValueSeries`** (`series.byValue('dist')`) bars against its value axis.
+     * - A **`ReadonlyMap<group, TimeSeries>`** — one series per stack group, all on
+     *   the same bin grid, the shape
+     *   `series.partitionBy('host', { groups }).aggregate(seq, m).toMap()` returns.
+     *   Stacked bars, `column` names the shared value column, groups = map order.
+     *
+     * **Live charts:** `series.byValue(…)` / `.toMap()` mint fresh objects each
+     * call, so an inline `series={…}` re-registers this layer every render — on a
+     * frequently re-rendering chart, memoize the projection (`useMemo`).
+     */
+    series?: TimeSeries<S> | ValueSeries<VS> | ReadonlyMap<string, TimeSeries<S>>;
+    /**
+     * `byColumn` **bin records** — `Array<{ start, end, …aggregates }>` from a
+     * value-band aggregation
+     * (`series.byColumn('power', { width: 20 }, { seconds: … })`). The value-axis
+     * alternative to `series`: `column` / `columns` name the aggregate field(s) to
+     * draw. Pair with `ordinal` for a category (band) axis.
+     */
+    bins?: readonly BinRecord[];
+    /**
+     * **Categorical** data — an ordered `{ label, value }[]`, one bar per category
+     * on a first-class **ordinal category x-axis** (the container infers
+     * `xKind:'category'` and builds a band scale over the labels). The transpose
+     * view's "columns on x": each `label` is a category (ticker / account / zone),
+     * `value` its bar height. Provide **exactly one** of `series` / `bins` /
+     * `categories`; `categories` takes no `column`/`columns` and is **vertical only**
+     * (categories on x). Colour per category via `binColors`. (Categorical-axis RFC,
+     * Phase 1.)
      */
-    series: TimeSeries<S> | ValueSeries<VS>;
-    /** Name of the numeric value column for the bar height. */
-    column: string;
+    categories?: readonly CategoryDatum[];
+    /** Name of the numeric value column for the bar height (single series). Provide
+     *  `column` **or** `columns`, not both. */
+    column?: string;
     /**
-     * The series' semantic identifier — what the data _is_ / how it should read.
-     * The theme maps it to a {@link BarStyle} (`theme.bar[as] ?? theme.bar.default`).
-     * **Omitted ⇒ the `default` style** — `column` is the data, `as` is the
-     * identity, and there's no per-component colour override (the single styling
-     * channel; restyle via the theme).
+     * Stacked-segment columns, **bottom → top** — one segment per name. Use with a
+     * **wide** `series` (e.g. `pivotByGroup` output) or with `bins`. Mutually
+     * exclusive with `column`, and invalid with a `Map` series (there the segments
+     * are the map's groups; use `column`).
+     */
+    columns?: readonly string[];
+    /**
+     * The single series' semantic identifier — what the data _is_. The theme maps
+     * it to a {@link BarStyle} (`theme.bar[as] ?? theme.bar.default`). **Single
+     * series only** — **ignored** (not an error) on a stacked chart, which colours
+     * its segments per group instead (see `colors`).
      */
     as?: string;
     /**
-     * Which `<YAxis>` (by its `id`) this bar scales against — picks the *scale*,
-     * where `as` picks the *style* (separate concerns). **Omitted ⇒ the row's
-     * default axis.**
+     * Per-group colour override for a **stacked** chart — `{ group: cssColor }`.
+     * A segment resolves `colors[group] ?? theme.bar[group]?.fill ??
+     * theme.bar.default.fill`, so named roles (e.g. a `crit` band styled in the
+     * theme) come from the theme while ad-hoc groups (five hosts) take a colour
+     * here without minting a theme role. The single styling channel still holds:
+     * this is the stack's one colour input.
+     */
+    colors?: Readonly<Record<string, string>>;
+    /**
+     * **Per-bin** colours for a single-series band chart — `binColors[i]` fills
+     * bar `i` (aligned to the bins / bands in order), overriding the `as`/theme
+     * fill. This is the way to colour heart-rate / power **zones** or value bands
+     * each their own colour (the `colors` map above is per-**group**, for stacks).
+     * An `undefined`/short entry falls back to the theme fill. Meant for a
+     * single-series chart (`column` + `bins`, or a horizontal single series); on a
+     * multi-group stack it would tint every segment of a bin alike, so it's not
+     * the tool there.
+     */
+    binColors?: readonly (string | undefined)[];
+    /**
+     * Bar growth direction (the histogram orientation). **Default `'vertical'`.**
+     *
+     * - `'vertical'` — bars grow **up** from a value baseline, bins on the **x**
+     *   axis (time buckets, value bands). The column / time-histogram look.
+     * - `'horizontal'` — bars grow **right**, bins on the **y** axis (a band axis
+     *   like heart-rate zones). Label the bands with `<YAxis ticks={[{ at, label }]}>`.
+     *
+     * A `'horizontal'` chart puts the **value** on the shared x axis, so its
+     * container's x-kind is `'value'` — it cannot share a `<ChartContainer>` with
+     * time-series rows (each horizontal histogram stands alone). Vertical charts
+     * have no such constraint. The in-chart `flag` / `crosshair` value cursor is
+     * drawn for the **single-series vertical** case only; stacked and horizontal
+     * charts read out via hover / click (`onHover` / `onSelect`).
+     */
+    orientation?: Orientation;
+    /**
+     * For `bins`: lay the bands out as uniform **unit slots** (`[i, i+1]`) instead
+     * of their numeric `[start, end]` edges — an ordinal band axis where every band
+     * reads the same width (heart-rate zones). Ignored for `series`.
+     */
+    ordinal?: boolean;
+    /**
+     * The **stable series identity** for selection + hover — and it **gates
+     * interactivity** (a bar layer is selectable/hoverable only when given an
+     * `id`). For a stack, a clicked / hovered **segment** is identified by
+     * `(id, key = bin begin, label = group)`, so two segments in one bin don't both
+     * light up.
+     */
+    id?: string;
+    /**
+     * Which `<YAxis>` (by its `id`) this layer scales against — the *scale* (`as`
+     * picks the *style*). **Omitted ⇒ the row's default axis.** For a horizontal
+     * histogram this is the **bin (band) axis**; for a vertical one the **value**
+     * axis.
      */
     axis?: string;
     /**
-     * Pixel gap between adjacent bars — each bar's key span is inset by this total
-     * (half each side), so neighbours breathe. **Omitted ⇒ the theme's
-     * `bar[as].gap`.** A span the gap would invert collapses to the style's
-     * `minWidth`, so a too-thin bucket stays visible.
+     * Pixel gap between adjacent bars / bins — the bar's key span is inset by this
+     * total (half each side). **Omitted ⇒ the theme's `bar` `gap`.** A span the gap
+     * would invert collapses to the style's `minWidth`.
      */
     gap?: number;
     /**
@@ -46,43 +127,47 @@ export interface BarChartProps<S extends SeriesSchema = SeriesSchema, VS extends
     index?: number;
 }
 /**
- * A bar draw layer: one rectangle per event, spanning the key's `[begin, end]`
- * (inset by `gap`) from the axis baseline to a numeric `column`'s value. Reads
- * the key endpoints + column into a {@link BarSeries}, registers into the
- * enclosing {@link Layers} (scaling against its `axis`), and renders nothing to
- * the DOM — the row draws it. A gap (missing value) is skipped (no bar).
+ * A bar / histogram draw layer. In its simplest form, one rectangle per event
+ * spanning the key's `[begin, end]` from the axis baseline to a numeric
+ * `column`'s value (see below). It also draws **stacked** bars (a group-by
+ * dimension → segments, `columns` / a `Map` series / `bins`) and **horizontal**
+ * bars (`orientation='horizontal'`, bins on the y axis) — first-class histogram
+ * support. Registers into the enclosing {@link Layers} and renders nothing to the
+ * DOM; the row draws it.
  *
- * **Baseline.** Bars rest on the zero line when the axis domain spans zero (the
- * common all-positive auto-fit case — {@link barExtent} pulls `0` into the
- * domain), or on the axis floor when an explicit `<YAxis min={…}>` sits above
- * zero (see {@link resolveBarBaseline}).
+ * **Data sources.** A time / value `TimeSeries` or `ValueSeries` (`column`), a
+ * wide series or `bins` array (`columns`), or a `Map<group, TimeSeries>`
+ * (`column`) — the last three stack. Every shape composes from pond's own
+ * aggregation (`aggregate` / `byColumn` / `partitionBy`); the histogram guide
+ * has the recipes.
  *
- * **Interaction.** Hover joins the tracker (`sampleAt` → the value of the bar
- * **under the cursor**) and lights that bar (hover-highlight). Click selects the
- * hit bar (`hitTest`); the matching bar — same key **and** this series' `label`,
- * so two series sharing a timestamp don't both light up — draws highlighted
- * (outlined for the committed select, fill-only for the transient hover). Both
- * resolve by **containment**: the tracker by the bar's `[begin, end]` time span
- * (`barIndexAtTime`), the click by the bar's pixel rect (`barAt`) — so the
- * readout reads the same bar you click, even across a wide bucket (they differ
- * only by the `gap` inset, where the pixel rect is narrower than the span).
+ * **Baseline (single, vertical).** Bars rest on the zero line when the axis
+ * domain spans zero, or on the axis floor when an explicit `<YAxis min>` sits
+ * above zero (see {@link resolveBarBaseline}).
  *
- * Both channels are also **controllable from outside** the chart via the
- * container: `selected`/`onSelect` (committed) and `hovered`/`onHover` (transient)
- * — pass either to pin the lit/selected bar from a legend or list row, and read
- * the callback to mirror a bar-originated hover/click out-of-band. Symmetric pair,
- * keyed by the same {@link SelectInfo} identity.
+ * **Baseline (stacked).** A stack is **cumulative from value 0** — the segments
+ * sum upward from the zero line, so its value axis **must include 0**. The
+ * auto-fit guarantees this: {@link stackValueExtent} always returns `[0, maxTotal]`.
+ * An explicit `<YAxis min>` **above** 0 is therefore unsupported for a stack — it
+ * would hide the bottom of the cumulative column; only the portion above the floor
+ * draws (clipped cleanly at the plot floor, as any bar below an explicit floor is).
+ * Segment values are assumed **non-negative** (a negative or zero segment is
+ * skipped — diverging stacks are out of scope).
  *
- * **Value axis** — bars also scale on a value axis when fed a `ValueSeries`
- * (`series.byValue('dist')`): estela's distance-domain splits/laps, one bar per
- * segment over a monotonic axis. A `ValueSeries` is point-keyed, so the span is
- * neighbour-derived like a point `TimeSeries` (see {@link barsFromValueSeries}).
+ * **Interaction (opt-in via `id`).** Hover lights the bar / segment under the
+ * cursor (hit-tested by pixel rect, so it works in both orientations); click
+ * selects it (outlined). A stacked segment's identity is `(id, key = bin begin,
+ * label = group)`. Both channels are controllable from outside via the container
+ * (`selected`/`onSelect`, `hovered`/`onHover`). The in-chart `flag`/`crosshair`
+ * value cursor is single-series-vertical only.
  *
  * ```tsx
  * <Layers>
  *   <BarChart series={hourlyVolume} column="count" />
+ *   <BarChart series={byHost} column="n" colors={{ web1: '#…' }} />
+ *   <BarChart bins={powerDist} column="seconds" orientation="horizontal" ordinal />
  * </Layers>
  * ```
  */
-export declare function BarChart<S extends SeriesSchema = SeriesSchema, VS extends ValueSeriesSchema = ValueSeriesSchema>({ series, column, as: semantic, axis, gap, index, }: BarChartProps<S, VS>): null;
+export declare function BarChart<S extends SeriesSchema = SeriesSchema, VS extends ValueSeriesSchema = ValueSeriesSchema>({ series, bins, categories, column, columns, as: semantic, colors, binColors, orientation, ordinal, id, axis, gap, index, }: BarChartProps<S, VS>): null;
 //# sourceMappingURL=BarChart.d.ts.map