layerchart 2.0.0-next.46 → 2.0.0-next.48

package/dist/components/Polygon.svelte

@@ -1,16 +1,20 @@
 <script lang="ts" module>
-  import type { CommonStyleProps, Without } from '../utils/types.js';
+  import type { Without } from '../utils/types.js';
+  import type { DataProp, DataDrivenStyleProps } from '../utils/dataProp.js';
 
   export type PolygonPropsWithoutHTML = {
     /**
      * The center x position of the polygon.
+     * - `number`: pixel value (direct)
+     * - `string`: data property name, resolved via xScale
+     * - `function(d)`: accessor called per data item, result passed through xScale
      *
      * @default 0
      */
-    cx?: number;
+    cx?: DataProp;
 
     /**
-     * The initial center x position of the polygon.
+     * The initial center x position of the polygon (pixel mode only).
      *
      * @default cx
      */
@@ -18,13 +22,16 @@
 
     /**
      * The center y position of the polygon.
+     * - `number`: pixel value (direct)
+     * - `string`: data property name, resolved via yScale
+     * - `function(d)`: accessor called per data item, result passed through yScale
      *
      * @default 0
      */
-    cy?: number;
+    cy?: DataProp;
 
     /**
-     * The initial center y position of the polygon.
+     * The initial center y position of the polygon (pixel mode only).
      *
      * @default cy
      */
@@ -32,18 +39,34 @@
 
     /**
      * The radius of the polygon.
+     * - `number`: pixel value (direct)
+     * - `string`: data property name, resolved via rScale
+     * - `function(d)`: accessor called per data item, result passed through rScale
      *
      * @default 1
      */
-    r?: number;
+    r?: DataProp;
 
     /**
-     * The initial radius of the polygon.
+     * The initial radius of the polygon (pixel mode only).
      *
      * @default r
      */
     initialR?: number;
 
+    /**
+     * Data array to iterate over in data mode.
+     * Falls back to chart context data when not provided.
+     */
+    data?: any[];
+
+    /**
+     * Key function for keyed {#each} rendering in data mode.
+     *
+     * @default (d, i) => i
+     */
+    key?: (d: any, index: number) => any;
+
     /**
      * The number of points or explicit points to create the polygon.
      *
@@ -122,27 +145,32 @@
     ref?: SVGPathElement;
 
     motion?: MotionProp;
-  } & CommonStyleProps;
+  } & DataDrivenStyleProps;
 
   export type PolygonProps = PolygonPropsWithoutHTML &
     Without<SVGAttributes<Element>, PolygonPropsWithoutHTML>;
 </script>
 
 <script lang="ts">
+  import { untrack } from 'svelte';
   import type { SVGAttributes } from 'svelte/elements';
   import { cls } from '@layerstack/tailwind';
   import { merge } from '@layerstack/utils';
   import { interpolatePath } from 'd3-interpolate-path';
 
   import { getLayerContext } from '../contexts/layer.js';
+  import { getChartContext } from '../contexts/chart.js';
   import {
     createMotion,
+    createDataMotionMap,
     extractTweenConfig,
     type MotionProp,
     type ResolvedMotion,
   } from '../utils/motion.svelte.js';
-  import { registerCanvasComponent } from './layers/Canvas.svelte';
   import { renderPathData, type ComputedStylesOptions } from '../utils/canvas.js';
+  import { hasAnyDataProp, resolveDataProp, resolveColorProp, resolveGeoDataPair, resolveStyleProp } from '../utils/dataProp.js';
+  import { getGeoContext } from '../contexts/geo.js';
+  import { chartDataArray } from '../utils/common.js';
   import { createKey } from '../utils/key.svelte.js';
   import { polygon } from '../utils/shape.js';
   import { roundedPolygonPath } from '../utils/path.js';
@@ -154,6 +182,8 @@
     initialCy: initialCyProp,
     r = 1,
     initialR: initialRProp,
+    data: dataProp,
+    key: keyFn = (_: any, i: number) => i,
     points = 4,
     cornerRadius = 0,
     rotate = 0,
@@ -181,13 +211,109 @@
     refProp = ref;
   });
 
-  const initialCx = initialCxProp ?? cx;
-  const initialCy = initialCyProp ?? cy;
-  const initialR = initialRProp ?? r;
+  // Chart context (safe to call outside Chart — returns fallback)
+  const chartCtx = getChartContext();
+  const geo = getGeoContext();
+
+  // Data mode detection: if any positional prop is a string or function
+  const dataMode = $derived(hasAnyDataProp(cx, cy, r));
 
-  const motionCx = createMotion(initialCx, () => cx, motion);
-  const motionCy = createMotion(initialCy, () => cy, motion);
-  const motionR = createMotion(initialR, () => r, motion);
+  // Data to iterate over in data mode
+  const resolvedData: any[] = $derived(
+    dataMode ? (dataProp ?? chartDataArray(chartCtx.data)) : []
+  );
+
+  // Resolve a single data item to a polygon path string
+  function resolvePolygon(d: any) {
+    let resolvedCx: number, resolvedCy: number;
+    if (geo.projection) {
+      [resolvedCx, resolvedCy] = resolveGeoDataPair(cx, cy, d, geo.projection);
+    } else {
+      resolvedCx = resolveDataProp(cx, d, chartCtx.xScale, 0);
+      resolvedCy = resolveDataProp(cy, d, chartCtx.yScale, 0);
+    }
+    const resolvedR = resolveDataProp(r, d, chartCtx.rScale, typeof r === 'number' ? r : 1);
+
+    const pts = typeof points === 'number'
+      ? polygon({
+          cx: resolvedCx,
+          cy: resolvedCy,
+          count: points,
+          radius: resolvedR,
+          rotate,
+          inset,
+          scaleX,
+          scaleY,
+          skewX,
+          skewY,
+          tiltX,
+          tiltY,
+        })
+      : points;
+
+    return roundedPolygonPath(pts, cornerRadius);
+  }
+
+  // --- Data mode motion ---
+  const dataMotionMap = createDataMotionMap(motion);
+
+  $effect(() => {
+    if (!dataMode || !dataMotionMap) return;
+    const activeKeys = new Set<any>();
+    for (let i = 0; i < resolvedData.length; i++) {
+      const d = resolvedData[i];
+      const key = keyFn(d, i);
+      activeKeys.add(key);
+      // Polygon resolve returns a path string, so resolve coords separately for motion
+      let resolvedCx: number, resolvedCy: number;
+      if (geo.projection) {
+        [resolvedCx, resolvedCy] = resolveGeoDataPair(cx, cy, d, geo.projection);
+      } else {
+        resolvedCx = resolveDataProp(cx, d, chartCtx.xScale, 0);
+        resolvedCy = resolveDataProp(cy, d, chartCtx.yScale, 0);
+      }
+      const resolvedR = resolveDataProp(r, d, chartCtx.rScale, typeof r === 'number' ? r : 1);
+      untrack(() => dataMotionMap.update(key, { cx: resolvedCx, cy: resolvedCy, r: resolvedR }));
+    }
+    untrack(() => dataMotionMap.cleanup(activeKeys));
+  });
+
+  // TODO: Apply animated values from dataMotionMap to SVG/HTML/Canvas templates.
+  // Polygon uses a path string from resolvePolygon(), so animated cx/cy/r values
+  // need to be passed through the polygon generator to produce an animated path.
+
+  // Single source of truth: resolved values with animated overlay
+  const resolvedItems = $derived.by(() => {
+    if (!dataMode) return [];
+    return resolvedData.map((d, i) => {
+      const key = keyFn(d, i);
+      let resolvedCx: number, resolvedCy: number;
+      if (geo.projection) {
+        [resolvedCx, resolvedCy] = resolveGeoDataPair(cx, cy, d, geo.projection);
+      } else {
+        resolvedCx = resolveDataProp(cx, d, chartCtx.xScale, 0);
+        resolvedCy = resolveDataProp(cy, d, chartCtx.yScale, 0);
+      }
+      const resolvedR = resolveDataProp(r, d, chartCtx.rScale, typeof r === 'number' ? r : 1);
+      const animated = dataMotionMap?.get(key);
+      return {
+        d,
+        key,
+        cx: animated?.cx ?? resolvedCx,
+        cy: animated?.cy ?? resolvedCy,
+        r: animated?.r ?? resolvedR,
+      };
+    });
+  });
+
+  // --- Pixel mode (motion only applies here) ---
+  const initialCx = initialCxProp ?? (typeof cx === 'number' ? cx : 0);
+  const initialCy = initialCyProp ?? (typeof cy === 'number' ? cy : 0);
+  const initialR = initialRProp ?? (typeof r === 'number' ? r : 1);
+
+  const motionCx = createMotion(initialCx, () => (typeof cx === 'number' ? cx : 0), motion);
+  const motionCy = createMotion(initialCy, () => (typeof cy === 'number' ? cy : 0), motion);
+  const motionR = createMotion(initialR, () => (typeof r === 'number' ? r : 1), motion);
 
   let polygonPoints = $derived(
     typeof points === 'number'
@@ -222,30 +348,69 @@
 
   const layerCtx = getLayerContext();
 
+  function getStyleOptions(
+    styleOverrides: ComputedStylesOptions | undefined,
+    itemFill?: string | undefined,
+    itemStroke?: string | undefined,
+    itemFillOpacity?: number | undefined,
+    itemStrokeWidth?: number | undefined,
+    itemOpacity?: number | undefined,
+    itemClass?: string | undefined
+  ) {
+    return styleOverrides
+      ? merge({ styles: { strokeWidth: itemStrokeWidth ?? (typeof strokeWidth === 'number' ? strokeWidth : undefined) } }, styleOverrides)
+      : {
+          styles: {
+            fill: itemFill ?? fill,
+            fillOpacity: itemFillOpacity ?? (typeof fillOpacity === 'number' ? fillOpacity : undefined),
+            stroke: itemStroke ?? stroke,
+            strokeWidth: itemStrokeWidth ?? (typeof strokeWidth === 'number' ? strokeWidth : undefined),
+            opacity: itemOpacity ?? (typeof opacity === 'number' ? opacity : undefined),
+          },
+          classes: cls('lc-polygon', itemClass ?? (typeof className === 'string' ? className : undefined)),
+          style: restProps.style as string | undefined,
+        };
+  }
+
   function render(
     ctx: CanvasRenderingContext2D,
     styleOverrides: ComputedStylesOptions | undefined
   ) {
-    renderPathData(
-      ctx,
-      tweenedState.current,
-      styleOverrides
-        ? merge({ styles: { strokeWidth } }, styleOverrides)
-        : {
-            styles: { fill, fillOpacity, stroke, strokeWidth, opacity },
-            classes: cls('lc-polygon', className),
-            style: restProps.style as string | undefined,
-          }
-    );
+    if (dataMode) {
+      for (const d of resolvedData) {
+        const pathData = resolvePolygon(d);
+        const resolvedFill = resolveColorProp(fill, d, chartCtx.cScale);
+        const resolvedStroke = resolveColorProp(stroke, d, chartCtx.cScale);
+        const resolvedFillOpacity = resolveStyleProp(fillOpacity, d);
+        const resolvedStrokeWidth = resolveStyleProp(strokeWidth, d);
+        const resolvedOpacity = resolveStyleProp(opacity, d);
+        const resolvedClass = resolveStyleProp(className, d);
+        const styleOpts = getStyleOptions(styleOverrides, resolvedFill, resolvedStroke, resolvedFillOpacity, resolvedStrokeWidth, resolvedOpacity, resolvedClass);
+        renderPathData(ctx, pathData, styleOpts);
+      }
+    } else {
+      const styleOpts = getStyleOptions(styleOverrides);
+      renderPathData(ctx, tweenedState.current, styleOpts);
+    }
   }
 
   // TODO: Use objectId to work around Svelte 4 reactivity issue (even when memoizing gradients)
   const fillKey = createKey(() => fill);
   const strokeKey = createKey(() => stroke);
 
-  if (layerCtx === 'canvas') {
-    registerCanvasComponent({
-      name: 'Polygon',
+  chartCtx.registerComponent({
+    name: 'Polygon',
+    kind: 'mark',
+    markInfo: () => {
+      if (!dataMode) return {};
+      return {
+        data: dataProp,
+        x: typeof cx === 'string' ? cx : undefined,
+        y: typeof cy === 'string' ? cy : undefined,
+        color: typeof fill === 'string' ? fill : typeof stroke === 'string' ? stroke : undefined,
+      };
+    },
+    canvasRender: layerCtx === 'canvas' ? {
       render,
       events: {
         click: restProps.onclick,
@@ -258,6 +423,8 @@
         touchmove: restProps.ontouchmove,
       },
       deps: () => [
+        dataMode,
+        dataMode ? resolvedItems : null,
         fillKey.current,
         fillOpacity,
         strokeKey.current,
@@ -267,22 +434,44 @@
         tweenedState.current,
         restProps.style,
       ],
-    });
-  }
+    } : undefined,
+  });
 </script>
 
 {#if layerCtx === 'svg'}
-  <path
-    d={tweenedState.current}
-    {fill}
-    fill-opacity={fillOpacity}
-    {stroke}
-    stroke-width={strokeWidth}
-    {opacity}
-    class={cls('lc-polygon', className)}
-    {...restProps}
-    bind:this={ref}
-  />
+  {#if dataMode}
+    {#each resolvedData as d, i (keyFn(d, i))}
+      {@const pathData = resolvePolygon(d)}
+      {@const resolvedFill = resolveColorProp(fill, d, chartCtx.cScale)}
+      {@const resolvedStroke = resolveColorProp(stroke, d, chartCtx.cScale)}
+      {@const resolvedFillOpacity = resolveStyleProp(fillOpacity, d)}
+      {@const resolvedStrokeWidth = resolveStyleProp(strokeWidth, d)}
+      {@const resolvedOpacity = resolveStyleProp(opacity, d)}
+      {@const resolvedClass = resolveStyleProp(className, d)}
+      <path
+        d={pathData}
+        fill={resolvedFill}
+        fill-opacity={resolvedFillOpacity}
+        stroke={resolvedStroke}
+        stroke-width={resolvedStrokeWidth}
+        opacity={resolvedOpacity}
+        class={cls('lc-polygon', resolvedClass)}
+        {...restProps}
+      />
+    {/each}
+  {:else}
+    <path
+      d={tweenedState.current}
+      fill={fill as string}
+      fill-opacity={fillOpacity as number}
+      stroke={stroke as string}
+      stroke-width={strokeWidth as number}
+      opacity={opacity as number}
+      class={cls('lc-polygon', className as string)}
+      {...restProps}
+      bind:this={ref}
+    />
+  {/if}
 {/if}
 
 <style>

package/dist/components/Polygon.svelte.d.ts

@@ -1,41 +1,62 @@
-import type { CommonStyleProps, Without } from '../utils/types.js';
+import type { Without } from '../utils/types.js';
+import type { DataProp, DataDrivenStyleProps } from '../utils/dataProp.js';
 export type PolygonPropsWithoutHTML = {
     /**
      * The center x position of the polygon.
+     * - `number`: pixel value (direct)
+     * - `string`: data property name, resolved via xScale
+     * - `function(d)`: accessor called per data item, result passed through xScale
      *
      * @default 0
      */
-    cx?: number;
+    cx?: DataProp;
     /**
-     * The initial center x position of the polygon.
+     * The initial center x position of the polygon (pixel mode only).
      *
      * @default cx
      */
     initialCx?: number;
     /**
      * The center y position of the polygon.
+     * - `number`: pixel value (direct)
+     * - `string`: data property name, resolved via yScale
+     * - `function(d)`: accessor called per data item, result passed through yScale
      *
      * @default 0
      */
-    cy?: number;
+    cy?: DataProp;
     /**
-     * The initial center y position of the polygon.
+     * The initial center y position of the polygon (pixel mode only).
      *
      * @default cy
      */
     initialCy?: number;
     /**
      * The radius of the polygon.
+     * - `number`: pixel value (direct)
+     * - `string`: data property name, resolved via rScale
+     * - `function(d)`: accessor called per data item, result passed through rScale
      *
      * @default 1
      */
-    r?: number;
+    r?: DataProp;
     /**
-     * The initial radius of the polygon.
+     * The initial radius of the polygon (pixel mode only).
      *
      * @default r
      */
     initialR?: number;
+    /**
+     * Data array to iterate over in data mode.
+     * Falls back to chart context data when not provided.
+     */
+    data?: any[];
+    /**
+     * Key function for keyed {#each} rendering in data mode.
+     *
+     * @default (d, i) => i
+     */
+    key?: (d: any, index: number) => any;
     /**
      * The number of points or explicit points to create the polygon.
      *
@@ -106,7 +127,7 @@ export type PolygonPropsWithoutHTML = {
      */
     ref?: SVGPathElement;
     motion?: MotionProp;
-} & CommonStyleProps;
+} & DataDrivenStyleProps;
 export type PolygonProps = PolygonPropsWithoutHTML & Without<SVGAttributes<Element>, PolygonPropsWithoutHTML>;
 import type { SVGAttributes } from 'svelte/elements';
 import { type MotionProp } from '../utils/motion.svelte.js';

package/dist/components/Polygon.svelte.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/components/Polygon.svelte.test.js

@@ -0,0 +1,121 @@
+import { describe, expect, it } from 'vitest';
+import { render } from 'vitest-browser-svelte';
+import { page } from 'vitest/browser';
+import TestHarness, { componentTestId } from './tests/TestHarness.svelte';
+import Polygon from './Polygon.svelte';
+describe('Polygon', () => {
+    describe('pixel mode', () => {
+        it('should render a polygon with pixel values', async () => {
+            render(TestHarness, {
+                component: Polygon,
+                componentProps: {
+                    cx: 50,
+                    cy: 50,
+                    r: 20,
+                    points: 6,
+                },
+            });
+            const el = page.getByTestId(componentTestId);
+            await expect.element(el).toBeInTheDocument();
+        });
+    });
+    describe('data mode', () => {
+        const data = [
+            { date: new Date('2024-01-01'), value: 20 },
+            { date: new Date('2024-02-01'), value: 40 },
+            { date: new Date('2024-03-01'), value: 60 },
+        ];
+        it('should render one polygon per data item with string accessors', async () => {
+            render(TestHarness, {
+                component: Polygon,
+                chartProps: {
+                    data,
+                    x: 'date',
+                    y: 'value',
+                    yDomain: [0, 100],
+                },
+                componentProps: {
+                    cx: 'date',
+                    cy: 'value',
+                    r: 8,
+                    points: 6,
+                },
+            });
+            const polygons = page.getByTestId(componentTestId).elements();
+            await expect.poll(() => polygons.length).toBe(3);
+        });
+        it('should resolve data-driven fill through cScale', async () => {
+            const colorData = [
+                { date: new Date('2024-01-01'), value: 20, category: 'A' },
+                { date: new Date('2024-02-01'), value: 40, category: 'B' },
+                { date: new Date('2024-03-01'), value: 60, category: 'A' },
+            ];
+            render(TestHarness, {
+                component: Polygon,
+                chartProps: {
+                    data: colorData,
+                    x: 'date',
+                    y: 'value',
+                    yDomain: [0, 100],
+                    c: 'category',
+                    cRange: ['steelblue', 'coral'],
+                },
+                componentProps: {
+                    cx: 'date',
+                    cy: 'value',
+                    r: 8,
+                    points: 6,
+                    fill: 'category',
+                },
+            });
+            const polygons = page.getByTestId(componentTestId).elements();
+            await expect.poll(() => polygons.length).toBe(3);
+            expect(polygons[0].getAttribute('fill')).toBe('steelblue');
+            expect(polygons[1].getAttribute('fill')).toBe('coral');
+            expect(polygons[2].getAttribute('fill')).toBe('steelblue');
+        });
+        it('should pass literal CSS colors through unchanged in data mode', async () => {
+            render(TestHarness, {
+                component: Polygon,
+                chartProps: {
+                    data,
+                    x: 'date',
+                    y: 'value',
+                    yDomain: [0, 100],
+                },
+                componentProps: {
+                    cx: 'date',
+                    cy: 'value',
+                    r: 8,
+                    points: 6,
+                    fill: 'red',
+                },
+            });
+            const polygons = page.getByTestId(componentTestId).elements();
+            await expect.poll(() => polygons.length).toBe(3);
+            expect(polygons[0].getAttribute('fill')).toBe('red');
+            expect(polygons[1].getAttribute('fill')).toBe('red');
+        });
+        it('should use explicit data prop over chart context data', async () => {
+            const explicitData = [{ date: new Date('2024-01-01'), value: 20 }];
+            render(TestHarness, {
+                component: Polygon,
+                chartProps: {
+                    data,
+                    x: 'date',
+                    y: 'value',
+                    yDomain: [0, 100],
+                },
+                componentProps: {
+                    data: explicitData,
+                    cx: 'date',
+                    cy: 'value',
+                    r: 8,
+                    points: 6,
+                },
+            });
+            const polygons = page.getByTestId(componentTestId).elements();
+            await expect.poll(() => polygons.length).toBe(1);
+        });
+    });
+});

package/dist/components/RadialGradient.svelte

@@ -84,7 +84,6 @@
 
 <script lang="ts">
   import { getLayerContext } from '../contexts/layer.js';
-  import { registerCanvasComponent } from './layers/Canvas.svelte';
   import { getComputedStyles } from '../utils/canvas.js';
   import { parsePercent } from '../utils/math.js';
   import { getChartContext } from '../contexts/chart.js';
@@ -145,11 +144,10 @@
   }
 
   if (layerCtx === 'canvas') {
-    registerCanvasComponent({
-      name: 'Gradient',
+    ctx.registerComponent({ name: 'Gradient', kind: 'mark', canvasRender: {
       render,
       deps: () => [stops, cx, cy, fx, fy, ctx.width, ctx.height],
-    });
+    } });
   }
 </script>