@lilt-ui/charts 0.1.0

package/dist/toolkit/comparison-details.d.ts

@@ -0,0 +1,7 @@
+import { ChartComparisonContext } from '../types';
+export interface ComparisonDetailsProps {
+    comparison: ChartComparisonContext;
+    className?: string;
+}
+/** Optional content. Use in a tooltip, header or footer, or replace with your own JSX. */
+export declare function ComparisonDetails({ comparison, className }: ComparisonDetailsProps): import("react/jsx-runtime").JSX.Element;

package/dist/types.d.ts

@@ -0,0 +1,555 @@
+import { CSSProperties, ReactElement, ReactNode } from 'react';
+/** step-after holds the left value until the next x; step-before holds the right value. */
+export type ChartCurve = 'linear' | 'monotone' | 'step-after' | 'step-before';
+/** Restrained fills shared by marks and their inspection keys. */
+export type ChartFillTreatment = 'solid' | 'fade' | 'hatch' | 'dots';
+export type ChartObservationStatus = 'observed' | 'provisional' | 'forecast';
+export type ChartMotion = 'auto' | 'none';
+export type ChartStatus = 'loading' | 'ready' | 'error';
+/** Standard CSS plus scoped Lilt tokens, usable on every chart root. */
+export type ChartStyle = CSSProperties & {
+    [token: `--lilt-${string}`]: string | number | undefined;
+};
+export interface ChartLineStyle {
+    width?: number;
+    opacity?: number;
+    dasharray?: string;
+    cap?: 'butt' | 'round' | 'square';
+    join?: 'miter' | 'round' | 'bevel';
+    /** Radius of isolated observations and inspected line or area points. */
+    pointRadius?: number;
+    pointStroke?: string;
+    pointStrokeWidth?: number;
+    /** Show the point on this series during inspection. Defaults to true. */
+    showInspectionPoint?: boolean;
+    /** Label the latest finite endpoint when the plot has a wide right gutter. */
+    directLabel?: boolean;
+    /** Mark every observation with a small dot ringed in the surface color. */
+    points?: boolean;
+}
+export interface ChartAreaStyle {
+    /** Fade a solid or patterned area toward its baseline without changing geometry. */
+    fade?: boolean;
+    /** Fill opacity at rest. Defaults to 0.62 for stacks and 1 for gradients. */
+    opacity?: number;
+    /** CSS color or paint value. Omit to use Lilt's gradient or the series color. */
+    fill?: string;
+    /** A chart-owned paint treatment; explicit fill takes precedence. */
+    treatment?: ChartFillTreatment;
+}
+/**
+ * How a bar is drawn: `solid`, `segmented` into small cells, `needle` (a thin segmented line that
+ * expands on hover), `gradient` fading toward the baseline, or `outline`.
+ */
+export type ChartBarAppearance = 'solid' | 'segmented' | 'needle' | 'gradient' | 'outline';
+export interface ChartBarStyle {
+    /** How each bar is drawn. Defaults to `solid`. */
+    appearance?: ChartBarAppearance;
+    /** Radius of the exposed value end in CSS pixels. Stacked bars default to 0. */
+    radius?: number;
+    /** Round both the top and bottom of each bar segment. */
+    roundBothEnds?: boolean;
+    stroke?: string;
+    strokeWidth?: number;
+    fillOpacity?: number;
+    /** Decorative paint clipped to the exact bar geometry. */
+    treatment?: Exclude<ChartFillTreatment, 'fade'>;
+    /**
+     * Quiet full-scale lane behind each observed bar. In a stack, the bottom series' track sits
+     * behind the whole column. It follows `roundBothEnds`.
+     */
+    track?: {
+        fill?: string;
+        opacity?: number;
+        radius?: number;
+    };
+}
+export interface ChartBarLayout {
+    /** Desired maximum width of each bar in CSS pixels; clamped to its x slot. */
+    width?: number;
+    /** Space between bars within a grouped x slot, in CSS pixels. */
+    gap?: number;
+    /** Space between segments of a stack, in CSS pixels. Defaults to 0. */
+    segmentGap?: number;
+}
+export interface ChartSeries<T> {
+    id: string;
+    label: string;
+    unit?: string;
+    accessor: (row: T) => number | null;
+    /** Explicit source status. The last row is never inferred to be provisional. */
+    status?: (row: T) => ChartObservationStatus;
+    /** Supplied bounds in the same unit as accessor; Lilt does not infer confidence. */
+    interval?: {
+        lower: (row: T) => number | null;
+        upper: (row: T) => number | null;
+        meaning: string;
+    };
+    color?: string;
+    line?: ChartLineStyle;
+    area?: ChartAreaStyle;
+    bar?: ChartBarStyle;
+    formatValue?: (value: number) => string;
+    curve?: ChartCurve;
+    /**
+     * `secondary` fits this series to its own value scale, for a different unit such as a rate
+     * over revenue bars. The scale shares the primary gridlines; `YAxis scale="secondary"` labels
+     * it. Stacked series always share the primary scale.
+     */
+    scale?: 'primary' | 'secondary';
+}
+export interface TimeXConfig<T> {
+    type: 'time';
+    accessor: (row: T) => Date | number;
+    format?: (value: number) => string;
+}
+export interface NumericXConfig<T> {
+    type: 'number';
+    accessor: (row: T) => number;
+    format?: (value: number) => string;
+}
+export interface CategoryXConfig<T> {
+    type: 'category';
+    /** Stable, unique category identity. Input order determines its position. */
+    accessor: (row: T) => string;
+    format?: (id: string) => string;
+}
+export type ChartXConfig<T> = TimeXConfig<T> | NumericXConfig<T> | CategoryXConfig<T>;
+export interface ChartYConfig {
+    includeZero?: boolean;
+    domain?: readonly [number, number];
+    /** Values the fitted domain must contain, such as a target line. Ignored with `domain`. */
+    include?: readonly number[];
+    format?: (value: number) => string;
+    /** Labels of the secondary scale. Defaults to the first secondary series' `formatValue`. */
+    secondaryFormat?: (value: number) => string;
+    ticks?: number;
+}
+export interface ChartMargins {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+}
+interface ChartCommonProps<T> {
+    data: readonly T[];
+    /** Suppress inspection and selection feedback while retaining external selection ownership. */
+    interactive?: boolean;
+    y?: ChartYConfig;
+    series: readonly ChartSeries<T>[];
+    className?: string;
+    style?: CSSProperties | ChartStyle;
+    'aria-label': string;
+    children?: ReactNode;
+    status?: ChartStatus;
+    error?: string;
+    renderRetry?: () => ReactNode;
+    motion?: ChartMotion;
+    /** Play the first-data entrance (also after resetKey). Defaults to true; updates remain animated. */
+    animateIn?: boolean;
+    resetKey?: string | number;
+    onSelectionChange?: (selection: ChartSelection<T> | null) => void;
+    /** Controlled series visibility. Omit to show every descriptor. */
+    visibleSeries?: readonly string[];
+    onVisibleSeriesChange?: (series: readonly string[]) => void;
+}
+export type ChartProps<T> = ChartCommonProps<T> & ({
+    x: TimeXConfig<T> | NumericXConfig<T>;
+    /** Share inspection and range state across charts. */
+    controller?: ChartController;
+    linkedSelection?: 'exact' | {
+        nearestWithin: number;
+    };
+    compare?: boolean | ChartCompareConfig;
+    focus?: boolean | ChartFocusConfig;
+    live?: boolean | ChartLiveConfig;
+    brush?: boolean;
+    selectedCategoryId?: never;
+    onSelectedCategoryIdChange?: never;
+} | {
+    x: CategoryXConfig<T>;
+    /** Controlled pinned category; hover and keyboard focus stay local. */
+    selectedCategoryId?: string | null;
+    onSelectedCategoryIdChange?: (id: string | null) => void;
+    controller?: never;
+    linkedSelection?: never;
+    compare?: never;
+    focus?: never;
+    live?: never;
+    brush?: never;
+});
+/**
+ * Axis presets.
+ * - `classic`: y labels in a left gutter, x labels under the plot.
+ * - `inline`: y labels sit on their grid lines inside the plot, so the plot runs full width.
+ * - `ruler`: inline y labels plus a crisp tick under every observation; the active tick grows.
+ * - `minimal`: no y labels or grid; the x axis labels only its ends.
+ * - `dots`: minimal plus a dot under every observation that swells under the pointer.
+ */
+export type ChartAxisStyle = 'classic' | 'inline' | 'ruler' | 'minimal' | 'dots';
+/**
+ * How hover pills and tooltips look: quiet surface glass `soft` (default), inverted `solid`, or
+ * `accent`, which takes the color of the series under the pointer.
+ */
+export type ChartHoverStyle = 'soft' | 'solid' | 'accent';
+/**
+ * What a card shows for the hovered point. `pills` (default) puts the date and value on the
+ * axes; `tooltip` gathers every series in one floating panel; `headline` keeps the plot clear
+ * and reads out through the headline and tiles alone.
+ */
+export type ChartHoverReadout = 'pills' | 'tooltip' | 'headline';
+/** The series marker on each tooltip row: a rounded `square` (default), a `dot`, or a `line`. */
+export type ChartTooltipIndicator = 'square' | 'dot' | 'line';
+/**
+ * Series color sets, each validated for color-vision deficiency in light and dark mode. `iris`
+ * is the default.
+ */
+export type ChartPalette = 'iris' | 'cobalt' | 'emerald';
+/** Texture behind the plot marks, faded toward the plot edges. */
+export type ChartBackground = 'dots' | 'grid' | 'lines' | 'none';
+/** Card treatments: raised `elevated` (default), border-only `outline`, or `ghost` for use inside your own card. */
+export type ChartSurface = 'elevated' | 'outline' | 'ghost';
+interface ChartPlotCommonProps {
+    children?: ReactNode;
+    /** Axis presentation. Defaults to `minimal`. */
+    axis?: ChartAxisStyle;
+    /** Hover pill treatment, or `false` to inspect without pills. Defaults to `soft`. */
+    pill?: ChartHoverStyle | false;
+    /**
+     * Which series the y pill follows. `nearest` (default) follows the line closest to the pointer;
+     * a series ID locks it; `total` follows the top of a stack.
+     */
+    pillSeries?: 'nearest' | 'total' | (string & {});
+    /** In stacks, show the series' own value (`series`, default) or the stacked height at its edge (`stack`). */
+    pillValue?: 'series' | 'stack';
+    /**
+     * Where the value pill sits: `axis` on the y axis, `mark` centered above the hovered bar or
+     * point. `auto` (default) uses `mark` when the axis shows no y labels.
+     */
+    pillPosition?: 'auto' | 'axis' | 'mark';
+    /** Texture behind the marks. Defaults to `none` here; cards default to `dots`. */
+    background?: ChartBackground;
+    /** Brighten the background around the inspected point. Defaults to true. */
+    spotlight?: boolean;
+    /**
+     * Padding in pixels between the plot's left and right edges and its axis labels, ruler ends,
+     * and hover pills. Observations move inward by the same amount so labels center on them.
+     * Defaults to 0.
+     */
+    axisInset?: number;
+    /**
+     * With an `axisInset`, continue lines and areas from the first and last observations to the
+     * plot edges, fading out. Decorative only: it carries no values and is not inspectable.
+     */
+    runoff?: boolean;
+    /**
+     * How far the first and last x labels may extend past the plot edges so they stay centered on
+     * their observations, as in a chart surrounded by padding. Defaults to 0.
+     */
+    labelOverhang?: number;
+    /** Use 'fill' to size the plot from its flex container; otherwise use a pixel height. */
+    height?: number | 'fill';
+    compactHeight?: number;
+    margins?: Partial<ChartMargins>;
+    /** Axis-free inspection presentation for compact charts. */
+    compact?: boolean;
+    className?: string;
+    style?: CSSProperties | ChartStyle;
+    /** Inspection panel settings. Use this when plot children are produced by a component. */
+    tooltip?: TooltipProps | ReactElement | false;
+    /** Series used for the inspection-axis badge. */
+    inspectionSeries?: string;
+}
+/** Bars for a plot. Series left out draw as lines over the bars, e.g. a target or a rate. */
+export interface ChartBars<Id extends string = string> extends ChartBarLayout {
+    /**
+     * Series drawn as bars. Defaults to every series, or to the stacked series when the plot also
+     * stacks; stacked bars always draw exactly the stack.
+     */
+    series?: readonly Id[];
+}
+/**
+ * How stacked series combine. `sum` adds values, positives above zero and negatives below;
+ * `percent` shows each series' share of its period and requires non-negative values.
+ */
+export type ChartStackMode = 'sum' | 'percent';
+export interface ChartStack<Id extends string = string> {
+    /**
+     * Series that stack, bottom to top in chart series order. Defaults to every series. The rest
+     * draw unstacked over the stack on the same scale, or on their own with `scale: 'secondary'`.
+     */
+    series?: readonly Id[];
+    /** Defaults to `sum`. */
+    mode?: ChartStackMode;
+}
+export interface ChartPlotProps extends ChartPlotCommonProps {
+    /** Draw series as bars: `true` for every series, or choose series and spacing. */
+    bars?: true | ChartBars;
+    /** Stack series: `true` or `'sum'` adds every series, `'percent'` shows shares. */
+    stack?: true | ChartStackMode | ChartStack;
+}
+export interface BarProps {
+    series: string;
+    className?: string;
+}
+export type RankingOrder = 'descending' | 'ascending' | 'input';
+export interface CategorySelection<T> {
+    id: string;
+    row: T;
+    value: number | null;
+    pinned: boolean;
+}
+export interface ChartToolbarProps {
+    actions?: ReactNode;
+    className?: string;
+}
+export interface ChartReadoutProps {
+    /** Optional normal-flow text summary; keyboard input remains in the plot. */
+    className?: string;
+}
+export interface ChartBrushProps {
+    className?: string;
+}
+export interface ChartOverviewProps {
+    className?: string;
+}
+export interface LineProps {
+    series: string;
+    className?: string;
+}
+export interface AreaProps {
+    series: string;
+    className?: string;
+}
+export interface IntervalBandProps {
+    series: string;
+    className?: string;
+}
+export interface PrimitiveProps {
+    className?: string;
+}
+export interface XAxisProps extends PrimitiveProps {
+    /** Insets only the first and last tick labels; the plotted data stays edge to edge. */
+    edgeInset?: number;
+    /**
+     * `ends` labels only the first and last observation; `fit` labels as many as fit. Minimal and
+     * dots axes default to `ends`, which suits lines and areas; bars read better with `fit`.
+     */
+    labels?: 'ends' | 'fit';
+}
+export interface GridProps extends PrimitiveProps {
+    pattern?: 'lines' | 'dots';
+    color?: string;
+    opacity?: number;
+    lineWidth?: number;
+    dotSpacing?: number;
+    dotRadius?: number;
+}
+export interface YAxisProps extends PrimitiveProps {
+    showTicks?: boolean;
+    /** `secondary` labels series drawn with `scale: 'secondary'` on the right edge. */
+    scale?: 'primary' | 'secondary';
+}
+export interface TooltipProps<Row = unknown, SeriesId extends string = string> extends PrimitiveProps {
+    /** Optional accessible label for the inspection panel. */
+    'aria-label'?: string;
+    /** Keep plot inspection without a floating panel. Add ChartReadout separately if wanted. */
+    floating?: boolean;
+    /** Panel treatment: `soft` (default), `solid`, or `accent`. */
+    variant?: ChartHoverStyle;
+    /** Series marker on each row: `square` (default), `dot`, or `line`. */
+    indicator?: ChartTooltipIndicator;
+    /**
+     * Below 420px, and while another chart drives inspection, show a readout under the plot
+     * instead of the floating panel. Defaults to true.
+     */
+    adaptive?: boolean;
+    /** Icon in the pinned inspection banner. Defaults to Lilt's native pin. */
+    pinIcon?: ReactNode;
+    /** Replace the default values body with accepted-value JSX; title, placement and pin actions remain. */
+    renderContent?: (context: ChartTooltipContext<Row, SeriesId>) => ReactNode;
+    /** Opt in to comparison content in this tooltip. Omit to render it elsewhere. */
+    renderComparison?: (context: ChartComparisonContext<SeriesId, Row>) => ReactNode;
+}
+export interface ChartTooltipContext<Row = unknown, SeriesId extends string = string> {
+    /** The series the pointer, keyboard, or legend currently points at, when there is one. */
+    activeSeriesId?: SeriesId | null;
+    row: Row;
+    sourceIndex: number;
+    x: number;
+    formattedX: string;
+    pinned: boolean;
+    series: readonly {
+        id: SeriesId;
+        label: string;
+        value: number | null;
+        formattedValue: string;
+        status: ChartObservationStatus;
+        interval: {
+            lower: number;
+            upper: number;
+            meaning: string;
+        } | null;
+    }[];
+}
+export interface ChartLegendValue {
+    id: string;
+    label: string;
+    value: number | null;
+    formattedValue: string;
+    status: ChartObservationStatus;
+}
+export interface LegendProps extends PrimitiveProps {
+    /** Value cards are the default; inline uses compact dot-and-label items. */
+    variant?: 'cards' | 'inline';
+    /** Series show one entry per descriptor; observations show one entry per x bucket. */
+    by?: 'series' | 'observation';
+    /** Value source for observation entries. Defaults to the first visible series. */
+    series?: string;
+    style?: CSSProperties;
+    /** Enable series toggles and hover/focus emphasis. Defaults to true. */
+    interactive?: boolean;
+    /** Show the isolate action; activating an isolated series restores the prior selection. Defaults to true. */
+    allowIsolate?: boolean;
+    /** Override the accepted hover/pin value slot. */
+    renderValue?: (entry: ChartLegendValue) => ReactNode;
+    renderLabel?: (entry: ChartLegendValue) => ReactNode;
+    renderSwatch?: (entry: ChartLegendValue & {
+        color: string;
+    }) => ReactNode;
+    /** Consumer-owned comparison presentation for each series card. */
+    renderDifference?: (difference: ChartComparisonSeries, entry: ChartLegendValue) => ReactNode;
+    /** Replace one item's content; the outer item keeps linked hover/focus behaviour. */
+    renderItem?: (entry: ChartLegendValue & {
+        color: string;
+    }, actions: {
+        toggle: () => void;
+        focus: () => void;
+        isolate: () => void;
+        comparison: ChartComparisonSeries | null;
+    }) => ReactNode;
+}
+export type ChartPercentagePolicy = 'positive-baseline' | 'signed' | 'absolute-baseline' | 'none';
+export interface ChartCompareConfig {
+    /** Lead series for the focus overview. Results always include every visible series. */
+    series?: string;
+    percentage?: ChartPercentagePolicy;
+    /** Accepted values for all visible series, including range previews. No UI is inserted. */
+    onChange?: (comparison: ChartComparisonResult | null) => void;
+}
+export interface ChartFocusConfig {
+    overview?: boolean;
+    onChange?: (range: ChartRange | null) => void;
+}
+export interface ChartLiveConfig {
+    label?: string;
+    returnLabel?: string;
+    onFollowingChange?: (following: boolean) => void;
+}
+export interface ChartRange {
+    readonly startX: number;
+    readonly endX: number;
+}
+export interface ChartComparison extends ChartRange {
+    series: string;
+    startValue: number | null;
+    endValue: number | null;
+    absoluteChange: number | null;
+    percentageChange: number | null;
+    elapsed: number;
+    unavailableReason?: string;
+}
+export interface ChartComparisonSeries<Id extends string = string> extends Omit<ChartComparison, 'series'> {
+    id: Id;
+    label: string;
+    color: string;
+    dasharray?: string;
+    formattedStartValue: string;
+    formattedEndValue: string;
+    formattedChange: string;
+    formattedPercentage: string | null;
+}
+/** Presentation-independent endpoint changes, never interval sums or interpolated values. */
+export interface ChartComparisonResult<Id extends string = string, Row = unknown> extends ChartRange {
+    kind: 'range';
+    startRow: Row | null;
+    endRow: Row | null;
+    startSourceIndex: number | null;
+    endSourceIndex: number | null;
+    percentagePolicy: ChartPercentagePolicy;
+    formattedStartX: string;
+    formattedEndX: string;
+    elapsed: number;
+    phase: 'preview' | 'complete';
+    focused: boolean;
+    series: readonly ChartComparisonSeries<Id>[];
+}
+/** Available through useChartComparison and an explicitly supplied tooltip renderer. */
+export interface ChartComparisonContext<Id extends string = string, Row = unknown> extends ChartComparisonResult<Id, Row> {
+    motion: ChartMotion;
+    clear: () => void;
+    focus?: () => void;
+    fullRange?: () => void;
+}
+export interface ChartControllerInspection {
+    readonly x: number;
+    readonly pinned: boolean;
+    readonly ownerId: string;
+}
+export interface ChartControllerSnapshot {
+    readonly inspection: ChartControllerInspection | null;
+    readonly comparison: (ChartRange & {
+        readonly series?: string;
+    }) | null;
+    readonly focus: ChartRange | null;
+}
+export interface ChartController {
+    getSnapshot: () => ChartControllerSnapshot;
+    subscribe: (listener: () => void) => () => void;
+    inspect: (inspection: ChartControllerInspection) => void;
+    clearInspection: (ownerId?: string) => void;
+    /** Detach an unmounted input owner; retained pins and ranges survive expansion. */
+    releaseOwner: (ownerId: string) => void;
+    setComparison: (comparison: (ChartRange & {
+        series?: string;
+    }) | null) => void;
+    setFocus: (range: ChartRange | null) => void;
+}
+export interface ChartAnnotation {
+    id: string;
+    x: number | Date;
+    label: string;
+    description?: string;
+    color?: string;
+}
+export interface AnnotationsProps extends PrimitiveProps {
+    items: readonly ChartAnnotation[];
+    onSelectionChange?: (annotation: ChartAnnotation | null) => void;
+}
+export interface ReferenceBandProps extends PrimitiveProps {
+    /** Pass `-Infinity` or `Infinity` for an open end that runs to the plot's edge. */
+    from: number | Date;
+    to: number | Date;
+    label: string;
+    color?: string;
+}
+export interface ReferenceLineProps extends PrimitiveProps {
+    /** The y value, in the primary scale's unit. */
+    value: number;
+    /** Text at the line's right end, e.g. "Target $4,000". */
+    label?: string;
+    color?: string;
+}
+export interface ChangeComparisonProps<T> extends PrimitiveProps {
+    data: readonly T[];
+    label: string;
+    series?: string;
+}
+export interface ChartSelection<T> {
+    row: T;
+    sourceIndex: number;
+    x: number;
+    categoryId?: string;
+    pinned: boolean;
+}
+export {};

package/dist/use-chart-width.d.ts

@@ -0,0 +1,5 @@
+/** Measured width keeps SVG text at a readable CSS-pixel size in compact cards. */
+export declare function useChartWidth<T extends HTMLElement>(): {
+    ref: import('react').RefObject<T | null>;
+    width: number;
+};

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "@lilt-ui/charts",
+  "version": "0.1.0",
+  "description": "Beautiful, key-typed React chart cards with linked hover, targets, forecasts, and calm motion.",
+  "keywords": [
+    "react",
+    "charts",
+    "chart",
+    "dashboard",
+    "data-visualization",
+    "area-chart",
+    "bar-chart",
+    "line-chart",
+    "sparkline",
+    "typescript"
+  ],
+  "author": "Lilt UI",
+  "homepage": "https://liltui.vercel.app",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./data": {
+      "types": "./dist/data.d.ts",
+      "import": "./dist/data.js",
+      "default": "./dist/data.js"
+    },
+    "./styles.css": "./dist/styles.css",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "media",
+    "README.md",
+    "LICENSE",
+    "THIRD_PARTY_NOTICES.md"
+  ],
+  "sideEffects": [
+    "./dist/styles.css"
+  ],
+  "scripts": {
+    "build": "vite build",
+    "prepublishOnly": "pnpm build",
+    "typecheck": "tsc --noEmit && pnpm build && pnpm run typecheck:consumer",
+    "typecheck:consumer": "tsc --noEmit --strict --target ES2022 --module ESNext --moduleResolution Bundler --skipLibCheck consumer/typecheck.ts",
+    "lint": "eslint src",
+    "test": "pnpm build && vitest run",
+    "format:check": "prettier --check src vite.config.ts tsconfig.json"
+  },
+  "dependencies": {
+    "@number-flow/react": "^0.6.2",
+    "d3-array": "^3.2.4",
+    "d3-scale": "^4.0.2",
+    "d3-shape": "^3.2.0",
+    "motion": "^13.4.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0"
+  }
+}