@rokkit/chart 1.3.8 → 1.3.9

package/dist/geoms/lib/marks/jitter.js

@@ -0,0 +1,36 @@
+import { buildSwarm } from '../../../lib/brewing/marks/swarm.js'
+import { resolveAlpha } from '../aesthetics.js'
+
+/**
+ * Build renderable jitter/swarm points. Fill + outline come from `fill` (defaulting to
+ * `x`); an explicit `color` channel overrides the outline stroke. Adds fixed `alpha`.
+ * Horizontal orientation swaps each point's screen coords via place().
+ * @param {{ data: any[], plot: any, channels: any, options?: any, alpha?: number, type?: string }} ctx
+ */
+export function buildJitterMarks({ data, plot, channels, options = {}, alpha, type = 'jitter' }) {
+	const { xScale, yScale, colors } = plot
+	if (!data?.length || !xScale || !yScale) return []
+
+	const fillField = channels.fill ?? channels.x
+	const raw = buildSwarm(
+		data,
+		{ x: channels.x, y: channels.y, fill: fillField },
+		xScale,
+		yScale,
+		colors,
+		{ method: options.method, r: options.r, side: options.side }
+	)
+	const a = resolveAlpha(alpha, type, plot.chartPreset)
+	const colorField = channels.color
+	const flip = plot.isFlipped
+	return raw.map((p) => {
+		const s = flip ? plot.place(p.cx, p.cy) : { x: p.cx, y: p.cy }
+		return {
+			...p,
+			cx: s.x,
+			cy: s.y,
+			stroke: colorField ? (colors.get(p.data[colorField])?.stroke ?? p.stroke) : p.stroke,
+			alpha: a
+		}
+	})
+}

package/dist/geoms/lib/marks/line.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Build renderable line segments. A line has no interior, so its single aesthetic is
+ * the stroke — driven by `color`, with `fill` accepted as an alias (ggplot geom_line
+ * uses `colour`). Each segment gets the geom's fixed `alpha`.
+ * @param {{ data: any[], plot: any, channels: any, options?: any, alpha?: number, type?: string }} ctx
+ */
+export function buildLineMarks({ data, plot, channels, options, alpha, type }: {
+    data: any[];
+    plot: any;
+    channels: any;
+    options?: any;
+    alpha?: number;
+    type?: string;
+}): {
+    alpha: number;
+    d: string | null;
+    fill: string;
+    stroke: string;
+    points: {
+        x: number;
+        y: number;
+        data: Record<string, unknown>;
+        i: number;
+    }[];
+    key?: unknown;
+}[];

package/dist/geoms/lib/marks/line.js

@@ -0,0 +1,25 @@
+import { buildLines } from '../../../lib/brewing/marks/lines.js'
+import { resolveAlpha } from '../aesthetics.js'
+
+/**
+ * Build renderable line segments. A line has no interior, so its single aesthetic is
+ * the stroke — driven by `color`, with `fill` accepted as an alias (ggplot geom_line
+ * uses `colour`). Each segment gets the geom's fixed `alpha`.
+ * @param {{ data: any[], plot: any, channels: any, options?: any, alpha?: number, type?: string }} ctx
+ */
+export function buildLineMarks({ data, plot, channels, options = {}, alpha, type = 'line' }) {
+	const { xScale, yScale, colors } = plot
+	if (!data?.length || !xScale || !yScale) return []
+	const lineColor = channels.color ?? channels.fill
+	const segs = buildLines(
+		data,
+		{ x: channels.x, y: channels.y, color: lineColor },
+		xScale,
+		yScale,
+		colors,
+		options.curve,
+		plot.place.bind(plot)
+	)
+	const a = resolveAlpha(alpha, type, plot.chartPreset)
+	return segs.map((seg) => ({ ...seg, alpha: a }))
+}

package/dist/geoms/lib/marks/point.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Build renderable point marks: geometry (from buildPoints) + shared aesthetics
+ * (fill/color split + alpha) + value/display. The geom template just renders these.
+ * @param {{ data: any[], plot: any, channels: any, options?: any, alpha?: number, type?: string }} ctx
+ */
+export function buildPointMarks({ data, plot, channels, options, alpha, type }: {
+    data: any[];
+    plot: any;
+    channels: any;
+    options?: any;
+    alpha?: number;
+    type?: string;
+}): {
+    cx: any;
+    cy: any;
+    fill: string;
+    stroke: string;
+    alpha: number;
+    value: unknown;
+    display: string;
+    key: string;
+    data: Record<string, unknown>;
+    r: number;
+    symbolPath: string | null;
+}[];

package/dist/geoms/lib/marks/point.js

@@ -0,0 +1,58 @@
+import { scaleSqrt } from 'd3-scale'
+import { buildPoints } from '../../../lib/brewing/marks/points.js'
+import { resolveFillStroke, resolveAlpha } from '../aesthetics.js'
+
+/**
+ * Size scale for a bubble/size channel — sqrt so area (not radius) is proportional.
+ * @returns {import('d3-scale').ScalePower<number, number> | null}
+ */
+function buildSizeScale(data, sizeField, options) {
+	if (!sizeField || !data?.length) return null
+	const vals = data.map((d) => Number(d[sizeField])).filter((v) => !isNaN(v))
+	if (!vals.length) return null
+	return scaleSqrt()
+		.domain([Math.min(...vals), Math.max(...vals)])
+		.range([options?.minRadius ?? 3, options?.maxRadius ?? 20])
+}
+
+/**
+ * Build renderable point marks: geometry (from buildPoints) + shared aesthetics
+ * (fill/color split + alpha) + value/display. The geom template just renders these.
+ * @param {{ data: any[], plot: any, channels: any, options?: any, alpha?: number, type?: string }} ctx
+ */
+export function buildPointMarks({ data, plot, channels, options = {}, alpha, type = 'point' }) {
+	const { xScale, yScale, colors } = plot
+	if (!data?.length || !xScale || !yScale) return []
+
+	const sizeScale = buildSizeScale(data, channels.size, options)
+	const raw = buildPoints(
+		data,
+		channels,
+		xScale,
+		yScale,
+		colors,
+		sizeScale,
+		plot.symbols,
+		options.radius ?? 4,
+		options.jitter ?? null
+	)
+	const a = resolveAlpha(alpha, type, plot.chartPreset)
+	const yf = channels.y
+
+	return raw.map((p, i) => {
+		const { fill, stroke } = resolveFillStroke(p.data, channels, colors)
+		// Horizontal orientation: swap each point's screen coords via place().
+		const s = plot.isFlipped ? plot.place(p.cx, p.cy) : { x: p.cx, y: p.cy }
+		return {
+			...p,
+			cx: s.x,
+			cy: s.y,
+			fill,
+			stroke,
+			alpha: a,
+			value: yf ? p.data[yf] : undefined,
+			display: yf ? String(p.data[yf] ?? '') : '',
+			key: `${i}::${p.data[channels.x ?? '']}::${p.data[yf ?? '']}`
+		}
+	})
+}

package/dist/geoms/lib/marks/ribbon.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Build a Sankey-style ribbon layout: links (flows) + source/target node boxes. Link fill
+ * comes from the source (then target) palette entry; `alpha` is fixed (default 0.5). Returns
+ * an object rather than a flat array, so the geom template renders links + node labels.
+ * @param {{ data: any[], plot: any, options?: any, alpha?: number, type?: string }} ctx
+ */
+export function buildRibbonMarks({ data, plot, options, alpha, type }: {
+    data: any[];
+    plot: any;
+    options?: any;
+    alpha?: number;
+    type?: string;
+}): {
+    links: {
+        key: string;
+        d: string;
+        fill: any;
+        alpha: number;
+        data: any;
+    }[];
+    sourceNodes: {
+        name: any;
+        y: number;
+        height: number;
+    }[];
+    targetNodes: {
+        name: any;
+        y: number;
+        height: number;
+    }[];
+};

package/dist/geoms/lib/marks/ribbon.js

@@ -0,0 +1,77 @@
+import { resolveAlpha } from '../aesthetics.js'
+
+/**
+ * Build a Sankey-style ribbon layout: links (flows) + source/target node boxes. Link fill
+ * comes from the source (then target) palette entry; `alpha` is fixed (default 0.5). Returns
+ * an object rather than a flat array, so the geom template renders links + node labels.
+ * @param {{ data: any[], plot: any, options?: any, alpha?: number, type?: string }} ctx
+ */
+export function buildRibbonMarks({ data, plot, options = {}, alpha, type = 'ribbon' }) {
+	const empty = { links: [], sourceNodes: [], targetNodes: [] }
+	if (!data?.length) return empty
+
+	const { colors, innerHeight, innerWidth } = plot
+	const sourceField = options.source ?? 'source'
+	const targetField = options.target ?? 'target'
+	const valueField = options.value ?? 'value'
+	const a = resolveAlpha(alpha, type, plot.chartPreset)
+
+	const flows = data.map((d) => ({
+		source: String(d[sourceField]),
+		target: String(d[targetField]),
+		value: Number(d[valueField]) || 0,
+		data: d
+	}))
+
+	const sourceMap = new Map()
+	const targetMap = new Map()
+	for (const f of flows) {
+		sourceMap.set(f.source, (sourceMap.get(f.source) ?? 0) + f.value)
+		targetMap.set(f.target, (targetMap.get(f.target) ?? 0) + f.value)
+	}
+
+	const totalSource = Math.max(1, [...sourceMap.values()].reduce((s, v) => s + v, 0))
+	const totalTarget = Math.max(1, [...targetMap.values()].reduce((s, v) => s + v, 0))
+	const padding = 4
+	const availHeight = innerHeight - padding * (Math.max(sourceMap.size, targetMap.size) - 1)
+
+	let sourceY = 0
+	const sourceNodes = []
+	for (const [name, value] of sourceMap) {
+		const h = (value / totalSource) * availHeight
+		sourceNodes.push({ name, y: sourceY, height: h })
+		sourceY += h + padding
+	}
+
+	let targetY = 0
+	const targetNodes = []
+	for (const [name, value] of targetMap) {
+		const h = (value / totalTarget) * availHeight
+		targetNodes.push({ name, y: targetY, height: h })
+		targetY += h + padding
+	}
+
+	const sourceOffsets = new Map(sourceNodes.map((n) => [n.name, n.y]))
+	const targetOffsets = new Map(targetNodes.map((n) => [n.name, n.y]))
+	const x0 = 0
+	const x1 = innerWidth
+
+	const links = flows.map((f, i) => {
+		const sy0 = sourceOffsets.get(f.source) ?? 0
+		const ty0 = targetOffsets.get(f.target) ?? 0
+		const sourceTotal = sourceMap.get(f.source) ?? 1
+		const targetTotal = targetMap.get(f.target) ?? 1
+		const sh = (f.value / sourceTotal) * (sourceNodes.find((n) => n.name === f.source)?.height ?? 0)
+		const th = (f.value / targetTotal) * (targetNodes.find((n) => n.name === f.target)?.height ?? 0)
+
+		const path = `M${x0},${sy0} C${innerWidth * 0.4},${sy0} ${innerWidth * 0.6},${ty0} ${x1},${ty0} L${x1},${ty0 + th} C${innerWidth * 0.6},${ty0 + th} ${innerWidth * 0.4},${sy0 + sh} ${x0},${sy0 + sh} Z`
+
+		sourceOffsets.set(f.source, sy0 + sh)
+		targetOffsets.set(f.target, ty0 + th)
+
+		const fill = colors?.get(f.source)?.fill ?? colors?.get(f.target)?.fill ?? '#888'
+		return { key: `ribbon-${i}`, d: path, fill, alpha: a, data: f.data }
+	})
+
+	return { links, sourceNodes, targetNodes }
+}

package/dist/geoms/lib/marks/violin.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Build renderable violin silhouettes. Interior + outline come from `fill` (defaulting to
+ * `x`); an explicit `color` channel overrides the outline stroke. Adds fixed `alpha`.
+ * @param {{ data: any[], plot: any, channels: any, options?: any, alpha?: number, type?: string }} ctx
+ */
+export function buildViolinMarks({ data, plot, channels, options, alpha, type }: {
+    data: any[];
+    plot: any;
+    channels: any;
+    options?: any;
+    alpha?: number;
+    type?: string;
+}): any;

package/dist/geoms/lib/marks/violin.js

@@ -0,0 +1,31 @@
+import { buildViolins } from '../../../lib/brewing/marks/violins.js'
+import { resolveAlpha } from '../aesthetics.js'
+
+/**
+ * Build renderable violin silhouettes. Interior + outline come from `fill` (defaulting to
+ * `x`); an explicit `color` channel overrides the outline stroke. Adds fixed `alpha`.
+ * @param {{ data: any[], plot: any, channels: any, options?: any, alpha?: number, type?: string }} ctx
+ */
+export function buildViolinMarks({ data, plot, channels, options = {}, alpha, type = 'violin' }) {
+	const { xScale, yScale, colors } = plot
+	if (!data?.length || !xScale || !yScale) return []
+
+	const fillField = channels.fill ?? channels.x
+	const violins = buildViolins(
+		data,
+		{ x: channels.x, fill: fillField, pattern: channels.pattern },
+		xScale,
+		yScale,
+		colors,
+		plot.place.bind(plot),
+		options.side,
+		plot.patterns
+	)
+	const a = resolveAlpha(alpha, type, plot.chartPreset)
+	const colorField = channels.color
+	return violins.map((v) => ({
+		...v,
+		stroke: colorField ? (colors.get(v.data[colorField])?.stroke ?? v.stroke) : v.stroke,
+		alpha: a
+	}))
+}

package/dist/geoms/lib/marks/waterfall.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Build renderable waterfall bars. Bar color is semantic (positive/negative/total from
+ * options), not the shared palette. Adds fixed `alpha` and carries connector anchors.
+ * @param {{ data: any[], plot: any, channels: any, options?: any, alpha?: number, type?: string }} ctx
+ */
+export function buildWaterfallMarks({ data, plot, channels, options, alpha, type }: {
+    data: any[];
+    plot: any;
+    channels: any;
+    options?: any;
+    alpha?: number;
+    type?: string;
+}): {
+    key: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    fill: any;
+    alpha: number;
+    bandStart: any;
+    bandEnd: any;
+    cumY: any;
+    data: any;
+}[];

package/dist/geoms/lib/marks/waterfall.js

@@ -0,0 +1,58 @@
+import { resolveAlpha } from '../aesthetics.js'
+
+/**
+ * Build renderable waterfall bars. Bar color is semantic (positive/negative/total from
+ * options), not the shared palette. Adds fixed `alpha` and carries connector anchors.
+ * @param {{ data: any[], plot: any, channels: any, options?: any, alpha?: number, type?: string }} ctx
+ */
+export function buildWaterfallMarks({ data, plot, channels, options = {}, alpha, type = 'waterfall' }) {
+	const { xScale, yScale } = plot
+	if (!data?.length || !xScale || !yScale) return []
+
+	const positiveColor = options.positiveColor ?? '#22c55e'
+	const negativeColor = options.negativeColor ?? '#ef4444'
+	const totalColor = options.totalColor ?? '#3b82f6'
+	const totalField = options.totalField ?? undefined
+	const a = resolveAlpha(alpha, type, plot.chartPreset)
+
+	const bw = typeof xScale.bandwidth === 'function' ? xScale.bandwidth() : 10
+	let cumulative = 0
+
+	return data.map((d, i) => {
+		const xVal = d[channels.x ?? '']
+		const yVal = Number(d[channels.y ?? ''])
+		const isTotal = totalField ? Boolean(d[totalField]) : false
+		const xPos = xScale(xVal) ?? 0
+		let barTop
+		let barBottom
+		let fill
+
+		if (isTotal) {
+			barTop = yScale(Math.max(0, cumulative)) ?? 0
+			barBottom = yScale(0) ?? 0
+			fill = totalColor
+		} else {
+			const start = cumulative
+			cumulative += yVal
+			barTop = yScale(Math.max(start, cumulative)) ?? 0
+			barBottom = yScale(Math.min(start, cumulative)) ?? 0
+			fill = yVal >= 0 ? positiveColor : negativeColor
+		}
+
+		const c1 = plot.place(xPos, barTop)
+		const c2 = plot.place(xPos + bw, barBottom)
+		return {
+			key: `${xVal}-${i}`,
+			x: Math.min(c1.x, c2.x),
+			y: Math.min(c1.y, c2.y),
+			width: Math.abs(c2.x - c1.x),
+			height: Math.max(1, Math.abs(c2.y - c1.y)),
+			fill,
+			alpha: a,
+			bandStart: xPos,
+			bandEnd: xPos + bw,
+			cumY: yScale(cumulative) ?? 0,
+			data: d
+		}
+	})
+}

package/dist/index.d.ts

@@ -54,13 +54,6 @@ export { default as BoxPlot } from "./charts/BoxPlot.svelte";
 export { default as ViolinPlot } from "./charts/ViolinPlot.svelte";
 export { default as BubbleChart } from "./charts/BubbleChart.svelte";
 export { PlotState } from "./PlotState.svelte.js";
-export { ChartBrewer } from "./lib/brewing/index.svelte.js";
-export * from "./lib/brewing/index.svelte.js";
-export { CartesianBrewer } from "./lib/brewing/CartesianBrewer.svelte.js";
-export { PieBrewer } from "./lib/brewing/PieBrewer.svelte.js";
-export { QuartileBrewer } from "./lib/brewing/QuartileBrewer.svelte.js";
-export { BoxBrewer } from "./lib/brewing/BoxBrewer.svelte.js";
-export { ViolinBrewer } from "./lib/brewing/ViolinBrewer.svelte.js";
 export { createCrossFilter } from "./crossfilter/createCrossFilter.svelte.js";
 export { default as CrossFilter } from "./crossfilter/CrossFilter.svelte";
 export { default as FilterBar } from "./crossfilter/FilterBar.svelte";
@@ -74,7 +67,7 @@ import Legend from './Plot/Legend.svelte';
 import Line from './geoms/Line.svelte';
 import Area from './geoms/Area.svelte';
 import Point from './geoms/Point.svelte';
-import Arc from './Plot/Arc.svelte';
+import Arc from './geoms/Arc.svelte';
 import Highlight from './geoms/Highlight.svelte';
 import Trend from './geoms/Trend.svelte';
 import Box from './geoms/Box.svelte';

package/dist/index.js

@@ -6,7 +6,7 @@ import Legend from './Plot/Legend.svelte'
 import Line from './geoms/Line.svelte'
 import Area from './geoms/Area.svelte'
 import Point from './geoms/Point.svelte'
-import Arc from './Plot/Arc.svelte'
+import Arc from './geoms/Arc.svelte'
 import Highlight from './geoms/Highlight.svelte'
 import Trend from './geoms/Trend.svelte'
 import Box from './geoms/Box.svelte'
@@ -91,14 +91,7 @@ export { default as BubbleChart } from './charts/BubbleChart.svelte'
 export { PlotState } from './PlotState.svelte.js'
 
 // Export utilities
-export { ChartBrewer } from './lib/brewing/index.svelte.js'
-export * from './lib/brewing/index.svelte.js'
 export { buildSequentialScale, buildDivergingScale } from './lib/brewing/colors.js'
-export { CartesianBrewer } from './lib/brewing/CartesianBrewer.svelte.js'
-export { PieBrewer } from './lib/brewing/PieBrewer.svelte.js'
-export { QuartileBrewer } from './lib/brewing/QuartileBrewer.svelte.js'
-export { BoxBrewer } from './lib/brewing/BoxBrewer.svelte.js'
-export { ViolinBrewer } from './lib/brewing/ViolinBrewer.svelte.js'
 
 // CrossFilter system
 export { createCrossFilter } from './crossfilter/createCrossFilter.svelte.js'

package/dist/lib/preset.d.ts

@@ -21,9 +21,19 @@ export namespace defaultPreset {
     }
     namespace opacity {
         let area: number;
+        let bar: number;
+        let line: number;
+        let point: number;
+        let arc: number;
         let box: number;
         let violin: number;
-        let point: number;
+        let jitter: number;
+        let heatmap: number;
+        let candlestick: number;
+        let hexbin: number;
+        let ribbon: number;
+        let waterfall: number;
+        let rule: number;
     }
     let patterns: string[];
     let symbols: string[];

package/dist/lib/preset.js

@@ -7,11 +7,23 @@ export const defaultPreset = {
     light: { fill: '300', stroke: '700' },
     dark:  { fill: '500', stroke: '200' }
   },
+  // Per-geom default mark opacity. `alpha` (a fixed 0–1 prop on each geom / Plot.Root)
+  // overrides these; solid marks default to 1 so `alpha` is the single opacity knob.
   opacity: {
-    area:   0.6,
-    box:    0.5,
-    violin: 0.5,
-    point:  0.8
+    area:        0.6,
+    bar:         1,
+    line:        1,
+    point:       0.8,
+    arc:         1,
+    box:         0.5,
+    violin:      0.5,
+    jitter:      0.8,
+    heatmap:     1,
+    candlestick: 1,
+    hexbin:      1,
+    ribbon:      0.5,
+    waterfall:   1,
+    rule:        1
   },
   patterns: ['diagonal', 'dots', 'triangles', 'hatch', 'lattice', 'swell',
              'checkerboard', 'waves', 'petals', 'brick', 'diamonds', 'tile',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rokkit/chart",
-  "version": "1.3.8",
+  "version": "1.3.9",
   "type": "module",
   "description": "Data-driven chart components",
   "repository": {

package/dist/Plot/Arc.svelte

@@ -1,30 +0,0 @@
-<script lang="ts">
-	import { getContext } from 'svelte'
-	import type { ChartBrewer } from '../lib/brewing/brewer.svelte.js'
-
-	const brewer = getContext<ChartBrewer>('chart-brewer')
-</script>
-
-{#if brewer && brewer.arcs && brewer.arcs.length > 0}
-	<g
-		class="chart-arcs"
-		data-plot-type="arc"
-		transform="translate({brewer.width / 2}, {brewer.height / 2})"
-	>
-		{#each brewer.arcs as arc (arc.key)}
-			<path
-				d={arc.d}
-				fill={arc.fill}
-				stroke={arc.stroke}
-				stroke-width="1"
-				data-plot-element="arc"
-			/>
-		{/each}
-	</g>
-{/if}
-
-<style>
-	.chart-arcs {
-		pointer-events: none;
-	}
-</style>

package/dist/Plot/Arc.svelte.d.ts

@@ -1,18 +0,0 @@
-interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
-    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
-        $$bindings?: Bindings;
-    } & Exports;
-    (internal: unknown, props: {
-        $$events?: Events;
-        $$slots?: Slots;
-    }): Exports & {
-        $set?: any;
-        $on?: any;
-    };
-    z_$$bindings?: Bindings;
-}
-declare const Arc: $$__sveltets_2_IsomorphicComponent<Record<string, never>, {
-    [evt: string]: CustomEvent<any>;
-}, {}, {}, string>;
-type Arc = InstanceType<typeof Arc>;
-export default Arc;

package/dist/lib/brewer.d.ts

@@ -1,9 +0,0 @@
-/**
- * Get fill patterns for a set of values
- *
- * @param {Array} values - Array of values
- * @param {Object} swatch - Object with keys for color, gray, and pattern
- * @param {Boolean} gray - Boolean to determine if gray or color
- * @returns {Object} - Object with keys for pattern and color
- */
-export function getFillPatterns(values: any[], swatch: Object, gray?: boolean): Object;

package/dist/lib/brewer.js

@@ -1,25 +0,0 @@
-/**
- * Get fill patterns for a set of values
- *
- * @param {Array} values - Array of values
- * @param {Object} swatch - Object with keys for color, gray, and pattern
- * @param {Boolean} gray - Boolean to determine if gray or color
- * @returns {Object} - Object with keys for pattern and color
- */
-export function getFillPatterns(values, swatch, gray = false) {
-	const colors = gray ? swatch.keys.gray : swatch.keys.color
-	const max_colors = colors.length
-	const max_patterns = swatch.keys.pattern.length
-
-	const mix = values
-		.map((value, index) => ({
-			[value]: {
-				pattern: swatch.keys.pattern[index % max_patterns],
-				color: colors[index % max_colors]
-			}
-		}))
-		.reduce((acc, current) => ({ ...acc, ...current }), {})
-	return mix
-}
-
-// export function getStrokePatterns() {}

package/dist/lib/brewing/BoxBrewer.svelte.d.ts

@@ -1,8 +0,0 @@
-/**
- * Brewer for box plots.
- * fill = box interior color, color = whisker/outline stroke.
- */
-export class BoxBrewer extends QuartileBrewer {
-    boxes: any[];
-}
-import { QuartileBrewer } from './QuartileBrewer.svelte.js';

package/dist/lib/brewing/BoxBrewer.svelte.js

@@ -1,14 +0,0 @@
-import { QuartileBrewer } from './QuartileBrewer.svelte.js'
-import { buildBoxes } from './marks/boxes.js'
-
-/**
- * Brewer for box plots.
- * fill = box interior color, color = whisker/outline stroke.
- */
-export class BoxBrewer extends QuartileBrewer {
-	boxes = $derived(
-		this.xScale && this.yScale
-			? buildBoxes(this.processedData, this.channels, this.xScale, this.yScale, this.colorMap)
-			: []
-	)
-}

package/dist/lib/brewing/CartesianBrewer.svelte.d.ts

@@ -1,8 +0,0 @@
-/**
- * Brewer for cartesian charts (Bar, Line, Area).
- * Groups by x (and fill/color if set) and applies the given stat.
- */
-export class CartesianBrewer extends ChartBrewer {
-    transform(data: any, channels: any, stat: any): any;
-}
-import { ChartBrewer } from './brewer.svelte.js';

package/dist/lib/brewing/CartesianBrewer.svelte.js

@@ -1,21 +0,0 @@
-import { SvelteSet } from 'svelte/reactivity'
-import { ChartBrewer } from './brewer.svelte.js'
-import { applyAggregate } from './stats.js'
-
-/**
- * Brewer for cartesian charts (Bar, Line, Area).
- * Groups by x (and fill/color if set) and applies the given stat.
- */
-export class CartesianBrewer extends ChartBrewer {
-	transform(data, channels, stat) {
-		if (stat === 'identity' || !channels.x || !channels.y) return data
-		// Group by all mapped aesthetic dimensions so they survive aggregation.
-		// e.g. x=region, fill=region, pattern=quarter → by=['region','quarter']
-		const by = [
-			...new SvelteSet(
-				[channels.x, channels.fill, channels.color, channels.pattern].filter(Boolean)
-			)
-		]
-		return applyAggregate(data, { by, value: channels.y, stat })
-	}
-}