@rokkit/chart 1.0.0-next.87 → 1.0.0-next.88

package/src/lib/lookup.js

@@ -1,29 +0,0 @@
-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/lib/pattern.js

@@ -1,182 +0,0 @@
-import { clamp } from 'yootils'
-import { ColorBrewer } from './color'
-import { toHexString, uniqueId, addToArray, toArray } from './utils'
-
-export const builtIn = [
-	{ path: 'M0 5A6 6 0 0 0 10 5', minAngle: 0, maxAngle: 90 },
-	{ path: 'M0 10L10 0', minAngle: 0, maxAngle: 90 },
-	{ path: 'M0 0A10 10 0 0 0 10 10', minAngle: 0, maxAngle: 90 },
-	{ path: 'M0 0L10 10', minAngle: 0, maxAngle: 90 },
-	{ path: 'M10 5A6 6 0 0 0 0 5', minAngle: 0, maxAngle: 90 },
-
-	{ path: 'M10 10A10 10 0 0 0 0 0', minAngle: 0, maxAngle: 90 },
-	{ path: 'M0 0L10 10ZM10 0L0 10Z', minAngle: 0, maxAngle: 90 },
-	{ path: 'M1 1L9 1L9 9L1 9Z', minAngle: 0, maxAngle: 90 },
-	{ path: 'M4 0L4 10M6 10L6 0M0 4L10 4M10 6L0 6', minAngle: 0, maxAngle: 90 },
-	{ path: 'M0 2L8 10M2 0L10 8M0 8L8 0M2 10L10 2', minAngle: 0, maxAngle: 90 },
-
-	{
-		path: 'M5 1A 4 4 0 0 0 9 5A4 4 0 0 0 5 9A4 4 0 0 0 1 5A4 4 0 0 0 5 1',
-		minAngle: 0,
-		maxAngle: 45
-	},
-	{ path: 'M1 3L7 9M3 1L9 7M1 7L7 1M3 9L9 3', minAngle: 0, maxAngle: 90 },
-	{
-		path: 'M2 2A4 4 0 0 0 8 2A4 4 0 0 0 8 8A4 4 0 0 0 2 8A4 4 0 0 0 2 2',
-		minAngle: 0,
-		maxAngle: 90
-	},
-	{
-		path: 'M0 0A5 5 0 0 0 10 0A5 5 0 0 0 10 10A5 5 0 0 0 0 10A5 5 0 0 0 0 0',
-		minAngle: 0,
-		maxAngle: 45
-	},
-	{
-		path: 'M5 2A 3 3 0 0 0 8 5A3 3 0 0 0 5 8A3 3 0 0 0 2 5A3 3 0 0 0 5 2',
-		minAngle: 0,
-		maxAngle: 90
-	},
-
-	{ path: 'M2 5L5 2L8 5L5 8Z', minAngle: 0, maxAngle: 90 },
-	{
-		path: 'M3 5A2 2 0 0 0 7 5A2 2 0 0 0 3 5M1 5L9 5M5 1L5 9',
-		minAngle: 0,
-		maxAngle: 90
-	},
-	{
-		path: 'M2 8L8 2ZM1.5 3.5L3.5 1.5ZM6.5 8.5L8.5 6.5ZM0 0L10 10Z',
-		minAngle: 0,
-		maxAngle: 90
-	},
-
-	{
-		path:
-			'M2 8L8 2ZM1.5 3.5L3.5 1.5Z' +
-			'M6.5 8.5L8.5 6.5Z' +
-			'M2 2L8 8M1.5 6.5L3.5 8.5' +
-			'M6.5 1.5L8.5 3.5',
-		minAngle: 0,
-		maxAngle: 90
-	},
-
-	{
-		path: 'M5 1 A6 6 0 0 0 5 9' + 'A6 6 0 0 0 5 1' + 'M1 5A6 6 0 0 0 9 5A6 6 0 0 0 1 5',
-		minAngle: 0,
-		maxAngle: 90
-	},
-	{
-		path:
-			'M1.5 5A1 1 0 0 0 3.5 5A1 1 0 0 0 1.5 5' +
-			'M6.5 5A1 1 0 0 0 8.5 5A1 1 0 0 0 6.5 5' +
-			'M5 1.5A1 1 0 0 0 5 3.5A1 1 0 0 0 5 1.5' +
-			'M5 6.5A1 1 0 0 0 5 8.5A1 1 0 0 0 5 6.5',
-		minAngle: 0,
-		maxAngle: 90
-	},
-	{
-		path:
-			'M1.5 2.5A1 1 0 0 0 3.5 2.5A1 1 0 0 0 1.5 2.5' +
-			'M6.5 2.5A1 1 0 0 0 8.5 2.5A1 1 0 0 0 6.5 2.5' +
-			'M2.5 6.5A1 1 0 0 0 2.5 8.5A1 1 0 0 0 2.5 6.5' +
-			'M7.5 6.5A1 1 0 0 0 7.5 8.5A1 1 0 0 0 7.5 6.5' +
-			'M3.5 5A1 1 0 0 0 6.5 5A1 1 0 0 0 3.5 5',
-		minAngle: 0,
-		maxAngle: 90
-	},
-	{
-		path: 'M5 0L6 4L10 5L6 6L5 10L4 6L0 5L4 4Z' + 'M2 1V3M1 2H3' + 'M8 9V7M9 8H7',
-		minAngle: 0,
-		maxAngle: 90
-	},
-	{ path: 'M5 2L2.5 9L8.8 4.6L1.2 4.6L7.5 9Z', minAngle: 0, maxAngle: 90 },
-	{
-		path: 'M0 5A5 5 0 0 0 5 0' + 'M5 10A5 5 0 0 0 0 5' + 'M5 10A5 5 0 0 0 5 0',
-		minAngle: 0,
-		maxAngle: 90
-	},
-	{
-		path: 'M0 0L10 10M5 0L10 5M0 5 L5 10',
-		minAngle: 0,
-		maxAngle: 90
-	},
-	{
-		path: 'M0 0L10 10M3 0L10 7M0 7 L3 10',
-		minAngle: 0,
-		maxAngle: 90
-	}
-]
-
-export class PatternBrewer {
-	constructor() {
-		this.paths = builtIn
-		this.shades = []
-		this.gray = new ColorBrewer().gray()
-		this.bw = false
-		this.repeat = false
-		this.indices = [...this.paths.keys()]
-	}
-
-	clear() {
-		this.paths = []
-	}
-
-	add(path) {
-		this.paths = addToArray(this.pathc, path)
-		return this
-	}
-
-	filter(indices) {
-		indices = toArray(indices)
-		this.indices = indices.filter((i) => i >= 0 && i < this.paths.length)
-		return this
-	}
-
-	colors(shades, repeat = false) {
-		this.shades = toArray(shades)
-		this.repeat = repeat
-		return this
-	}
-
-	variants(count) {
-		count = clamp(count, 1, 15)
-		this.paths = this.paths.map((path) => ({
-			...path,
-			angles: [...Array(count).keys()].map((i) => (i * (path.maxAngle - path.minAngle)) / count)
-		}))
-		return this
-	}
-
-	brew() {
-		// const hexPrefix = toHexString(prefix)
-		const hexPrefix = uniqueId()
-
-		let patterns = []
-
-		// apply filter and add angle variations
-		this.indices
-			.map((i) => this.paths[i])
-			.map((path) => {
-				if ('angles' in path) {
-					path.angles.map((angle) => patterns.push({ ...path, angle }))
-				} else {
-					patterns.push(path)
-				}
-			})
-
-		patterns = patterns
-			// Add reference ids
-			.map((path, index) => ({
-				id: hexPrefix + '-' + toHexString(index),
-				...path,
-				fillUrl: `url(#${hexPrefix}-${toHexString(index)})`
-			}))
-			// Add colors
-			.map((pattern, i) => {
-				return i < this.shades.length || this.repeat
-					? { ...pattern, ...this.shades[i % this.shades.length] }
-					: { ...pattern, ...this.gray }
-			})
-
-		return patterns
-	}
-}

package/src/lib/rollup.js

@@ -1,49 +0,0 @@
-import { min, max, add, format } from 'date-fns'
-
-export function uniques(data, attr) {
-	return data && attr ? [...new Set(data.map((item) => item[attr]))] : []
-}
-
-export function slidingWindow(values, size, step, offset, fmt) {
-	return size && typeof size === 'object'
-		? slidingWindowForDates(values, size, step, offset, fmt)
-		: slidingWindowForNumbers(values, size, step, offset, fmt)
-}
-
-function slidingWindowForNumbers(values, size, step, offset = 0, fmt = 0) {
-	const smallest = Number(Math.min(...values).toFixed(fmt))
-	let largest = Math.max(...values)
-	let count = Math.ceil((largest - smallest + offset) / step)
-
-	if (smallest + count * step + offset == largest) {
-		count += 1
-	}
-
-	const range = [...Array(count).keys()]
-
-	const result = range.map((key) => ({
-		key: smallest + key * step,
-		lowerBound: smallest + key * step + offset,
-		upperBound: smallest + key * step + offset + size
-	}))
-	return result
-}
-
-function slidingWindowForDates(values, size, step, offset = {}, fmt = 'yyyy-MM-dd') {
-	const largest = max(values)
-	let current = new Date(format(min(values), fmt))
-	let blocks = []
-	let lowerBound = current
-
-	while (lowerBound <= largest) {
-		lowerBound = add(current, offset)
-
-		blocks.push({
-			key: current,
-			lowerBound,
-			upperBound: add(lowerBound, size)
-		})
-		current = add(current, step)
-	}
-	return blocks
-}

package/src/lib/shape.js

@@ -1,46 +0,0 @@
-import { ColorBrewer } from './color'
-import { symbols } from '@rokkit/atoms/symbols'
-import { addToArray, toArray } from './utils'
-export class ShapeBrewer {
-	constructor() {
-		this.shapes = Object.keys(symbols)
-		this.repeat = false
-		this.keys = Object.keys(this.shapes)
-		this.gray = new ColorBrewer().gray()
-		this.shades = []
-		this.repeat = false
-	}
-
-	clear() {
-		this.shapes = []
-		return this
-	}
-
-	add(shape) {
-		this.shapes = addToArray(this.shapes, shape)
-
-		return this
-	}
-
-	filter(keys) {
-		this.keys = toArray(keys).filter((key) => key in this.shapes)
-
-		return this
-	}
-
-	colors(shades, repeat = false) {
-		this.shades = toArray(shades)
-		this.repeat = repeat
-		return this
-	}
-
-	brew() {
-		return this.keys
-			.map((i) => this.shapes[i])
-			.map((shape, i) => {
-				return i < this.shades.length || this.repeat
-					? { shape, ...this.shades[i % this.shades.length] }
-					: { shape, ...this.gray }
-			})
-	}
-}

package/src/lib/store.js

@@ -1,63 +0,0 @@
-// import { writable } from 'svelte/store'
-import { tweened, cubicOut } from 'svelte/motion'
-// function createChart() {
-// 	const { subscribe, set } = writable({
-// 		data: [],
-// 		x: '',
-// 		y: ''
-// 	})
-// 	return { subscribe, set }
-// }
-
-export function animatedChart(input, key, valueFields = [], previous = []) {
-	const previousKeys = new Set(previous.map((item) => item[key]))
-	const currentKeys = new Set(input.map((item) => item[key]))
-	const toAdd = new Set([...currentKeys].filter((key) => !previousKeys.has(key)))
-	const toRemove = new Set([...previousKeys].filter((key) => !currentKeys.has(key)))
-
-	let data = input
-		.filter((item) => toAdd.has(item[key]))
-		.map((item) => {
-			let el = { ...item }
-			valueFields.forEach(
-				({ field, initialValue, attrs }) =>
-					(el[field] = typeof initialValue === 'function' ? initialValue(el, attrs) : initialValue)
-			)
-			return el
-		})
-	let prev = previous
-		.filter((item) => !toRemove.has(item[key]))
-		.map((item) => {
-			let el = { ...item }
-			valueFields.forEach(
-				({ field, initialValue, attrs }) =>
-					(el[field] =
-						typeof initialValue === 'function'
-							? initialValue(el, { ...attrs, isPrevious: true })
-							: initialValue)
-			)
-			return el
-		})
-	data = [...prev, ...data]
-
-	return tweened(data, { duration: 500, easing: cubicOut })
-}
-// function createAxis() {
-// 	const { subscribe, set } = writable({})
-
-// 	let data
-// 	let x = {}
-// 	let y = {}
-
-// 	// find origin & orientation
-// 	function getOriginAndOrientation(data, x, y) {
-// 		this.data = data
-// 		this.x = x
-// 		this.y = y
-// 	}
-// 	function init(config, data) {}
-// 	return { subscribe, init, set, getOriginAndOrientation }
-// }
-
-// export const chart = createChart()
-// export const axis = createAxis()

package/src/lib/summary.js

@@ -1,28 +0,0 @@
-import { sum, median, max, mean, min, quantile, cumsum } from 'd3-array'
-import { nest } from 'd3-collection'
-import { pick, flatten } from 'ramda'
-
-export const aggregate = {
-	count: (values) => values.length,
-	sum: (values) => sum(values),
-	min: (values) => min(values),
-	max: (values) => max(values),
-	mean: (values) => mean(values),
-	median: (values) => median(values),
-	cumsum: (values) => cumsum(values),
-	q1: (values) => quantile(values, 0.25),
-	q3: (values) => quantile(values, 0.75)
-}
-
-export function summarize(data, by, attr, stat = 'count') {
-	const stats = Array.isArray(stat) ? stat : [stat]
-	const grouped = nest()
-		.key((d) => by.map((f) => d[f]).join('|'))
-		.rollup((rows) => {
-			let agg = pick(by, rows[0])
-			stats.map((stat) => (agg[stat] = aggregate[stat](rows.map((d) => d[attr]))))
-			return [agg]
-		})
-		.entries(data)
-	return flatten(grouped.map((group) => group.value))
-}

package/src/lib/theme.js

@@ -1,31 +0,0 @@
-import { builtIn as patterns } from './pattern'
-import { namedShapes as shapes } from './shape'
-import { builtIn as symbols } from './shape'
-import { colors, palette } from './color'
-/**
- *
- */
-export class ThemeBrewer {
-	constructor() {
-		this.patterns = []
-		this.shapes = []
-		this.palette = []
-		this.defaults = {}
-	}
-}
-
-export const builtIn = {
-	colors,
-	palette,
-	patterns,
-	shapes,
-	symbols,
-	tick: {
-		size: {
-			major: 6,
-			minor: 4,
-			end: 6,
-			padding: 3
-		}
-	}
-}

package/src/lib/utils.js

@@ -1,158 +0,0 @@
-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'
-
-export function toArray(value) {
-	return Array.isArray(value) ? value : [value]
-}
-export function addToArray(array, value) {
-	return [...array, ...toArray(value)]
-}
-/**
- * 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/plots/BarPlot.svelte

@@ -1,51 +0,0 @@
-<script>
-	import { getContext } from 'svelte'
-	import { colorBrewer } from '../lib/palette'
-
-	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 + ')'
-		}
-	}))
-</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/BarPlot2.svelte

@@ -1,34 +0,0 @@
-<script>
-	import { getContext } from 'svelte'
-
-	let chart = getContext('chart')
-
-	// export let data = []
-	export let limit = 8
-	export let fields
-	// export let valueFormat
-	// export let scales
-	export let colors
-	export let h = 10
-
-	function size(value) {
-		return $chart.axis.x.scale(value)
-	}
-	function top(value) {
-		return $chart.axis.y.scale(value)
-	}
-
-	$: bars = $chart.data.slice(0, limit)
-</script>
-
-{#each bars as item}
-	<rect
-		x="0"
-		y={top(item[fields.y]) + h / 2}
-		width={size(item[fields.x])}
-		height={h * 3}
-		fill={colors[item[fields.label]]}
-	/>
-	<text x="10" y={top(item[fields.y]) + 2.5 * h}>{item[fields.label]}</text>
-	<!-- <text x="10" y={top(item[fields.y]) + 10}>{item[fields.x]}</text> -->
-{/each}