layerchart 0.5.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];
 /**

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

@@ -1,11 +1,11 @@
 <script>import { getContext } from 'svelte';
-import { cubicOut } from 'svelte/easing';
 import { scaleLinear } from 'd3-scale';
-import { tweenedScale } from '../utils/scales';
+import { motionScale } from '../utils/scales';
 const { width, height } = getContext('LayerCake');
 export let domain;
 export let range;
-const tweenedOptions = { easing: cubicOut, duration: 800 };
+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 [
@@ -13,10 +13,10 @@ function getExtents(extents, axis, fallback) {
         resolvedExtents?.[axis + '1'] ?? fallback // x1 or y1, fallback as $width or $height
     ];
 }
-const xScale = tweenedScale(scaleLinear, tweenedOptions);
+const xScale = motionScale(scaleLinear, { spring, tweened });
 $: xScale.domain(getExtents(domain, 'x', $width));
 $: xScale.range(getExtents(range, 'x', $width));
-const yScale = tweenedScale(scaleLinear, tweenedOptions);
+const yScale = motionScale(scaleLinear, { spring, tweened });
 $: yScale.domain(getExtents(domain, 'y', $height));
 $: yScale.range(getExtents(range, 'y', $height));
 </script>

package/components/Bounds.svelte.d.ts

@@ -1,4 +1,5 @@
 import { SvelteComponentTyped } from "svelte";
+import { motionScale } from '../utils/scales';
 declare const __propDef: {
     props: {
         domain: {
@@ -29,6 +30,8 @@ declare const __propDef: {
             x1: number;
             y1: number;
         });
+        spring?: boolean | Parameters<typeof motionScale>[1]['spring'];
+        tweened?: boolean | Parameters<typeof motionScale>[1]['tweened'];
     };
     events: {
         [evt: string]: CustomEvent<any>;

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/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/package.json

@@ -3,7 +3,7 @@
   "author": "Sean Lynch <techniq35@gmail.com>",
   "license": "MIT",
   "repository": "techniq/layerchart",
-  "version": "0.5.1",
+  "version": "0.5.2",
   "devDependencies": {
     "@rollup/plugin-dsv": "^2.0.3",
     "@sveltejs/adapter-vercel": "^1.0.0-next.58",

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,4 +1,5 @@
-import { tweened, spring } from 'svelte/motion';
+import { tweened } from 'svelte/motion';
+import { MotionOptions } from '../stores/motionStore';
 /**
  * Implemenation for missing `scaleBand().invert()`
  *
@@ -18,10 +19,10 @@ export declare function tweenedScale(scale: any, tweenedOptions?: Parameters<typ
     range: (values: any) => Promise<void>;
 };
 /**
- * Animate d3-scale as domain and/or range are updated using spring store
+ * 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 springScale(scale: any, springOptions?: Parameters<typeof spring>[1]): {
+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) => Promise<void>;
-    range: (values: any) => Promise<void>;
+    domain: (values: any) => void | Promise<void>;
+    range: (values: any) => void | Promise<void>;
 };

package/utils/scales.js

@@ -1,5 +1,6 @@
 import { derived } from 'svelte/store';
-import { tweened, spring } from 'svelte/motion';
+import { tweened } from 'svelte/motion';
+import { motionStore } from '../stores/motionStore';
 /**
  * Implemenation for missing `scaleBand().invert()`
  *
@@ -44,12 +45,12 @@ export function tweenedScale(scale, tweenedOptions = {}) {
     };
 }
 /**
- * Animate d3-scale as domain and/or range are updated using spring store
+ * 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 springScale(scale, springOptions = {}) {
-    const springDomain = spring(undefined, springOptions);
-    const springRange = spring(undefined, springOptions);
-    const tweenedScale = derived([springDomain, springRange], ([domain, range]) => {
+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);
@@ -61,7 +62,7 @@ export function springScale(scale, springOptions = {}) {
     });
     return {
         subscribe: tweenedScale.subscribe,
-        domain: (values) => springDomain.set(values),
-        range: (values) => springRange.set(values)
+        domain: (values) => domainStore.set(values),
+        range: (values) => rangeStore.set(values)
     };
 }