@fundar/data-chart-telling 0.0.13 → 0.0.15

package/dist/types/plots/segments/common.d.ts

@@ -0,0 +1,25 @@
+import type { StrokeStyle, DotStyle } from '../styling';
+/** Per-segment styling for a line: its stroke and/or its endpoint dots. */
+export type LineSegmentStyle = {
+    stroke?: StrokeStyle;
+    dots?: DotStyle;
+};
+/** Per-segment styling for a bar-shaped mark: its fill. Shared by `BarPlot` and `PyramidPlot`. */
+export type BarSegmentStyle = {
+    fill?: string;
+    fillOpacity?: number;
+};
+/** Per-cell styling override for a heatmap cell. */
+export type CellSegmentStyle = {
+    fill?: string;
+    fillOpacity?: number;
+    stroke?: string;
+    strokeWidth?: number;
+};
+/** Per-feature styling override for `GeoPlot` — the geo analog of `CellSegmentStyle`. */
+export type GeoSegmentStyle = {
+    fill?: string;
+    fillOpacity?: number;
+    stroke?: string;
+    strokeWidth?: number;
+};

package/dist/types/plots/segments/common.js

@@ -0,0 +1 @@
+export {};

package/dist/types/plots/segments/config.d.ts

@@ -0,0 +1,51 @@
+import type { AxisValue } from '../axis';
+import type { Series } from '../data/common';
+import type { LineSegmentStyle } from './common';
+/** A half-open interval on one axis. Both bounds are inclusive; omit either to leave that end open. */
+export type Range = {
+    from?: AxisValue;
+    to?: AxisValue;
+};
+/**
+ * A 2-D rectangular area on the plot, addressed by optional x and y intervals.
+ * Omitting an interval leaves that axis unrestricted (matches all values).
+ *
+ * - For line/bar/pyramid plots only the `x` interval is used (the series' primary
+ *   axis); `y` is evaluated but filters by the series' value axis.
+ * - For heatmaps both `x` (column) and `y` (row) are used to address cells.
+ */
+export type Area = {
+    x?: Range;
+    y?: Range;
+};
+/**
+ * One styled rule for a plot. A data point (or cell) is styled when it falls
+ * inside **any** of the listed `areas`. Omitting `areas` (or passing an empty
+ * array) makes the segment a catch-all that matches every data point — useful
+ * as a baseline style. `TStyle` is the per-mark shape ({@link LineSegmentStyle},
+ * {@link BarSegmentStyle}, {@link CellSegmentStyle}, …).
+ *
+ * Catch-alls are evaluated last so that area-specific segments always take
+ * priority, regardless of their position in the list. A catch-all placed first
+ * therefore acts as a fallback baseline that area-specific segments override.
+ */
+export type Segment<TStyle> = {
+    areas?: Area[];
+    style?: TStyle;
+};
+/** One contiguous, styled slice of a series' data — ready to draw as its own mark. */
+export type VisualSegment<T extends Record<string, unknown>, TStyle = LineSegmentStyle> = {
+    data: T[];
+    style: TStyle;
+};
+/**
+ * A series split into its styled visual segments. `S` is the full series
+ * type Series<T> — its row type is read off `S['data']`
+ * rather than taken as a separate parameter, since TypeScript can't reliably
+ * infer a type parameter that only appears inside another parameter's
+ * constraint.
+ */
+export type VisualGroup<S extends Series<any>, TStyle = LineSegmentStyle> = {
+    series: S;
+    visualSegments: VisualSegment<S['data'][number], TStyle>[];
+};

package/dist/types/plots/segments/config.js

@@ -0,0 +1 @@
+export {};

package/dist/types/plots/styles/common.d.ts

@@ -0,0 +1,37 @@
+import type { ValueAnchor } from '../constants';
+import type { FontStyle } from '../styling';
+/**
+ * Controls if and how value labels are rendered on a plot. The high-level
+ * `anchor` sets sensible defaults for placement; the inherited {@link FontStyle}
+ * fields (`dx`, `dy`, `textAnchor`, `lineAnchor`, `lineHeight`, `rotate`,
+ * `class`, `textClass`, `fill`, …) override those defaults when provided.
+ */
+export type ValuesStyle = FontStyle & {
+    show?: boolean;
+    anchor?: ValueAnchor;
+    /** Called with the numeric value and the series name. Return a string to render. */
+    format?: (value: number, seriesName: string) => string;
+};
+/**
+ * Color overrides for plots that derive their palette from data.
+ * Each plot uses only the fields relevant to its kind; unused fields are
+ * silently ignored.
+ *
+ * - `min` / `max` — sequential colour ramp endpoints (heatmap).
+ * - `left` / `right` — diverging bar sides (pyramid).
+ */
+export type ColorsStyle = {
+    min?: string;
+    max?: string;
+    left?: string;
+    right?: string;
+};
+/**
+ * Top-level rendering style overrides shared by the non-geo plot kinds.
+ * Passed as the `styles` prop. Each plot reads only the fields it cares
+ * about.
+ */
+export type BasePlotStyles = {
+    values?: ValuesStyle;
+    colors?: ColorsStyle;
+};

package/dist/types/plots/styles/common.js

@@ -0,0 +1 @@
+export {};

package/dist/types/plots/styles/geo.d.ts

@@ -0,0 +1,42 @@
+import type { ColorsStyle } from './common';
+import type { GeoFeature } from '../data/geo';
+export type GeoTileLayerConfig = {
+    /** XYZ tile URL template, e.g. `'https://tile.openstreetmap.org/{z}/{x}/{y}.png'`. */
+    url: string;
+    attribution?: string;
+    opacity?: number;
+    minZoom?: number;
+    maxZoom?: number;
+    /** Tile edge length in pixels. Defaults to `256`. */
+    tileSize?: number;
+};
+export type GeoZoomConfig = {
+    min?: number;
+    max?: number;
+    initial?: {
+        x?: number;
+        y?: number;
+        k?: number;
+    };
+};
+/**
+ * `styles` prop for GeoPlot — the geo analog of `BasePlotStyles`. Unlike the
+ * other plot kinds, GeoPlot's styling needs (base map, choropleth ramp, tile
+ * background, zoom, click handling) are unlike anything x/y plots need, so
+ * this is its own type rather than a reuse of `BasePlotStyles`.
+ */
+export type GeoStyles<TProps extends Record<string, unknown> = Record<string, unknown>> = {
+    /** Base map fill, used when a feature isn't styled by `segments` or the choropleth ramp. */
+    fill?: string;
+    fillOpacity?: number;
+    stroke?: string;
+    strokeWidth?: number;
+    /** Continuous choropleth ramp endpoints — used when `value` is provided on data. Mirrors heatmap's `styles.colors`. */
+    colors?: ColorsStyle;
+    /** Raster XYZ tile basemap under the vector geometry. Mercator-family projections only. */
+    tileLayer?: GeoTileLayerConfig;
+    /** `true`/config enables drag-pan + scroll-zoom. Omitted/`false` = static map. */
+    zoom?: boolean | GeoZoomConfig;
+    /** Fired when a base-map feature is clicked. */
+    onFeatureClick?: (feature: GeoFeature<TProps>, event: Event) => void;
+};

package/dist/types/plots/styles/geo.js

@@ -0,0 +1 @@
+export {};

package/dist/types/plots/styling.d.ts

@@ -0,0 +1,45 @@
+import type { FontWeight, FontStyleKeyword, TextAnchor, LineAnchor, LineStyle, LineCap, LineJoin, SymbolType } from './constants';
+/** Text/label styling for any text mark — a marker's label, an annotation, a value label. */
+export type FontStyle = {
+    fill?: string;
+    fontSize?: number;
+    fontWeight?: FontWeight;
+    fontStyle?: FontStyleKeyword;
+    textAnchor?: TextAnchor;
+    lineAnchor?: LineAnchor;
+    lineHeight?: number;
+    rotate?: number;
+    stroke?: string;
+    strokeWidth?: number;
+    paintOrder?: string;
+    dx?: number;
+    dy?: number;
+    class?: string;
+    textClass?: string;
+};
+/** Stroke styling for any line-ish mark — a line, a rule, a marker's connector. */
+export type StrokeStyle = {
+    stroke?: string;
+    strokeWidth?: number;
+    strokeOpacity?: number;
+    strokeDasharray?: string | LineStyle;
+    strokeLinecap?: LineCap;
+    strokeLinejoin?: LineJoin;
+};
+/**
+ * Dot styling for any point mark — a line's endpoint dots, a marker's dot.
+ * Carries its own `dotStroke*` fields rather than nesting a {@link StrokeStyle},
+ * because a dot's outline is a distinct style from the stroke of the line (or
+ * other mark) it sits next to — e.g. a `LineSegmentStyle` styles its
+ * line's stroke and its dots' outline independently.
+ */
+export type DotStyle = {
+    dotRadius?: number;
+    dotFill?: string;
+    dotFillOpacity?: number;
+    dotSymbol?: SymbolType;
+    dotStroke?: string;
+    dotStrokeWidth?: number;
+    dotStrokeOpacity?: number;
+    dotStrokeDasharray?: string | LineStyle;
+};

package/dist/types/plots/styling.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/grouping.d.ts

@@ -1,4 +1,5 @@
-import type { Series, AxisValue, Accessor } from '../types/plots/common';
+import type { AxisValue } from '../types/plots/axis';
+import type { Series, Accessor } from '../types/plots/data/common';
 /**
  * Splits rows into ordered groups keyed by the stringified accessor value.
  * Insertion order of first appearance is preserved, which keeps colours stable

package/dist/utils/interpolate.d.ts

@@ -1,6 +1,7 @@
 import type { EasingName, EasingFn } from '../types/charts/interpolate';
 import type { TimeValue, TimelineInterpolation } from '../types/charts/common';
-import type { Accessor, AxisValue } from '../types/plots/common';
+import type { AxisValue } from '../types/plots/axis';
+import type { Accessor } from '../types/plots/data/common';
 export declare function resolveEasing(easing?: EasingName | EasingFn): EasingFn;
 /**
  * Brackets a continuous target position `x` within one key-group's sorted

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fundar/data-chart-telling",
-  "version": "0.0.13",
+  "version": "0.0.15",
   "type": "module",
   "files": [
     "dist"
@@ -18,46 +18,60 @@
     }
   },
   "dependencies": {
-    "d3-interpolate": "^3.0.1"
+    "@types/geojson": "^7946.0.16",
+    "d3-geo": "^3.1.1",
+    "d3-interpolate": "^3.0.1",
+    "d3-selection": "^3.0.0",
+    "d3-zoom": "^3.0.0"
   },
   "peerDependencies": {
     "svelte": "^5.0.0",
-    "svelteplot": "^0.14.0"
+    "svelteplot": "^0.14.0",
+    "topojson-client": "^3.1.0"
+  },
+  "peerDependenciesMeta": {
+    "topojson-client": {
+      "optional": true
+    }
   },
   "devDependencies": {
+    "@chromatic-com/storybook": "^5.2.1",
     "@eslint/compat": "^2.0.4",
     "@eslint/js": "^10.0.1",
+    "@storybook/addon-a11y": "^10.4.1",
+    "@storybook/addon-docs": "^10.4.1",
+    "@storybook/addon-svelte-csf": "^5.1.2",
+    "@storybook/addon-vitest": "^10.4.1",
+    "@storybook/svelte-vite": "^10.4.1",
     "@sveltejs/package": "^2.5.7",
     "@sveltejs/vite-plugin-svelte": "^7.0.0",
+    "@types/d3-geo": "^3.1.0",
     "@types/d3-interpolate": "^3.0.4",
+    "@types/d3-selection": "^3.0.11",
+    "@types/d3-zoom": "^3.0.8",
     "@types/node": "^22",
     "@vitest/browser": "^4.1.7",
     "@vitest/browser-playwright": "^4.1.7",
+    "@vitest/coverage-v8": "4.1.7",
     "eslint": "^10.2.0",
     "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-storybook": "^10.4.1",
     "eslint-plugin-svelte": "^3.17.0",
     "globals": "^17.4.0",
     "playwright": "^1.60.0",
     "prettier": "^3.8.1",
     "prettier-plugin-svelte": "^3.5.1",
     "publint": "^0.3.18",
+    "storybook": "^10.4.1",
     "svelte": "^5.55.2",
     "svelte-check": "^4.4.6",
     "svelteplot": "^0.14.0",
+    "topojson-client": "^3.1.0",
     "typescript": "^6.0.2",
     "typescript-eslint": "^8.58.1",
     "vite": "^8.0.7",
     "vitest": "^4.1.3",
-    "vitest-browser-svelte": "^2.1.1",
-    "storybook": "^10.4.1",
-    "@storybook/svelte-vite": "^10.4.1",
-    "@storybook/addon-svelte-csf": "^5.1.2",
-    "@chromatic-com/storybook": "^5.2.1",
-    "@storybook/addon-vitest": "^10.4.1",
-    "@storybook/addon-a11y": "^10.4.1",
-    "@storybook/addon-docs": "^10.4.1",
-    "eslint-plugin-storybook": "^10.4.1",
-    "@vitest/coverage-v8": "4.1.7"
+    "vitest-browser-svelte": "^2.1.1"
   },
   "keywords": [
     "svelte"

package/dist/layout/plot/PlotLayout.svelte

@@ -1,237 +0,0 @@
-<script lang="ts" generics="TData extends Record<string, unknown>">
-  import type { ComponentProps, Snippet } from 'svelte';
-  import { Plot, Pointer, RuleX, RuleY, AxisX, AxisY } from 'svelteplot';
-  import { getConfiguration } from '../../configuration/config.svelte';
-  import { getHover, createHover } from '../tooltip/hover.svelte';
-  import { createHoverController } from '../tooltip/controller.svelte';
-  import { hasHoverMarker, findHoverMarker } from '../tooltip/utils';
-  import HoverMarker from '../../plots/markers/HoverMarker.svelte';
-  import Tooltip from '../tooltip/Tooltip.svelte';
-  import type { AxisValue, Series, ScalesConfig, MarginConfig } from '../../types/plots/common';
-  import type { Marker } from '../../types/plots/markers';
-  import type { HoverStrategy, HoverDisplayPoint, HoverPoint, TooltipRuntime } from '../../types/layout/tooltip';
-
-  type SveltePlotProps = ComponentProps<typeof Plot>;
-
-  /**
-   * Shared chrome around every plot kind's svelteplot markup: the pointer-event
-   * wrapper, the hover/tooltip state machine, the `<Plot>` element itself plus
-   * standalone markers (`ruleX`/`ruleY`/un-scoped `component`) and the floating
-   * tooltip. A plot kind only supplies its data/accessors and its marks
-   * (`<Line>`/`<BarY>`/`<Cell>`, …) through `children`.
-   */
-  let {
-    width,
-    height,
-    x,
-    y,
-    data,
-    getX,
-    getY,
-    matchY,
-    hoverPoints,
-    label,
-    tooltip = undefined,
-    markers = [],
-    seriesData = [],
-    showHoverLabels = true,
-    scales,
-    margins,
-    defaultStrategy = 'x',
-    children,
-  }: {
-    width: number;
-    height: number;
-    x?: SveltePlotProps['x'];
-    y?: SveltePlotProps['y'];
-    /** Flat rows fed to svelteplot's `<Pointer>` for nearest-point matching. */
-    data: TData[];
-    getX: (d: TData) => AxisValue;
-    getY: (d: TData) => AxisValue;
-    /** Pointer's `y` channel — only needed when matching must be 2D (e.g. a heatmap grid). */
-    matchY?: (d: TData) => AxisValue;
-    hoverPoints: HoverPoint<TData>[];
-    label: (row: TData) => string;
-    tooltip?: TooltipRuntime<TData>;
-    markers?: Marker[];
-    /** All resolved series, forwarded to unscoped component markers (e.g. DeltaMarker). */
-    seriesData?: Series<TData>[];
-    /** Scale config forwarded from the plot. */
-    scales?: ScalesConfig;
-    /** Partial margin override — merged on top of the theme before tickRotate adjustment. */
-    margins?: MarginConfig;
-    showHoverLabels?: boolean;
-    /**
-     * The plot kind's default hover strategy when none is set on the tooltip or
-     * hover marker. Line/bar → `'x'`, pyramid → `'y'`, heatmap → `'punctual'`.
-     */
-    defaultStrategy?: HoverStrategy;
-    /**
-     * `matchedPoints` carries only display info (+ `series`), not `row` — a
-     * per-series-scoped `HoverMarker` never needs the source row, just enough
-     * to filter and place dots/labels, which sidesteps forcing a concrete
-     * `TData` resolution through this snippet's type for every plot kind.
-     * `impliesRuleX`/`impliesRuleY` tell the plot kind whether the active
-     * strategy implies a crosshair rule on each axis by default.
-     */
-    children: Snippet<
-      [{
-        matchedPoints: HoverDisplayPoint[];
-        ruleX: AxisValue | null;
-        ruleY: AxisValue | null;
-        impliesRuleX: boolean;
-        impliesRuleY: boolean;
-      }]
-    >;
-  } = $props();
-
-  const cfg = $derived(getConfiguration());
-
-  const computedMargins = $derived.by(() => {
-    const base = { ...cfg.margins, ...margins };
-    const xRotate = scales?.x?.tickRotate;
-    if (!xRotate) return base;
-    const rad = Math.abs(xRotate) * Math.PI / 180;
-    return {
-      ...base,
-      bottom: base.bottom + Math.ceil(Math.sin(rad) * 20),
-    };
-  });
-
-  // ── Hover / tooltip ───────────────────────────────────────────────────────
-  const hoverActive = $derived(tooltip != null || hasHoverMarker(markers));
-
-  const sharedHover = getHover();
-  const localHover = createHover();
-  const hover = $derived(sharedHover ?? localHover);
-
-  $effect(() => {
-    if (sharedHover) return;
-    const hoverMarker = findHoverMarker(markers);
-    localHover.strategy = tooltip?.strategy ?? hoverMarker?.strategy ?? defaultStrategy;
-    localHover.sync = tooltip?.sync ?? hoverMarker?.sync ?? false;
-  });
-
-  const ctrl = createHoverController<TData>({
-    hover: () => hover,
-    facetId: () => tooltip?.facetId ?? '',
-    points: () => hoverPoints,
-    getX: () => getX,
-    getY: () => getY,
-    label: () => label,
-    format: () => tooltip?.format ?? label,
-    seriesFilter: () => tooltip?.series,
-    width: () => width,
-    height: () => height,
-  });
-
-  const topLevelMarkers = $derived(
-    markers.filter(
-      (marker) =>
-        marker.type === 'ruleX' ||
-        marker.type === 'ruleY' ||
-        (marker.type === 'component' && !marker.series),
-    ),
-  );
-
-  /** The unscoped (no `series`) hover marker, if any. */
-  const unscopedHoverMarker = $derived(
-    markers.find((m) => m.type === 'hover' && !m.series) as
-      | Extract<Marker, { type: 'hover' }>
-      | undefined,
-  );
-
-  /**
-   * Gate ruleX display: shows when the strategy implies it (default) or the
-   * marker explicitly requests it (`ruleX: true`), and is never suppressed
-   * unless the marker explicitly disables it (`ruleX: false`).
-   */
-  const showRuleX = $derived(
-    unscopedHoverMarker != null &&
-    unscopedHoverMarker.ruleX !== false &&
-    (ctrl.impliesRuleX || unscopedHoverMarker.ruleX === true),
-  );
-  const showRuleY = $derived(
-    unscopedHoverMarker != null &&
-    unscopedHoverMarker.ruleY !== false &&
-    (ctrl.impliesRuleY || unscopedHoverMarker.ruleY === true),
-  );
-</script>
-
-<!-- svelte-ignore a11y_no_static_element_interactions -->
-<div
-  class="dct-plot"
-  style:color={cfg.axis.color}
-  onpointermove={hoverActive ? ctrl.onMove : undefined}
-  onpointerleave={hoverActive ? ctrl.onLeave : undefined}
->
-  <Plot {width} {height} margin={computedMargins} {x} {y}>
-    <AxisX tickSize={scales?.x?.tickSize ?? cfg.axis.xTickSize} tickPadding={scales?.x?.tickPadding ?? cfg.axis.xTickPadding} tickFontSize={cfg.axis.fontSize} titleFontSize={scales?.x?.titleFontSize ?? cfg.axis.titleFontSize} />
-    <AxisY tickSize={scales?.y?.tickSize ?? cfg.axis.yTickSize} tickPadding={scales?.y?.tickPadding ?? cfg.axis.yTickPadding} tickFontSize={cfg.axis.fontSize} titleFontSize={scales?.y?.titleFontSize ?? cfg.axis.titleFontSize} />
-    {@render children({
-      matchedPoints: ctrl.points,
-      ruleX: ctrl.ruleX,
-      ruleY: ctrl.ruleY,
-      impliesRuleX: ctrl.impliesRuleX,
-      impliesRuleY: ctrl.impliesRuleY,
-    })}
-
-    {#each topLevelMarkers as marker, i (marker.type === 'ruleX' ? `${marker.type}-${marker.x}` : marker.type === 'ruleY' ? `${marker.type}-${marker.y}` : `${marker.type}-${i}`)}
-      {#if marker.type === 'ruleX'}
-        <RuleX
-          data={[{ xValue: marker.x }]}
-          x={(d) => d.xValue}
-          stroke={marker.style?.stroke ?? 'currentColor'}
-          strokeWidth={marker.style?.strokeWidth ?? 1}
-          strokeOpacity={marker.style?.strokeOpacity ?? 1}
-          strokeDasharray={marker.style?.strokeDasharray}
-        />
-      {:else if marker.type === 'ruleY'}
-        <RuleY
-          data={[{ yValue: marker.y }]}
-          y={(d) => d.yValue}
-          stroke={marker.style?.stroke ?? 'currentColor'}
-          strokeWidth={marker.style?.strokeWidth ?? 1}
-          strokeOpacity={marker.style?.strokeOpacity ?? 1}
-          strokeDasharray={marker.style?.strokeDasharray}
-        />
-      {:else if marker.type === 'component'}
-        <marker.component {...marker.props} data={marker.data ?? seriesData} />
-      {/if}
-    {/each}
-
-    {#if hoverActive}
-      <Pointer {data} x={getX} y={matchY} maxDistance={400} onupdate={ctrl.onPointer} />
-    {/if}
-
-    {#if unscopedHoverMarker}
-      <HoverMarker
-        data={ctrl.points}
-        ruleX={showRuleX ? ctrl.ruleX : null}
-        ruleY={showRuleY ? ctrl.ruleY : null}
-        showLabels={unscopedHoverMarker.showLabels ?? showHoverLabels}
-        format={unscopedHoverMarker.format}
-        ruleStyle={unscopedHoverMarker.ruleStyle}
-        dotStyle={unscopedHoverMarker.dotStyle}
-        fontStyle={unscopedHoverMarker.fontStyle}
-      />
-    {/if}
-  </Plot>
-
-  {#if tooltip && ctrl.showTooltip && ctrl.tooltipPosition}
-    <Tooltip x={ctrl.tooltipPosition?.x ?? 0} y={ctrl.tooltipPosition?.y ?? 0} bounds={{ width, height }}>
-      {#if tooltip.content}
-        {@render tooltip.content({ rows: ctrl.matchedRows.map((p) => p.row) })}
-      {:else}
-        {ctrl.tooltipText}
-      {/if}
-    </Tooltip>
-  {/if}
-</div>
-
-<style>
-  .dct-plot {
-    position: relative;
-    line-height: 0;
-  }
-</style>

package/dist/layout/plot/PlotLayout.svelte.d.ts

@@ -1,70 +0,0 @@
-import type { Snippet } from 'svelte';
-import type { AxisValue, Series, ScalesConfig, MarginConfig } from '../../types/plots/common';
-import type { Marker } from '../../types/plots/markers';
-import type { HoverStrategy, HoverDisplayPoint, HoverPoint, TooltipRuntime } from '../../types/layout/tooltip';
-declare function $$render<TData extends Record<string, unknown>>(): {
-    props: {
-        width: number;
-        height: number;
-        x?: false | Partial<import("svelteplot/types/scale.js").XScaleOptions> | import("svelteplot/types/data.js").RawValue[] | undefined;
-        y?: false | import("svelteplot/types/data.js").RawValue[] | Partial<import("svelteplot/types/scale.js").YScaleOptions> | undefined;
-        /** Flat rows fed to svelteplot's `<Pointer>` for nearest-point matching. */
-        data: TData[];
-        getX: (d: TData) => AxisValue;
-        getY: (d: TData) => AxisValue;
-        /** Pointer's `y` channel — only needed when matching must be 2D (e.g. a heatmap grid). */
-        matchY?: (d: TData) => AxisValue;
-        hoverPoints: HoverPoint<TData>[];
-        label: (row: TData) => string;
-        tooltip?: TooltipRuntime<TData>;
-        markers?: Marker[];
-        /** All resolved series, forwarded to unscoped component markers (e.g. DeltaMarker). */
-        seriesData?: Series<TData>[];
-        /** Scale config forwarded from the plot. */
-        scales?: ScalesConfig;
-        /** Partial margin override — merged on top of the theme before tickRotate adjustment. */
-        margins?: MarginConfig;
-        showHoverLabels?: boolean;
-        /**
-         * The plot kind's default hover strategy when none is set on the tooltip or
-         * hover marker. Line/bar → `'x'`, pyramid → `'y'`, heatmap → `'punctual'`.
-         */
-        defaultStrategy?: HoverStrategy;
-        /**
-         * `matchedPoints` carries only display info (+ `series`), not `row` — a
-         * per-series-scoped `HoverMarker` never needs the source row, just enough
-         * to filter and place dots/labels, which sidesteps forcing a concrete
-         * `TData` resolution through this snippet's type for every plot kind.
-         * `impliesRuleX`/`impliesRuleY` tell the plot kind whether the active
-         * strategy implies a crosshair rule on each axis by default.
-         */
-        children: Snippet<[{
-            matchedPoints: HoverDisplayPoint[];
-            ruleX: AxisValue | null;
-            ruleY: AxisValue | null;
-            impliesRuleX: boolean;
-            impliesRuleY: boolean;
-        }]>;
-    };
-    exports: {};
-    bindings: "";
-    slots: {};
-    events: {};
-};
-declare class __sveltets_Render<TData extends Record<string, unknown>> {
-    props(): ReturnType<typeof $$render<TData>>['props'];
-    events(): ReturnType<typeof $$render<TData>>['events'];
-    slots(): ReturnType<typeof $$render<TData>>['slots'];
-    bindings(): "";
-    exports(): {};
-}
-interface $$IsomorphicComponent {
-    new <TData extends Record<string, unknown>>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<TData>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<TData>['props']>, ReturnType<__sveltets_Render<TData>['events']>, ReturnType<__sveltets_Render<TData>['slots']>> & {
-        $$bindings?: ReturnType<__sveltets_Render<TData>['bindings']>;
-    } & ReturnType<__sveltets_Render<TData>['exports']>;
-    <TData extends Record<string, unknown>>(internal: unknown, props: ReturnType<__sveltets_Render<TData>['props']> & {}): ReturnType<__sveltets_Render<TData>['exports']>;
-    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
-}
-declare const PlotLayout: $$IsomorphicComponent;
-type PlotLayout<TData extends Record<string, unknown>> = InstanceType<typeof PlotLayout<TData>>;
-export default PlotLayout;