semiotic 2.0.2 → 3.0.0-beta.1

package/dist/charts/xy/LineChart.d.ts

@@ -0,0 +1,193 @@
+import * as React from "react";
+import type { XYFrameProps } from "../../types/xyTypes";
+import type { BaseChartProps, AxisConfig, ChartAccessor } from "../shared/types";
+import { type TooltipProp } from "../../Tooltip/Tooltip";
+/**
+ * LineChart component props
+ */
+export interface LineChartProps<TDatum extends Record<string, any> = Record<string, any>> extends BaseChartProps, AxisConfig {
+    /**
+     * Array of data points or array of line objects with coordinates.
+     * @example
+     * ```ts
+     * // Simple format (single line)
+     * [{x: 1, y: 10}, {x: 2, y: 20}]
+     *
+     * // Multiple lines with grouping
+     * [{x: 1, y: 10, series: 'A'}, {x: 2, y: 20, series: 'A'}, {x: 1, y: 15, series: 'B'}]
+     *
+     * // Line objects format
+     * [{label: 'Series A', coordinates: [{x: 1, y: 10}, {x: 2, y: 20}]}]
+     * ```
+     */
+    data: TDatum[];
+    /**
+     * Field name or function to access x values
+     * @default "x"
+     */
+    xAccessor?: ChartAccessor<TDatum, number>;
+    /**
+     * Field name or function to access y values
+     * @default "y"
+     */
+    yAccessor?: ChartAccessor<TDatum, number>;
+    /**
+     * Field name or function to group data into multiple lines
+     * @example
+     * ```ts
+     * lineBy="series"  // Group by series field
+     * lineBy={d => d.category}  // Use function
+     * ```
+     */
+    lineBy?: ChartAccessor<TDatum, string>;
+    /**
+     * Field name in line objects that contains coordinate arrays
+     * Used when data is in line objects format
+     * @default "coordinates"
+     */
+    lineDataAccessor?: string;
+    /**
+     * Field name or function to determine line color
+     * @example
+     * ```ts
+     * colorBy="series"
+     * colorBy={d => d.label}
+     * ```
+     */
+    colorBy?: ChartAccessor<TDatum, string>;
+    /**
+     * Color scheme for categorical data or custom colors array
+     * @default "category10"
+     */
+    colorScheme?: string | string[];
+    /**
+     * Curve interpolation type
+     * @default "linear"
+     */
+    curve?: "linear" | "monotoneX" | "monotoneY" | "step" | "stepAfter" | "stepBefore" | "basis" | "cardinal" | "catmullRom";
+    /**
+     * Show points on the line
+     * @default false
+     */
+    showPoints?: boolean;
+    /**
+     * Point radius when showPoints is true
+     * @default 3
+     */
+    pointRadius?: number;
+    /**
+     * Fill area under the line
+     * @default false
+     */
+    fillArea?: boolean;
+    /**
+     * Area opacity when fillArea is true
+     * @default 0.3
+     */
+    areaOpacity?: number;
+    /**
+     * Line stroke width
+     * @default 2
+     */
+    lineWidth?: number;
+    /**
+     * Enable hover annotations
+     * @default true
+     */
+    enableHover?: boolean;
+    /**
+     * Show grid lines
+     * @default false
+     */
+    showGrid?: boolean;
+    /**
+     * Show legend for multiple lines
+     * @default true (when multiple lines)
+     */
+    showLegend?: boolean;
+    /**
+     * Tooltip configuration
+     */
+    tooltip?: TooltipProp;
+    /**
+     * Additional XYFrame props for advanced customization
+     * For full control, consider using XYFrame directly
+     * @see https://semiotic.nteract.io/guides/xy-frame
+     */
+    frameProps?: Partial<Omit<XYFrameProps, "lines" | "size">>;
+}
+/**
+ * LineChart - Visualize trends and time series data with lines
+ *
+ * A simplified wrapper around XYFrame for creating line charts. Perfect for
+ * showing trends, comparisons, and temporal patterns in your data.
+ *
+ * @example
+ * ```tsx
+ * // Simple line chart
+ * <LineChart
+ *   data={[
+ *     {x: 1, y: 10},
+ *     {x: 2, y: 20},
+ *     {x: 3, y: 15}
+ *   ]}
+ *   xLabel="Time"
+ *   yLabel="Value"
+ * />
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Multiple lines with grouping
+ * <LineChart
+ *   data={[
+ *     {x: 1, y: 10, series: 'A'},
+ *     {x: 2, y: 20, series: 'A'},
+ *     {x: 1, y: 15, series: 'B'},
+ *     {x: 2, y: 25, series: 'B'}
+ *   ]}
+ *   lineBy="series"
+ *   colorBy="series"
+ *   xLabel="Time"
+ *   yLabel="Value"
+ * />
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Area chart with custom curve
+ * <LineChart
+ *   data={data}
+ *   curve="monotoneX"
+ *   fillArea={true}
+ *   areaOpacity={0.3}
+ *   showPoints={true}
+ * />
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Advanced: Override XYFrame props
+ * <LineChart
+ *   data={data}
+ *   frameProps={{
+ *     lineType: { type: "line", interpolator: d3.curveCardinal },
+ *     customLineMark: ({ d }) => <path stroke="red" />
+ *   }}
+ * />
+ * ```
+ *
+ * @remarks
+ * This component wraps {@link XYFrame} with sensible defaults for line charts.
+ * For more advanced features like custom marks, annotations, or complex interactions,
+ * use XYFrame directly.
+ *
+ * **Breadcrumb to advanced usage:**
+ * - Use the `frameProps` prop to pass any XYFrame prop
+ * - See XYFrame documentation: https://semiotic.nteract.io/guides/xy-frame
+ * - All XYFrame props are available via `frameProps`
+ *
+ * @param props - LineChart configuration
+ * @returns Rendered line chart
+ */
+export declare function LineChart<TDatum extends Record<string, any> = Record<string, any>>(props: LineChartProps<TDatum>): React.JSX.Element;

package/dist/charts/xy/Scatterplot.d.ts

@@ -0,0 +1,50 @@
+import * as React from "react";
+import type { XYFrameProps } from "../../types/xyTypes";
+import type { BaseChartProps, AxisConfig, ChartAccessor } from "../shared/types";
+import { type TooltipProp } from "../../Tooltip/Tooltip";
+/**
+ * Scatterplot component props
+ */
+export interface ScatterplotProps<TDatum extends Record<string, any> = Record<string, any>> extends BaseChartProps, AxisConfig {
+    /** Array of data points. Each point should have x and y properties. */
+    data: TDatum[];
+    /** Field name or function to access x values @default "x" */
+    xAccessor?: ChartAccessor<TDatum, number>;
+    /** Field name or function to access y values @default "y" */
+    yAccessor?: ChartAccessor<TDatum, number>;
+    /** Field name or function to determine point color */
+    colorBy?: ChartAccessor<TDatum, string>;
+    /** Color scheme for categorical data or custom colors array @default "category10" */
+    colorScheme?: string | string[];
+    /** Field name or function to determine point size */
+    sizeBy?: ChartAccessor<TDatum, number>;
+    /** Min and max radius for points @default [3, 15] */
+    sizeRange?: [number, number];
+    /** Default point radius when sizeBy is not specified @default 5 */
+    pointRadius?: number;
+    /** Point opacity @default 0.8 */
+    pointOpacity?: number;
+    /** Enable hover annotations @default true */
+    enableHover?: boolean;
+    /** Show grid lines @default false */
+    showGrid?: boolean;
+    /** Show legend @default true (when colorBy is specified) */
+    showLegend?: boolean;
+    /** Tooltip configuration */
+    tooltip?: TooltipProp;
+    /** Additional XYFrame props for advanced customization */
+    frameProps?: Partial<Omit<XYFrameProps, "points" | "size">>;
+}
+/**
+ * Scatterplot - Visualize relationships between two continuous variables
+ *
+ * @example
+ * ```tsx
+ * <Scatterplot
+ *   data={[{x: 1, y: 10}, {x: 2, y: 20}]}
+ *   xLabel="Time"
+ *   yLabel="Value"
+ * />
+ * ```
+ */
+export declare function Scatterplot<TDatum extends Record<string, any> = Record<string, any>>(props: ScatterplotProps<TDatum>): React.JSX.Element;

package/dist/charts/xy/StackedAreaChart.d.ts

@@ -0,0 +1,131 @@
+import * as React from "react";
+import type { XYFrameProps } from "../../types/xyTypes";
+import type { BaseChartProps, AxisConfig, ChartAccessor } from "../shared/types";
+import { type TooltipProp } from "../../Tooltip/Tooltip";
+/**
+ * StackedAreaChart component props
+ */
+export interface StackedAreaChartProps<TDatum extends Record<string, any> = Record<string, any>> extends BaseChartProps, AxisConfig {
+    /**
+     * Array of data points, grouped by category.
+     * @example
+     * ```ts
+     * [{x: 1, y: 10, category: 'A'}, {x: 2, y: 20, category: 'A'}, {x: 1, y: 15, category: 'B'}]
+     * ```
+     */
+    data: TDatum[];
+    /**
+     * Field name or function to access x values
+     * @default "x"
+     */
+    xAccessor?: ChartAccessor<TDatum, number>;
+    /**
+     * Field name or function to access y values
+     * @default "y"
+     */
+    yAccessor?: ChartAccessor<TDatum, number>;
+    /**
+     * Field name or function to group data into multiple areas
+     * @example
+     * ```ts
+     * areaBy="category"  // Group by category field
+     * areaBy={d => d.group}  // Use function
+     * ```
+     */
+    areaBy?: ChartAccessor<TDatum, string>;
+    /**
+     * Field name in area objects that contains coordinate arrays
+     * Used when data is in area objects format
+     * @default "coordinates"
+     */
+    lineDataAccessor?: string;
+    /**
+     * Field name or function to determine area color
+     * @example
+     * ```ts
+     * colorBy="category"
+     * colorBy={d => d.label}
+     * ```
+     */
+    colorBy?: ChartAccessor<TDatum, string>;
+    /**
+     * Color scheme for categorical data or custom colors array
+     * @default "category10"
+     */
+    colorScheme?: string | string[];
+    /**
+     * Curve interpolation type
+     * @default "monotoneX"
+     */
+    curve?: "linear" | "monotoneX" | "monotoneY" | "step" | "stepAfter" | "stepBefore" | "basis" | "cardinal" | "catmullRom";
+    /**
+     * Area opacity
+     * @default 0.7
+     */
+    areaOpacity?: number;
+    /**
+     * Show line on top of area
+     * @default true
+     */
+    showLine?: boolean;
+    /**
+     * Line stroke width when showLine is true
+     * @default 2
+     */
+    lineWidth?: number;
+    /**
+     * Normalize to 100% stacked (proportional)
+     * @default false
+     */
+    normalize?: boolean;
+    /**
+     * Enable hover annotations
+     * @default true
+     */
+    enableHover?: boolean;
+    /**
+     * Show grid lines
+     * @default false
+     */
+    showGrid?: boolean;
+    /**
+     * Show legend for multiple areas
+     * @default true (when multiple areas)
+     */
+    showLegend?: boolean;
+    /**
+     * Tooltip configuration
+     */
+    tooltip?: TooltipProp;
+    /**
+     * Additional XYFrame props for advanced customization
+     * For full control, consider using XYFrame directly
+     * @see https://semiotic.nteract.io/guides/xy-frame
+     */
+    frameProps?: Partial<Omit<XYFrameProps, "lines" | "size">>;
+}
+/**
+ * StackedAreaChart - Visualize quantities stacked on top of each other over continuous intervals
+ *
+ * Each series is stacked so that the total height represents the sum of all series.
+ * Use `normalize` for 100% stacked (proportional) areas.
+ *
+ * For overlapping (non-stacked) areas use {@link AreaChart}.
+ *
+ * @example
+ * ```tsx
+ * <StackedAreaChart
+ *   data={[
+ *     {x: 1, y: 10, category: 'A'},
+ *     {x: 2, y: 20, category: 'A'},
+ *     {x: 1, y: 15, category: 'B'},
+ *     {x: 2, y: 25, category: 'B'}
+ *   ]}
+ *   areaBy="category"
+ *   colorBy="category"
+ *   xLabel="Time"
+ *   yLabel="Value"
+ * />
+ * ```
+ */
+export declare function StackedAreaChart<TDatum extends Record<string, any> = Record<string, any>>(props: StackedAreaChartProps<TDatum>): React.JSX.Element;

package/dist/constants/coordinateNames.d.ts

@@ -0,0 +1,8 @@
+export declare const projectedX = "x";
+export declare const projectedY = "y";
+export declare const projectedYMiddle = "yMiddle";
+export declare const projectedYTop = "yTop";
+export declare const projectedYBottom = "yBottom";
+export declare const projectedXMiddle = "xMiddle";
+export declare const projectedXTop = "xTop";
+export declare const projectedXBottom = "xBottom";

package/dist/constants/frame_props.d.ts

@@ -0,0 +1,13 @@
+export declare const xyFrameDataProps: string[];
+export declare const xyFrameDataAffectingProps: string[];
+export declare const xyFrameScaleAffectingProps: string[];
+export declare const xyFrameStylingProps: string[];
+export declare const xyFrameChangeProps: string[];
+export declare const orFrameDataAffectingProps: string[];
+export declare const orFrameScaleAffectingProps: string[];
+export declare const orFrameStylingProps: string[];
+export declare const orFrameChangeProps: string[];
+export declare const networkFrameDataAffectingProps: string[];
+export declare const networkFrameScaleAffectingProps: string[];
+export declare const networkFrameStylingProps: string[];
+export declare const networkFrameChangeProps: string[];

package/dist/constants/jsx.d.ts

@@ -0,0 +1,19 @@
+import * as React from "react";
+type FilterDefTypes = {
+    matte?: React.ReactNode;
+    key: string;
+    additionalDefs?: React.ReactNode;
+};
+export declare const filterDefs: ({ matte, key, additionalDefs }: FilterDefTypes) => React.JSX.Element;
+export declare const generateFinalDefs: ({ matte, size, margin, frameKey, additionalDefs, name }: {
+    matte: any;
+    size: any;
+    margin: any;
+    frameKey: any;
+    additionalDefs: any;
+    name: any;
+}) => {
+    defs: React.JSX.Element;
+    matte: any;
+};
+export {};

package/dist/data/dataFunctions.d.ts

@@ -0,0 +1,45 @@
+import { ProjectedPoint, ProjectedLine, ProjectedSummary, ProjectedBin, RawSummary, RawPoint, RawLine, LineTypeSettings, SummaryTypeSettings, ExtentType, MarginType } from "../types/generalTypes";
+type validStrFnTypes = boolean | string | number | Record<string, any> | Record<string, any>[] | RawPoint | RawPoint[];
+export declare function stringToFn<StrFnType extends validStrFnTypes>(accessor?: ((args?: Record<string, any>, index?: number) => StrFnType) | string | StrFnType, defaultAccessor?: (arg?: Record<string, any>, i?: number) => StrFnType, raw?: boolean): (d?: Record<string, any>, i?: number) => StrFnType;
+export declare function stringToArrayFn<StrFnType extends validStrFnTypes>(accessor?: ((arg?: Record<string, any>, index?: number) => StrFnType) | string | StrFnType | Array<((arg?: Record<string, any>, index?: number) => StrFnType) | string | StrFnType>, defaultAccessor?: (arg?: Record<string, any>, index?: number) => StrFnType, raw?: boolean): Array<(arg?: Record<string, any>, index?: number) => StrFnType>;
+type CalculateDataTypes = {
+    lineDataAccessor: Array<Function>;
+    summaryDataAccessor: Array<Function>;
+    summaryStyleFn: Function;
+    summaryClassFn: Function;
+    summaryRenderModeFn: Function;
+    xAccessor: Array<Function>;
+    yAccessor: Array<Function>;
+    summaries?: Array<RawSummary>;
+    points?: Array<RawPoint>;
+    lines?: Array<RawLine>;
+    lineType: LineTypeSettings;
+    showLinePoints?: boolean | string;
+    showSummaryPoints?: boolean;
+    xExtent?: ExtentType;
+    yExtent?: ExtentType;
+    invertX?: boolean;
+    invertY?: boolean;
+    summaryType: SummaryTypeSettings;
+    adjustedSize: Array<number>;
+    chartSize: Array<number>;
+    xScaleType: Function;
+    yScaleType: Function;
+    margin: MarginType;
+    defined?: Function;
+    annotations: object[];
+    filterRenderedLines: (value: ProjectedLine, index: number, array: ProjectedLine[]) => any;
+    filterRenderedSummaries: (value: ProjectedSummary, index: number, array: ProjectedSummary[]) => any;
+    filterRenderedPoints: (value: ProjectedPoint | ProjectedBin | ProjectedSummary, index: number, array: (ProjectedPoint | ProjectedBin | ProjectedSummary)[]) => any;
+};
+export declare const calculateDataExtent: ({ lineDataAccessor, xAccessor, yAccessor, summaries, points, lines, lineType, showLinePoints, showSummaryPoints, xExtent, yExtent, invertX, invertY, summaryDataAccessor, summaryType, adjustedSize: size, margin, summaryStyleFn, summaryClassFn, summaryRenderModeFn, chartSize, filterRenderedLines, filterRenderedSummaries, filterRenderedPoints, defined, annotations }: CalculateDataTypes) => {
+    xExtent: number[];
+    yExtent: number[];
+    projectedLines: ProjectedLine[];
+    projectedPoints: ProjectedPoint[];
+    projectedSummaries: ProjectedSummary[];
+    fullDataset: (ProjectedPoint | ProjectedBin | ProjectedSummary)[];
+    calculatedXExtent: number[];
+    calculatedYExtent: number[];
+};
+export {};

package/dist/data/multiAccessorUtils.d.ts

@@ -0,0 +1 @@
+export declare const findFirstAccessorValue: (accessorArray: any, data: any) => any;

package/dist/data/networkPipelineCache.d.ts

@@ -0,0 +1,27 @@
+export declare function createNetworkPipelineCache(): {
+    marginCalc: (margin: any, title: any, size: number[]) => {
+        margin: import("../semiotic-network").MarginType;
+        adjustedPosition: number[];
+        adjustedSize: number[];
+    };
+    accessorConversions: (nodeIDAccessor: any, sourceAccessor: any, targetAccessor: any, nodeSizeAccessor: any, edgeWidthAccessor: any) => {
+        nodeIDAccessor: (d?: Record<string, any>, i?: number) => string;
+        sourceAccessor: (d?: Record<string, any>, i?: number) => string | Record<string, any>;
+        targetAccessor: (d?: Record<string, any>, i?: number) => string | Record<string, any>;
+        nodeSizeAccessor: (() => any) | ((d?: Record<string, any>, i?: number) => number);
+        edgeWidthAccessor: (d?: Record<string, any>, i?: number) => number;
+    };
+    nodeStyleFns: (nodeStyle: any, nodeClass: any, nodeRenderMode: any, canvasNodes: any) => {
+        nodeStyleFn: (d?: Record<string, any>, i?: number) => Record<string, any>;
+        nodeClassFn: (d?: Record<string, any>, i?: number) => string;
+        nodeRenderModeFn: (d?: Record<string, any>, i?: number) => string | Record<string, any>;
+        nodeCanvasRenderFn: (d?: Record<string, any>, i?: number) => boolean;
+    };
+    edgeStyleFns: (edgeStyle: any, edgeClass: any, edgeRenderMode: any, canvasEdges: any) => {
+        edgeStyleFn: (d?: Record<string, any>, i?: number) => Record<string, any>;
+        edgeClassFn: (d?: Record<string, any>, i?: number) => string;
+        edgeRenderModeFn: (d?: Record<string, any>, i?: number) => string | Record<string, any>;
+        edgeCanvasRenderFn: (d?: Record<string, any>, i?: number) => boolean;
+    };
+};
+export type NetworkPipelineCache = ReturnType<typeof createNetworkPipelineCache>;

package/dist/data/ordinalPipelineCache.d.ts

@@ -0,0 +1,33 @@
+import { ProjectionTypes } from "../types/generalTypes";
+export declare function createOrdinalPipelineCache(): {
+    marginCalc: (margin: any, axes: any, title: any, oLabel: any, projection: ProjectionTypes, size: number[]) => {
+        margin: import("../types/generalTypes").MarginType;
+        adjustedPosition: number[];
+        adjustedSize: number[];
+    };
+    structureData: (data: any[], renderKey: any, oAccessor: Function[], rAccessor: Array<(d: number | object, i?: number) => number>, originalRAccessor: any[], originalOAccessor: any[], multiAxis: boolean) => {
+        allData: Array<object>;
+        multiExtents?: Array<Array<number>>;
+    };
+    accessorConversions: (baseOAccessor: any, baseRAccessor: any, baseRenderKey: any, basePieceIDAccessor: any) => {
+        oAccessor: ((arg?: Record<string, any>, index?: number) => string | number)[];
+        rAccessor: ((arg?: Record<string, any>, index?: number) => number)[];
+        renderKey: (d?: Record<string, any>, i?: number) => string | number;
+        pieceIDAccessor: (d?: Record<string, any>, i?: number) => string;
+    };
+    styleFns: (baseConnectorStyle: any, baseSummaryStyle: any, baseStyle: any, basePieceClass: any, baseSummaryClass: any, baseConnectorClass: any, baseRenderMode: any, baseSummaryRenderMode: any, baseConnectorRenderMode: any, canvasPieces: any, canvasSummaries: any, canvasConnectors: any) => {
+        connectorStyle: (d?: Record<string, any>, i?: number) => Record<string, any>;
+        summaryStyle: (d?: Record<string, any>, i?: number) => Record<string, any>;
+        pieceStyle: (d?: Record<string, any>, i?: number) => Record<string, any>;
+        pieceClass: (d?: Record<string, any>, i?: number) => string;
+        summaryClass: (d?: Record<string, any>, i?: number) => string;
+        connectorClass: (d?: Record<string, any>, i?: number) => string;
+        pieceRenderMode: (d?: Record<string, any>, i?: number) => string | Record<string, any>;
+        summaryRenderMode: (d?: Record<string, any>, i?: number) => string | Record<string, any>;
+        connectorRenderMode: (d?: Record<string, any>, i?: number) => string | Record<string, any>;
+        pieceCanvasRender: (d?: Record<string, any>, i?: number) => boolean;
+        summaryCanvasRender: (d?: Record<string, any>, i?: number) => boolean;
+        connectorCanvasRender: (d?: Record<string, any>, i?: number) => boolean;
+    };
+};
+export type OrdinalPipelineCache = ReturnType<typeof createOrdinalPipelineCache>;

package/dist/data/unflowedFunctions.d.ts

@@ -0,0 +1 @@
+export declare const extentValue: (extent: any) => any;

package/dist/data/xyPipelineCache.d.ts

@@ -0,0 +1,35 @@
+import { RawPoint } from "../types/generalTypes";
+export declare function createXYPipelineCache(): {
+    annotatedSettings: (xAccessor: any, yAccessor: any, summaryDataAccessor: any, lineDataAccessor: any, renderKey: any, lineType: any, summaryType: any, lineIDAccessor: any) => {
+        xAccessor: ((arg?: Record<string, any>, index?: number) => number)[];
+        yAccessor: ((arg?: Record<string, any>, index?: number) => number)[];
+        summaryDataAccessor: ((arg?: Record<string, any>, index?: number) => RawPoint<Record<string, any>>[])[];
+        lineDataAccessor: ((arg?: Record<string, any>, index?: number) => RawPoint<Record<string, any>>[])[];
+        renderKeyFn: (d?: Record<string, any>, i?: number) => string;
+        lineIDAccessor: (d?: Record<string, any>, i?: number) => string;
+    };
+    marginCalc: (margin: any, axes: any, title: any, size: number[]) => {
+        margin: import("../types/generalTypes").MarginType;
+        adjustedPosition: number[];
+        adjustedSize: number[];
+    };
+    summaryStyleFns: (summaryStyle: any, summaryClass: any, summaryRenderMode: any) => {
+        summaryStyleFn: (d?: Record<string, any>, i?: number) => Record<string, any>;
+        summaryClassFn: (d?: Record<string, any>, i?: number) => string;
+        summaryRenderModeFn: (d?: Record<string, any>, i?: number) => string | Record<string, any>;
+    };
+    lineStyleFns: (lineStyle: any, lineClass: any, lineRenderMode: any, canvasLines: any) => {
+        styleFn: (d?: Record<string, any>, i?: number) => Record<string, any>;
+        classFn: (d?: Record<string, any>, i?: number) => string;
+        renderMode: (d?: Record<string, any>, i?: number) => string | Record<string, any>;
+        canvasRender: (d?: Record<string, any>, i?: number) => boolean;
+    };
+    pointStyleFns: (pointStyle: any, pointClass: any, pointRenderMode: any, canvasPoints: any) => {
+        styleFn: (d?: Record<string, any>, i?: number) => Record<string, any>;
+        classFn: (d?: Record<string, any>, i?: number) => string;
+        renderMode: (d?: Record<string, any>, i?: number) => string | Record<string, any>;
+        canvasRender: (d?: Record<string, any>, i?: number) => boolean;
+    };
+    summaryCanvasRender: (canvasSummaries: any) => (d?: Record<string, any>, i?: number) => boolean;
+};
+export type XYPipelineCache = ReturnType<typeof createXYPipelineCache>;

package/dist/generic_utilities/functions.d.ts

@@ -0,0 +1 @@
+export declare const genericFunction: (value: any) => () => any;