svelteplot 0.4.6 → 0.4.7-pr-219.0

package/dist/core/Plot.svelte

@@ -8,7 +8,7 @@
     this component. 
 -->
 <script lang="ts">
-    import { getContext, setContext } from 'svelte';
+    import { setContext } from 'svelte';
     import { SvelteMap } from 'svelte/reactivity';
     import { writable } from 'svelte/store';
 
@@ -21,13 +21,15 @@
         PlotScale,
         PlotDefaults,
         PlotState,
-        RawValue
+        RawValue,
+        PlotMargin
     } from '../types/index.js';
     import FacetGrid from './FacetGrid.svelte';
 
     import mergeDeep from '../helpers/mergeDeep.js';
     import { computeScales, projectXY } from '../helpers/scales.js';
     import { CHANNEL_SCALE, SCALES } from '../constants.js';
+    import { getPlotDefaults, setPlotDefaults } from '../hooks/plotDefaults.js';
 
     // automatic margins can be applied by the marks, registered
     // with their respective unique identifier as keys
@@ -51,7 +53,7 @@
     const maxMarginBottom = $derived(Math.max(...$autoMarginBottom.values()));
     const maxMarginTop = $derived(Math.max(...$autoMarginTop.values()));
 
-    const USER_DEFAULTS = getContext<Partial<PlotDefaults>>('svelteplot/defaults') || {};
+    const USER_DEFAULTS = getPlotDefaults();
 
     // default settings in the plot and marks can be overwritten by
     // defining the svelteplot/defaults context outside of Plot
@@ -59,6 +61,7 @@
         height: 350,
         initialWidth: 500,
         inset: 0,
+        margin: 'auto',
         colorScheme: 'turbo',
         unknown: '#cccccc99',
 
@@ -115,14 +118,14 @@
 
     let width = $state(DEFAULTS.initialWidth);
 
-    setContext('svelteplot/_defaults', DEFAULTS);
+    setPlotDefaults(DEFAULTS);
 
     // information that influences the default plot options
     type PlotOptionsParameters = {
         explicitScales: Set<ScaleName>;
         explicitDomains: Set<ScaleName>;
         hasProjection: boolean;
-        margins?: number;
+        margin?: number | 'auto';
         inset?: number;
     };
 
@@ -173,7 +176,7 @@
             explicitScales,
             explicitDomains,
             hasProjection: !!initialOpts.projection,
-            margins: initialOpts.margins,
+            margin: initialOpts.margin,
             inset: initialOpts.inset
         })
     );
@@ -363,6 +366,38 @@
         return mergeDeep<PlotOptions>({}, smartDefaultPlotOptions(opts), initialOpts);
     }
 
+    function maybeMargin(
+        // the margin option provided to the <Plot> component
+        margin: number | 'auto' | PlotMargin | undefined,
+        // direction to extract from the margin object
+        direction: 'left' | 'right' | 'top' | 'bottom',
+        // the margin option defined in the plot defaults
+        defaultValue: PlotMargin | number | 'auto',
+        // automatic margins computed from the marks
+        autoMargins: {
+            left: number;
+            right: number;
+            top: number;
+            bottom: number;
+        }
+    ): number {
+        // direction-specific margin value takes precedence
+        const marginValue =
+            typeof margin === 'object' && margin[direction] != null
+                ? margin[direction]
+                : // use the margin value if it's a number
+                  typeof margin === 'number' || margin === 'auto'
+                  ? margin
+                  : // use direction-specific default value if defined
+                    typeof defaultValue === 'object' && defaultValue[direction] != null
+                    ? defaultValue[direction]
+                    : typeof defaultValue === 'number' || defaultValue === 'auto'
+                      ? defaultValue
+                      : 'auto';
+
+        return marginValue === 'auto' ? autoMargins[direction] : marginValue;
+    }
+
     /**
      * compute smart default options for the plot based on the scales and marks
      */
@@ -370,43 +405,31 @@
         explicitScales,
         explicitDomains,
         hasProjection,
-        margins
+        margin
     }: PlotOptionsParameters): PlotOptions {
         const autoXAxis = explicitScales.has('x') || explicitDomains.has('x');
         const autoYAxis = explicitScales.has('y') || explicitDomains.has('y');
         const isOneDimensional = autoXAxis !== autoYAxis;
         const oneDimX = autoXAxis && !autoYAxis;
         const oneDimY = autoYAxis && !autoXAxis;
+
+        const autoMargins = {
+            left: hasProjection ? 0 : Math.max(maxMarginLeft + 1, 1),
+            right: hasProjection ? 0 : oneDimY ? 0 : Math.max(maxMarginRight + 1, 4),
+            top: hasProjection ? 0 : oneDimX ? 0 : Math.max(5, maxMarginTop),
+            bottom: hasProjection ? 0 : Math.max(5, maxMarginBottom)
+        };
+
         return {
             title: '',
             subtitle: '',
             caption: '',
             height: 'auto',
             // maxWidth: oneDimY ? `${60 * e}px` : undefined,
-            marginLeft: hasProjection
-                ? 0
-                : margins != null
-                  ? margins
-                  : Math.max(maxMarginLeft + 1, 1),
-            marginRight: hasProjection
-                ? 0
-                : margins != null
-                  ? margins
-                  : oneDimY
-                    ? 0
-                    : Math.max(maxMarginRight + 1, 4),
-            marginTop: hasProjection
-                ? 0
-                : margins != null
-                  ? margins
-                  : oneDimX
-                    ? 0
-                    : Math.max(5, maxMarginTop),
-            marginBottom: hasProjection
-                ? 0
-                : margins != null
-                  ? margins
-                  : Math.max(5, maxMarginBottom),
+            marginLeft: maybeMargin(margin, 'left', DEFAULTS.margin, autoMargins),
+            marginRight: maybeMargin(margin, 'right', DEFAULTS.margin, autoMargins),
+            marginTop: maybeMargin(margin, 'top', DEFAULTS.margin, autoMargins),
+            marginBottom: maybeMargin(margin, 'bottom', DEFAULTS.margin, autoMargins),
             inset: isOneDimensional ? 10 : DEFAULTS.inset,
             grid: (DEFAULTS.gridX?.implicit ?? false) && (DEFAULTS.gridY?.implicit ?? false),
             axes: (DEFAULTS.axisX?.implicit ?? false) && (DEFAULTS.axisY?.implicit ?? false),

package/dist/helpers/colors.d.ts

@@ -6,7 +6,7 @@ type SchemeGetter = (n: number) => readonly string[];
 export declare function isOrdinalScheme(scheme: ColorScheme): boolean;
 export declare function ordinalScheme(scheme: string): SchemeGetter | undefined;
 export declare function ordinalRange(scheme: string, length: number): readonly string[] | undefined;
-export declare function maybeBooleanRange(domain: boolean[], scheme?: string): unknown[] | undefined;
+export declare function maybeBooleanRange(domain: boolean[], scheme?: string): any[] | undefined;
 export declare function isQuantitativeScheme(scheme: string): boolean;
 export declare function quantitativeScheme(scheme: string): typeof interpolateBrBG | undefined;
 export declare function isDivergingScheme(scheme: string): boolean;

package/dist/helpers/index.d.ts

@@ -3,8 +3,8 @@ import type { Snippet } from 'svelte';
 /**
  * Returns first argument that is not null or undefined
  */
-export declare function coalesce(...args: (RawValue | undefined | null)[]): RawValue | null;
-export declare function testFilter<T>(datum: T, options: Channels<T>): true | T | null;
+export declare function coalesce(...args: (RawValue | undefined | null)[]): any;
+export declare function testFilter<T>(datum: T, options: Channels<T>): any;
 export declare function randomId(): string;
 export declare function isSnippet(value: unknown): value is Snippet;
 export declare function isValid(value: RawValue | undefined): value is number | Date | string;

package/dist/helpers/scales.d.ts

@@ -15,7 +15,7 @@ export declare function createScale<T extends ScaleOptions>(name: ScaleName, sca
     autoTitle?: undefined;
 } | {
     type: ScaleType;
-    domain: RawValue[] | [undefined, undefined];
+    domain: any;
     range: any;
     fn: any;
     skip: Map<ScaledChannelName, Set<symbol>>;
@@ -28,7 +28,7 @@ export declare function createScale<T extends ScaleOptions>(name: ScaleName, sca
  * Infer a scale type based on the scale name, the data values mapped to it and
  * the mark types that are bound to the scale
  */
-export declare function inferScaleType(name: ScaleName, dataValues: RawValue[], markTypes: Set<MarkType>): ScaleType;
+export declare function inferScaleType(name: ScaleName, dataValues: RawValue[], markTypes: Set<MarkType>, scaleOptions?: Partial<ScaleOptions>): ScaleType;
 /**
  * Mark channels can explicitly or implicitly be exempt from being
  * mapped to a scale, so everywhere where values are being mapped to

package/dist/helpers/scales.js

@@ -1,5 +1,5 @@
 import { extent, ascending } from 'd3-array';
-import { isColorOrNull, isDateOrNull, isNumberOrNull, isNumberOrNullOrNaN, isStringOrNull } from './typeChecks.js';
+import { isColorOrNull, isDate, isDateOrNull, isNumberOrNull, isNumberOrNullOrNaN, isStringOrNull } from './typeChecks.js';
 import { CHANNEL_SCALE, VALID_SCALE_TYPES } from '../constants.js';
 import { isSymbolOrNull } from './typeChecks.js';
 import { resolveProp, toChannelOption } from './resolve.js';
@@ -146,7 +146,7 @@ export function createScale(name, scaleOptions, marks, plotOptions, plotWidth, p
     // construct domain from data values
     const valueArr = [...dataValues.values(), ...(scaleOptions.domain || [])].filter((d) => d != null);
     const type = scaleOptions.type === 'auto'
-        ? inferScaleType(name, valueArr, markTypes)
+        ? inferScaleType(name, valueArr, markTypes, scaleOptions)
         : scaleOptions.type;
     if (VALID_SCALE_TYPES[name] && !VALID_SCALE_TYPES[name].has(type)) {
         throw new Error(`Invalid scale type ${type} for scale
@@ -217,11 +217,15 @@ function domainFromInterval(domain, interval, name) {
     const out = interval_.range(lo, interval_.offset(hi));
     return name === 'y' ? out.toReversed() : out;
 }
+const markTypesWithBandDefault = {
+    x: new Set(['barY', 'cell', 'tickY']),
+    y: new Set(['barX', 'cell', 'tickX'])
+};
 /**
  * Infer a scale type based on the scale name, the data values mapped to it and
  * the mark types that are bound to the scale
  */
-export function inferScaleType(name, dataValues, markTypes) {
+export function inferScaleType(name, dataValues, markTypes, scaleOptions = {}) {
     if (name === 'color') {
         if (!dataValues.length)
             return 'ordinal';
@@ -235,15 +239,22 @@ export function inferScaleType(name, dataValues, markTypes) {
     }
     if (name === 'symbol')
         return 'ordinal';
-    // for positional scales, try to pick a scale that's required by the mark types
     if (name === 'x' || name === 'y') {
-        if (name === 'y' &&
-            (markTypes.has('barX') || markTypes.has('tickX') || markTypes.has('cell')))
-            return 'band';
-        if (name === 'x' &&
-            (markTypes.has('barY') || markTypes.has('tickY') || markTypes.has('cell')))
-            return 'band';
+        // if for a positional scale we may infer the scale type from the scale options
+        if (scaleOptions.nice || scaleOptions.zero)
+            return 'linear';
+        if (scaleOptions.domain && scaleOptions.domain.length === 2) {
+            if (scaleOptions.domain.every(Number.isFinite))
+                return 'linear';
+            if (scaleOptions.domain.every(isDate))
+                return 'time';
+        }
     }
+    // for positional scales, try to pick a scale that's required by the mark types
+    if (name === 'y' && Array.from(markTypes).some((d) => markTypesWithBandDefault.y.has(d)))
+        return 'band';
+    if (name === 'x' && Array.from(markTypes).some((d) => markTypesWithBandDefault.x.has(d)))
+        return 'band';
     if (!dataValues.length)
         return 'linear';
     if (dataValues.length === 1)

package/dist/helpers/typeChecks.d.ts

@@ -1,10 +1,10 @@
 import type { RawValue } from '../types/index.js';
-export declare function isBooleanOrNull(v: RawValue): v is boolean;
+export declare function isBooleanOrNull(v: RawValue): boolean;
 export declare function isDate(v: RawValue): v is Date;
-export declare function isDateOrNull(v: RawValue | null | undefined): v is Date | null | undefined;
+export declare function isDateOrNull(v: RawValue | null | undefined): boolean;
 export declare function isNumberOrNull(v: RawValue | null | undefined): boolean;
 export declare function isNumberOrNullOrNaN(v: RawValue | null | undefined): boolean;
-export declare function isStringOrNull(v: RawValue | null | undefined): v is string | null | undefined;
+export declare function isStringOrNull(v: RawValue | null | undefined): boolean;
 export declare function isSymbolOrNull(v: RawValue | null | undefined): boolean;
-export declare function isColorOrNull(v: RawValue | null | undefined): boolean;
+export declare function isColorOrNull(v: RawValue | null | undefined): any;
 export declare function isOpacityOrNull(v: RawValue): boolean;

package/dist/hooks/plotDefaults.d.ts

@@ -0,0 +1,3 @@
+import type { PlotDefaults } from '../types';
+export declare function setPlotDefaults(plotDefaults: Partial<PlotDefaults>): void;
+export declare function getPlotDefaults(): Partial<PlotDefaults>;

package/dist/hooks/plotDefaults.js

@@ -0,0 +1,16 @@
+import { getContext, hasContext, setContext } from 'svelte';
+const PLOT_DEFAULTS_KEY = Symbol('svelteplot/defaults');
+export function setPlotDefaults(plotDefaults) {
+    const existingDefaults = getPlotDefaults();
+    const mergedDefaults = { ...existingDefaults, ...plotDefaults };
+    setContext(PLOT_DEFAULTS_KEY, mergedDefaults);
+}
+export function getPlotDefaults() {
+    return hasContext(PLOT_DEFAULTS_KEY)
+        ? getContext(PLOT_DEFAULTS_KEY)
+        : // Fallback for backward compatibility
+            hasContext('svelteplot/defaults')
+                ? (console.error(`svelteplot: Please use new setPlotDefaults hook instead of 'svelteplot/defaults' context`),
+                    getContext('svelteplot/defaults'))
+                : {};
+}

package/dist/index.d.ts

@@ -3,3 +3,4 @@ export { default as PlotCore } from './core/Plot.svelte';
 export * from './marks/index.js';
 export * from './transforms/index.js';
 export { formatMonth } from './helpers/formats.js';
+export * from './hooks/plotDefaults.js';

package/dist/index.js

@@ -4,3 +4,5 @@ export * from './marks/index.js';
 export * from './transforms/index.js';
 // helpers
 export { formatMonth } from './helpers/formats.js';
+// hooks
+export * from './hooks/plotDefaults.js';

package/dist/marks/Area.svelte

@@ -42,6 +42,7 @@
     } from '../types/index.js';
     import type { StackOptions } from '../transforms/stack.js';
     import { addEventHandlers } from './helpers/events';
+    import { getPlotDefaults } from '../hooks/plotDefaults.js';
 
     let markProps: AreaMarkProps = $props();
 
@@ -49,7 +50,7 @@
         fill: 'currentColor',
         curve: 'linear' as CurveName,
         tension: 0,
-        ...getContext<PlotDefaults>('svelteplot/_defaults').area
+        ...getPlotDefaults().area
     };
 
     const {

package/dist/marks/AreaX.svelte

@@ -11,12 +11,13 @@
     import { renameChannels } from '../transforms/rename.js';
     import { stackX } from '../transforms/stack.js';
     import { recordizeX } from '../transforms/recordize.js';
-    import type { ChannelAccessor, DataRow, PlotDefaults } from '../types/index.js';
-    import { getContext, type ComponentProps } from 'svelte';
+    import type { ChannelAccessor, DataRow } from '../types/index.js';
+    import { type ComponentProps } from 'svelte';
+    import { getPlotDefaults } from '../hooks/plotDefaults.js';
 
     let markProps: AreaXMarkProps = $props();
 
-    const DEFAULTS = getContext<PlotDefaults>('svelteplot/_defaults').areaX;
+    const DEFAULTS = getPlotDefaults().areaX;
 
     const { data, stack, ...options }: AreaXMarkProps = $derived({
         ...(markProps.x == undefined ? { x1: 0, x2: 0 } : {}),

package/dist/marks/AreaX.svelte.d.ts

@@ -1,3 +1,4 @@
+import { renameChannels } from '../transforms/rename.js';
 import type { ChannelAccessor, DataRow } from '../types/index.js';
 declare class __sveltets_Render<Datum extends DataRow> {
     props(): Omit<Partial<{
@@ -72,7 +73,7 @@ declare class __sveltets_Render<Datum extends DataRow> {
         sort?: import("../types/index.js").ConstantAccessor<import("../types/data").RawValue> | {
             channel: "stroke" | "fill";
         };
-        stack?: Partial<import("../transforms/stack.js").StackOptions>;
+        stack?: Partial<renameChannels>;
         canvas?: boolean;
     }, "y1" | "y2"> & {
         x?: ChannelAccessor<Datum>;

package/dist/marks/AreaY.svelte

@@ -10,14 +10,13 @@
     import Area from './Area.svelte';
     import { renameChannels } from '../transforms/rename.js';
     import { stackY } from '../transforms/stack.js';
-    import { RAW_VALUE, recordizeY } from '../transforms/recordize.js';
-    import type { ChannelAccessor, DataRow, PlotDefaults } from '../types/index.js';
-    import { getContext, type Component, type ComponentProps } from 'svelte';
-    import { area } from 'd3-shape';
+    import { recordizeY } from '../transforms/recordize.js';
+    import type { ChannelAccessor, DataRow } from '../types/index.js';
+    import { getPlotDefaults } from '../hooks/plotDefaults.js';
 
     let markProps: AreaYMarkProps = $props();
 
-    const DEFAULTS = getContext<PlotDefaults>('svelteplot/_defaults').areaY;
+    const DEFAULTS = getPlotDefaults().areaY;
 
     const { data, stack, ...options }: AreaYMarkProps = $derived({
         ...(markProps.y == undefined ? { y1: 0, y2: 0 } : {}),

package/dist/marks/Arrow.svelte

@@ -47,7 +47,7 @@
         RawValue,
         PlotDefaults
     } from '../types/index.js';
-    import { resolveChannel, resolveProp, resolveStyles } from '../helpers/resolve.js';
+    import { resolveProp, resolveStyles } from '../helpers/resolve.js';
     import { coalesce, maybeNumber } from '../helpers/index.js';
     import Mark from '../Mark.svelte';
     import { arrowPath, maybeSweep, type SweepOption } from '../helpers/arrowPath.js';
@@ -56,6 +56,7 @@
     import GroupMultiple from './helpers/GroupMultiple.svelte';
     import { sort } from '../transforms/sort.js';
     import { indexData } from '../transforms/recordize.js';
+    import { getPlotDefaults } from '../hooks/plotDefaults.js';
 
     let markProps: ArrowMarkProps = $props();
 
@@ -63,7 +64,7 @@
         headAngle: 60,
         headLength: 8,
         inset: 0,
-        ...getContext<PlotDefaults>('svelteplot/_defaults').arrow
+        ...getPlotDefaults().arrow
     };
 
     const {

package/dist/marks/AxisX.svelte

@@ -11,14 +11,13 @@
         RawValue,
         ConstantAccessor,
         FacetContext,
-        PlotDefaults,
         ChannelName
     } from '../types/index.js';
     import type * as CSS from 'csstype';
     import autoTimeFormat from '../helpers/autoTimeFormat.js';
-    import { derived } from 'svelte/store';
     import { autoTicks } from '../helpers/autoTicks.js';
     import { resolveScaledStyles } from '../helpers/resolve.js';
+    import { getPlotDefaults } from '../hooks/plotDefaults.js';
 
     interface AxisXMarkProps
         extends Omit<
@@ -64,8 +63,8 @@
         textAnchor: 'auto',
         opacity: 0.8,
         anchor: 'bottom',
-        ...getContext<PlotDefaults>('svelteplot/_defaults').axis,
-        ...getContext<PlotDefaults>('svelteplot/_defaults').axisX
+        ...getPlotDefaults().axis,
+        ...getPlotDefaults().axisX
     };
 
     const {

package/dist/marks/AxisX.svelte.d.ts

@@ -61,7 +61,7 @@ declare class __sveltets_Render<Datum extends RawValue> {
         class?: string;
         style?: string;
         cursor: ConstantAccessor<CSS.Property.Cursor, Datum>;
-    }>, "fillOpacity" | "href" | "target" | "paintOrder" | "title"> & {
+    }>, "fillOpacity" | "href" | "target" | "title" | "paintOrder"> & {
         data?: Datum[] | undefined;
         automatic?: boolean;
         title?: string | false | null;

package/dist/marks/AxisY.svelte

@@ -10,14 +10,13 @@
         BaseMarkProps,
         RawValue,
         FacetContext,
-        PlotDefaults,
         ChannelName,
         ConstantAccessor
     } from '../types/index.js';
-    import type * as CSS from 'csstype';
     import autoTimeFormat from '../helpers/autoTimeFormat.js';
     import { autoTicks } from '../helpers/autoTicks.js';
     import { resolveScaledStyles } from '../helpers/resolve.js';
+    import { getPlotDefaults } from '../hooks/plotDefaults.js';
 
     interface AxisYMarkProps
         extends Omit<
@@ -62,8 +61,8 @@
         opacity: 0.8,
         anchor: 'left',
         textAnchor: 'auto',
-        ...getContext<PlotDefaults>('svelteplot/_defaults').axis,
-        ...getContext<PlotDefaults>('svelteplot/_defaults').axisY
+        ...getPlotDefaults().axis,
+        ...getPlotDefaults().axisY
     };
 
     const {

package/dist/marks/AxisY.svelte.d.ts

@@ -1,5 +1,4 @@
 import type { RawValue, ConstantAccessor } from '../types/index.js';
-import type * as CSS from 'csstype';
 declare class __sveltets_Render<Datum extends RawValue> {
     props(): Omit<Partial<{
         filter?: ConstantAccessor<boolean, Datum>;
@@ -17,16 +16,16 @@ declare class __sveltets_Render<Datum extends RawValue> {
         stroke: import("../types/channel").ChannelAccessor<Datum>;
         strokeWidth: ConstantAccessor<number, Datum>;
         strokeOpacity: ConstantAccessor<number, Datum>;
-        strokeLinejoin: ConstantAccessor<CSS.Property.StrokeLinejoin, Datum>;
-        strokeLinecap: ConstantAccessor<CSS.Property.StrokeLinecap, Datum>;
+        strokeLinejoin: ConstantAccessor<import("csstype").Property.StrokeLinejoin, Datum>;
+        strokeLinecap: ConstantAccessor<import("csstype").Property.StrokeLinecap, Datum>;
         strokeMiterlimit: ConstantAccessor<number, Datum>;
         opacity: import("../types/channel").ChannelAccessor<Datum>;
         strokeDasharray: ConstantAccessor<string, Datum>;
         strokeDashoffset: ConstantAccessor<number, Datum>;
-        mixBlendMode: ConstantAccessor<CSS.Property.MixBlendMode, Datum>;
+        mixBlendMode: ConstantAccessor<import("csstype").Property.MixBlendMode, Datum>;
         clipPath: string;
         imageFilter: ConstantAccessor<string, Datum>;
-        shapeRendering: ConstantAccessor<CSS.Property.ShapeRendering, Datum>;
+        shapeRendering: ConstantAccessor<import("csstype").Property.ShapeRendering, Datum>;
         paintOrder: ConstantAccessor<string, Datum>;
         onclick?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
         ondblclick?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
@@ -60,8 +59,8 @@ declare class __sveltets_Render<Datum extends RawValue> {
         onwheel?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
         class?: string;
         style?: string;
-        cursor: ConstantAccessor<CSS.Property.Cursor, Datum>;
-    }>, "fillOpacity" | "href" | "target" | "paintOrder" | "title"> & {
+        cursor: ConstantAccessor<import("csstype").Property.Cursor, Datum>;
+    }>, "fillOpacity" | "href" | "target" | "title" | "paintOrder"> & {
         data?: Datum[] | undefined;
         automatic?: boolean;
         title?: string | false | null;

package/dist/marks/BarX.svelte

@@ -33,14 +33,14 @@
         BaseMarkProps,
         BaseRectMarkProps,
         ChannelAccessor,
-        LinkableMarkProps,
-        PlotDefaults
+        LinkableMarkProps
     } from '../types/index.js';
+    import { getPlotDefaults } from '../hooks/plotDefaults.js';
 
     const DEFAULTS = {
         fill: 'currentColor',
-        ...getContext<PlotDefaults>('svelteplot/_defaults').bar,
-        ...getContext<PlotDefaults>('svelteplot/_defaults').barX
+        ...getPlotDefaults().bar,
+        ...getPlotDefaults().barX
     };
 
     let markProps: BarXMarkProps = $props();

package/dist/marks/BarX.svelte.d.ts

@@ -14,7 +14,7 @@ declare class __sveltets_Render<Datum extends DataRow> {
         sort: {
             channel: string;
             order?: "ascending" | "descending";
-        } | ((a: import("../types/index.js").RawValue, b: import("../types/index.js").RawValue) => number) | import("../types/index.js").ConstantAccessor<import("../types/index.js").RawValue, Datum>;
+        } | ((a: import("../types/data").RawValue, b: import("../types/data").RawValue) => number) | import("../types/index.js").ConstantAccessor<import("../types/data").RawValue, Datum>;
         stroke: ChannelAccessor<Datum>;
         strokeWidth: import("../types/index.js").ConstantAccessor<number, Datum>;
         strokeOpacity: import("../types/index.js").ConstantAccessor<number, Datum>;

package/dist/marks/BarY.svelte

@@ -34,16 +34,16 @@
         BaseRectMarkProps,
         ChannelAccessor,
         DataRow,
-        PlotDefaults,
         LinkableMarkProps
     } from '../types/index.js';
+    import { getPlotDefaults } from '../hooks/plotDefaults.js';
 
     const { getPlotState } = getContext<PlotContext>('svelteplot');
     const plot = $derived(getPlotState());
 
     const DEFAULTS = {
-        ...getContext<PlotDefaults>('svelteplot/_defaults').bar,
-        ...getContext<PlotDefaults>('svelteplot/_defaults').barY
+        ...getPlotDefaults().bar,
+        ...getPlotDefaults().barY
     };
 
     let markProps: BarYMarkProps = $props();