svelteplot 0.3.4 → 0.3.5-pr-121.0

package/dist/types/scale.d.ts

@@ -0,0 +1,143 @@
+import type { ScaleBand, ScaleLinear, ScaleOrdinal } from 'd3-scale';
+import type { ChannelAccessor, RawValue, ScaledChannelName } from '.';
+export type AxisXAnchor = 'bottom' | 'top' | 'both';
+export type AxisYAnchor = 'left' | 'right' | 'both';
+export type ScaleName = 'x' | 'y' | 'r' | 'color' | 'opacity' | 'length' | 'symbol' | 'fx' | 'fy' | 'projection';
+export type ScaleOptions = {
+    /**
+     * Override the automatic scale type detection.
+     */
+    type: ScaleType | 'auto';
+    /**
+     * Set a custom domain for the scale instead of auto-computing the domain
+     * from the mark data channels.
+     */
+    domain?: RawValue[];
+    /**
+     * Set a custom range for the scale.
+     */
+    range?: RawValue[];
+    /**
+     * Reverse the scale.
+     */
+    reverse: boolean;
+    label?: string;
+    interval?: string | number;
+    clamp: boolean;
+    nice: boolean;
+    zero: boolean;
+    round: boolean;
+    percent: boolean;
+    transform?: (d: RawValue) => RawValue;
+    /**
+     * set the padding for band scales
+     */
+    padding: number;
+    /**
+     * set the align for band or point scales
+     */
+    align: number;
+    /**
+     * set the inner padding for band scales
+     */
+    paddingInner?: number;
+    /**
+     * set the outer padding for band scales
+     */
+    paddingOuter?: number;
+    insetLeft?: number;
+    insetRight?: number;
+    insetTop?: number;
+    insetBottom?: number;
+    ticks?: (number | Date)[];
+    tickSpacing: number;
+    base?: number;
+    sort?: ChannelAccessor | ((a: RawValue, b: RawValue) => number) | {
+        channel: string;
+        order: 'ascending' | 'descending';
+    };
+    constant?: number;
+};
+export type ColorScaleOptions = ScaleOptions & {
+    legend: boolean;
+    type: ScaleType | 'categorical' | 'sequential' | 'cyclical' | 'threshold' | 'quantile' | 'quantize' | 'diverging' | 'diverging-log' | 'diverging-pow' | 'diverging-sqrt' | 'diverging-symlog';
+    scheme: string;
+    /**
+     * fallback color used for null/undefined
+     */
+    unknown: string;
+    /**
+     * center value for diverging scales
+     */
+    pivot: number;
+    /**
+     * number of colors for quantize and quantile-threshold scales
+     */
+    n: number;
+    interpolate: (d: any) => typeof d;
+    /**
+     * The tick format for the color scale legend.
+     */
+    tickFormat: false | Intl.NumberFormatOptions | ((d: RawValue) => string);
+};
+export type ScaleType = 'linear' | 'pow' | 'sqrt' | 'log' | 'symlog' | 'time' | 'point' | 'ordinal' | 'sequential' | 'band' | 'categorical' | 'cyclical' | 'threshold' | 'quantile-cont' | 'quantile' | 'quantize' | 'diverging' | 'diverging-log' | 'diverging-pow' | 'diverging-sqrt' | 'diverging-symlog';
+export type XScaleOptions = ScaleOptions & {
+    /**
+     * Activate the implicit GridX mark. For more control over the grid styling
+     * and layering, add an explicit GridX mark to your plot instead of using the
+     * implicit grids.
+     */
+    grid: boolean;
+    /**
+     * Controls the position of the implicit AxisX mark, or set to false to disable
+     * the implicit AxisX mark. For more control over the axis styling and layering
+     * add an explicit AxisX mark to your plot instead of using the implicit axes.
+     */
+    axis: AxisXAnchor | false;
+    /**
+     * rotate the axis ticks
+     */
+    tickRotate: number;
+    labelAnchor: 'auto' | 'left' | 'center' | 'right';
+    tickFormat: false | Intl.NumberFormatOptions | ((d: RawValue) => string);
+};
+export type YScaleOptions = ScaleOptions & {
+    /**
+     * Activate the implicit GridY mark. For more control over the grid styling
+     * and layering, add an explicit GridY mark to your plot instead of using the
+     * implicit grids.
+     */
+    grid: boolean;
+    /**
+     * Controls the position of the implicit AxisY mark, or set to false to disable
+     * the implicit AxisY mark. For more control over the axis styling and layering
+     * add an explicit AxisY mark to your plot instead of using the implicit axes.
+     */
+    axis: AxisYAnchor | false;
+    tickFormat: false | Intl.NumberFormatOptions | ((d: RawValue) => string);
+    /**
+     * rotate the axis ticks
+     */
+    tickRotate: number;
+    labelAnchor: 'auto' | 'bottom' | 'middle' | 'top';
+};
+export type LegendScaleOptions = ScaleOptions & {
+    legend: boolean;
+};
+export type PlotScale = {
+    type: ScaleType;
+    domain: RawValue[];
+    range: RawValue[];
+    autoTitle?: string;
+    /**
+     * The number of marks that are using this scale.
+     */
+    manualActiveMarks: number;
+    /**
+     * Set of accessors used in channels that are bound to this scale.
+     */
+    uniqueScaleProps: Set<ChannelAccessor>;
+    skip: Map<ScaledChannelName, Set<symbol>>;
+    fn: ScaleLinear<RawValue, number> & ScaleBand<RawValue> & ScaleOrdinal<string | Date, number> & ScaleOrdinal<string | Date, string>;
+};
+export type PlotScales = Record<ScaleName, PlotScale>;

package/dist/types/scale.js

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

package/dist/types.d.ts

@@ -1,40 +1,12 @@
 import type { ScaleBand, ScaleLinear, ScaleOrdinal } from 'd3-scale';
-import type { Snippet } from 'svelte';
+import type { ComponentProps, Snippet } from 'svelte';
 import type { MouseEventHandler } from 'svelte/elements';
 import type { MarkerShape } from './marks/helpers/Marker.svelte';
 import type { Writable } from 'svelte/store';
 import type * as CSS from 'csstype';
-import type { AreaMarkProps } from './marks/Area.svelte';
-import type { ArrowMarkProps } from './marks/Arrow.svelte';
-import type { AxisXMarkProps } from './marks/AxisX.svelte';
-import type { AxisYMarkProps } from './marks/AxisY.svelte';
-import type { BarXMarkProps } from './marks/BarX.svelte';
-import type { CellMarkProps } from './marks/Cell.svelte';
-import type { DotMarkProps } from './marks/Dot.svelte';
-import type { FrameMarkProps } from './marks/Frame.svelte';
-import type { GeoMarkProps } from './marks/Geo.svelte';
-import type { GraticuleMarkProps } from './marks/Graticule.svelte';
-import type { LineMarkProps } from './marks/Line.svelte';
-import type { LinkMarkProps } from './marks/Link.svelte';
-import type { RectMarkProps } from './marks/Rect.svelte';
-import type { RuleXMarkProps } from './marks/RuleX.svelte';
-import type { SphereMarkProps } from './marks/Sphere.svelte';
-import type { SpikeMarkProps } from './marks/Spike.svelte';
-import type { TextMarkProps } from './marks/Text.svelte';
-import type { TickXMarkProps } from './marks/TickX.svelte';
-import type { VectorMarkProps } from './marks/Vector.svelte';
-import type { BrushMarkProps } from './marks/Brush.svelte';
-import type { BrushXMarkProps } from './marks/BrushX.svelte';
-import type { BrushYMarkProps } from './marks/BrushY.svelte';
-import type { RectXMarkProps } from './marks/RectX.svelte';
-import type { RectYMarkProps } from './marks/RectY.svelte';
-import type { RuleYMarkProps } from './marks/RuleY.svelte';
-import type { TickYMarkProps } from './marks/TickY.svelte';
-import type { GridYMarkProps } from './marks/GridY.svelte';
-import type { GridXMarkProps } from './marks/GridX.svelte';
-import type { PointerMarkProps } from './marks/Pointer.svelte';
-import type { BoxXMarkProps } from './marks/BoxX.svelte';
-import type { BoxYMarkProps } from './marks/BoxY.svelte';
+import type { Area, AreaX, AreaY, Arrow, AxisX, AxisY, BarX, BarY, BoxX, BoxY, Brush, BrushX, BrushY, Cell, Dot, Frame, Geo, Graticule, GridX, GridY, Line, Link, Pointer, Rect, RectX, RectY, RuleX, RuleY, Sphere, Spike, Text, TickX, TickY, Vector } from './marks';
+import type { GeoProjection } from 'd3-geo';
+import type { Clip } from './helpers/projection';
 export type MarkType = 'area' | 'arrow' | 'axisX' | 'axisY' | 'barX' | 'barY' | 'cell' | 'dot' | 'vector' | 'frame' | 'geo' | 'gridX' | 'gridY' | 'line' | 'rect' | 'regression' | 'ruleX' | 'ruleY' | 'swoopyArrow' | 'text' | 'tickX' | 'tickY';
 export type ScaleName = 'x' | 'y' | 'r' | 'color' | 'opacity' | 'length' | 'symbol' | 'fx' | 'fy' | 'projection';
 export type ScaleType = 'linear' | 'pow' | 'sqrt' | 'log' | 'symlog' | 'time' | 'point' | 'ordinal' | 'sequential' | 'band' | 'categorical' | 'cyclical' | 'threshold' | 'quantile-cont' | 'quantile' | 'quantize' | 'diverging' | 'diverging-log' | 'diverging-pow' | 'diverging-sqrt' | 'diverging-symlog';
@@ -43,7 +15,7 @@ export type Mark<T> = {
     type: MarkType;
     channels: ScaledChannelName[];
     scales: Set<ScaleName>;
-    data: DataRecord[];
+    data: DataRecord<T>[];
     options: T;
 };
 export type ScaledChannelName = 'fill' | 'fillOpacity' | 'opacity' | 'r' | 'length' | 'stroke' | 'strokeOpacity' | 'symbol' | 'fx' | 'fy' | 'x' | 'x1' | 'x2' | 'y' | 'y1' | 'y2';
@@ -121,6 +93,10 @@ export type ColorScaleOptions = ScaleOptions & {
      */
     n: number;
     interpolate: (d: any) => typeof d;
+    /**
+     * The tick format for the color scale legend.
+     */
+    tickFormat: false | Intl.NumberFormatOptions | ((d: RawValue) => string);
 };
 export type AxisXAnchor = 'bottom' | 'top' | 'both';
 export type AxisYAnchor = 'left' | 'right' | 'both';
@@ -142,7 +118,7 @@ export type XScaleOptions = ScaleOptions & {
      */
     tickRotate: number;
     labelAnchor: 'auto' | 'left' | 'center' | 'right';
-    tickFormat: 'auto' | string | ((d: RawValue) => string);
+    tickFormat: false | Intl.NumberFormatOptions | ((d: RawValue) => string);
 };
 export type YScaleOptions = ScaleOptions & {
     /**
@@ -157,7 +133,7 @@ export type YScaleOptions = ScaleOptions & {
      * add an explicit AxisY mark to your plot instead of using the implicit axes.
      */
     axis: AxisYAnchor | false;
-    tickFormat: string | ((d: RawValue) => string);
+    tickFormat: false | Intl.NumberFormatOptions | ((d: RawValue) => string);
     /**
      * rotate the axis ticks
      */
@@ -247,7 +223,18 @@ export type PlotOptions = {
     /**
      * Geo-projection
      */
-    projection: string | null;
+    projection: string | null | {
+        type?: string;
+        rotate?: [number, number] | [number, number, number];
+        domain?: object;
+        inset?: number;
+        clip?: Clip;
+    } | {
+        type: (d: {
+            width: number;
+            height: number;
+        }) => GeoProjection;
+    };
     /**
      * if not null, computes a default height such that a variation of one
      * unit in the x dimension is represented by the corresponding number
@@ -262,7 +249,7 @@ export type PlotOptions = {
          * The data to facet by. Turns on automatic faceting for all marks that
          * use the exact same data (===)
          */
-        data: DataRecord[];
+        data: DataRecord<any>[];
         x: ChannelAccessor;
         y: ChannelAccessor;
     }>;
@@ -332,17 +319,17 @@ export type PlotOptions = {
     css: (d: string) => string | undefined;
 };
 export type GenericMarkOptions = Record<string | symbol, any>;
-export type DataRecord = Record<string | symbol, RawValue> & {
+export type DataRecord<T = Record<string | symbol, RawValue>> = T & {
     ___orig___?: RawValue | [RawValue, RawValue];
 };
-export type ResolvedDataRecord = Partial<Record<ScaledChannelName, any>> & {
-    datum: DataRecord;
+export type ResolvedDataRecord<T = Record<string | symbol, RawValue>> = Partial<Record<ScaledChannelName, any>> & {
+    datum: DataRecord<T>;
 };
-export type ScaledDataRecord = Partial<Record<ScaledChannelName, number | string | boolean | undefined>> & {
-    datum: DataRecord;
+export type ScaledDataRecord<T = Record<string | symbol, RawValue>> = Partial<Record<ScaledChannelName, number | string | boolean | undefined>> & {
+    datum: DataRecord<T>;
     valid: Boolean;
 };
-export type DataRow = DataRecord | RawValue | [number, number] | null;
+export type DataRow<T = Record<string | symbol, RawValue>> = DataRecord<T> | RawValue | [number, number] | null;
 export type PlotScale = {
     type: ScaleType;
     domain: RawValue[];
@@ -379,8 +366,14 @@ export type MarkerOptions = {
     marker?: boolean | MarkerShape | Snippet;
 };
 export type PlotScales = Record<ScaleName, PlotScale>;
-export type ChannelAccessor = RawValue | ((d: DataRow) => RawValue) | null | undefined;
-export type ConstantAccessor<T> = T | ((d: DataRow) => T) | null | undefined;
+export type ChannelAccessor<T = Record<string | symbol, RawValue>> = ChannelValue<T> | {
+    /** the channel value */
+    value: ChannelValue<T>;
+    /** you can bypass the scale by passing null */
+    scale: boolean | null;
+};
+export type ChannelValue<T = Record<string | symbol, RawValue>> = RawValue | keyof T | ((d: T) => RawValue) | null | undefined;
+export type ConstantAccessor<T, D = Record<string | symbol, RawValue>> = T | ((d: D) => T) | null | undefined;
 export type PlotState = {
     width: number;
     height: number;
@@ -465,7 +458,7 @@ type FacetState = {
 /**
  * Test if the given data record is visible in the current facet.
  */
-type TestFacetFunction = (datum: DataRecord, channels: Record<ChannelName, ChannelAccessor>) => boolean;
+type TestFacetFunction = (datum: DataRecord<any>, channels: Record<ChannelName, ChannelAccessor>) => boolean;
 export type FacetContext = {
     /**
      * Returns a stateful function that tests whether a specific data
@@ -474,65 +467,65 @@ export type FacetContext = {
     getTestFacet: () => TestFacetFunction;
     getFacetState: () => FacetState;
 };
-export type LinkableMarkProps = {
+export type LinkableMarkProps<T> = {
     /**
      * if set, the mark element will be wrapped in a <a> link element
      */
-    href?: ConstantAccessor<string>;
+    href?: ConstantAccessor<string, T>;
     /**
      * the relationship of the target object to the link object (e.g. "noopener")
      * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/a#rel
      */
-    rel?: ConstantAccessor<string>;
+    rel?: ConstantAccessor<string, T>;
     /**
      * the link target mime type, e.g. "text/csv"
      * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/a#type
      */
-    type?: ConstantAccessor<string>;
+    type?: ConstantAccessor<string, T>;
     /**
      * the target of the link, e.g. "_blank" or "_self"
      * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/a#target
      */
-    target?: ConstantAccessor<'_self' | '_blank' | '_parent' | '_top' | string>;
+    target?: ConstantAccessor<'_self' | '_blank' | '_parent' | '_top' | string, 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>;
-    [key: `data-sveltekit-${string}`]: string | boolean;
+    download?: ConstantAccessor<boolean, T>;
+    [key: `data-sveltekit-${string}`]: string | boolean | undefined;
 };
-export type BaseMarkProps = Partial<{
+export type BaseMarkProps<T> = Partial<{
     /**
      * Filter the data without modifying the inferred scales
      */
-    filter?: ConstantAccessor<boolean>;
+    filter?: ConstantAccessor<boolean, T>;
     facet?: 'auto' | 'include' | 'exclude';
-    fx: ChannelAccessor;
-    fy: ChannelAccessor;
-    dx: ConstantAccessor<number>;
-    dy: ConstantAccessor<number>;
-    fill: ConstantAccessor<string>;
-    fillOpacity: ConstantAccessor<number>;
-    sort: string | ConstantAccessor<RawValue> | ((a: RawValue, b: RawValue) => number) | {
+    fx: ChannelAccessor<T>;
+    fy: ChannelAccessor<T>;
+    dx: ConstantAccessor<number, T>;
+    dy: ConstantAccessor<number, T>;
+    fill: ChannelAccessor<T>;
+    fillOpacity: ConstantAccessor<number, T>;
+    sort: string | ConstantAccessor<RawValue, T> | ((a: RawValue, b: RawValue) => number) | {
         /** sort data using an already defined channel */
         channel: string;
         /** sort order */
         order?: 'ascending' | 'descending';
     };
-    stroke: ConstantAccessor<string>;
-    strokeWidth: ConstantAccessor<number>;
-    strokeOpacity: ConstantAccessor<number>;
-    strokeLinejoin: ConstantAccessor<CSS.Property.StrokeLinejoin>;
-    strokeLinecap: ConstantAccessor<CSS.Property.StrokeLinecap>;
-    strokeMiterlimit: ConstantAccessor<number>;
-    opacity: ConstantAccessor<number>;
-    strokeDasharray: ConstantAccessor<string>;
-    strokeDashoffset: ConstantAccessor<number>;
-    mixBlendMode: ConstantAccessor<CSS.Property.MixBlendMode>;
+    stroke: ChannelAccessor<T>;
+    strokeWidth: ConstantAccessor<number, T>;
+    strokeOpacity: ConstantAccessor<number, T>;
+    strokeLinejoin: ConstantAccessor<CSS.Property.StrokeLinejoin, T>;
+    strokeLinecap: ConstantAccessor<CSS.Property.StrokeLinecap, T>;
+    strokeMiterlimit: ConstantAccessor<number, T>;
+    opacity: ChannelAccessor<T>;
+    strokeDasharray: ConstantAccessor<string, T>;
+    strokeDashoffset: ConstantAccessor<number, T>;
+    mixBlendMode: ConstantAccessor<CSS.Property.MixBlendMode, T>;
     clipPath: string;
-    imageFilter: ConstantAccessor<string>;
-    shapeRendering: ConstantAccessor<CSS.Property.ShapeRendering>;
-    paintOrder: ConstantAccessor<string>;
+    imageFilter: ConstantAccessor<string, T>;
+    shapeRendering: ConstantAccessor<CSS.Property.ShapeRendering, T>;
+    paintOrder: ConstantAccessor<string, T>;
     onclick?: MouseEventHandler<SVGPathElement>;
     ondblclick?: MouseEventHandler<SVGPathElement>;
     onmouseup?: MouseEventHandler<SVGPathElement>;
@@ -567,7 +560,7 @@ export type BaseMarkProps = Partial<{
      * if you want to give your mark element an extra CSS class
      */
     class: string | null;
-    cursor: ConstantAccessor<CSS.Property.Cursor>;
+    cursor: ConstantAccessor<CSS.Property.Cursor, T>;
 }>;
 export type BorderRadius = number | {
     topLeft?: number;
@@ -575,20 +568,20 @@ export type BorderRadius = number | {
     bottomRight?: number;
     bottomLeft?: number;
 };
-export type BaseRectMarkProps = {
-    inset?: ConstantAccessor<number>;
-    insetLeft?: ConstantAccessor<number>;
-    insetTop?: ConstantAccessor<number>;
-    insetRight?: ConstantAccessor<number>;
-    insetBottom?: ConstantAccessor<number>;
+export type BaseRectMarkProps<T> = {
+    inset?: ConstantAccessor<number, T>;
+    insetLeft?: ConstantAccessor<number, T>;
+    insetTop?: ConstantAccessor<number, T>;
+    insetRight?: ConstantAccessor<number, T>;
+    insetBottom?: ConstantAccessor<number, T>;
     borderRadius?: BorderRadius;
 };
-export type Channels = Record<string, ChannelAccessor | ConstantAccessor<string | number | boolean | symbol>>;
-export type TransformArg<K> = Channels & BaseMarkProps & {
-    data: K[];
+export type Channels<T> = Record<string, ChannelAccessor<T> | ConstantAccessor<string | number | boolean | symbol, T>>;
+export type TransformArg<T> = Channels<T> & BaseMarkProps<T> & {
+    data: T[];
 };
-export type MapArg<K> = Channels & {
-    data: K[];
+export type MapArg<T> = Channels<T> & {
+    data: T[];
 };
 export type TransformArgsRow = Partial<Channels> & {
     data: DataRow[];
@@ -660,177 +653,177 @@ export type PlotDefaults = {
     /**
      * default props for area marks, applied to area, areaX, and areaY marks
      */
-    area: Partial<Omit<AreaMarkProps, IgnoreDefaults>>;
+    area: Partial<Omit<ComponentProps<typeof Area>, IgnoreDefaults>>;
     /**
      * default props for areaX marks
      */
-    areaX: Partial<Omit<AreaMarkProps, IgnoreDefaults>>;
+    areaX: Partial<Omit<ComponentProps<typeof AreaX>, IgnoreDefaults>>;
     /**
      * default props for areaY marks
      */
-    areaY: Partial<Omit<AreaMarkProps, IgnoreDefaults>>;
+    areaY: Partial<Omit<ComponentProps<typeof AreaY>, IgnoreDefaults>>;
     /**
      * default props for arrow marks
      */
-    arrow: Partial<Omit<ArrowMarkProps, IgnoreDefaults>>;
+    arrow: Partial<Omit<ComponentProps<typeof Arrow>, IgnoreDefaults>>;
     /**
      * default props for axis marks, applied to both axisX and axisY marks
      */
-    axis: Partial<Omit<AxisXMarkProps, 'data' | 'facet' | ChannelName | 'facetAnchor' | 'labelAnchor' | 'anchor'> & {
+    axis: Partial<Omit<ComponentProps<typeof AxisX>, 'data' | 'facet' | ChannelName | 'facetAnchor' | 'labelAnchor' | 'anchor'> & {
         implicit: boolean;
     }>;
     /**
      * default props for axisX marks
      */
-    axisX: Partial<Omit<AxisXMarkProps, IgnoreDefaults> & {
+    axisX: Partial<Omit<ComponentProps<typeof AxisX>, IgnoreDefaults> & {
         implicit: boolean;
     }>;
     /**
      * default props for axisY marks
      */
-    axisY: Partial<Omit<AxisYMarkProps, IgnoreDefaults> & {
+    axisY: Partial<Omit<ComponentProps<typeof AxisY>, IgnoreDefaults> & {
         implicit: boolean;
     }>;
     /**
      * default props for bar marks, applied to both barX and barY marks
      */
-    bar: Partial<Omit<BarXMarkProps, IgnoreDefaults>>;
+    bar: Partial<Omit<ComponentProps<typeof BarX>, IgnoreDefaults>>;
     /**
      * default props for barX marks
      */
-    barX: Partial<Omit<BarXMarkProps, IgnoreDefaults>>;
+    barX: Partial<Omit<ComponentProps<typeof BarX>, IgnoreDefaults>>;
     /**
      * default props for barY marks
      */
-    barY: Partial<Omit<BarXMarkProps, IgnoreDefaults>>;
+    barY: Partial<Omit<ComponentProps<typeof BarY>, IgnoreDefaults>>;
     /**
      * default props for box marks, applied to boxX and boxY marks
      */
-    box: Partial<Omit<BoxXMarkProps, IgnoreDefaults>>;
+    box: Partial<Omit<ComponentProps<typeof BoxX>, IgnoreDefaults>>;
     /**
      * default props for boxX marks
      */
-    boxX: Partial<Omit<BoxXMarkProps, IgnoreDefaults>>;
+    boxX: Partial<Omit<ComponentProps<typeof BoxX>, IgnoreDefaults>>;
     /**
      * default props for boxY marks
      */
-    boxY: Partial<Omit<BoxYMarkProps, IgnoreDefaults>>;
+    boxY: Partial<Omit<ComponentProps<typeof BoxY>, IgnoreDefaults>>;
     /**
      * default props for brush marks, applied to brush, brushX and brushY marks
      */
-    brush: Partial<Omit<BrushMarkProps, IgnoreDefaults | 'limitDimension'>>;
+    brush: Partial<Omit<ComponentProps<typeof Brush>, IgnoreDefaults | 'limitDimension'>>;
     /**
      * default props for brushX marks
      */
-    brushX: Partial<Omit<BrushXMarkProps, IgnoreDefaults>>;
+    brushX: Partial<Omit<ComponentProps<typeof BrushX>, IgnoreDefaults>>;
     /**
      * default props for brushY marks
      */
-    brushY: Partial<Omit<BrushYMarkProps, IgnoreDefaults>>;
+    brushY: Partial<Omit<ComponentProps<typeof BrushY>, IgnoreDefaults>>;
     /**
      * default props for cell marks
      */
-    cell: Partial<Omit<CellMarkProps, IgnoreDefaults>>;
+    cell: Partial<Omit<ComponentProps<typeof Cell>, IgnoreDefaults>>;
     /**
      * default props for dot marks
      */
-    dot: Partial<Omit<DotMarkProps, IgnoreDefaults>>;
+    dot: Partial<Omit<ComponentProps<typeof Dot>, IgnoreDefaults>>;
     /**
      * default props for frame marks
      */
-    frame: Partial<FrameMarkProps & {
+    frame: Partial<ComponentProps<typeof Frame> & {
         implicit: boolean;
     }>;
     /**
      * default props for geo marks
      */
-    geo: Partial<Omit<GeoMarkProps, IgnoreDefaults>>;
+    geo: Partial<Omit<ComponentProps<typeof Geo>, IgnoreDefaults>>;
     /**
      * default props for graticule marks
      */
-    graticule: Partial<Omit<GraticuleMarkProps, IgnoreDefaults>>;
+    graticule: Partial<Omit<ComponentProps<typeof Graticule>, IgnoreDefaults>>;
     /**
      * default props for grid marks, applied to both gridX and gridY marks
      */
-    grid: Partial<Omit<GridXMarkProps, IgnoreDefaults> & {
+    grid: Partial<Omit<ComponentProps<typeof GridX>, IgnoreDefaults> & {
         implicit: boolean;
     }>;
     /**
      * default props for gridX marks
      */
-    gridX: Partial<Omit<GridXMarkProps, IgnoreDefaults> & {
+    gridX: Partial<Omit<ComponentProps<typeof GridX>, IgnoreDefaults> & {
         implicit: boolean;
     }>;
     /**
      * default props for gridY marks
      */
-    gridY: Partial<Omit<GridYMarkProps, IgnoreDefaults> & {
+    gridY: Partial<Omit<ComponentProps<typeof GridY>, IgnoreDefaults> & {
         implicit: boolean;
     }>;
     /**
      * default props for line marks
      */
-    line: Partial<Omit<LineMarkProps, IgnoreDefaults>>;
+    line: Partial<Omit<ComponentProps<typeof Line>, IgnoreDefaults>>;
     /**
      * default props for link marks
      */
-    link: Partial<Omit<LinkMarkProps, IgnoreDefaults>>;
+    link: Partial<Omit<ComponentProps<typeof Link>, IgnoreDefaults>>;
     /**
      * default props for pointer marks
      */
-    pointer: Partial<Omit<PointerMarkProps, IgnoreDefaults>>;
+    pointer: Partial<Omit<ComponentProps<typeof Pointer>, IgnoreDefaults>>;
     /**
      * default props for rect marks, applied to rect and rectX marks
      */
-    rect: Partial<Omit<RectMarkProps, IgnoreDefaults>>;
+    rect: Partial<Omit<ComponentProps<typeof Rect>, IgnoreDefaults>>;
     /**
      * default props for rectX marks
      */
-    rectX: Partial<Omit<RectXMarkProps, IgnoreDefaults>>;
+    rectX: Partial<Omit<ComponentProps<typeof RectX>, IgnoreDefaults>>;
     /**
      * default props for rectY marks
      */
-    rectY: Partial<Omit<RectYMarkProps, IgnoreDefaults>>;
+    rectY: Partial<Omit<ComponentProps<typeof RectY>, IgnoreDefaults>>;
     /**
      * default props for rule marks
      */
-    rule: Partial<Omit<RuleXMarkProps, IgnoreDefaults>>;
+    rule: Partial<Omit<ComponentProps<typeof RuleX>, IgnoreDefaults>>;
     /**
      * default props for rule marks
      */
-    ruleX: Partial<Omit<RuleXMarkProps, IgnoreDefaults>>;
+    ruleX: Partial<Omit<ComponentProps<typeof RuleX>, IgnoreDefaults>>;
     /**
      * default props for rule marks
      */
-    ruleY: Partial<Omit<RuleYMarkProps, IgnoreDefaults>>;
+    ruleY: Partial<Omit<ComponentProps<typeof RuleY>, IgnoreDefaults>>;
     /**
      * default props for sphere marks
      */
-    sphere: Partial<SphereMarkProps>;
+    sphere: Partial<ComponentProps<typeof Sphere>>;
     /**
      * default props for spike marks
      */
-    spike: Partial<Omit<SpikeMarkProps, IgnoreDefaults>>;
+    spike: Partial<Omit<ComponentProps<typeof Spike>, IgnoreDefaults>>;
     /**
      * default props for text marks
      */
-    text: Partial<Omit<TextMarkProps, IgnoreDefaults>>;
+    text: Partial<Omit<ComponentProps<typeof Text>, IgnoreDefaults>>;
     /**
      * default props for tick marks, applied to tickX and tickY marks
      */
-    tick: Partial<Omit<TickXMarkProps, IgnoreDefaults>>;
+    tick: Partial<Omit<ComponentProps<typeof TickX>, IgnoreDefaults>>;
     /**
      * default props for tickX marks
      */
-    tickX: Partial<Omit<TickXMarkProps, IgnoreDefaults>>;
+    tickX: Partial<Omit<ComponentProps<typeof TickX>, IgnoreDefaults>>;
     /**
      * default props for tickY marks
      */
-    tickY: Partial<Omit<TickYMarkProps, IgnoreDefaults>>;
+    tickY: Partial<Omit<ComponentProps<typeof TickY>, IgnoreDefaults>>;
     /**
      * default props for vector marks
      */
-    vector: Partial<Omit<VectorMarkProps, IgnoreDefaults>>;
+    vector: Partial<Omit<ComponentProps<typeof Vector>, IgnoreDefaults>>;
 };
 export type MapIndexObject = {
     mapIndex: (I: number[], S: RawValue[], T: RawValue[]) => void;