@fundar/data-chart-telling 0.0.13 → 0.0.15

package/dist/plots/markers/HoverMarker.svelte

@@ -1,98 +0,0 @@
-<script lang="ts">
-  import { RuleX, RuleY } from 'svelteplot';
-  import DotMarker from './DotMarker.svelte';
-  import TextMarker from './TextMarker.svelte';
-  import { getConfiguration } from '../../configuration/config.svelte';
-  import type { MarkerProps } from '../../types/plots/markers';
-  import type { AxisValue } from '../../types/plots/common';
-  import type { DotStyle, FontStyle, StrokeStyle } from '../../types/plots/styles';
-  import type { HoverDisplayPoint } from '../../types/layout/tooltip';
-
-  /**
-   * In-SVG hover highlight, rendered *inside* a `<Plot>`. Because it positions
-   * itself through the host plot's scales, it places the same coordinate
-   * correctly in every facet — that is what makes cross-facet sync work without
-   * any pixel math. Draws optional x/y crosshair rules plus a dot + value label
-   * for each matched point.
-   */
-  interface Props extends MarkerProps<HoverDisplayPoint> {
-    ruleX?: AxisValue | null;
-    ruleY?: AxisValue | null;
-    showLabels?: boolean;
-    format?: (point: HoverDisplayPoint) => string;
-    ruleStyle?: StrokeStyle;
-    dotStyle?: DotStyle;
-    fontStyle?: FontStyle;
-  }
-
-  let {
-    data = [],
-    ruleX = null,
-    ruleY = null,
-    showLabels = true,
-    format,
-    ruleStyle,
-    dotStyle,
-    fontStyle,
-    seriesColor,
-  }: Props = $props();
-
-  const cfg = $derived(getConfiguration());
-
-  /** Explicit style wins; otherwise fall back to the series color, then the point's own resolved color. */
-  const resolveColor = (explicit: string | undefined, point: HoverDisplayPoint) =>
-    explicit ?? seriesColor ?? point.color;
-</script>
-
-{#if ruleX != null}
-  <RuleX
-    data={[{ v: ruleX }]}
-    x={(d) => d.v}
-    stroke={ruleStyle?.stroke ?? cfg.hover.rule.stroke}
-    strokeOpacity={ruleStyle?.strokeOpacity ?? cfg.hover.rule.strokeOpacity}
-    strokeWidth={ruleStyle?.strokeWidth ?? cfg.hover.rule.strokeWidth}
-    strokeDasharray={ruleStyle?.strokeDasharray ?? cfg.hover.rule.strokeDasharray}
-  />
-{/if}
-
-{#if ruleY != null}
-  <RuleY
-    data={[{ v: ruleY }]}
-    y={(d) => d.v}
-    stroke={ruleStyle?.stroke ?? cfg.hover.rule.stroke}
-    strokeOpacity={ruleStyle?.strokeOpacity ?? cfg.hover.rule.strokeOpacity}
-    strokeWidth={ruleStyle?.strokeWidth ?? cfg.hover.rule.strokeWidth}
-    strokeDasharray={ruleStyle?.strokeDasharray ?? cfg.hover.rule.strokeDasharray}
-  />
-{/if}
-
-{#if data.length > 0}
-  {#each data as point (point.series ?? `${point.x}_${point.y}`)}
-    <DotMarker
-      data={[point]}
-      x={(d) => d.x}
-      y={(d) => d.y}
-      style={{
-        ...cfg.hover.dot,
-        ...dotStyle,
-        dotFill: resolveColor(dotStyle?.dotFill, point),
-        dotStroke: resolveColor(dotStyle?.dotStroke, point),
-      }}
-    />
-  {/each}
-  {#if showLabels}
-    {#each data as point (point.series ?? `${point.x}_${point.y}`)}
-      <TextMarker
-        data={[point]}
-        x={(d) => d.x}
-        y={(d) => d.y}
-        text={(d) => format ? format(d) : (d.label ?? '')}
-        style={{
-          ...cfg.hover.font,
-          ...fontStyle,
-          fill: resolveColor(fontStyle?.fill, point),
-        }}
-      />
-    {/each}
-  {/if}
-{/if}

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

@@ -1,100 +0,0 @@
-export type AxisValue = number | string | Date;
-/** Partial margin override — only the sides you specify are overridden; the rest come from the theme. */
-export type MarginConfig = Partial<{
-    top: number;
-    right: number;
-    bottom: number;
-    left: number;
-}>;
-/**
- * Author-facing scale overrides for a plot axis. Mirrors svelteplot's
- * `ScaleOptions` + `XScaleOptions` in full — `type`, `padding`, `domain`,
- * `nice`, `reverse`, `label`, `tickFormat`, `labelAnchor`, etc.
- *
- * Used for both `x` and `y` entries in {@link ScalesConfig}. X-specific
- * fields (`labelAnchor`, `tickRotate`) are accepted on `y` too; svelteplot
- * silently ignores any inapplicable options.
- */
-export type AxisScale = {
-    type?: 'auto' | 'linear' | 'pow' | 'sqrt' | 'log' | 'symlog' | 'time' | 'utc' | 'point' | 'ordinal' | 'sequential' | 'band' | 'categorical' | 'cyclical' | 'threshold' | 'quantile-cont' | 'quantile' | 'quantize' | 'diverging' | 'diverging-log' | 'diverging-pow' | 'diverging-sqrt' | 'diverging-symlog';
-    domain?: (number | string | boolean | Date | null)[];
-    range?: (number | string | boolean | Date | null)[];
-    reverse?: boolean;
-    label?: string | false;
-    interval?: string | number;
-    clamp?: boolean;
-    nice?: boolean;
-    zero?: boolean;
-    round?: boolean;
-    percent?: boolean;
-    padding?: number;
-    align?: number;
-    paddingInner?: number;
-    paddingOuter?: number;
-    insetLeft?: number;
-    insetRight?: number;
-    insetTop?: number;
-    insetBottom?: number;
-    ticks?: (number | string | boolean | Date | null)[];
-    tickSpacing?: number;
-    tickSize?: number;
-    tickPadding?: number;
-    titleFontSize?: number;
-    base?: number;
-    constant?: number;
-    sort?: ((a: unknown, b: unknown) => number) | {
-        channel: string;
-        order: 'ascending' | 'descending';
-    };
-    grid?: boolean;
-    tickRotate?: number;
-    tickFormat?: false | Intl.NumberFormatOptions | Intl.DateTimeFormatOptions | ((d: unknown, index: number, ticks: unknown[]) => string | string[]);
-};
-/**
- * Per-axis scale overrides, passed as a single `scales` prop to every plot
- * kind.
- */
-export type ScalesConfig = {
-    x?: AxisScale;
-    y?: AxisScale;
-    z?: AxisScale;
-};
-/**
- * A field key or accessor function. Mirrors the shorthand used across plots
- * so chart-level encodings (`x`, `y`, `z`, facet, timeline) feel consistent
- * with the plot-level series definitions.
- */
-export type Accessor<TRow extends Record<string, unknown>, V> = keyof TRow | ((d: TRow) => V);
-/**
- * A plot series: a name, x/y accessors and the rows it draws. Shared as-is by
- * every mark (line, bar, …) — none of them need anything beyond this shape;
- * visual styling lives separately in `segments`.
- */
-export type Series<T extends Record<string, unknown> = Record<string, unknown>> = {
-    name: string;
-    x: Accessor<T, AxisValue>;
-    y: Accessor<T, AxisValue>;
-    z?: Accessor<T, unknown>;
-    data: T[];
-};
-/**
- * Pre-built series. Mutually exclusive with {@link DataProps} — takes
- * precedence when both could apply.
- */
-export type SeriesProps<T extends Record<string, unknown>> = {
-    series: Series<T>[];
-    data?: never;
-    x?: never;
-    y?: never;
-    z?: never;
-};
-/**
- * Flat rows to group into series, as an alternative to {@link SeriesProps}.
- */
-export type DataProps<T extends Record<string, unknown>> = {
-    series?: never;
-    data: T[];
-    x: Accessor<T, AxisValue>;
-    y: Accessor<T, AxisValue>;
-    z?: Accessor<T, unknown>;
-};

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

@@ -1,187 +0,0 @@
-import type { AxisValue, Series } from './common';
-/**
- * Unified positional anchor for value labels across all plot kinds.
- *
- * - `'outside'` — beyond the tip of the mark (above a vertical bar, to the
- *   far end of a horizontal bar or line). This is the only value with no
- *   direct svelteplot equivalent; the plot computes dx/dy internally.
- * - `'start'` — at the tip of the mark, just inside (top of a bar, far end
- *   of a pyramid bar from zero, right of a line's last point).
- * - `'middle'` — centred on the mark.
- * - `'end'` — at the baseline/zero end of the mark.
- */
-export type ValueAnchor = 'outside' | 'start' | 'middle' | 'end';
-/**
- * Controls if and how value labels are rendered on a plot. The high-level
- * `anchor` sets sensible defaults for placement; the low-level svelteplot
- * Text-mark fields (`dx`, `dy`, `textAnchor`, `lineAnchor`, `lineHeight`,
- * `rotate`, `class`, `textClass`) override those defaults when provided.
- */
-export type ValuesStyle = {
-    show?: boolean;
-    anchor?: ValueAnchor;
-    /** Called with the numeric value and the series name. Return a string to render. */
-    format?: (value: number, seriesName: string) => string;
-    dx?: number;
-    dy?: number;
-    textAnchor?: 'start' | 'end' | 'middle';
-    lineAnchor?: 'top' | 'bottom' | 'middle';
-    lineHeight?: number;
-    rotate?: number;
-    class?: string;
-    textClass?: 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 all plot kinds. Passed as the
- * `styles` prop. Each plot reads only the fields it cares about.
- */
-export type PlotStyles = {
-    values?: ValuesStyle;
-    colors?: ColorsStyle;
-};
-export type SymbolType = 'circle' | 'square' | 'triangle' | 'line';
-export type LineStyle = 'solid' | 'dashed' | 'dotted' | 'dashdot';
-export type LineCap = 'butt' | 'round' | 'square';
-export type LineJoin = 'arcs' | 'bevel' | 'miter' | 'miter-clip' | 'round';
-/** 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 {@link 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;
-};
-/** Text/label styling for any text mark — a marker's label, an annotation. */
-export type FontStyle = {
-    fill?: string;
-    fontSize?: number;
-    fontWeight?: 'normal' | 'bold';
-    fontStyle?: 'normal' | 'italic';
-    textAnchor?: 'start' | 'middle' | 'end';
-    lineAnchor?: 'top' | 'middle' | 'bottom';
-    stroke?: string;
-    strokeWidth?: number;
-    paintOrder?: string;
-    dx?: number;
-    dy?: number;
-};
-/** 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: its fill. */
-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;
-};
-/** 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;
-};
-/**
- * The `segments` prop accepted by every plot kind.
- *
- * A record mapping series names (or `'default'` for all series) to lists of
- * {@link Segment}s. Segments in a named key apply only to that series;
- * segments under `'default'` apply to every series.
- *
- * ```ts
- * segments: {
- *   female:  [{ style: { stroke: { stroke: 'tomato' } } }],   // catch-all for female
- *   male:    [{ style: { stroke: { stroke: 'steelblue' } } }], // catch-all for male
- *   default: [{ areas: [{ x: { from: 2012, to: 2014 } }], style: { dots: { dotSymbol: 'circle' } } }],
- * }
- * ```
- *
- * Within each resolved series list, catch-alls (no `areas`) are evaluated last
- * so that area-specific segments always override them, regardless of position.
- * Area-specific segments also inherit any style key absent from their own style
- * by merging the catch-all as a baseline — the area's own style wins on conflict.
- * This lets you set a series colour once in a catch-all and add per-range dots
- * or dash patterns without repeating the colour on every area segment.
- */
-export type Segments<TStyle> = Record<string, Segment<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>[];
-};