layerchart 2.0.0-next.5 → 2.0.0-next.51

package/dist/utils/trail.js

@@ -0,0 +1,341 @@
+/**
+ * Trail path utilities for variable-width lines.
+ *
+ * Round cap (capsule) approach adapted from Vega's trail mark.
+ * Copyright (c) 2015-2023, University of Washington Interactive Data Lab.
+ * BSD 3-Clause License: https://github.com/vega/vega/blob/main/LICENSE
+ *
+ * Butt cap (polygon offset) and curve resampling via fake context
+ * adapted from SveltePlot's trail mark.
+ * Copyright 2024-2026, Gregor Aisch.
+ * ISC License: https://github.com/svelteplot/svelteplot/blob/main/LICENSE
+ */
+/**
+ * Computes a filled SVG path for a trail with variable width.
+ *
+ * Supports optional curve interpolation (via d3-shape curve factories)
+ * and two cap styles: 'round' (capsule-based) and 'butt' (polygon offset).
+ */
+export function computeTrailPath(points, options = {}) {
+    if (points.length === 0)
+        return '';
+    const { curve, cap = 'round', tension, resolution } = options;
+    let drawPoints = points;
+    // Resample through curve if provided
+    if (curve) {
+        drawPoints = resampleWithCurve(points, curve, tension, resolution);
+    }
+    if (drawPoints.length === 0)
+        return '';
+    if (drawPoints.length === 1) {
+        const { x, y, r } = drawPoints[0];
+        if (cap === 'butt')
+            return '';
+        return `M${x - r},${y}A${r},${r},0,1,1,${x + r},${y}A${r},${r},0,1,1,${x - r},${y}Z`;
+    }
+    return cap === 'butt' ? trailPathButt(drawPoints) : trailPathRound(drawPoints);
+}
+// ---------------------------------------------------------------------------
+// Round caps (capsule-based, original approach)
+// ---------------------------------------------------------------------------
+function trailPathRound(points) {
+    let d = '';
+    for (let i = 0; i < points.length - 1; i++) {
+        const p1 = points[i];
+        const p2 = points[i + 1];
+        const r1 = p1.r;
+        const r2 = p2.r;
+        let nx = p1.y - p2.y;
+        let ny = p2.x - p1.x;
+        const len = Math.hypot(nx, ny);
+        if (len < 1e-6)
+            continue;
+        nx /= len;
+        ny /= len;
+        const x1L = p1.x - nx * r1, y1L = p1.y - ny * r1;
+        const x1R = p1.x + nx * r1, y1R = p1.y + ny * r1;
+        const x2L = p2.x - nx * r2, y2L = p2.y - ny * r2;
+        const x2R = p2.x + nx * r2, y2R = p2.y + ny * r2;
+        d += `M${x1L},${y1L}`;
+        d += `L${x2L},${y2L}`;
+        d += `A${r2},${r2},0,0,1,${x2R},${y2R}`;
+        d += `L${x1R},${y1R}`;
+        d += `A${r1},${r1},0,0,1,${x1L},${y1L}`;
+        d += 'Z';
+    }
+    return d;
+}
+// ---------------------------------------------------------------------------
+// Butt caps (polygon offset using angle bisector normals)
+// ---------------------------------------------------------------------------
+function trailPathButt(points) {
+    const n = points.length;
+    if (n < 2)
+        return '';
+    const left = [];
+    const right = [];
+    const normalize = (x, y) => {
+        const len = Math.hypot(x, y);
+        return len === 0 ? [0, 0] : [x / len, y / len];
+    };
+    for (let i = 0; i < n; i++) {
+        const curr = points[i];
+        const r = curr.r;
+        const hasPrev = i > 0;
+        const hasNext = i < n - 1;
+        const prev = hasPrev ? points[i - 1] : curr;
+        const next = hasNext ? points[i + 1] : curr;
+        const dirPrev = hasPrev
+            ? normalize(curr.x - prev.x, curr.y - prev.y)
+            : normalize(next.x - curr.x, next.y - curr.y);
+        const dirNext = hasNext
+            ? normalize(next.x - curr.x, next.y - curr.y)
+            : dirPrev;
+        // Perpendicular normals (rotate 90° CCW)
+        const normPrev = [-dirPrev[1], dirPrev[0]];
+        const normNext = [-dirNext[1], dirNext[0]];
+        // Average normal (bisector direction)
+        let nx = normPrev[0] + normNext[0];
+        let ny = normPrev[1] + normNext[1];
+        const nLen = Math.hypot(nx, ny);
+        if (nLen < 1e-6) {
+            nx = normPrev[0];
+            ny = normPrev[1];
+        }
+        else {
+            nx /= nLen;
+            ny /= nLen;
+        }
+        // Miter scale: compensate for the angle so offset width is correct
+        const dot = nx * normPrev[0] + ny * normPrev[1];
+        const safeDot = Math.abs(dot) < 1e-6 ? 1 : dot;
+        // Clamp miter to avoid extreme spikes at sharp turns
+        const scale = Math.min(r / safeDot, r * 4);
+        const ox = nx * scale;
+        const oy = ny * scale;
+        left.push([curr.x + ox, curr.y + oy]);
+        right.push([curr.x - ox, curr.y - oy]);
+    }
+    let d = `M${left[0][0]},${left[0][1]}`;
+    for (let i = 1; i < left.length; i++) {
+        d += `L${left[i][0]},${left[i][1]}`;
+    }
+    for (let i = right.length - 1; i >= 0; i--) {
+        d += `L${right[i][0]},${right[i][1]}`;
+    }
+    d += 'Z';
+    return d;
+}
+/**
+ * Resample points through a d3-shape curve factory, producing dense
+ * intermediate points with interpolated radii.
+ */
+function resampleWithCurve(points, curveFactory, tension, resolution) {
+    if (points.length < 2)
+        return points;
+    // Apply tension if the curve factory supports it
+    const factory = applyTension(curveFactory, tension);
+    // Capture curve commands via a fake context
+    const commands = [];
+    let currentPoint = null;
+    let currentRadius = points[0].r;
+    let pendingRadius = points[0].r;
+    const ctx = {
+        moveTo(x, y) {
+            currentPoint = [x, y];
+            currentRadius = pendingRadius;
+            commands.push({ type: 'M', x, y, r: currentRadius });
+        },
+        lineTo(x, y) {
+            const from = currentPoint ?? [x, y];
+            commands.push({
+                type: 'L',
+                from: [from[0], from[1], currentRadius],
+                to: [x, y, pendingRadius],
+            });
+            currentPoint = [x, y];
+            currentRadius = pendingRadius;
+        },
+        bezierCurveTo(x1, y1, x2, y2, x, y) {
+            const from = currentPoint ?? [x, y];
+            commands.push({
+                type: 'C',
+                from: [from[0], from[1], currentRadius],
+                cp1: [x1, y1],
+                cp2: [x2, y2],
+                to: [x, y, pendingRadius],
+            });
+            currentPoint = [x, y];
+            currentRadius = pendingRadius;
+        },
+        quadraticCurveTo(x1, y1, x, y) {
+            const from = currentPoint ?? [x, y];
+            commands.push({
+                type: 'Q',
+                from: [from[0], from[1], currentRadius],
+                cp: [x1, y1],
+                to: [x, y, pendingRadius],
+            });
+            currentPoint = [x, y];
+            currentRadius = pendingRadius;
+        },
+        closePath() { },
+        beginPath() { },
+        arc() { },
+        rect() { },
+    };
+    // Drive the curve factory with our points
+    const curve = factory(ctx);
+    curve.lineStart();
+    for (const pt of points) {
+        pendingRadius = pt.r;
+        curve.point(pt.x, pt.y);
+    }
+    curve.lineEnd();
+    // Determine samples per segment
+    const samplesPerSegment = resolution ?? estimateSamplesPerSegment(points);
+    // Flatten captured commands into dense points
+    const dense = flattenCommands(commands, samplesPerSegment);
+    if (dense.length === 0)
+        return points;
+    // Interpolate radii based on arc-length proportion
+    interpolateRadii(points, dense);
+    return dense;
+}
+/**
+ * Apply tension to a curve factory if it supports it.
+ * d3-shape conventions: curveCardinal.tension(), curveCatmullRom.alpha(), curveBundle.beta()
+ */
+function applyTension(factory, tension) {
+    if (tension == null)
+        return factory;
+    const f = factory;
+    if (typeof f.tension === 'function')
+        return f.tension(tension);
+    if (typeof f.alpha === 'function')
+        return f.alpha(tension);
+    if (typeof f.beta === 'function')
+        return f.beta(tension);
+    return factory;
+}
+/**
+ * Auto-estimate samples per segment based on average segment length relative to radius.
+ */
+function estimateSamplesPerSegment(points) {
+    let distSum = 0;
+    let rSum = 0;
+    for (let i = 0; i < points.length; i++) {
+        rSum += points[i].r;
+        if (i > 0) {
+            distSum += Math.hypot(points[i].x - points[i - 1].x, points[i].y - points[i - 1].y);
+        }
+    }
+    const meanDist = points.length > 1 ? distSum / (points.length - 1) : 0;
+    const meanRadius = rSum / points.length;
+    const base = meanRadius > 0 ? meanDist / meanRadius : meanDist;
+    return Math.max(4, Math.min(32, Math.round(base || 8)));
+}
+/**
+ * Flatten captured path commands into dense {x, y, r} samples.
+ * Bézier curves are subdivided parametrically.
+ */
+function flattenCommands(commands, samplesPerSegment) {
+    const result = [];
+    let last = null;
+    const push = (x, y, r) => {
+        // Deduplicate consecutive identical points
+        if (last && Math.abs(last[0] - x) < 1e-6 && Math.abs(last[1] - y) < 1e-6)
+            return;
+        result.push({ x, y, r });
+        last = [x, y];
+    };
+    for (const cmd of commands) {
+        if (cmd.type === 'M') {
+            push(cmd.x, cmd.y, cmd.r);
+            continue;
+        }
+        if (cmd.type === 'L') {
+            const [x0, y0, r0] = cmd.from;
+            const [x1, y1, r1] = cmd.to;
+            for (let s = 1; s <= samplesPerSegment; s++) {
+                const t = s / samplesPerSegment;
+                push(lerp(x0, x1, t), lerp(y0, y1, t), lerp(r0, r1, t));
+            }
+            continue;
+        }
+        if (cmd.type === 'C') {
+            const [x0, y0, r0] = cmd.from;
+            const [x1, y1] = cmd.cp1;
+            const [x2, y2] = cmd.cp2;
+            const [x3, y3, r3] = cmd.to;
+            for (let s = 1; s <= samplesPerSegment; s++) {
+                const t = s / samplesPerSegment;
+                push(cubic(x0, x1, x2, x3, t), cubic(y0, y1, y2, y3, t), lerp(r0, r3, t));
+            }
+            continue;
+        }
+        if (cmd.type === 'Q') {
+            const [x0, y0, r0] = cmd.from;
+            const [cx, cy] = cmd.cp;
+            const [x1, y1, r1] = cmd.to;
+            for (let s = 1; s <= samplesPerSegment; s++) {
+                const t = s / samplesPerSegment;
+                push(quad(x0, cx, x1, t), quad(y0, cy, y1, t), lerp(r0, r1, t));
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Assign interpolated radii to dense resampled points based on
+ * arc-length proportion relative to the original points.
+ */
+function interpolateRadii(original, dense) {
+    if (original.length < 2 || dense.length < 2)
+        return;
+    // Cumulative arc-length of original points
+    const origCum = [0];
+    for (let i = 1; i < original.length; i++) {
+        origCum.push(origCum[i - 1] + Math.hypot(original[i].x - original[i - 1].x, original[i].y - original[i - 1].y));
+    }
+    const origTotal = origCum[origCum.length - 1] || 1;
+    // Cumulative arc-length of dense points
+    const denseCum = [0];
+    for (let i = 1; i < dense.length; i++) {
+        denseCum.push(denseCum[i - 1] + Math.hypot(dense[i].x - dense[i - 1].x, dense[i].y - dense[i - 1].y));
+    }
+    const denseTotal = denseCum[denseCum.length - 1] || 1;
+    for (let i = 0; i < dense.length; i++) {
+        const frac = denseCum[i] / denseTotal;
+        const target = frac * origTotal;
+        // Find bracketing segment in original
+        let idx = 1;
+        while (idx < origCum.length && origCum[idx] < target)
+            idx++;
+        if (idx >= origCum.length) {
+            dense[i].r = original[original.length - 1].r;
+        }
+        else {
+            const t0 = origCum[idx - 1];
+            const t1 = origCum[idx];
+            const r0 = original[idx - 1].r;
+            const r1 = original[idx].r;
+            const t = t1 === t0 ? 0 : (target - t0) / (t1 - t0);
+            dense[i].r = lerp(r0, r1, t);
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Math helpers
+// ---------------------------------------------------------------------------
+function lerp(a, b, t) {
+    return a + (b - a) * t;
+}
+function cubic(p0, p1, p2, p3, t) {
+    const it = 1 - t;
+    return it * it * it * p0 + 3 * it * it * t * p1 + 3 * it * t * t * p2 + t * t * t * p3;
+}
+function quad(p0, p1, p2, t) {
+    const it = 1 - t;
+    return it * it * p0 + 2 * it * t * p1 + t * t * p2;
+}

package/dist/utils/treemap.d.ts

@@ -9,5 +9,5 @@ export declare function aspectTile(tile: TileFunc, width: number, height: number
 /**
  * Show if the node (a) is a child of the selected (b), or any parent above selected
  */
-export declare function isNodeVisible(a: HierarchyNode<any>, b: HierarchyNode<any> | null): boolean;
+export declare function isNodeVisible(a: HierarchyNode<any>, b: HierarchyNode<any> | null | undefined): boolean;
 export {};

package/dist/utils/types.d.ts

@@ -1,7 +1,8 @@
+import type { MouseEventHandler, PointerEventHandler } from 'svelte/elements';
+import type { TransitionConfig } from 'svelte/transition';
 import type { HierarchyNode } from 'd3-hierarchy';
-import type { AnyScale } from './scales.svelte.js';
 import type { SankeyGraph } from 'd3-sankey';
-import type { TransitionConfig } from 'svelte/transition';
+import type { AnyScale } from './scales.svelte.js';
 /**
  * Useful to workaround Svelte 3/4 markup type issues
  * TODO: Remove usage after migrating to Svelte 5
@@ -13,11 +14,20 @@ export declare function asAny(x: any): any;
  *
  * @template T - The base object type from which properties will be omitted.
  * @template U - The object type whose properties will be omitted from 'T'.
+ *
  * @example
  * type Result = Without<{ a: number; b: string; }, { b: string; }>;
  * // Result type will be { a: number; }
  */
 export type Without<T extends object, U extends object> = Omit<T, keyof U>;
+/**
+ * Extracts the non-nullable array type from a type that may include nulls.
+ *
+ * @example
+ * type Result = NonNullArray<(number | null)[]>;
+ * // Result type will be number[].
+ */
+export type NonNullArray<T> = T extends (infer U | null)[] ? U[] : never;
 export type AxisKey = 'x' | 'y' | 'z' | 'r';
 export type Extents = {
     [K in AxisKey]?: Array<number | string>;
@@ -70,6 +80,10 @@ export type CommonStyleProps = {
      * The stroke color of the element.
      */
     stroke?: string;
+    /**
+     * The stroke opacity of the element. (0 to 1)
+     */
+    strokeOpacity?: number;
     /**
      * The stroke width of the element.
      */
@@ -79,6 +93,18 @@ export type CommonStyleProps = {
      */
     opacity?: number;
 };
+/**
+ * Events for primatives which support `SVGRectElement` and `HTMLDivElement` elements based on render context
+ */
+export type CommonEvents = {
+    onclick?: MouseEventHandler<Element> | null;
+    ondblclick?: MouseEventHandler<Element> | null;
+    onpointerenter?: PointerEventHandler<Element> | null;
+    onpointermove?: PointerEventHandler<Element> | null;
+    onpointerleave?: PointerEventHandler<Element> | null;
+    onpointerover?: PointerEventHandler<Element> | null;
+    onpointerout?: PointerEventHandler<Element> | null;
+};
 export type OnlyObjects<T> = T extends object ? T : never;
 export type Getter<T> = () => T;
 export type GetterValues<T> = {

package/package.json

@@ -4,21 +4,19 @@
   "author": "Sean Lynch <techniq35@gmail.com>",
   "license": "MIT",
   "repository": "techniq/layerchart",
-  "version": "2.0.0-next.5",
+  "homepage": "https://layerchart.com",
+  "version": "2.0.0-next.51",
   "devDependencies": {
-    "@changesets/cli": "^2.29.2",
-    "@iconify-json/lucide": "^1.2.42",
-    "@mdi/js": "^7.4.47",
-    "@rollup/plugin-dsv": "^3.0.5",
-    "@sveltejs/adapter-cloudflare": "^4.9.0",
-    "@sveltejs/kit": "^2.20.8",
-    "@sveltejs/package": "^2.3.11",
-    "@sveltejs/vite-plugin-svelte": "^5.0.3",
+    "@changesets/cli": "^2.30.0",
+    "@napi-rs/canvas": "^0.1.97",
+    "@sveltejs/adapter-auto": "^7.0.1",
+    "@sveltejs/kit": "^2.55.0",
+    "@sveltejs/package": "^2.5.7",
+    "@sveltejs/vite-plugin-svelte": "^7.0.0",
     "@svitejs/changesets-changelog-github-compact": "^1.2.0",
-    "@tailwindcss/typography": "^0.5.16",
-    "@tailwindcss/vite": "^4.1.5",
     "@types/d3": "^7.4.3",
-    "@types/d3-array": "^3.2.1",
+    "@types/d3-array": "^3.2.2",
+    "@types/d3-chord": "^3.0.6",
     "@types/d3-color": "^3.1.3",
     "@types/d3-delaunay": "^6.0.4",
     "@types/d3-dsv": "^3.0.7",
@@ -30,54 +28,38 @@
     "@types/d3-path": "^3.1.1",
     "@types/d3-quadtree": "^3.0.6",
     "@types/d3-random": "^3.0.3",
-    "@types/d3-sankey": "^0.12.4",
+    "@types/d3-sankey": "^0.12.5",
     "@types/d3-scale": "^4.0.9",
     "@types/d3-scale-chromatic": "^3.1.0",
-    "@types/d3-shape": "^3.1.7",
+    "@types/d3-shape": "^3.1.8",
     "@types/d3-time": "^3.0.4",
-    "@types/lodash-es": "^4.17.12",
-    "@types/prismjs": "^1.26.5",
-    "@types/shapefile": "^0.6.4",
-    "@types/topojson-client": "^3.1.5",
-    "@types/topojson-simplify": "^3.0.3",
-    "@types/topojson-specification": "^1.0.5",
-    "marked": "^15.0.11",
-    "mdsvex": "0.12.3",
-    "posthog-js": "^1.239.0",
-    "prettier": "^3.5.3",
-    "prettier-plugin-svelte": "^3.3.3",
-    "prism-svelte": "^0.5.0",
-    "prism-themes": "^1.9.0",
-    "prismjs": "^1.30.0",
-    "rehype-slug": "^6.0.0",
-    "shapefile": "^0.6.6",
-    "solar-calculator": "^0.3.0",
-    "svelte": "5.28.2",
-    "svelte-check": "^4.1.6",
-    "svelte-json-tree": "^2.2.0",
-    "svelte-ux": "2.0.0-next.2",
-    "svelte2tsx": "^0.7.36",
-    "tailwindcss": "^4.1.5",
-    "topojson-client": "^3.1.0",
-    "topojson-simplify": "^3.0.3",
+    "@vitest/browser": "^4.1.0",
+    "@vitest/browser-playwright": "^4.1.0",
+    "@vitest/ui": "^4.1.0",
+    "playwright": "^1.58.2",
+    "prettier": "^3.8.1",
+    "prettier-plugin-svelte": "^3.5.1",
+    "svelte": "5.54.1",
+    "svelte-check": "^4.4.5",
+    "svelte2tsx": "^0.7.52",
     "tslib": "^2.8.1",
-    "typescript": "^5.8.3",
-    "unist-util-visit": "^5.0.0",
-    "unplugin-icons": "^22.1.0",
-    "us-atlas": "^3.0.1",
-    "vite": "^6.3.4",
-    "vitest": "^3.1.2"
+    "typescript": "^5.9.3",
+    "vite": "^8.0.1",
+    "vitest": "^4.1.0",
+    "vitest-browser-svelte": "^2.1.0"
   },
   "type": "module",
   "dependencies": {
-    "@dagrejs/dagre": "^1.1.4",
-    "@layerstack/svelte-actions": "1.0.1-next.0",
-    "@layerstack/svelte-state": "0.1.0-next.1",
-    "@layerstack/svelte-stores": "1.0.2-next.0",
-    "@layerstack/tailwind": "2.0.0-next.2",
-    "@layerstack/utils": "1.1.0-next.0",
+    "@dagrejs/dagre": "^2.0.4",
+    "@layerstack/svelte-actions": "1.0.1-next.18",
+    "@layerstack/svelte-state": "0.1.0-next.23",
+    "@layerstack/tailwind": "2.0.0-next.21",
+    "@layerstack/utils": "2.0.0-next.18",
+    "@types/d3-contour": "^3.0.6",
     "d3-array": "^3.2.4",
+    "d3-chord": "^3.0.1",
     "d3-color": "^3.1.0",
+    "d3-contour": "^4.0.2",
     "d3-delaunay": "^6.0.4",
     "d3-dsv": "^3.0.1",
     "d3-force": "^3.0.0",
@@ -95,9 +77,8 @@
     "d3-shape": "^3.2.0",
     "d3-tile": "^1.0.0",
     "d3-time": "^3.1.0",
-    "date-fns": "^4.1.0",
-    "lodash-es": "^4.17.21",
-    "runed": "^0.26.0"
+    "memoize": "^10.2.0",
+    "runed": "^0.37.1"
   },
   "peerDependencies": {
     "svelte": "^5.0.0"
@@ -109,10 +90,19 @@
       "svelte": "./dist/index.js",
       "default": "./dist/index.js"
     },
+    "./server": {
+      "types": "./dist/server/index.d.ts",
+      "svelte": "./dist/server/index.js",
+      "default": "./dist/server/index.js"
+    },
     "./utils/*": {
       "types": "./dist/utils/*.d.ts",
       "svelte": "./dist/utils/*.js",
       "default": "./dist/utils/*.js"
+    },
+    "./*.css": {
+      "style": "./dist/styles/*.css",
+      "default": "./dist/styles/*.css"
     }
   },
   "files": [
@@ -120,13 +110,20 @@
   ],
   "svelte": "./dist/index.js",
   "scripts": {
-    "dev": "vite dev --port 3002",
-    "build": "vite build",
-    "preview": "vite preview",
+    "dev": "pnpm package:watch",
     "package": "svelte-package",
+    "package:watch": "svelte-package --watch",
     "check": "svelte-check --tsconfig ./tsconfig.json",
     "check:watch": "svelte-check --tsconfig ./tsconfig.json --watch",
     "test:unit": "TZ=UTC-5 vitest",
+    "test:ui": "TZ=UTC-5 vitest --ui",
+    "bench": "pnpm bench:primitives && pnpm bench:linechart && pnpm bench:composable && pnpm bench:svg-vs-canvas",
+    "bench:primitives": "TZ=UTC-5 vitest bench --project bench src/lib/bench/primitives.svelte.bench.ts",
+    "bench:linechart": "TZ=UTC-5 vitest bench --project bench src/lib/components/charts/LineChart.svelte.bench.ts",
+    "bench:composable": "TZ=UTC-5 vitest bench --project bench src/lib/bench/composable-vs-linechart.svelte.bench.ts",
+    "bench:svg-vs-canvas": "TZ=UTC-5 vitest bench --project bench src/lib/bench/svg-vs-canvas.svelte.bench.ts",
+    "bench:save": "TZ=UTC-5 vitest bench --project bench --outputJson bench-results/latest.json",
+    "bench:compare": "TZ=UTC-5 vitest bench --project bench --compare bench-results/latest.json",
     "lint": "prettier --check .",
     "format": "prettier --write ."
   }

package/README.md

@@ -1,41 +0,0 @@
-# LayerChart
-
-![](https://img.shields.io/github/license/techniq/layerchart?style=flat)
-[![](https://img.shields.io/npm/v/layerchart?style=flat)](https://www.npmjs.com/package/layerchart)
-![npm](https://img.shields.io/npm/dw/layerchart?style=flat&color=orange)
-
-![](https://img.shields.io/github/license/layerchart?style=flat)
-[![](https://dcbadge.vercel.app/api/server/697JhMPD3t?style=flat)](https://discord.gg/697JhMPD3t)
-
-A large collection of composable Svelte chart components to build a wide range of visualizations
-
-- Cartesian (Bar, Area, Stack, Scatter)
-- Radial (Pie, Arc, Sunburst)
-- Hierarchy (Pack, Tree, Treemap, Sunburst)
-- Graph (Sankey)
-- Geo (Choropleth, Spike, Bubble, Point, Globe)
-
-Interactions
-
-- Tooltip, Highlights, Pan/Zoom
-
-SVG
-
-- Basic (Arc, Circle, Group, Line, Spline, Text)
-- Gradients and Patterns
-- ClipPath
-- Multi-line text
-
-Others
-
-- Legends including ColorRamps
-
-See also [Svelte UX](http://svelte-ux.techniq.dev) for a large collection of components, actions, stores, and utilities to build highly interactive applications.
-
-## Publishing
-
-- `npm run changeset` for each changelog worthy change
-- `npm run version` to bump `package.json` version based on changesets, materialize changesets into CHANGELOG.md
-- Commit as `Version bump to x.y.z` (TODO: automate)
-- `npm run publish` to publish version to npm
-- `git push --tags` to publish tags to Github