layerchart 0.4.1 → 0.5.2

package/components/Arc.svelte

@@ -15,12 +15,12 @@
 import { getContext } from 'svelte';
 import { arc as d3arc } from 'd3-shape';
 import { scaleLinear } from 'd3-scale';
-import { createMotionStore } from '../stores/motionStore';
+import { motionStore } from '../stores/motionStore';
 import { degreesToRadians } from '../utils/math';
 export let spring = undefined;
 export let tweened = undefined;
 export let value = 0;
-let tweened_value = createMotionStore(value, { spring, tweened });
+let tweened_value = motionStore(value, { spring, tweened });
 $: tweened_value.set(value);
 export let domain = [0, 100];
 /**
@@ -110,6 +110,6 @@ $: yOffset = -Math.cos(angle) * offset;
 	<path d={trackArc()} class="track" bind:this={trackArcEl} {...track} />
 {/if}
 
-<path d={arc()} transform="translate({xOffset}, {yOffset})" {...$$restProps} />
+<path d={arc()} transform="translate({xOffset}, {yOffset})" {...$$restProps} on:click />
 
 <slot value={$tweened_value} centroid={trackArcCentroid} {boundingBox} />

package/components/Arc.svelte.d.ts

@@ -18,6 +18,8 @@ declare const __propDef: {
         offset?: number;
     };
     events: {
+        click: MouseEvent;
+    } & {
         [evt: string]: CustomEvent<any>;
     };
     slots: {

package/components/Area.svelte

@@ -1,7 +1,7 @@
 <script>import { getContext } from 'svelte';
 import { area as d3Area } from 'd3-shape';
 import { interpolatePath } from 'd3-interpolate-path';
-import { createMotionStore } from '../stores/motionStore';
+import { motionStore } from '../stores/motionStore';
 import Path from './Path.svelte';
 const { data: contextData, xGet, yGet, yRange } = getContext('LayerCake');
 // Properties to override what is used from context
@@ -18,7 +18,7 @@ export let color = 'var(--color-blue-500)';
 export let opacity = 0.3;
 export let line = false;
 $: tweenedOptions = tweened ? { interpolate: interpolatePath, ...tweened } : false;
-$: tweened_d = createMotionStore('', { tweened: tweenedOptions });
+$: tweened_d = motionStore('', { tweened: tweenedOptions });
 $: {
     const path = d3Area()
         .x(x ?? $xGet)

package/components/Bounds.svelte

@@ -0,0 +1,24 @@
+<script>import { getContext } from 'svelte';
+import { scaleLinear } from 'd3-scale';
+import { motionScale } from '../utils/scales';
+const { width, height } = getContext('LayerCake');
+export let domain;
+export let range;
+export let spring = undefined;
+export let tweened = undefined;
+function getExtents(extents, axis, fallback) {
+    const resolvedExtents = typeof extents === 'function' ? extents({ width: $width, height: $height }) : extents;
+    return [
+        resolvedExtents?.[axis + '0'] ?? 0,
+        resolvedExtents?.[axis + '1'] ?? fallback // x1 or y1, fallback as $width or $height
+    ];
+}
+const xScale = motionScale(scaleLinear, { spring, tweened });
+$: xScale.domain(getExtents(domain, 'x', $width));
+$: xScale.range(getExtents(range, 'x', $width));
+const yScale = motionScale(scaleLinear, { spring, tweened });
+$: yScale.domain(getExtents(domain, 'y', $height));
+$: yScale.range(getExtents(range, 'y', $height));
+</script>
+
+<slot xScale={$xScale} yScale={$yScale} />

package/components/Bounds.svelte.d.ts

@@ -0,0 +1,51 @@
+import { SvelteComponentTyped } from "svelte";
+import { motionScale } from '../utils/scales';
+declare const __propDef: {
+    props: {
+        domain: {
+            x0: number;
+            y0: number;
+            x1: number;
+            y1: number;
+        } | ((dimensions: {
+            width: number;
+            height: number;
+        }) => {
+            x0: number;
+            y0: number;
+            x1: number;
+            y1: number;
+        });
+        range: {
+            x0: number;
+            y0: number;
+            x1: number;
+            y1: number;
+        } | ((dimensions: {
+            width: number;
+            height: number;
+        }) => {
+            x0: number;
+            y0: number;
+            x1: number;
+            y1: number;
+        });
+        spring?: boolean | Parameters<typeof motionScale>[1]['spring'];
+        tweened?: boolean | Parameters<typeof motionScale>[1]['tweened'];
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {
+        default: {
+            xScale: any;
+            yScale: any;
+        };
+    };
+};
+export declare type BoundsProps = typeof __propDef.props;
+export declare type BoundsEvents = typeof __propDef.events;
+export declare type BoundsSlots = typeof __propDef.slots;
+export default class Bounds extends SvelteComponentTyped<BoundsProps, BoundsEvents, BoundsSlots> {
+}
+export {};

package/components/Circle.svelte

@@ -1,12 +1,12 @@
-<script>import { createMotionStore } from '../stores/motionStore';
+<script>import { motionStore } from '../stores/motionStore';
 export let cx;
 export let cy;
 export let r;
 export let spring = undefined;
 export let tweened = undefined;
-let tweened_cx = createMotionStore(cx, { spring, tweened });
-let tweened_cy = createMotionStore(cy, { spring, tweened });
-let tweened_r = createMotionStore(r, { spring, tweened });
+let tweened_cx = motionStore(cx, { spring, tweened });
+let tweened_cy = motionStore(cy, { spring, tweened });
+let tweened_r = motionStore(r, { spring, tweened });
 $: tweened_cx.set(cx);
 $: tweened_cy.set(cy);
 $: tweened_r.set(r);

package/components/Group.svelte

@@ -1,5 +1,5 @@
 <script>import { getContext } from 'svelte';
-import { createMotionStore } from '../stores/motionStore';
+import { motionStore } from '../stores/motionStore';
 const { width, height } = getContext('LayerCake');
 /**
  * Translate x
@@ -15,8 +15,8 @@ export let y = undefined;
 export let center = false;
 export let spring = undefined;
 export let tweened = undefined;
-let tweened_x = createMotionStore(x, { spring, tweened });
-let tweened_y = createMotionStore(y, { spring, tweened });
+let tweened_x = motionStore(x, { spring, tweened });
+let tweened_y = motionStore(y, { spring, tweened });
 $: tweened_x.set(x);
 $: tweened_y.set(y);
 let transform = undefined;

package/components/Line.svelte

@@ -1,14 +1,14 @@
-<script>import { createMotionStore } from '../stores/motionStore';
+<script>import { motionStore } from '../stores/motionStore';
 export let x1;
 export let y1;
 export let x2;
 export let y2;
 export let spring = undefined;
 export let tweened = undefined;
-let tweened_x1 = createMotionStore(x1, { spring, tweened });
-let tweened_y1 = createMotionStore(y1, { spring, tweened });
-let tweened_x2 = createMotionStore(x2, { spring, tweened });
-let tweened_y2 = createMotionStore(y2, { spring, tweened });
+let tweened_x1 = motionStore(x1, { spring, tweened });
+let tweened_y1 = motionStore(y1, { spring, tweened });
+let tweened_x2 = motionStore(x2, { spring, tweened });
+let tweened_y2 = motionStore(y2, { spring, tweened });
 $: tweened_x1.set(x1);
 $: tweened_y1.set(y1);
 $: tweened_x2.set(x2);

package/components/Link.svelte

@@ -1,6 +1,6 @@
 <script>import { link as d3Link, curveBumpX, curveBumpY } from 'd3-shape';
 import { interpolatePath } from 'd3-interpolate-path';
-import { createMotionStore } from '../stores/motionStore';
+import { motionStore } from '../stores/motionStore';
 // Properties to override what is used from context
 export let data = undefined; // TODO: Update Type
 export let orientation = 'horizontal';
@@ -17,7 +17,7 @@ export let tweened = undefined;
 export let color = 'black';
 export let width = undefined;
 $: tweenedOptions = tweened ? { interpolate: interpolatePath, ...tweened } : false;
-$: tweened_d = createMotionStore('', { tweened: tweenedOptions });
+$: tweened_d = motionStore('', { tweened: tweenedOptions });
 $: {
     orientation; // subscribe to orientation changes to link is update
     const link = d3Link(curve).source(source).target(target).x(x).y(y);

package/components/Partition.svelte

@@ -0,0 +1,27 @@
+<script>import { getContext } from 'svelte';
+import { partition as d3Partition } from 'd3-hierarchy';
+const { data, width, height } = getContext('LayerCake');
+export let orientation = 'horizontal';
+export let size = undefined;
+/**
+ * see: https://github.com/d3/d3-hierarchy#tree_nodeSize
+ */
+export let padding = undefined;
+/**
+ * see: https://github.com/d3/d3-hierarchy#tree_nodeSize
+ */
+export let round = undefined;
+let partition;
+$: {
+    partition = d3Partition().size(size ?? (orientation === 'horizontal' ? [$height, $width] : [$width, $height]));
+    if (padding) {
+        partition.padding(padding);
+    }
+    if (round) {
+        partition.round(round);
+    }
+}
+$: partitionData = partition($data);
+</script>
+
+<slot nodes={partitionData.descendants()} />

package/components/Partition.svelte.d.ts

@@ -0,0 +1,27 @@
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: {
+        orientation?: 'vertical' | 'horizontal';
+        size?: [number, number] | undefined;
+        /**
+             * see: https://github.com/d3/d3-hierarchy#tree_nodeSize
+             */ padding?: number | undefined;
+        /**
+             * see: https://github.com/d3/d3-hierarchy#tree_nodeSize
+             */ round?: boolean | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {
+        default: {
+            nodes: import("d3-hierarchy").HierarchyRectangularNode<unknown>[];
+        };
+    };
+};
+export declare type PartitionProps = typeof __propDef.props;
+export declare type PartitionEvents = typeof __propDef.events;
+export declare type PartitionSlots = typeof __propDef.slots;
+export default class Partition extends SvelteComponentTyped<PartitionProps, PartitionEvents, PartitionSlots> {
+}
+export {};

package/components/Path.svelte

@@ -6,7 +6,7 @@ import { getContext } from 'svelte';
 import { line as d3Line } from 'd3-shape';
 // import { interpolateString } from 'd3-interpolate';
 import { interpolatePath } from 'd3-interpolate-path';
-import { createMotionStore } from '../stores/motionStore';
+import { motionStore } from '../stores/motionStore';
 const { data: contextData, xGet, yGet, zGet } = getContext('LayerCake');
 // Properties to override what is used from context
 export let data = undefined; // TODO: Update Type
@@ -19,7 +19,7 @@ export let defined = undefined;
 export let color = 'black';
 export let width = undefined;
 $: tweenedOptions = tweened ? { interpolate: interpolatePath, ...tweened } : false;
-$: tweened_d = createMotionStore('', { tweened: tweenedOptions });
+$: tweened_d = motionStore('', { tweened: tweenedOptions });
 $: {
     const path = d3Line()
         .x(x ?? $xGet)

package/components/Pie.svelte

@@ -3,7 +3,7 @@ import { pie as d3pie } from 'd3-shape';
 import Arc from './Arc.svelte';
 import Group from './Group.svelte';
 import { degreesToRadians } from '../utils/math';
-import { createMotionStore } from '../stores/motionStore';
+import { motionStore } from '../stores/motionStore';
 /*
 TODO:
 - [ ] Offset (always, on hover)
@@ -48,7 +48,7 @@ export let tweened = undefined;
 export let offset = 0;
 const { data: contextData, x, y, xRange, rGet, config } = getContext('LayerCake');
 $: resolved_endAngle = endAngle ?? degreesToRadians($config.xRange ? $xRange[1] : range[1]);
-let tweened_endAngle = createMotionStore(0, { spring, tweened });
+let tweened_endAngle = motionStore(0, { spring, tweened });
 $: tweened_endAngle.set(resolved_endAngle);
 $: pie = d3pie()
     .startAngle(startAngle ?? degreesToRadians($config.xRange ? $xRange[0] : range[0]))

package/components/Rect.svelte

@@ -1,14 +1,14 @@
-<script>import { createMotionStore } from '../stores/motionStore';
+<script>import { motionStore } from '../stores/motionStore';
 export let x = 0;
 export let y = 0;
 export let width;
 export let height;
 export let spring = undefined;
 export let tweened = undefined;
-let tweened_x = createMotionStore(x, { spring, tweened });
-let tweened_y = createMotionStore(y, { spring, tweened });
-let tweened_width = createMotionStore(width, { spring, tweened });
-let tweened_height = createMotionStore(height, { spring, tweened });
+let tweened_x = motionStore(x, { spring, tweened });
+let tweened_y = motionStore(y, { spring, tweened });
+let tweened_width = motionStore(width, { spring, tweened });
+let tweened_height = motionStore(height, { spring, tweened });
 $: tweened_x.set(x);
 $: tweened_y.set(y);
 $: tweened_width.set(width);

package/components/Treemap.svelte

@@ -3,12 +3,8 @@
  *   - [ ] Improve zoomable nested (apply extent ratio?  const extentRatio = ($extents.y1 - $extents.y0) / $height;
  */
 import { getContext } from 'svelte';
-import { tweened } from 'svelte/motion';
-import { cubicOut } from 'svelte/easing';
 import * as d3 from 'd3-hierarchy';
-import { scaleLinear } from 'd3-scale';
 import { group } from 'd3-array';
-import RectClipPath from './RectClipPath.svelte';
 import { aspectTile } from '../utils/treemap';
 const { data, width, height } = getContext('LayerCake');
 export let tile = d3.treemapSquarify;
@@ -61,43 +57,16 @@ $: {
     }
 }
 $: root = treemap($data);
+// TODO: Remove selected
 $: selected = root; // set initial selection
-// group nodes by depth so can be rendered lowest to highest
+// group nodes by depth so can be rendered lowest to highest, to stack properly
 $: nodesByDepth = group(root, (d) => d.depth);
-const duration = 800;
-const extents = tweened(undefined, { easing: cubicOut, duration });
-$: $extents = selected
-    ? {
-        x0: selected.x0,
-        y0: selected.y0,
-        x1: selected.x1,
-        y1: selected.y1
-    }
-    : {
-        x0: 0,
-        y0: 0,
-        x1: $width,
-        y1: $height
-    };
-$: xScale = scaleLinear().domain([$extents.x0, $extents.x1]).rangeRound([0, $width]);
-$: yScale = scaleLinear().domain([$extents.y0, $extents.y1]).rangeRound([0, $height]);
 </script>
 
-<RectClipPath width={$width} height={$height}>
-	{#each Array.from(nodesByDepth) as [depth, nodes]}
-		<g>
-			{#each nodes as node, i (nodeKey(node, i))}
-				<slot
-					name="node"
-					{node}
-					rect={{
-						x: xScale(node.x0),
-						y: yScale(node.y0),
-						width: xScale(node.x1) - xScale(node.x0),
-						height: yScale(node.y1) - yScale(node.y0)
-					}}
-				/>
-			{/each}
-		</g>
-	{/each}
-</RectClipPath>
+{#each Array.from(nodesByDepth) as [depth, nodes]}
+	<g>
+		{#each nodes as node, i (nodeKey(node, i))}
+			<slot name="node" {node} />
+		{/each}
+	</g>
+{/each}

package/components/Treemap.svelte.d.ts

@@ -19,12 +19,6 @@ declare const __propDef: {
     slots: {
         node: {
             node: unknown;
-            rect: {
-                x: number;
-                y: number;
-                width: number;
-                height: number;
-            };
         };
     };
 };

package/components/index.d.ts

@@ -5,6 +5,7 @@ export { default as AxisX } from './AxisX.svelte';
 export { default as AxisY } from './AxisY.svelte';
 export { default as Bars } from './Bars.svelte';
 export { default as Baseline } from './Baseline.svelte';
+export { default as Bounds } from './Bounds.svelte';
 export { default as Chart } from './Chart.svelte';
 export { default as ChartClipPath } from './ChartClipPath.svelte';
 export { default as Circle } from './Circle.svelte';
@@ -18,6 +19,7 @@ export { default as Labels } from './Labels.svelte';
 export { default as Line } from './Line.svelte';
 export { default as LinearGradient } from './LinearGradient.svelte';
 export { default as Link } from './Link.svelte';
+export { default as Partition } from './Partition.svelte';
 export { default as Path } from './Path.svelte';
 export { default as Pattern } from './Pattern.svelte';
 export { default as Pie } from './Pie.svelte';
@@ -28,5 +30,6 @@ export { default as Sankey } from './Sankey.svelte';
 export { default as Text } from './Text.svelte';
 export { default as Threshold } from './Threshold.svelte';
 export { default as Tooltip } from './Tooltip.svelte';
+export { default as Tree } from './Tree.svelte';
 export { default as Treemap } from './Treemap.svelte';
 export { default as Zoom } from './Zoom.svelte';

package/components/index.js

@@ -5,6 +5,7 @@ export { default as AxisX } from './AxisX.svelte';
 export { default as AxisY } from './AxisY.svelte';
 export { default as Bars } from './Bars.svelte';
 export { default as Baseline } from './Baseline.svelte';
+export { default as Bounds } from './Bounds.svelte';
 export { default as Chart } from './Chart.svelte';
 export { default as ChartClipPath } from './ChartClipPath.svelte';
 export { default as Circle } from './Circle.svelte';
@@ -18,6 +19,7 @@ export { default as Labels } from './Labels.svelte';
 export { default as Line } from './Line.svelte';
 export { default as LinearGradient } from './LinearGradient.svelte';
 export { default as Link } from './Link.svelte';
+export { default as Partition } from './Partition.svelte';
 export { default as Path } from './Path.svelte';
 export { default as Pattern } from './Pattern.svelte';
 export { default as Pie } from './Pie.svelte';
@@ -28,5 +30,6 @@ export { default as Sankey } from './Sankey.svelte';
 export { default as Text } from './Text.svelte';
 export { default as Threshold } from './Threshold.svelte';
 export { default as Tooltip } from './Tooltip.svelte';
+export { default as Tree } from './Tree.svelte';
 export { default as Treemap } from './Treemap.svelte';
 export { default as Zoom } from './Zoom.svelte';

package/package.json

@@ -3,7 +3,7 @@
   "author": "Sean Lynch <techniq35@gmail.com>",
   "license": "MIT",
   "repository": "techniq/layerchart",
-  "version": "0.4.1",
+  "version": "0.5.2",
   "devDependencies": {
     "@rollup/plugin-dsv": "^2.0.3",
     "@sveltejs/adapter-vercel": "^1.0.0-next.58",
@@ -56,6 +56,7 @@
     "./components/AxisY.svelte": "./components/AxisY.svelte",
     "./components/Bars.svelte": "./components/Bars.svelte",
     "./components/Baseline.svelte": "./components/Baseline.svelte",
+    "./components/Bounds.svelte": "./components/Bounds.svelte",
     "./components/Chart.svelte": "./components/Chart.svelte",
     "./components/ChartClipPath.svelte": "./components/ChartClipPath.svelte",
     "./components/Circle.svelte": "./components/Circle.svelte",
@@ -69,6 +70,7 @@
     "./components/Line.svelte": "./components/Line.svelte",
     "./components/LinearGradient.svelte": "./components/LinearGradient.svelte",
     "./components/Link.svelte": "./components/Link.svelte",
+    "./components/Partition.svelte": "./components/Partition.svelte",
     "./components/Path.svelte": "./components/Path.svelte",
     "./components/Pattern.svelte": "./components/Pattern.svelte",
     "./components/Pie.svelte": "./components/Pie.svelte",

package/stores/motionStore.d.ts

@@ -1,8 +1,9 @@
 import { spring, tweened } from 'svelte/motion';
+export declare type MotionOptions = {
+    spring?: boolean | Parameters<typeof spring>[1];
+    tweened?: boolean | Parameters<typeof tweened>[1];
+};
 /**
  * Convenient wrapper to create a motion store (spring(), tweened()) based on properties, or fall back to basic writable() store
  */
-export declare function createMotionStore(value: any, options: {
-    spring?: boolean | Parameters<typeof spring>[1];
-    tweened?: boolean | Parameters<typeof tweened>[1];
-}): import("svelte/motion").Tweened<unknown> | import("svelte/motion").Spring<any> | import("svelte/store").Writable<any>;
+export declare function motionStore(value: any, options: MotionOptions): import("svelte/motion").Tweened<unknown> | import("svelte/motion").Spring<any> | import("svelte/store").Writable<any>;

package/stores/motionStore.js

@@ -3,7 +3,7 @@ import { spring, tweened } from 'svelte/motion';
 /**
  * Convenient wrapper to create a motion store (spring(), tweened()) based on properties, or fall back to basic writable() store
  */
-export function createMotionStore(value, options) {
+export function motionStore(value, options) {
     if (options.spring) {
         return spring(value, options.spring === true ? undefined : options.spring);
     }

package/utils/scales.d.ts

@@ -1,3 +1,5 @@
+import { tweened } from 'svelte/motion';
+import { MotionOptions } from '../stores/motionStore';
 /**
  * Implemenation for missing `scaleBand().invert()`
  *
@@ -8,3 +10,19 @@
  */
 export declare function scaleBandInvert(scale: any): (value: any) => any;
 export declare function isScaleBand(scale: any): boolean;
+/**
+ * Animate d3-scale as domain and/or range are updated using tweened store
+ */
+export declare function tweenedScale(scale: any, tweenedOptions?: Parameters<typeof tweened>[1]): {
+    subscribe: (this: void, run: import("svelte/store").Subscriber<any>, invalidate?: (value?: any) => void) => import("svelte/store").Unsubscriber;
+    domain: (values: any) => Promise<void>;
+    range: (values: any) => Promise<void>;
+};
+/**
+ * Create a store wrapper around a d3-scale which interpolates the domain and/or range using `tweened()` or `spring()` stores.  Fallbacks to `writable()` if not interpolating
+ */
+export declare function motionScale(scale: any, options: MotionOptions): {
+    subscribe: (this: void, run: import("svelte/store").Subscriber<any>, invalidate?: (value?: any) => void) => import("svelte/store").Unsubscriber;
+    domain: (values: any) => void | Promise<void>;
+    range: (values: any) => void | Promise<void>;
+};

package/utils/scales.js

@@ -1,3 +1,6 @@
+import { derived } from 'svelte/store';
+import { tweened } from 'svelte/motion';
+import { motionStore } from '../stores/motionStore';
 /**
  * Implemenation for missing `scaleBand().invert()`
  *
@@ -19,3 +22,47 @@ export function scaleBandInvert(scale) {
 export function isScaleBand(scale) {
     return typeof scale.bandwidth === 'function';
 }
+/**
+ * Animate d3-scale as domain and/or range are updated using tweened store
+ */
+export function tweenedScale(scale, tweenedOptions = {}) {
+    const tweenedDomain = tweened(undefined, tweenedOptions);
+    const tweenedRange = tweened(undefined, tweenedOptions);
+    const tweenedScale = derived([tweenedDomain, tweenedRange], ([domain, range]) => {
+        const scaleInstance = scale.domain ? scale : scale(); // support `scaleLinear` or `scaleLinear()` (which could have `.interpolate()` and others set)
+        if (domain) {
+            scaleInstance.domain(domain);
+        }
+        if (range) {
+            scaleInstance.range(range);
+        }
+        return scaleInstance;
+    });
+    return {
+        subscribe: tweenedScale.subscribe,
+        domain: (values) => tweenedDomain.set(values),
+        range: (values) => tweenedRange.set(values)
+    };
+}
+/**
+ * Create a store wrapper around a d3-scale which interpolates the domain and/or range using `tweened()` or `spring()` stores.  Fallbacks to `writable()` if not interpolating
+ */
+export function motionScale(scale, options) {
+    const domainStore = motionStore(undefined, options);
+    const rangeStore = motionStore(undefined, options);
+    const tweenedScale = derived([domainStore, rangeStore], ([domain, range]) => {
+        const scaleInstance = scale.domain ? scale : scale(); // support `scaleLinear` or `scaleLinear()` (which could have `.interpolate()` and others set)
+        if (domain) {
+            scaleInstance.domain(domain);
+        }
+        if (range) {
+            scaleInstance.range(range);
+        }
+        return scaleInstance;
+    });
+    return {
+        subscribe: tweenedScale.subscribe,
+        domain: (values) => domainStore.set(values),
+        range: (values) => rangeStore.set(values)
+    };
+}