@internetstiftelsen/charts 0.10.0 → 0.11.0

package/dist/xy-motion/config.js

@@ -0,0 +1,177 @@
+import { ChartValidationError, ChartValidator } from '../validation.js';
+import { easeBounceOut, easeCubicIn, easeCubicInOut, easeCubicOut, easeElasticOut, easeLinear, } from 'd3';
+const DEFAULT_ANIMATE = false;
+const DEFAULT_ANIMATION_DURATION_MS = 700;
+const DEFAULT_ANIMATION_EASING_PRESET = 'ease-in-out';
+const XY_ANIMATION_EASING_PRESETS = {
+    linear: easeLinear,
+    'ease-in': easeCubicIn,
+    'ease-out': easeCubicOut,
+    'ease-in-out': easeCubicInOut,
+    'bounce-out': easeBounceOut,
+    'elastic-out': easeElasticOut,
+};
+export function normalizeXYAnimationConfig(config) {
+    if (config === undefined) {
+        return {
+            show: DEFAULT_ANIMATE,
+            duration: DEFAULT_ANIMATION_DURATION_MS,
+            easing: XY_ANIMATION_EASING_PRESETS[DEFAULT_ANIMATION_EASING_PRESET],
+        };
+    }
+    if (typeof config === 'boolean') {
+        return {
+            show: config,
+            duration: DEFAULT_ANIMATION_DURATION_MS,
+            easing: XY_ANIMATION_EASING_PRESETS[DEFAULT_ANIMATION_EASING_PRESET],
+        };
+    }
+    const normalized = {
+        show: config.show ?? true,
+        duration: config.duration ?? DEFAULT_ANIMATION_DURATION_MS,
+        easing: resolveXYAnimationEasing(config.easing),
+    };
+    if (!Number.isFinite(normalized.duration) || normalized.duration < 0) {
+        throw new ChartValidationError(`XYChart: animate.duration must be >= 0, received '${normalized.duration}'`);
+    }
+    return normalized;
+}
+function resolveXYAnimationEasing(easing) {
+    if (!easing) {
+        return XY_ANIMATION_EASING_PRESETS[DEFAULT_ANIMATION_EASING_PRESET];
+    }
+    if (typeof easing === 'function') {
+        return easing;
+    }
+    if (easing in XY_ANIMATION_EASING_PRESETS) {
+        return XY_ANIMATION_EASING_PRESETS[easing];
+    }
+    if (easing.startsWith('linear(')) {
+        const parsedCssLinear = parseCssLinearEasing(easing);
+        if (parsedCssLinear) {
+            return parsedCssLinear;
+        }
+    }
+    ChartValidator.warn(`XYChart: unsupported animate.easing '${easing}', falling back to '${DEFAULT_ANIMATION_EASING_PRESET}'`);
+    return XY_ANIMATION_EASING_PRESETS[DEFAULT_ANIMATION_EASING_PRESET];
+}
+function parseCssLinearEasing(cssLinearEasing) {
+    const normalized = cssLinearEasing.trim();
+    if (!normalized.startsWith('linear(') || !normalized.endsWith(')')) {
+        return null;
+    }
+    const body = normalized.slice('linear('.length, -1);
+    const tokens = body
+        .split(',')
+        .map((token) => token.trim())
+        .filter((token) => token.length > 0);
+    if (tokens.length < 2) {
+        return null;
+    }
+    const rawStops = tokens.map((token) => parseLinearEasingStop(token));
+    if (rawStops.some((stop) => stop === null)) {
+        return null;
+    }
+    const stops = rawStops;
+    const firstPosition = stops[0].position ?? 0;
+    const lastPosition = stops[stops.length - 1].position ?? 1;
+    if (!hasValidLinearStopPositions(stops, firstPosition, lastPosition)) {
+        return null;
+    }
+    fillMissingLinearStopPositions(stops, firstPosition, lastPosition);
+    return (progress) => sampleLinearEasing(stops, progress);
+}
+function hasValidLinearStopPositions(stops, firstPosition, lastPosition) {
+    if (lastPosition <= firstPosition) {
+        return false;
+    }
+    let previousPosition = firstPosition;
+    for (let index = 1; index < stops.length; index += 1) {
+        const stopPosition = stops[index].position;
+        if (stopPosition === undefined) {
+            continue;
+        }
+        if (stopPosition < previousPosition) {
+            return false;
+        }
+        previousPosition = stopPosition;
+    }
+    return true;
+}
+function parseLinearEasingStop(token) {
+    const parts = token
+        .trim()
+        .split(/\s+/)
+        .map((part) => part.trim())
+        .filter((part) => part.length > 0);
+    if (parts.length === 0 || parts.length > 2) {
+        return null;
+    }
+    const value = Number(parts[0]);
+    if (!Number.isFinite(value)) {
+        return null;
+    }
+    if (parts.length === 1) {
+        return { value, position: undefined };
+    }
+    const positionText = parts[1];
+    if (!positionText.endsWith('%')) {
+        return null;
+    }
+    const percentValue = Number(positionText.slice(0, -1));
+    if (!Number.isFinite(percentValue)) {
+        return null;
+    }
+    return {
+        value,
+        position: percentValue / 100,
+    };
+}
+function fillMissingLinearStopPositions(stops, firstPosition, lastPosition) {
+    stops[0].position = firstPosition;
+    stops[stops.length - 1].position = lastPosition;
+    let index = 1;
+    while (index < stops.length - 1) {
+        if (stops[index].position !== undefined) {
+            index += 1;
+            continue;
+        }
+        const startIndex = index - 1;
+        let endIndex = index + 1;
+        while (endIndex < stops.length &&
+            stops[endIndex].position === undefined) {
+            endIndex += 1;
+        }
+        const start = stops[startIndex].position ?? firstPosition;
+        const end = stops[endIndex].position ?? lastPosition;
+        const gapSize = (end - start) / (endIndex - startIndex);
+        for (let fillIndex = index; fillIndex < endIndex; fillIndex += 1) {
+            stops[fillIndex].position =
+                start + gapSize * (fillIndex - startIndex);
+        }
+        index = endIndex;
+    }
+}
+function sampleLinearEasing(stops, progress) {
+    if (progress <= (stops[0].position ?? 0)) {
+        return stops[0].value;
+    }
+    if (progress >= (stops[stops.length - 1].position ?? 1)) {
+        return stops[stops.length - 1].value;
+    }
+    for (let index = 1; index < stops.length; index += 1) {
+        const previousStop = stops[index - 1];
+        const nextStop = stops[index];
+        const start = previousStop.position ?? 0;
+        const end = nextStop.position ?? 1;
+        if (progress > end) {
+            continue;
+        }
+        if (end === start) {
+            return nextStop.value;
+        }
+        const ratio = (progress - start) / (end - start);
+        return (previousStop.value + (nextStop.value - previousStop.value) * ratio);
+    }
+    return stops[stops.length - 1].value;
+}

package/dist/xy-motion/driver.d.ts

@@ -0,0 +1,9 @@
+import type { XYAnimationConfig, XYAreaAnimationContext, XYBarAnimationContext, XYMotionRenderResult, XYMotionSeries, XYMotionUpdateContext, XYPointAnimationContext } from './types.js';
+export interface XYMotionDriverContract {
+    prepareForUpdate(context: XYMotionUpdateContext): void;
+    getPointAnimationContext(series: XYMotionSeries, baselineY: number): XYPointAnimationContext | undefined;
+    getAreaAnimationContext(series: XYMotionSeries): XYAreaAnimationContext | undefined;
+    getBarAnimationContext(series: XYMotionSeries, baselineValuePosition: number): XYBarAnimationContext | undefined;
+    completeRender(result: XYMotionRenderResult): Promise<void>;
+}
+export declare function createXYMotionDriver(config: boolean | XYAnimationConfig | undefined): XYMotionDriverContract;

package/dist/xy-motion/driver.js

@@ -0,0 +1,10 @@
+import { normalizeXYAnimationConfig } from './config.js';
+import { NoopXYMotionDriver } from './noop-xy-motion-driver.js';
+import { XYMotionDriver } from './xy-motion-driver.js';
+export function createXYMotionDriver(config) {
+    const animation = normalizeXYAnimationConfig(config);
+    if (!animation.show) {
+        return new NoopXYMotionDriver();
+    }
+    return new XYMotionDriver(animation);
+}

package/dist/xy-motion/helpers.d.ts

@@ -0,0 +1,17 @@
+import type { DataItem } from '../types.js';
+type TransitionLike = {
+    end: () => Promise<unknown>;
+};
+type XYEnterStaggerTiming = {
+    delay: number;
+    duration: number;
+};
+export declare function createXYSeriesSnapshotId(seriesType: string, dataKey: string): string;
+export declare function createXYDatumKey(value: unknown): string;
+export declare function buildXYDatumSnapshotKeys(data: DataItem[], xKey: string): string[];
+export declare function cloneXYSeriesSnapshotCollection<TSnapshot>(collection: Map<string, Map<string, TSnapshot>>): Map<string, Map<string, TSnapshot>>;
+export declare function createTransitionCompletionPromise(transition: TransitionLike): Promise<void>;
+export declare function createXYAnimationId(prefix: string): string;
+export declare function createLeftToRightRevealTransition(target: SVGGraphicsElement | null, duration: number, easing: (progress: number) => number, idPrefix: string, padding?: number, initialProgress?: number): Promise<void>[];
+export declare function getEnterStaggerTiming(index: number, itemCount: number, totalDuration: number, maxDelayShare?: number): XYEnterStaggerTiming;
+export {};

package/dist/xy-motion/helpers.js

@@ -0,0 +1,105 @@
+import { select } from 'd3';
+const DEFAULT_ENTER_STAGGER_SHARE = 0.55;
+export function createXYSeriesSnapshotId(seriesType, dataKey) {
+    return `${seriesType}:${dataKey}`;
+}
+export function createXYDatumKey(value) {
+    return createXYDatumKeyWithOccurrence(value, 0);
+}
+function createXYDatumKeyWithOccurrence(value, occurrenceIndex) {
+    if (value instanceof Date) {
+        const isoValue = value.toISOString();
+        return occurrenceIndex === 0
+            ? isoValue
+            : `${isoValue}::${occurrenceIndex}`;
+    }
+    const stringValue = String(value);
+    return occurrenceIndex === 0
+        ? stringValue
+        : `${stringValue}::${occurrenceIndex}`;
+}
+export function buildXYDatumSnapshotKeys(data, xKey) {
+    const occurrenceCounts = new Map();
+    return data.map((entry) => {
+        const baseKey = createXYDatumKey(entry[xKey]);
+        const occurrenceIndex = occurrenceCounts.get(baseKey) ?? 0;
+        occurrenceCounts.set(baseKey, occurrenceIndex + 1);
+        return createXYDatumKeyWithOccurrence(entry[xKey], occurrenceIndex);
+    });
+}
+export function cloneXYSeriesSnapshotCollection(collection) {
+    return new Map(Array.from(collection.entries(), ([seriesKey, snapshot]) => {
+        return [seriesKey, new Map(snapshot)];
+    }));
+}
+export function createTransitionCompletionPromise(transition) {
+    return transition.end().then(() => undefined, () => undefined);
+}
+let xyAnimationIdCounter = 0;
+export function createXYAnimationId(prefix) {
+    xyAnimationIdCounter += 1;
+    return `${prefix}-${xyAnimationIdCounter}`;
+}
+export function createLeftToRightRevealTransition(target, duration, easing, idPrefix, padding = 0, initialProgress = 0) {
+    if (!target) {
+        return [];
+    }
+    const svg = target.ownerSVGElement;
+    if (!svg) {
+        return [];
+    }
+    const bbox = target.getBBox();
+    const clipWidth = Math.max(1, bbox.width + padding * 2);
+    const clipHeight = Math.max(1, bbox.height + padding * 2);
+    const clampedInitialProgress = Math.max(0, Math.min(1, initialProgress));
+    if (clampedInitialProgress >= 1) {
+        return [];
+    }
+    const clipId = createXYAnimationId(idPrefix);
+    const defs = select(svg)
+        .selectAll('defs.xy-animation-defs')
+        .data([undefined])
+        .join('defs')
+        .attr('class', 'xy-animation-defs');
+    const clipPath = defs
+        .append('clipPath')
+        .attr('id', clipId)
+        .attr('class', 'xy-animation-reveal-clip');
+    const clipRect = clipPath
+        .append('rect')
+        .attr('x', bbox.x - padding)
+        .attr('y', bbox.y - padding)
+        .attr('width', clipWidth * clampedInitialProgress)
+        .attr('height', clipHeight);
+    const targetSelection = select(target);
+    targetSelection.attr('clip-path', `url(#${clipId})`);
+    return [
+        clipRect
+            .transition()
+            .duration(duration)
+            .ease(easing)
+            .attr('width', clipWidth)
+            .end()
+            .then(() => {
+            targetSelection.attr('clip-path', null);
+            clipPath.remove();
+        }, () => {
+            targetSelection.attr('clip-path', null);
+            clipPath.remove();
+        }),
+    ];
+}
+export function getEnterStaggerTiming(index, itemCount, totalDuration, maxDelayShare = DEFAULT_ENTER_STAGGER_SHARE) {
+    const delayRange = totalDuration * maxDelayShare;
+    const duration = Math.max(totalDuration - delayRange, 1);
+    if (itemCount <= 1) {
+        return {
+            delay: 0,
+            duration,
+        };
+    }
+    return {
+        delay: (delayRange * index) / (itemCount - 1),
+        duration,
+    };
+}

package/dist/xy-motion/live-state.d.ts

@@ -0,0 +1,8 @@
+import { type Selection } from 'd3';
+import { type XYLivePathStateCollection, type XYMotionSeries, type XYSeriesSnapshotCollection } from './types.js';
+type PlotGroup = Selection<SVGGElement, undefined, null, undefined>;
+export declare function captureLiveAnimationState(plotGroup: PlotGroup | null, visibleSeries: XYMotionSeries[], lastSeriesSnapshot: XYSeriesSnapshotCollection): {
+    snapshotCollection: XYSeriesSnapshotCollection;
+    pathState: XYLivePathStateCollection;
+};
+export {};

package/dist/xy-motion/live-state.js

@@ -0,0 +1,240 @@
+import { select } from 'd3';
+import { sanitizeForCSS } from '../utils.js';
+import { cloneXYSeriesSnapshotCollection, createXYSeriesSnapshotId, } from './helpers.js';
+export function captureLiveAnimationState(plotGroup, visibleSeries, lastSeriesSnapshot) {
+    const snapshotCollection = cloneXYSeriesSnapshotCollection(lastSeriesSnapshot);
+    const pathState = new Map();
+    if (!plotGroup) {
+        return {
+            snapshotCollection,
+            pathState,
+        };
+    }
+    visibleSeries.forEach((series) => {
+        captureLiveSeriesState(series, plotGroup, snapshotCollection, pathState, lastSeriesSnapshot);
+    });
+    return {
+        snapshotCollection,
+        pathState,
+    };
+}
+function captureLiveSeriesState(series, plotGroup, snapshotCollection, pathState, lastSeriesSnapshot) {
+    switch (series.type) {
+        case 'bar':
+            captureLiveBarSeriesState(series, plotGroup, snapshotCollection);
+            return;
+        case 'line':
+            captureLiveLineSeriesState(series, plotGroup, snapshotCollection, pathState);
+            return;
+        case 'scatter':
+            captureLiveScatterSeriesState(series, plotGroup, snapshotCollection);
+            return;
+        case 'area':
+            captureLiveAreaSeriesState(series, plotGroup, snapshotCollection, pathState, lastSeriesSnapshot);
+            return;
+    }
+}
+function captureLiveBarSeriesState(series, plotGroup, snapshotCollection) {
+    const seriesId = createXYSeriesSnapshotId(series.type, series.dataKey);
+    const snapshot = captureLiveBarSnapshot(plotGroup, series.dataKey);
+    if (!snapshot) {
+        return;
+    }
+    snapshotCollection.set(seriesId, new Map([
+        ...(snapshotCollection.get(seriesId) ?? new Map()),
+        ...snapshot,
+    ]));
+}
+function captureLiveLineSeriesState(series, plotGroup, snapshotCollection, pathState) {
+    const seriesId = createXYSeriesSnapshotId(series.type, series.dataKey);
+    const snapshot = captureLivePointSnapshot(plotGroup, `.circle-${sanitizeForCSS(series.dataKey)}`);
+    const linePathState = captureLivePathState(plotGroup, `.line-${sanitizeForCSS(series.dataKey)}`);
+    if (snapshot) {
+        snapshotCollection.set(seriesId, new Map([
+            ...(snapshotCollection.get(seriesId) ?? new Map()),
+            ...snapshot,
+        ]));
+    }
+    if (linePathState.path !== null || linePathState.revealProgress !== null) {
+        pathState.set(seriesId, {
+            linePath: linePathState.path,
+            lineRevealProgress: linePathState.revealProgress,
+        });
+    }
+}
+function captureLiveScatterSeriesState(series, plotGroup, snapshotCollection) {
+    const seriesId = createXYSeriesSnapshotId(series.type, series.dataKey);
+    const snapshot = captureLivePointSnapshot(plotGroup, `.scatter-point-${sanitizeForCSS(series.dataKey)}`);
+    if (!snapshot) {
+        return;
+    }
+    snapshotCollection.set(seriesId, new Map([
+        ...(snapshotCollection.get(seriesId) ?? new Map()),
+        ...snapshot,
+    ]));
+}
+function captureLiveAreaSeriesState(series, plotGroup, snapshotCollection, pathState, lastSeriesSnapshot) {
+    const seriesId = createXYSeriesSnapshotId(series.type, series.dataKey);
+    const snapshot = captureLiveAreaSnapshot(plotGroup, series.dataKey, lastSeriesSnapshot.get(seriesId));
+    const areaPathState = captureLivePathState(plotGroup, `.area-${sanitizeForCSS(series.dataKey)}`);
+    const areaLinePathState = captureLivePathState(plotGroup, `.area-line-${sanitizeForCSS(series.dataKey)}`);
+    if (snapshot) {
+        snapshotCollection.set(seriesId, new Map([
+            ...(snapshotCollection.get(seriesId) ?? new Map()),
+            ...snapshot,
+        ]));
+    }
+    if (areaPathState.path !== null ||
+        areaLinePathState.path !== null ||
+        areaPathState.revealProgress !== null ||
+        areaLinePathState.revealProgress !== null) {
+        pathState.set(seriesId, {
+            areaPath: areaPathState.path,
+            areaLinePath: areaLinePathState.path,
+            areaRevealProgress: areaPathState.revealProgress,
+            areaLineRevealProgress: areaLinePathState.revealProgress,
+        });
+    }
+}
+function captureLiveBarSnapshot(plotGroup, dataKey) {
+    const bars = plotGroup.selectAll(`.bar-${sanitizeForCSS(dataKey)}`);
+    if (bars.empty()) {
+        return null;
+    }
+    bars.interrupt();
+    const snapshot = new Map();
+    bars.each((datum, index, nodes) => {
+        if (!datum.snapshotKey) {
+            return;
+        }
+        const node = nodes[index];
+        const x = getNumericAttribute(node, 'x');
+        const y = getNumericAttribute(node, 'y');
+        const width = getNumericAttribute(node, 'width');
+        const height = getNumericAttribute(node, 'height');
+        if (x === null || y === null || width === null || height === null) {
+            return;
+        }
+        snapshot.set(datum.snapshotKey, {
+            x,
+            y,
+            width,
+            height,
+        });
+    });
+    return snapshot.size > 0 ? snapshot : null;
+}
+function captureLivePointSnapshot(plotGroup, selector) {
+    const points = plotGroup.selectAll(selector);
+    if (points.empty()) {
+        return null;
+    }
+    points.interrupt();
+    const snapshot = new Map();
+    points.each((datum, index, nodes) => {
+        if (!datum.snapshotKey) {
+            return;
+        }
+        const node = nodes[index];
+        const x = getNumericAttribute(node, 'cx');
+        const y = getNumericAttribute(node, 'cy');
+        if (x === null || y === null) {
+            return;
+        }
+        snapshot.set(datum.snapshotKey, {
+            x,
+            y,
+        });
+    });
+    return snapshot.size > 0 ? snapshot : null;
+}
+function captureLiveAreaSnapshot(plotGroup, dataKey, previousSnapshot) {
+    const pointSnapshot = captureLivePointSnapshot(plotGroup, `.area-point-${sanitizeForCSS(dataKey)}`);
+    if (!pointSnapshot) {
+        return null;
+    }
+    const snapshot = new Map();
+    pointSnapshot.forEach((point, snapshotKey) => {
+        snapshot.set(snapshotKey, {
+            x: point.x,
+            y0: previousSnapshot?.get(snapshotKey)?.y0 ?? point.y,
+            y1: point.y,
+        });
+    });
+    return snapshot.size > 0 ? snapshot : null;
+}
+function captureLivePathState(plotGroup, selector) {
+    const path = plotGroup.select(selector);
+    if (path.empty()) {
+        return {
+            path: null,
+            revealProgress: null,
+        };
+    }
+    const node = path.node();
+    const revealProgress = node ? captureLeftToRightRevealProgress(node) : null;
+    path.interrupt();
+    interruptLeftToRightReveal(path.node());
+    return {
+        path: path.attr('d') || null,
+        revealProgress,
+    };
+}
+function getNumericAttribute(element, attribute) {
+    if (!element) {
+        return null;
+    }
+    const value = Number(element.getAttribute(attribute));
+    return Number.isFinite(value) ? value : null;
+}
+function captureLeftToRightRevealProgress(target) {
+    const clipRect = getRevealClipRect(target);
+    if (!clipRect) {
+        return null;
+    }
+    const targetBounds = target.getBBox();
+    const clipWidth = getNumericAttribute(clipRect, 'width');
+    const clipX = getNumericAttribute(clipRect, 'x');
+    if (clipWidth === null || clipX === null) {
+        return null;
+    }
+    const padding = targetBounds.x - clipX;
+    const totalWidth = targetBounds.width + padding * 2;
+    if (totalWidth <= 0) {
+        return null;
+    }
+    const progress = clipWidth / totalWidth;
+    if (!Number.isFinite(progress) || progress >= 1) {
+        return null;
+    }
+    return Math.max(0, Math.min(1, progress));
+}
+function interruptLeftToRightReveal(target) {
+    const clipRect = target ? getRevealClipRect(target) : null;
+    if (!clipRect) {
+        return;
+    }
+    select(clipRect).interrupt();
+}
+function getRevealClipRect(target) {
+    const svg = target.ownerSVGElement;
+    if (!svg) {
+        return null;
+    }
+    const clipPathId = extractClipPathId(target.getAttribute('clip-path'));
+    if (!clipPathId) {
+        return null;
+    }
+    const clipPath = target.ownerDocument?.getElementById(clipPathId);
+    if (!clipPath || !clipPath.classList.contains('xy-animation-reveal-clip')) {
+        return null;
+    }
+    return clipPath.querySelector('rect');
+}
+function extractClipPathId(value) {
+    if (!value) {
+        return null;
+    }
+    const match = value.match(/url\((?:['"])?#([^'")]+)(?:['"])?\)/);
+    return match?.[1] ?? null;
+}

package/dist/xy-motion/noop-xy-motion-driver.d.ts

@@ -0,0 +1,9 @@
+import type { XYMotionDriverContract } from './driver.js';
+import type { XYAreaAnimationContext, XYBarAnimationContext, XYMotionRenderResult, XYMotionSeries, XYMotionUpdateContext, XYPointAnimationContext } from './types.js';
+export declare class NoopXYMotionDriver implements XYMotionDriverContract {
+    prepareForUpdate(_context: XYMotionUpdateContext): void;
+    getPointAnimationContext(_series: XYMotionSeries, _baselineY: number): XYPointAnimationContext | undefined;
+    getAreaAnimationContext(_series: XYMotionSeries): XYAreaAnimationContext | undefined;
+    getBarAnimationContext(_series: XYMotionSeries, _baselineValuePosition: number): XYBarAnimationContext | undefined;
+    completeRender(_result: XYMotionRenderResult): Promise<void>;
+}

package/dist/xy-motion/noop-xy-motion-driver.js

@@ -0,0 +1,15 @@
+export class NoopXYMotionDriver {
+    prepareForUpdate(_context) { }
+    getPointAnimationContext(_series, _baselineY) {
+        return undefined;
+    }
+    getAreaAnimationContext(_series) {
+        return undefined;
+    }
+    getBarAnimationContext(_series, _baselineValuePosition) {
+        return undefined;
+    }
+    completeRender(_result) {
+        return Promise.resolve();
+    }
+}

package/dist/xy-motion/types.d.ts

@@ -0,0 +1,85 @@
+import type { Selection } from 'd3';
+export type XYAnimationEasingPreset = 'linear' | 'ease-in' | 'ease-out' | 'ease-in-out' | 'bounce-out' | 'elastic-out';
+export type XYAnimationConfig = {
+    show?: boolean;
+    duration?: number;
+    easing?: XYAnimationEasingPreset | `linear(${string})` | ((progress: number) => number);
+};
+export type XYRenderAnimationMode = 'none' | 'initial' | 'update';
+export type XYPointSnapshot = {
+    x: number;
+    y: number;
+};
+export type XYAreaPointSnapshot = {
+    x: number;
+    y0: number;
+    y1: number;
+};
+export type XYBarSnapshot = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+export type XYSeriesDatumSnapshot = XYPointSnapshot | XYAreaPointSnapshot | XYBarSnapshot;
+export type XYSeriesSnapshot<TSnapshot = XYSeriesDatumSnapshot> = Map<string, TSnapshot>;
+export type XYSeriesSnapshotCollection = Map<string, XYSeriesSnapshot<XYSeriesDatumSnapshot>>;
+export type NormalizedXYAnimation = {
+    show: boolean;
+    duration: number;
+    easing: (progress: number) => number;
+};
+export type XYPointAnimationContext = {
+    mode: Exclude<XYRenderAnimationMode, 'none'>;
+    duration: number;
+    easing: (progress: number) => number;
+    baselineY: number;
+    previousSnapshot?: XYSeriesSnapshot<XYPointSnapshot>;
+    previousPath?: string | null;
+    previousRevealProgress?: number | null;
+};
+export type XYAreaAnimationContext = {
+    mode: Exclude<XYRenderAnimationMode, 'none'>;
+    duration: number;
+    easing: (progress: number) => number;
+    previousSnapshot?: XYSeriesSnapshot<XYAreaPointSnapshot>;
+    previousAreaPath?: string | null;
+    previousLinePath?: string | null;
+    previousAreaRevealProgress?: number | null;
+    previousLineRevealProgress?: number | null;
+};
+export type XYBarAnimationContext = {
+    mode: Exclude<XYRenderAnimationMode, 'none'>;
+    duration: number;
+    easing: (progress: number) => number;
+    baselineValuePosition: number;
+    previousSnapshot?: XYSeriesSnapshot<XYBarSnapshot>;
+};
+export type XYSeriesRenderResult<TSnapshot = XYSeriesDatumSnapshot> = {
+    snapshot: XYSeriesSnapshot<TSnapshot>;
+    transitions: Promise<void>[];
+};
+export type XYMotionSeries = {
+    type: 'line' | 'scatter' | 'bar' | 'area';
+    dataKey: string;
+};
+export type XYMotionRenderResult = {
+    snapshotCollection: XYSeriesSnapshotCollection;
+    transitions: Promise<void>[];
+};
+export type XYMotionUpdateContext = {
+    plotGroup: Selection<SVGGElement, undefined, null, undefined> | null;
+    visibleSeries: XYMotionSeries[];
+};
+export type XYLivePathState = {
+    linePath?: string | null;
+    areaPath?: string | null;
+    areaLinePath?: string | null;
+    lineRevealProgress?: number | null;
+    areaRevealProgress?: number | null;
+    areaLineRevealProgress?: number | null;
+};
+export type XYLivePathStateCollection = Map<string, XYLivePathState>;
+export type XYSnapshotBoundDatum = {
+    snapshotKey?: string;
+};

package/dist/xy-motion/types.js

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