@rokkit/chart 1.0.0-next.11

package/src/lib/timer.js

@@ -0,0 +1,44 @@
+import { writable } from 'svelte/store'
+
+let req
+let prev
+const elapsed = writable(0)
+
+const tick = (timestamp) => {
+	if (!prev) prev = timestamp
+	const diff = Math.round(timestamp - prev)
+
+	if (diff > 0) {
+		prev = timestamp
+	}
+	elapsed.update((e) => e + diff)
+	req = window.requestAnimationFrame(tick)
+}
+
+const timer = {
+	start() {
+		if (typeof window === 'undefined') return
+		else if (!req) {
+			prev = null
+			req = window.requestAnimationFrame(tick)
+		}
+	},
+	stop() {
+		if (typeof window === 'undefined') return
+		else if (req) {
+			window.cancelAnimationFrame(req)
+			req = null
+		}
+	},
+	toggle() {
+		req ? timer.stop() : timer.start()
+	},
+	set(val) {
+		if (typeof val === 'number') elapsed.set(val)
+	},
+	reset() {
+		timer.set(0)
+	}
+}
+
+export { timer, elapsed }

package/src/lib/utils.js

@@ -0,0 +1,157 @@
+import { scaleBand, scaleLinear } from 'd3-scale'
+import { min, max } from 'd3-array'
+import { ascending, quantile } from 'd3-array'
+import { nest } from 'd3-collection'
+import { omit } from 'ramda'
+
+/**
+ * Calculates a grid of centres to fit a list of items of `size` within the number of `columns` and `rows`.
+ *
+ * - Attempts to find a best fit square if both columns and rows are not specified
+ * - Value in columns is prioritized over rows for recalculating the grid
+ * - Supports padding between the items
+ *
+ * @param {number} count
+ * @param {number} size
+ * @param {number} pad
+ * @param {number} columns
+ * @param {number} rows
+ * @returns
+ */
+export function swatch(count, size, pad = 0, columns, rows) {
+	if (columns > 0) {
+		rows = Math.ceil(count / columns)
+	} else if (rows > 0) {
+		columns = Math.ceil(count / rows)
+	} else {
+		columns = Math.ceil(Math.sqrt(count))
+		rows = Math.ceil(count / columns)
+	}
+
+	const width = (size + pad) * columns + pad
+	const height = (size + pad) * rows + pad
+	const data = [...Array(count).keys()].map((index) => ({
+		cx: (size + pad) / 2 + (index % columns) * (size + pad),
+		cy: (size + pad) / 2 + Math.floor(index / columns) * (size + pad),
+		r: size / 2
+	}))
+
+	return { width, height, data }
+}
+/**
+ * Get a scale function mapping the values between a range of lower and upper values
+ *
+ * @param {Array} values
+ * @param {Array[2]} bounds
+ * @param {number} buffer
+ * @returns
+ */
+export function getScale(values, bounds, buffer = 0, ordinal = false) {
+	if (ordinal || values.some(isNaN)) {
+		return scaleBand().range(bounds).domain(values).padding(0.5)
+	} else {
+		values = values.map((x) => +x)
+
+		let minValue = min([...values, 0])
+		let maxValue = max(values)
+
+		if (minValue < 0 && maxValue > 0) {
+			maxValue = max([-1 * minValue, maxValue])
+			minValue = -1 * maxValue
+		}
+		const margin = (maxValue - minValue) * buffer
+		return scaleLinear()
+			.domain([minValue - margin, maxValue + margin])
+			.range(bounds)
+	}
+}
+/**
+ * Obtain the scale function for the `x` and `y` fields in the data set.
+ *
+ * @param {array<dict>} data
+ * @param {string} x
+ * @param {string} y
+ * @param {number} width
+ * @param {number} height
+ * @returns
+ */
+export function getScales(data, x, y, width, height, margin, ordinal) {
+	const xValues = [...new Set(data.map((item) => item[x]))]
+	const yValues = [...new Set(data.map((item) => item[y]))]
+
+	return {
+		x: getScale(xValues, [0 + margin.left, width - margin.right], 0, ordinal.x),
+		y: getScale(yValues, [height - margin.top, margin.bottom], 0.1, ordinal.y)
+	}
+}
+
+/**
+ * Summarize `data` by fields `x` and `y` and return a nested array with
+ * key as unique `x` values and value as statistical summaries of `y` values
+ *
+ * @param {*} data
+ * @param {*} x
+ * @param {*} y
+ * @returns
+ */
+export function aggregate(data, x, y) {
+	const summary = nest()
+		.key((d) => d[x])
+		.rollup((d) => {
+			let values = d.map((g) => g[y]).sort(ascending)
+			let q1 = quantile(values, 0.25)
+			let q3 = quantile(values, 0.75)
+			let median = quantile(values, 0.5)
+			let interQuantileRange = q3 - q1
+			let min = q1 - 1.5 * interQuantileRange
+			let max = q3 + 1.5 * interQuantileRange
+			return { q1, q3, median, interQuantileRange, min, max }
+		})
+		.entries(data)
+	return summary
+}
+
+/**
+ * Generate a palette with same size as input data containing values from palette array.
+ * After the palette array is exhausted the fallback value is used
+ *
+ * @param {Array} values
+ * @param {Array} palette
+ * @param {*}     fallback
+ * @returns
+ */
+export function getPaletteForValues(values, palette, fallback) {
+	return values.map((_, index) =>
+		index < palette.length ? palette[index] : fallback
+	)
+}
+
+/**
+ * Converts input object array into a nested key,value array.
+ * 'key' contains unique values for the attribute specified by the key parameter
+ * and value contains array of all remaining attributes in an array.
+ *
+ * @param {Array<Object>} data
+ * @param {string} key
+ * @param {string} label
+ * @returns
+ */
+export function toNested(data, key, label) {
+	return nest()
+		.key((d) => d[key])
+		.rollup((values) => values.map((value) => omit([key], value)))
+		.entries(data.sort((a, b) => ascending(a[label], b[label])))
+}
+/**
+ * Repeats array items of b using array items of a ask keys
+ *
+ * @param {Array} b
+ * @param {Array} a
+ * @returns {Object} with keys as items in a and values as items in b
+ */
+export function repeatAcross(b, a) {
+	return a.reduce(
+		(acc, item, index) => ({ ...acc, [item]: b[index % b.length] }),
+		{}
+	)
+}

package/src/lookup.js

@@ -0,0 +1,29 @@
+import { writable } from 'svelte/store'
+
+// import { __patterns__, __colors__, __shapes__ } from './constants'
+
+export const swatchStore = writable({})
+
+// export function swatch(colors, patterns, shapes, defaults) {
+// 	const limit = min([colors.length, patterns.length, shapes.length])
+
+// 	swatchStore.set({
+// 		colors: colors.slice(0, limit),
+// 		patterns: patterns.slice(0, limit),
+// 		shapes: shapes.slice(0, limit),
+// 		defaults: {
+// 			color: '#eeeeee',
+// 			shape: __shapes__.circle,
+// 			pattern: __patterns__.empty,
+// 			...defaults
+// 		}
+// 	})
+// }
+
+export function spread(values, across, filler) {
+	const unique = [...new Set(values)]
+	const lookup = unique.map((k, i) => ({
+		[k]: i < across.length ? across[i] : filler
+	}))
+	return (k) => lookup[k]
+}

package/src/plots/BarPlot.svelte

@@ -0,0 +1,55 @@
+<script>
+	import { getContext } from 'svelte'
+	import { colorBrewer } from '../lib/colors'
+
+	let chart = getContext('chart')
+
+	export let labels = false
+	export let fontSize = $chart.height / 32
+	export let color = 'white'
+
+	$: fills = colorBrewer($chart.data.map((d) => d.fill))
+	// export let limit = 8
+
+	$: data = $chart.data.map((d) => ({
+		x: $chart.flipCoords ? $chart.scale.x(0) : $chart.scale.x(d.x),
+		y: $chart.flipCoords ? $chart.scale.y(d.y) : $chart.scale.y(d.y),
+		y0: $chart.scale.y(0),
+		width: $chart.flipCoords
+			? $chart.scale.x(d.x) - $chart.scale.x(0)
+			: $chart.scale.x.bandwidth(),
+		height: $chart.flipCoords
+			? $chart.scale.y.bandwidth()
+			: $chart.scale.y(0) - $chart.scale.y(d.y),
+		fill: fills[d.fill],
+		label: {
+			x: $chart.flipCoords
+				? $chart.scale.x(d.x) - $chart.scale.x(0) - 10
+				: $chart.scale.x.bandwidth() / 2,
+			y: $chart.flipCoords ? $chart.scale.y.bandwidth() / 2 : 10,
+			angle: $chart.flipCoords ? 0 : -90,
+			text: $chart.flipCoords ? d.y + ' (' + d.x + ')' : d.x + ' (' + d.y + ')'
+		}
+	}))
+
+	// $: console.log(data)
+</script>
+
+{#each data as { x, y, width, height, fill, label }}
+	<rect {x} {y} {width} {height} {fill} />
+	{#if labels}
+		{@const tx = x + label.x}
+		{@const ty = y + label.y}
+		<text
+			x={tx}
+			y={ty}
+			transform="rotate({label.angle},{tx},{ty})"
+			font-size={fontSize}
+			text-anchor="end"
+			alignment-baseline="middle"
+			fill={color}
+		>
+			{label.text}
+		</text>
+	{/if}
+{/each}

package/src/plots/FunnelPlot.svelte

@@ -0,0 +1,33 @@
+<script>
+	import { getContext } from 'svelte'
+	import { compact } from '../components/lib/utils'
+	import { funnel } from '../components/lib/funnel'
+
+	const chart = getContext('chart')
+
+	export let x
+	export let y
+	export let fill
+	export let curve = 'bump'
+	export let stat = 'count'
+
+	$: aes = { ...$chart.aes, ...compact({ x, y, fill, stat, curve }) }
+	$: data = funnel($chart.data, aes, $chart.width, $chart.height)
+	// $: console.log(data)
+</script>
+
+{#each data.stats as stat, i}
+	<path d={data.path(stat.value)} fill={$chart.theme.colors[i]} />
+{/each}
+{#each data.labels as label, index}
+	{#if index < data.labels.length - 1}
+		<line
+			x1={label.x1}
+			x2={label.x2}
+			y1={label.y1}
+			y2={label.y2}
+			stroke="currentColor"
+		/>
+	{/if}
+	<text x={label.x} y={label.y} fill="currentColor">{label.label}</text>
+{/each}

package/src/plots/HeatMap.svelte

@@ -0,0 +1,5 @@
+<script>
+	let y // axis (day of week)
+	let x // week Number (week starts sunday)
+	let weeks //weeks
+</script>

package/src/plots/HeatMapCalendar.svelte

@@ -0,0 +1,129 @@
+<script>
+	import { summarize, heatmap } from './heatmap'
+	import { interpolateHsl } from 'd3-interpolate'
+	import { scaleLinear } from 'd3-scale'
+	import ContinuousLegend from '../elements/ContinuousLegend.svelte'
+	import DiscreteLegend from '../elements/DiscreteLegend.svelte'
+	import ColorRamp from '../elements/ColorRamp.svelte'
+
+	const dayLabelWidth = 20
+	const labelHeight = 6
+
+	export let data
+	export let dateField = 'date'
+	export let valueField = null
+	export let months = 12
+	export let colors = [transparent, '#FB8C00']
+	export let padding = 8
+	export let space = 2
+	export let size = 10
+	export let maximum = 10
+	export let tickCount = 5
+	export let discreteLegend = false
+
+	export let tooltipText = (d) => `${d.date} => ${d.value}`
+
+	let tooltip = null
+
+	function showToolTip(event, d) {
+		tooltip = d
+	}
+	function hideToolTip() {
+		tooltip = null
+	}
+	$: scale = scaleLinear()
+		.domain([0, maximum])
+		.range(colors)
+		.interpolate(interpolateHsl)
+
+	$: legendHeight = 2 * size + space * 3
+	$: sizeWithSpace = size + space
+	$: summary = summarize(data, dateField, valueField)
+	$: datamap = heatmap(summary, months)
+	$: width =
+		datamap.numberOfWeeks * sizeWithSpace + dayLabelWidth + 2 * padding - space
+	$: height = 7 * sizeWithSpace + labelHeight + 2 * padding + legendHeight
+</script>
+
+<div>
+	<svg class="chart" viewBox="0 0 {width} {height}">
+		{#if tooltip}
+			<text
+				x={padding + dayLabelWidth}
+				y={padding + legendHeight - labelHeight}
+				text-anchor="start"
+				font-size={labelHeight}
+			>
+				{tooltipText(tooltip)}
+			</text>
+		{/if}
+		{#if discreteLegend}
+			<DiscreteLegend
+				{scale}
+				x={width - (tickCount + 1) * sizeWithSpace - padding - space}
+				y={padding}
+				{tickCount}
+			/>
+		{:else}
+			<ColorRamp {scale} x={width - 100 - padding} y={padding} {tickCount} />
+			<!-- <ContinuousLegend
+				{scale}
+				x={width - 100 - padding}
+				y={padding}
+				{tickCount}
+			/> -->
+		{/if}
+		{#each datamap.weekdays as name, i}
+			<text
+				x={padding + dayLabelWidth - 2 * space}
+				y={padding +
+					legendHeight +
+					i * sizeWithSpace +
+					labelHeight +
+					(size - labelHeight) / 2}
+				text-anchor="end"
+				font-size={labelHeight}>{name}</text
+			>
+		{/each}
+
+		{#each datamap.grid as d}
+			<rect
+				x={d.x * sizeWithSpace + padding + dayLabelWidth}
+				y={d.y * sizeWithSpace + padding + legendHeight}
+				width={size}
+				height={size}
+				fill={scale(d.value)}
+				rx="1"
+				ry="1"
+				on:mouseover={(e) => showToolTip(e, d)}
+				on:focus={(e) => showToolTip(e, d)}
+				on:blur={hideToolTip}
+				on:mouseout={hideToolTip}
+			/>
+		{/each}
+
+		{#each Object.keys(datamap.months) as name}
+			<text
+				x={padding + dayLabelWidth + datamap.months[name] * sizeWithSpace}
+				y={padding + legendHeight + 7 * sizeWithSpace + 3 * space}
+				text-anchor="start"
+				font-size={labelHeight}
+				fill="currentColor">{name}</text
+			>
+		{/each}
+	</svg>
+</div>
+
+<style>
+	div {
+		position: relative;
+	}
+	rect {
+		stroke: currentColor;
+		stroke-width: 0.5;
+		stroke-opacity: 0.1;
+	}
+	text {
+		fill: currentColor;
+	}
+</style>

package/src/plots/LinePlot.svelte

@@ -0,0 +1,55 @@
+<script>
+	import { getContext } from 'svelte'
+	import { colorBrewer } from '../lib/colors'
+
+	let chart = getContext('chart')
+
+	export let labels = false
+	export let fontSize = $chart.height / 32
+	// export let color = 'white'
+
+	$: colors = colorBrewer($chart.data.map((d) => d.color))
+	// export let limit = 8
+
+	$: data = $chart.data.map((d) => ({
+		x: $chart.flipCoords ? $chart.scale.x(0) : $chart.scale.x(d.x),
+		y: $chart.flipCoords ? $chart.scale.y(d.y) : $chart.scale.y(d.y),
+		y0: $chart.scale.y(0),
+		width: $chart.flipCoords
+			? $chart.scale.x(d.x) - $chart.scale.x(0)
+			: $chart.scale.x.bandwidth(),
+		height: $chart.flipCoords
+			? $chart.scale.y.bandwidth()
+			: $chart.scale.y(0) - $chart.scale.y(d.y),
+		color: colors[d.color],
+		label: {
+			x: $chart.flipCoords
+				? $chart.scale.x(d.x) - $chart.scale.x(0) - 10
+				: $chart.scale.x.bandwidth() / 2,
+			y: $chart.flipCoords ? $chart.scale.y.bandwidth() / 2 : 10,
+			angle: $chart.flipCoords ? 0 : -90,
+			text: $chart.flipCoords ? d.y + ' (' + d.x + ')' : d.x + ' (' + d.y + ')'
+		}
+	}))
+
+	// $: console.log(data)
+</script>
+
+{#each data as { x1, y1, x2, y2, color, label }}
+	<line {x1} {y1} {x2} {y2} stroke={color} />
+	{#if labels}
+		{@const tx = x1 + label.x}
+		{@const ty = y1 + label.y}
+		<text
+			x={tx}
+			y={ty}
+			transform="rotate({label.angle},{tx},{ty})"
+			font-size={fontSize}
+			text-anchor="end"
+			alignment-baseline="middle"
+			fill={color}
+		>
+			{label.text}
+		</text>
+	{/if}
+{/each}

package/src/plots/Plot.svelte

@@ -0,0 +1,25 @@
+<script>
+  import { aggregate, getScales } from '../lib/utils'
+
+  import BoxPlot from './BoxPlot.svelte'
+  import ScatterPlot from './ScatterPlot.svelte'
+
+  export let data
+  export let width
+  export let height
+  export let x
+  export let y
+  export let plots = []
+
+  $: nested = aggregate(data, x, y)
+  $: scales = getScales(data, x, y, width, height)
+</script>
+
+<svg viewBox="0 0 {width} {height}">
+  {#if plots.includes('box')}
+    <BoxPlot data={nested} {...scales} />
+  {/if}
+  {#if plots.includes('scatter')}
+    <ScatterPlot {data} {x} {y} {...scales} />
+  {/if}
+</svg>

package/src/plots/RankBarPlot.svelte

@@ -0,0 +1,38 @@
+<script>
+	import Bar from '../elements/Bar.svelte'
+	import { max } from 'd3-array'
+	import { writable } from 'svelte/store'
+	import { tweened } from 'svelte/motion'
+	import { scaleLinear } from 'd3-scale'
+
+	export let data
+	export let colors
+	export let width = 800
+	export let limit = 8
+	export let duration = 300
+	const h = 50
+	let height
+	const pad = 5
+
+	const xMax = tweened(null, { duration })
+	const scales = writable({})
+
+	$: xMax.set(max(data.map((d) => d.value)))
+	$: height = pad + (h + pad) * limit
+	$: scales.set({
+		x: scaleLinear()
+			.domain([0, $xMax])
+			.range([10, width - 10]),
+		y: scaleLinear().domain([0, limit]).range([0, height])
+	})
+</script>
+
+<svg viewBox="0 0 {width} {height}">
+	{#if Array.isArray(data)}
+		{#each data as item, i}
+			{#if item.rank < limit}
+				<Bar {...item} fill={colors[item.name]} {scales} />
+			{/if}
+		{/each}
+	{/if}
+</svg>

package/src/plots/ScatterPlot.svelte

@@ -0,0 +1,20 @@
+<script>
+	import { getContext } from 'svelte'
+	import { colorBrewer } from '../lib/colors'
+
+	let chart = getContext('chart')
+
+	export let size = $chart.height / 128
+
+	$: colors = colorBrewer($chart.data.map((d) => d.fill))
+	$: points = $chart.data.map((d) => ({
+		cx: $chart.scale.x(d.x),
+		cy: $chart.scale.y(d.y),
+		fill: colors[d.fill]
+	}))
+	// support shapes and sizes for scatter
+</script>
+
+{#each points as { cx, cy, fill }}
+	<circle {cx} {cy} r={size} {fill} fill-opacity="0.5" />
+{/each}

package/src/plots/ViolinPlot.svelte

@@ -0,0 +1,11 @@
+<script>
+  import { getContext } from 'svelte'
+
+  let chart = getContext('chart')
+  $: data = $chart.violin()
+  // $: console.log(data)
+</script>
+
+{#each data as { x, curve }, i}
+  <path d={curve} transform="translate({x},0)" fill="gray" stroke="none" />
+{/each}

package/src/plots/heatmap.js

@@ -0,0 +1,70 @@
+import {
+	isSunday,
+	addDays,
+	subMonths,
+	startOfMonth,
+	format,
+	previousSunday,
+	differenceInDays,
+	differenceInWeeks,
+	endOfWeek
+} from 'date-fns'
+import { nest } from 'd3-collection'
+import { group } from 'd3-array'
+
+const DATE_FORMAT = 'yyyy-MM-dd'
+const weekdays = ['sun', 'mon', 'tue', 'wed', 'thu', 'fri', 'sat']
+
+export function summarize(data, dateField = 'date', valueField) {
+	// const summary = group(data, d => d[dateField])
+	const nested = nest()
+		.key((d) => format(new Date(d[dateField]), DATE_FORMAT))
+		.rollup((d) =>
+			valueField
+				? d.map((value) => value[valueField]).reduce((a, b) => a + b, 0)
+				: d.length
+		)
+		.entries(data)
+	// console.log(Object.fromEntries(nested))
+	return nested.reduce((obj, item) => ((obj[item.key] = item.value), obj), {})
+}
+
+export function heatmap(data, numberOfMonths) {
+	const today = new Date()
+	const firstDay = getFirstDay(numberOfMonths, today)
+	const months = {}
+	const grid = generateGrid(firstDay, today).map((d) => ({
+		...d,
+		value: d.date in data ? data[d.date] : 0
+	}))
+
+	grid.map((d) => {
+		const month = format(endOfWeek(new Date(d.date)), 'MMM')
+		// console.log(month)
+		if (!(month in months)) {
+			months[month] = d.x
+		}
+	})
+	return {
+		grid,
+		months,
+		weekdays,
+		numberOfWeeks: differenceInWeeks(today, firstDay) + 1
+	}
+}
+
+function getFirstDay(months, lastDay = new Date()) {
+	const firstDay = subMonths(startOfMonth(lastDay), months)
+	return isSunday(firstDay) ? firstDay : previousSunday(firstDay)
+}
+
+function generateGrid(firstDay, lastDay) {
+	const days = differenceInDays(lastDay, firstDay) + 1
+
+	const grid = [...Array(days).keys()].map((day) => ({
+		x: Math.floor(day / 7),
+		y: day % 7,
+		date: format(addDays(firstDay, day), DATE_FORMAT)
+	}))
+	return grid
+}

package/src/plots/index.js

@@ -0,0 +1,10 @@
+export { default as Box } from './BoxPlot.svelte'
+export { default as BoxPlot } from './BoxPlot.svelte'
+export { default as Bar } from './BarPlot.svelte'
+export { default as BarPlot } from './BarPlot.svelte'
+export { default as Line } from './LinePlot.svelte'
+export { default as LinePlot } from './LinePlot.svelte'
+export { default as Violin } from './ViolinPlot.svelte'
+export { default as ViolinPlot } from './ViolinPlot.svelte'
+export { default as Scatter } from './ScatterPlot.svelte'
+export { default as ScatterPlot } from './ScatterPlot.svelte'