svelteplot 0.10.3 → 0.11.0

package/dist/types/data.d.ts

@@ -1,18 +1,31 @@
 import type { ScaledChannelName, ScaledChannelType } from './channel.js';
+/** a raw data value that can be used in channels */
 export type RawValue = number | Date | boolean | string | symbol | object | null;
+/** a data record passed to marks; generic over the user's row shape */
 export type DataRecord<T = Record<string | symbol, RawValue>> = T;
+/** a data record after channel accessors have been resolved to concrete values */
 export type ResolvedDataRecord<T = Record<string | symbol, RawValue>> = Partial<Record<ScaledChannelName, any>> & {
+    /** the original data record before resolution */
     datum: DataRecord<T>;
+    /** the index of this record in the original data array */
     index: number;
 };
+/** a data record after scale functions have been applied to channel values */
 export type ScaledDataRecord<T = Record<string | symbol, RawValue>> = Partial<{
     [K in ScaledChannelName]?: ScaledChannelType<K>;
 }> & {
+    /** horizontal pixel offset applied after scaling */
     dx: number;
+    /** vertical pixel offset applied after scaling */
     dy: number;
+    /** the original data record */
     datum: DataRecord<T>;
+    /** the resolved (pre-scaling) channel values */
     resolved: ResolvedDataRecord<T>;
-    valid: Boolean;
+    /** whether this record has valid values for all required channels */
+    valid: boolean;
+    /** the index of this record in the original data array */
     index: number;
 };
+/** a data row as passed by the user; can be a record, a raw value, a coordinate pair, or null */
 export type DataRow<T = Record<string | symbol, RawValue>> = DataRecord<T> | RawValue | [number, number] | null;

package/dist/types/facet.d.ts

@@ -1,6 +1,9 @@
 import type { ChannelAccessor, ChannelName, DataRecord, RawValue } from './index.js';
+/** the state of a single facet panel within a faceted plot */
 type FacetState = {
+    /** the current horizontal facet value */
     fx: RawValue;
+    /** the current vertical facet value */
     fy: RawValue;
     /**
      * True, if the facet is the leftmost in its row
@@ -39,12 +42,14 @@ type FacetState = {
  * Test if the given data record is visible in the current facet.
  */
 type TestFacetFunction = (datum: DataRecord<any>, channels: Record<ChannelName, ChannelAccessor>) => boolean;
+/** context provided to marks for facet-aware filtering and state access */
 export type FacetContext = {
     /**
      * Returns a stateful function that tests whether a specific data
      * record is visible in the current facet or not.
      */
     getTestFacet: () => TestFacetFunction;
+    /** returns the current facet panel state (position, edge flags) */
     getFacetState: () => FacetState;
 };
 export {};

package/dist/types/index.d.ts

@@ -4,7 +4,9 @@ import type { MarkerShape } from '../marks/helpers/Marker.svelte';
 import type { Channels, ScaledChannelName } from './channel.js';
 import type { RawValue } from './data.js';
 import type { BaseMarkProps } from './mark.js';
+/** a generic record type used when the specific mark options type is not known */
 export type GenericMarkOptions = Record<string | symbol, any>;
+/** the name of a d3 curve interpolation method */
 export type CurveName = 'basis' | 'basis-closed' | 'basis-open' | 'bundle' | 'bump-x' | 'bump-y' | 'cardinal' | 'cardinal-closed' | 'cardinal-open' | 'catmull-rom' | 'catmull-rom-closed' | 'catmull-rom-open' | 'linear' | 'linear-closed' | 'monotone-x' | 'monotone-y' | 'natural' | 'step' | 'step-after' | 'step-before';
 export type MarkerOptions = {
     /**
@@ -28,41 +30,64 @@ export type MarkerOptions = {
      */
     markerScale?: ConstantAccessor<number>;
 };
-export type ConstantAccessor<K, T = Record<string | symbol, RawValue>> = K | ((d: T, index: number) => K) | null | undefined;
+/** a value that is either a constant or a function that computes a per-datum value */
+type BivariantCallback<TArgs extends unknown[], TResult> = {
+    bivarianceHack(...args: TArgs): TResult;
+}['bivarianceHack'];
+export type ConstantAccessor<K, T = Record<string | symbol, RawValue>> = K | BivariantCallback<[d: T, index: number], K> | null | undefined;
+/** the input argument to a data transform: data array plus channel mappings and mark props */
 export type TransformArg<T> = Channels<T> & BaseMarkProps<T> & {
     data: T[];
 };
+/** the input argument to a map transform: data array plus channel mappings */
 export type MapArg<T> = Channels<T> & {
     data: T[];
 };
+/** transform input for raw data rows (before recordization) */
 export type TransformArgsRow<T extends RawValue | object> = Partial<Channels<T>> & {
     data: T[];
 };
+/** transform input for data records (after recordization) */
 export type TransformArgsRecord<T extends object> = Partial<Channels<T>> & {
     data: T[];
 };
+/** the return type of a transform, ensuring data is always present */
 export type TransformReturn<C extends TransformArg<T>, T> = C & Required<Pick<Channels<T>, 'data'>>;
+/** writable stores used by marks to contribute to automatic margin computation */
 export type AutoMarginStores = {
+    /** per-mark contributions to the top margin */
     autoMarginTop: Writable<Map<string, number>>;
+    /** per-mark contributions to the left margin */
     autoMarginLeft: Writable<Map<string, number>>;
+    /** per-mark contributions to the right margin */
     autoMarginRight: Writable<Map<string, number>>;
+    /** per-mark contributions to the bottom margin */
     autoMarginBottom: Writable<Map<string, number>>;
 };
+/** a function that maps source values (S) to target values (T) for the given indices (I) */
 export type MapIndexFunction = (I: number[], S: RawValue[], T: RawValue[]) => void;
+/** an object implementing the mapIndex interface for custom map transforms */
 export type MapIndexObject = {
+    /** the function that performs the index-based mapping */
     mapIndex: MapIndexFunction;
 };
+/** a named map method, a custom mapping function, or a MapIndexObject */
 export type MapMethod = 'cumsum' | 'rank' | 'quantile' | ((I: number[], S: number[]) => number[]) | MapIndexObject;
 /**
  * An object specifying mapping methods for one or more scaled channels
  * e.g. ```{ x: 'rank' }```
  */
 export type MapOptions = Partial<Record<ScaledChannelName, MapMethod>>;
+/** a record indicating which scaled channels are actively used by a mark */
 export type UsedScales = Record<ScaledChannelName, boolean>;
-export * from './channel';
-export * from './colorScheme';
-export * from './data';
-export * from './facet';
-export * from './mark';
-export * from './plot';
-export * from './scale';
+export * from './channel.js';
+export * from './axes.js';
+export * from './colorScheme.js';
+export * from './data.js';
+export * from './facet.js';
+export * from './mark.js';
+export * from './plot.js';
+export * from './scale.js';
+export * from '../transforms/density.js';
+export * from '../transforms/window.js';
+export * from '../helpers/reduce.js';

package/dist/types/index.js

@@ -1,7 +1,11 @@
-export * from './channel';
-export * from './colorScheme';
-export * from './data';
-export * from './facet';
-export * from './mark';
-export * from './plot';
-export * from './scale';
+export * from './channel.js';
+export * from './axes.js';
+export * from './colorScheme.js';
+export * from './data.js';
+export * from './facet.js';
+export * from './mark.js';
+export * from './plot.js';
+export * from './scale.js';
+export * from '../transforms/density.js';
+export * from '../transforms/window.js';
+export * from '../helpers/reduce.js';

package/dist/types/mark.d.ts

@@ -6,79 +6,158 @@ export type Mark<T> = {
     data: DataRecord<T>[];
     options: T;
 };
-export type MarkType = 'area' | 'arrow' | 'barX' | 'barY' | 'cell' | 'custom' | 'dot' | 'vector' | 'frame' | 'geo' | 'gridX' | 'gridY' | 'line' | 'rect' | 'regression' | 'ruleX' | 'ruleY' | 'swoopyArrow' | 'text' | 'tickX' | 'tickY' | 'trail' | 'waffleX' | 'waffleY';
+export type MarkType = 'area' | 'arrow' | 'axisX' | 'axisY' | 'barX' | 'barY' | 'cell' | 'custom' | 'dot' | 'vector' | 'frame' | 'geo' | 'gridX' | 'gridY' | 'image' | 'link' | 'line' | 'rect' | 'regression' | 'ruleX' | 'ruleY' | 'swoopyArrow' | 'text' | 'tickX' | 'tickY' | 'trail' | 'waffleX' | 'waffleY';
 export type MarkStyleProps = 'strokeDasharray' | 'strokeLinejoin' | 'strokeLinecap' | 'opacity' | 'cursor' | 'pointerEvents' | 'blend' | 'fill' | 'fillOpacity' | 'fontFamily' | 'fontWeight' | 'fontVariant' | 'fontSize' | 'fontStyle' | 'letterSpacing' | 'wordSpacing' | 'stroke' | 'strokeWidth' | 'strokeOpacity' | 'x' | 'y' | 'clipPath' | 'mask' | 'filter' | 'angle' | 'radius' | 'symbol' | 'textAnchor' | 'textTransform' | 'textDecoration' | 'width';
-import type { MouseEventHandler } from 'svelte/elements';
 import type { ChannelAccessor, ConstantAccessor, DataRecord, RawValue } from './index.js';
 import type * as CSS from 'csstype';
 import type { ScaledChannelName } from './channel.js';
 import type { ScaleName } from './scale.js';
 import type { DodgeXOptions, DodgeYOptions } from '../transforms/dodge.js';
-export type BaseMarkProps<T> = Partial<{
+type MarkEventHandler<TDatum, TTarget extends EventTarget = EventTarget> = (event: Event & {
+    currentTarget: TTarget;
+}, datum: TDatum, index: number) => void;
+export type BaseMarkProps<T = DataRecord> = Partial<{
     /**
      * Filter the data without modifying the inferred scales
      */
     filter: ConstantAccessor<boolean, T>;
+    /** controls whether this mark participates in faceting; "exclude" to ignore facet filters, "include" to require matching facet values */
     facet: 'auto' | 'include' | 'exclude';
+    /** the horizontal facet channel */
     fx: ChannelAccessor<T>;
+    /** the vertical facet channel */
     fy: ChannelAccessor<T>;
+    /** a horizontal offset in pixels applied after scaling */
     dx: ConstantAccessor<number, T>;
+    /** a vertical offset in pixels applied after scaling */
     dy: ConstantAccessor<number, T>;
+    /** options for horizontal dodge positioning to avoid overlapping marks */
     dodgeX: DodgeXOptions;
+    /** options for vertical dodge positioning to avoid overlapping marks */
     dodgeY: DodgeYOptions;
+    /** the fill color; can be a fixed CSS color string or a channel accessor bound to the color scale */
     fill: ChannelAccessor<T>;
+    /** the fill opacity; a number between 0 and 1 */
     fillOpacity: ConstantAccessor<number, T>;
+    /** font family for text-capable marks */
+    fontFamily: ConstantAccessor<CSS.Property.FontFamily, T>;
+    /** font size for text-capable marks */
+    fontSize: ConstantAccessor<CSS.Property.FontSize | number, T>;
+    /** font style for text-capable marks */
+    fontStyle: ConstantAccessor<CSS.Property.FontStyle, T>;
+    /** font variant for text-capable marks */
+    fontVariant: ConstantAccessor<CSS.Property.FontVariant, T>;
+    /** font weight for text-capable marks */
+    fontWeight: ConstantAccessor<CSS.Property.FontWeight, T>;
+    /** letter spacing for text-capable marks */
+    letterSpacing: ConstantAccessor<CSS.Property.LetterSpacing, T>;
+    /** word spacing for text-capable marks */
+    wordSpacing: ConstantAccessor<CSS.Property.WordSpacing, T>;
+    /** text anchor for text-capable marks */
+    textAnchor: ConstantAccessor<CSS.Property.TextAnchor, T>;
+    /** text transform for text-capable marks */
+    textTransform: ConstantAccessor<CSS.Property.TextTransform, T>;
+    /** text decoration for text-capable marks */
+    textDecoration: ConstantAccessor<CSS.Property.TextDecoration, T>;
+    /** how to sort the mark data before rendering; can be a channel name string, an accessor, a comparator, or an object with channel and order */
     sort: string | ConstantAccessor<RawValue, T> | ((a: RawValue, b: RawValue) => number) | {
         /** sort data using an already defined channel */
         channel: string;
         /** sort order */
         order?: 'ascending' | 'descending';
     };
+    /** the stroke color; can be a fixed CSS color string or a channel accessor bound to the color scale */
     stroke: ChannelAccessor<T>;
+    /** the stroke width in pixels */
     strokeWidth: ConstantAccessor<number, T>;
+    /** the stroke opacity; a number between 0 and 1 */
     strokeOpacity: ConstantAccessor<number, T>;
+    /** the SVG stroke line join style (e.g. "round", "bevel") */
     strokeLinejoin: ConstantAccessor<CSS.Property.StrokeLinejoin, T>;
+    /** the SVG stroke line cap style (e.g. "round", "butt") */
     strokeLinecap: ConstantAccessor<CSS.Property.StrokeLinecap, T>;
+    /** the SVG stroke miter limit */
     strokeMiterlimit: ConstantAccessor<number, T>;
+    /** the overall element opacity; can be a fixed number or a channel accessor bound to the opacity scale */
     opacity: ChannelAccessor<T>;
+    /** the SVG stroke dash pattern (e.g. "4 2") */
     strokeDasharray: ConstantAccessor<string, T>;
+    /** the SVG stroke dash offset in pixels */
     strokeDashoffset: ConstantAccessor<number, T>;
+    /** the CSS mix-blend-mode for compositing (e.g. "multiply", "screen") */
+    blend: ConstantAccessor<CSS.Property.MixBlendMode, T>;
+    /** legacy alias of blend */
     mixBlendMode: ConstantAccessor<CSS.Property.MixBlendMode, T>;
+    /** a CSS clip-path to clip the mark element */
     clipPath: string;
+    /** a CSS mask to apply to the mark element */
     mask: string;
+    /** a CSS filter to apply to the mark element (e.g. "blur(2px)") */
     imageFilter: ConstantAccessor<string, T>;
+    /** the SVG shape-rendering attribute (e.g. "crispEdges", "geometricPrecision") */
     shapeRendering: ConstantAccessor<CSS.Property.ShapeRendering, T>;
+    /** the SVG paint-order attribute (e.g. "stroke" to render stroke behind fill) */
     paintOrder: ConstantAccessor<string, T>;
-    onclick: MouseEventHandler<SVGPathElement>;
-    ondblclick: MouseEventHandler<SVGPathElement>;
-    onmouseup: MouseEventHandler<SVGPathElement>;
-    onmousedown: MouseEventHandler<SVGPathElement>;
-    onmouseenter: MouseEventHandler<SVGPathElement>;
-    onmousemove: MouseEventHandler<SVGPathElement>;
-    onmouseleave: MouseEventHandler<SVGPathElement>;
-    onmouseout: MouseEventHandler<SVGPathElement>;
-    onmouseover: MouseEventHandler<SVGPathElement>;
-    onpointercancel: MouseEventHandler<SVGPathElement>;
-    onpointerdown: MouseEventHandler<SVGPathElement>;
-    onpointerup: MouseEventHandler<SVGPathElement>;
-    onpointerenter: MouseEventHandler<SVGPathElement>;
-    onpointerleave: MouseEventHandler<SVGPathElement>;
-    onpointermove: MouseEventHandler<SVGPathElement>;
-    onpointerover: MouseEventHandler<SVGPathElement>;
-    onpointerout: MouseEventHandler<SVGPathElement>;
-    ondrag: MouseEventHandler<SVGPathElement>;
-    ondrop: MouseEventHandler<SVGPathElement>;
-    ondragstart: MouseEventHandler<SVGPathElement>;
-    ondragenter: MouseEventHandler<SVGPathElement>;
-    ondragleave: MouseEventHandler<SVGPathElement>;
-    ondragover: MouseEventHandler<SVGPathElement>;
-    ondragend: MouseEventHandler<SVGPathElement>;
-    ontouchstart: MouseEventHandler<SVGPathElement>;
-    ontouchmove: MouseEventHandler<SVGPathElement>;
-    ontouchend: MouseEventHandler<SVGPathElement>;
-    ontouchcancel: MouseEventHandler<SVGPathElement>;
-    oncontextmenu: MouseEventHandler<SVGPathElement>;
-    onwheel: MouseEventHandler<SVGPathElement>;
+    /** fired when the mark element is clicked */
+    onclick: MarkEventHandler<T, SVGPathElement>;
+    /** fired when the mark element is double-clicked */
+    ondblclick: MarkEventHandler<T, SVGPathElement>;
+    /** fired when a mouse button is released over the mark */
+    onmouseup: MarkEventHandler<T, SVGPathElement>;
+    /** fired when a mouse button is pressed over the mark */
+    onmousedown: MarkEventHandler<T, SVGPathElement>;
+    /** fired when the pointer enters the mark element */
+    onmouseenter: MarkEventHandler<T, SVGPathElement>;
+    /** fired when the pointer moves within the mark element */
+    onmousemove: MarkEventHandler<T, SVGPathElement>;
+    /** fired when the pointer leaves the mark element */
+    onmouseleave: MarkEventHandler<T, SVGPathElement>;
+    /** fired when the pointer moves out of the mark element */
+    onmouseout: MarkEventHandler<T, SVGPathElement>;
+    /** fired when the pointer moves onto the mark element */
+    onmouseover: MarkEventHandler<T, SVGPathElement>;
+    /** fired when a pointer event is canceled */
+    onpointercancel: MarkEventHandler<T, SVGPathElement>;
+    /** fired when a pointer becomes active over the mark */
+    onpointerdown: MarkEventHandler<T, SVGPathElement>;
+    /** fired when a pointer is released over the mark */
+    onpointerup: MarkEventHandler<T, SVGPathElement>;
+    /** fired when a pointer enters the mark element */
+    onpointerenter: MarkEventHandler<T, SVGPathElement>;
+    /** fired when a pointer leaves the mark element */
+    onpointerleave: MarkEventHandler<T, SVGPathElement>;
+    /** fired when a pointer moves within the mark element */
+    onpointermove: MarkEventHandler<T, SVGPathElement>;
+    /** fired when a pointer moves onto the mark element */
+    onpointerover: MarkEventHandler<T, SVGPathElement>;
+    /** fired when a pointer moves out of the mark element */
+    onpointerout: MarkEventHandler<T, SVGPathElement>;
+    /** fired continuously while the mark is being dragged */
+    ondrag: MarkEventHandler<T, SVGPathElement>;
+    /** fired when a dragged element is dropped on the mark */
+    ondrop: MarkEventHandler<T, SVGPathElement>;
+    /** fired when a drag operation begins on the mark */
+    ondragstart: MarkEventHandler<T, SVGPathElement>;
+    /** fired when a dragged element enters the mark */
+    ondragenter: MarkEventHandler<T, SVGPathElement>;
+    /** fired when a dragged element leaves the mark */
+    ondragleave: MarkEventHandler<T, SVGPathElement>;
+    /** fired when a dragged element is over the mark */
+    ondragover: MarkEventHandler<T, SVGPathElement>;
+    /** fired when a drag operation ends */
+    ondragend: MarkEventHandler<T, SVGPathElement>;
+    /** fired when a touch point is placed on the mark */
+    ontouchstart: MarkEventHandler<T, SVGPathElement>;
+    /** fired when a touch point moves along the mark */
+    ontouchmove: MarkEventHandler<T, SVGPathElement>;
+    /** fired when a touch point is removed from the mark */
+    ontouchend: MarkEventHandler<T, SVGPathElement>;
+    /** fired when a touch event is canceled */
+    ontouchcancel: MarkEventHandler<T, SVGPathElement>;
+    /** fired when the context menu is triggered on the mark */
+    oncontextmenu: MarkEventHandler<T, SVGPathElement>;
+    /** fired when the mouse wheel is scrolled over the mark */
+    onwheel: MarkEventHandler<T, SVGPathElement>;
     /**
      * if you want to give your mark element an extra CSS class
      */
@@ -87,7 +166,10 @@ export type BaseMarkProps<T> = Partial<{
      * if you want to give your mark element an extra inline style
      */
     style: string;
+    /** the CSS cursor style when hovering over the mark (e.g. "pointer", "crosshair") */
     cursor: ConstantAccessor<CSS.Property.Cursor, T>;
+    /** tooltip text shown in an SVG <title> element when provided */
+    title: ConstantAccessor<string, T>;
 }>;
 export type LinkableMarkProps<T> = {
     /**
@@ -113,8 +195,8 @@ export type LinkableMarkProps<T> = {
      * if set to true, the link will be downloaded instead of navigating to it
      * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/a#download
      */
-    download?: ConstantAccessor<boolean, T>;
-    [key: `data-sveltekit-${string}`]: string | boolean | undefined;
+    download?: ConstantAccessor<string, T>;
+    [key: `data-sveltekit-${string}`]: unknown;
 };
 export type BorderRadius = number | {
     topLeft?: number;
@@ -123,10 +205,17 @@ export type BorderRadius = number | {
     bottomLeft?: number;
 };
 export type BaseRectMarkProps<T> = {
+    /** shorthand to inset the rectangle on all sides, in pixels */
     inset?: ConstantAccessor<number, T>;
+    /** inset the rectangle from the left edge, in pixels */
     insetLeft?: ConstantAccessor<number, T>;
+    /** inset the rectangle from the top edge, in pixels */
     insetTop?: ConstantAccessor<number, T>;
+    /** inset the rectangle from the right edge, in pixels */
     insetRight?: ConstantAccessor<number, T>;
+    /** inset the rectangle from the bottom edge, in pixels */
     insetBottom?: ConstantAccessor<number, T>;
+    /** the border radius of the rectangle; can be a number or a per-corner object */
     borderRadius?: ConstantAccessor<BorderRadius, T>;
 };
+export {};

package/dist/types/plot.d.ts

@@ -8,10 +8,12 @@ import type { Clip } from '../helpers/projection.js';
 import type { Area, AreaX, AreaY, Arrow, AxisX, AxisY, BarX, BarY, BoxX, BoxY, Brush, BrushX, BrushY, Cell, DifferenceY, Dot, Frame, Geo, Graticule, GridX, GridY, Image, Line, Link, Pointer, Rect, RectX, RectY, RuleX, RuleY, Sphere, Spike, Text, TickX, TickY, Trail, Vector } from '../marks/index.js';
 import type WaffleX from '../marks/WaffleX.svelte';
 import type WaffleY from '../marks/WaffleY.svelte';
+import type BaseAxisX from '../marks/helpers/BaseAxisX.svelte';
+import type BaseAxisY from '../marks/helpers/BaseAxisY.svelte';
 export type PlotState = {
     width: number;
     height: number;
-    options: PlotOptions;
+    options: ResolvedPlotOptions;
     facetWidth: number;
     facetHeight: number;
     plotWidth: number;
@@ -54,7 +56,7 @@ export type PlotContext = {
      */
     updateDimensions: (width: number, height: number) => void;
 };
-type IgnoreDefaults = 'data' | 'facet' | ChannelName | 'title' | 'automatic' | 'children';
+type IgnoreDefaults = 'data' | 'facet' | Exclude<ChannelName, 'stroke' | 'fill'> | 'title' | 'automatic' | 'children';
 export type PlotMargin = {
     top?: number | 'auto';
     right?: number | 'auto';
@@ -208,7 +210,7 @@ export type PlotDefaults = {
      */
     frame: Partial<ComponentProps<typeof Frame> & {
         implicit: boolean;
-    }>;
+    }> | true;
     /**
      * default props for geo marks
      */
@@ -222,19 +224,19 @@ export type PlotDefaults = {
      */
     grid: Partial<Omit<ComponentProps<typeof GridX>, IgnoreDefaults> & {
         implicit: boolean;
-    }>;
+    }> | true;
     /**
      * default props for gridX marks
      */
     gridX: Partial<Omit<ComponentProps<typeof GridX>, IgnoreDefaults> & {
         implicit: boolean;
-    }>;
+    }> | true;
     /**
      * default props for gridY marks
      */
     gridY: Partial<Omit<ComponentProps<typeof GridY>, IgnoreDefaults> & {
         implicit: boolean;
-    }>;
+    }> | true;
     /**
      * default props for image marks
      */
@@ -439,18 +441,66 @@ export type PlotOptions = {
      * Options for the shared radius scale
      */
     r: Partial<ScaleOptions>;
+    /**
+     * Options for the shared color scale
+     */
     color: Partial<ColorScaleOptions>;
+    /**
+     * Options for the shared opacity scale
+     */
     opacity: Partial<ScaleOptions>;
+    /**
+     * Options for the shared symbol scale
+     */
     symbol: Partial<LegendScaleOptions>;
+    /**
+     * Options for the shared length scale (e.g. for vectors and spikes)
+     */
     length: Partial<ScaleOptions>;
-    fx: Partial<XScaleOptions> | false | RawValue[];
-    fy: Partial<YScaleOptions> | false | RawValue[];
+    /**
+     * Options for the horizontal facet scale, or false to disable, or an
+     * array of domain values
+     */
+    fx: (Partial<XScaleOptions> & {
+        /**
+         * customize base axis props used for rendering facet axis
+         */
+        axisProps?: Partial<ComponentProps<typeof BaseAxisX>>;
+        /**
+         * customize base axis options used for rendering facet axis
+         */
+        axisOptions?: Partial<ComponentProps<typeof BaseAxisX>['options']>;
+    }) | false | RawValue[];
+    /**
+     * Options for the vertical facet scale, or false to disable, or an
+     * array of domain values
+     */
+    fy: (Partial<YScaleOptions> & {
+        /**
+         * customize base axis props used for rendering facet axis
+         */
+        axisProps?: Partial<ComponentProps<typeof BaseAxisY>>;
+        /**
+         * customize base axis options used for rendering facet axis
+         */
+        axisOptions?: Partial<ComponentProps<typeof BaseAxisY>['options']>;
+    }) | false | RawValue[];
+    /**
+     * The plot content as a Svelte snippet. Receives the plot dimensions,
+     * options, and resolved scales as arguments.
+     */
     children: Snippet<[
         {
             width: number;
             height: number;
-            options: PlotOptions;
+            options: ResolvedPlotOptions;
             scales: PlotScales;
+            hasProjection: boolean;
+            hasExplicitAxisX: boolean;
+            hasExplicitAxisY: boolean;
+            hasExplicitGridX: boolean;
+            hasExplicitGridY: boolean;
+            [key: string]: any;
         }
     ]>;
     /**
@@ -458,22 +508,37 @@ export type PlotOptions = {
      * your plot, or place a legend above the visualization.
      */
     header: Snippet;
+    /**
+     * The footer snippet is useful for rendering custom markup below the SVG body
+     * of your plot, e.g. for a caption or legend.
+     */
     footer: Snippet;
     /**
      * The underlay snippet is useful for adding a layer of custom HTML markup
      * behind the SVG body of your plot, e.g. for a watermark or background image.
      */
-    underlay: Snippet<[PlotOptions]>;
+    underlay: Snippet<[ResolvedPlotOptions]>;
     /**
      * The overlay snippet is useful for adding a layer of custom HTML markup
      * in front of the SVG body of your plot, e.g. for HTML tooltips.
      */
-    overlay: Snippet<[{
-        width: number;
-        height: number;
-        options: PlotOptions;
-        scales: PlotScales;
-    }]>;
+    overlay: Snippet<[
+        {
+            width: number;
+            height: number;
+            options: ResolvedPlotOptions;
+            scales: PlotScales;
+            hasProjection: boolean;
+            hasExplicitAxisX: boolean;
+            hasExplicitAxisY: boolean;
+            hasExplicitGridX: boolean;
+            hasExplicitGridY: boolean;
+            [key: string]: any;
+        }
+    ]>;
+    /**
+     * snippet for rendering custom facet axes
+     */
     facetAxes: Snippet;
     /**
      * if you set testid, the plot container will get a data-testid attribute which
@@ -501,4 +566,41 @@ export type PlotOptions = {
      */
     sortOrdinalDomains: boolean;
 };
+type ResolvedFacetXOptions = Partial<XScaleOptions> & {
+    /**
+     * customize base axis props used for rendering facet axis
+     */
+    axisProps?: Partial<ComponentProps<typeof BaseAxisX>>;
+    /**
+     * customize base axis options used for rendering facet axis
+     */
+    axisOptions?: Partial<ComponentProps<typeof BaseAxisX>['options']>;
+};
+type ResolvedFacetYOptions = Partial<YScaleOptions> & {
+    /**
+     * customize base axis props used for rendering facet axis
+     */
+    axisProps?: Partial<ComponentProps<typeof BaseAxisY>>;
+    /**
+     * customize base axis options used for rendering facet axis
+     */
+    axisOptions?: Partial<ComponentProps<typeof BaseAxisY>['options']>;
+};
+/**
+ * Internal plot options shape after shorthand forms (`false`, arrays) are normalized.
+ */
+type ResolvedXScaleOptions = Partial<XScaleOptions> & {
+    tickSpacing: number;
+    ticks?: RawValue[];
+};
+type ResolvedYScaleOptions = Partial<YScaleOptions> & {
+    tickSpacing: number;
+    ticks?: RawValue[];
+};
+export type ResolvedPlotOptions = Omit<PlotOptions, 'x' | 'y' | 'fx' | 'fy'> & {
+    x: ResolvedXScaleOptions;
+    y: ResolvedYScaleOptions;
+    fx: ResolvedFacetXOptions;
+    fy: ResolvedFacetYOptions;
+};
 export {};