@fundar/data-chart-telling 0.0.14 → 0.0.16

package/dist/layout/plot/PlotLayout.svelte

@@ -1,294 +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, AxisScale, 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),
-    };
-  });
-
-  // ── Axis ticks / domain ──────────────────────────────────────────────────
-
-  const xValues = $derived(data.map(getX));
-  const yValues = $derived(data.map(getY));
-
-  /**
-   * Caps the requested tick count to the axis's own number of distinct
-   * values, but never above what the pixel width would naturally request —
-   * so a narrow domain (e.g. 5 whole years) never gets subdivided into
-   * fractional ticks (2020, 2020.5, 2021, …) just to fill the space. Skipped
-   * whenever the caller already controls tick density directly.
-   */
-  function autoTickCount(scale: AxisScale | undefined, values: AxisValue[], span: number, spacing: number, min: number): number | undefined {
-    if (scale?.ticks != null || scale?.tickSpacing != null || scale?.interval != null) return undefined;
-    const uniqueCount = new Set(values.map(String)).size;
-    const natural = Math.max(min, Math.round(span / spacing));
-    return uniqueCount >= 2 && uniqueCount < natural ? uniqueCount : undefined;
-  }
-
-  const xTickCount = $derived(
-    autoTickCount(scales?.x, xValues, Math.max(0, width - computedMargins.left - computedMargins.right), 80, 3),
-  );
-  const yTickCount = $derived(
-    autoTickCount(scales?.y, yValues, Math.max(0, height - computedMargins.top - computedMargins.bottom), 50, 2),
-  );
-
-  /**
-   * svelteplot's own `sort` scale option only toggles a fixed ascending sort
-   * (lexicographic for strings) — it can't take a custom comparator. When the
-   * caller supplies one via `scales.x.sort`/`scales.y.sort` for a string-valued
-   * axis (e.g. dates formatted as text), compute the ordered domain ourselves
-   * and hand it to the scale as an explicit `domain`, which svelteplot does
-   * respect as-is for ordinal scales.
-   */
-  function sortedScale<T>(scale: T, scaleConfig: AxisScale | undefined, values: AxisValue[]): T {
-    const sort = scaleConfig?.sort;
-    if (!sort || scaleConfig?.domain || values.length === 0) return scale;
-    if (!values.every((v) => typeof v === 'string')) return scale;
-    const domain = [...new Set(values)].sort(sort);
-    return { ...(scale as object), domain } as T;
-  }
-
-  const resolvedX = $derived(sortedScale(x, scales?.x, xValues));
-  const resolvedY = $derived(sortedScale(y, scales?.y, yValues));
-
-  // ── 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={resolvedX} y={resolvedY}>
-    <AxisX
-      tickCount={xTickCount}
-      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
-      tickCount={yTickCount}
-      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;

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,97 +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: AxisValue, b: AxisValue) => number;
-    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>;
-};