katucharts.js 0.2.1

package/dist/series/financial/BaselineChart.d.ts

@@ -0,0 +1,20 @@
+import { BaseSeries } from '../BaseSeries';
+import type { InternalSeriesConfig } from '../../types/options';
+export declare class BaselineChart extends BaseSeries {
+    constructor(config: InternalSeriesConfig);
+    render(): void;
+    /**
+     * Renders an area + line pair clipped to one side of the threshold.
+     */
+    private renderZone;
+    /**
+     * Stroke-dasharray draw-in animation from left to right.
+     */
+    private animateDrawIn;
+    getDataExtents(): {
+        xMin: number;
+        xMax: number;
+        yMin: number;
+        yMax: number;
+    };
+}

package/dist/series/financial/CandlestickChart.d.ts

@@ -0,0 +1,55 @@
+import 'd3-transition';
+import { BaseSeries } from '../BaseSeries';
+import type { InternalSeriesConfig } from '../../types/options';
+export interface CandleStyleContext {
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+    isUp: boolean;
+    index: number;
+    data: any[];
+    upColor: string;
+    downColor: string;
+    upLineColor: string;
+    downLineColor: string;
+}
+export declare class CandlestickChart extends BaseSeries {
+    private selectedIndices;
+    constructor(config: InternalSeriesConfig);
+    /**
+     * Per-candle body fill, border stroke and wick color. Standard candlesticks
+     * fill solid by direction; subclasses (hollow) override this hook to change
+     * the coloring rule without duplicating the render loop.
+     */
+    protected getCandleStyle(ctx: CandleStyleContext): {
+        fill: string;
+        stroke: string;
+        wick: string;
+    };
+    /** CSS class for each candle group; overridden by subclasses to add a marker class. */
+    protected getCandleClass(): string;
+    render(): void;
+    private renderCandlestickLabels;
+    /**
+     * Groups OHLC data when dataGrouping is enabled, aggregating open/high/low/close
+     * within each group interval using the standard OHLC approximation.
+     */
+    private applyDataGrouping;
+    getDataExtents(): {
+        xMin: number;
+        xMax: number;
+        yMin: number;
+        yMax: number;
+    };
+}
+export declare class OHLCChart extends BaseSeries {
+    constructor(config: InternalSeriesConfig);
+    render(): void;
+    getDataExtents(): {
+        xMin: number;
+        xMax: number;
+        yMin: number;
+        yMax: number;
+    };
+}

package/dist/series/financial/ColumnRangeChart.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Column range series: a vertical bar spanning from a low to a high value at
+ * each x (e.g. daily temperature min/max).
+ */
+import { BaseSeries } from '../BaseSeries';
+import type { InternalSeriesConfig } from '../../types/options';
+export declare class ColumnRangeChart extends BaseSeries {
+    constructor(config: InternalSeriesConfig);
+    render(): void;
+    getDataExtents(): {
+        xMin: number;
+        xMax: number;
+        yMin: number;
+        yMax: number;
+    };
+}

package/dist/series/financial/FlagsChart.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Event marker/flag series for annotating price charts.
+ * Renders flags at specific x positions with configurable shapes
+ * (flag, circlepin, squarepin) that can optionally attach to another series.
+ */
+import { BaseSeries } from '../BaseSeries';
+import type { InternalSeriesConfig } from '../../types/options';
+export declare class FlagsChart extends BaseSeries {
+    constructor(config: InternalSeriesConfig);
+    render(): void;
+    /**
+     * Flags are decorative markers and should not influence the y-axis range.
+     * Only x extents are contributed.
+     */
+    getDataExtents(): {
+        xMin: number;
+        xMax: number;
+        yMin: number;
+        yMax: number;
+    };
+    /**
+     * Find the series referenced by the onSeries config option.
+     * When found, flags will attach at the y-value of that series at each flag's x position.
+     */
+    private resolveOnSeries;
+    /**
+     * Determine the vertical anchor point for a flag. If onSeries is set,
+     * interpolate the target series y-value at the flag's x position.
+     * Otherwise anchor at the top of the plot area.
+     */
+    private resolveAnchorY;
+    private renderShape;
+    private attachFlagEvents;
+}

package/dist/series/financial/HeikinAshiChart.d.ts

@@ -0,0 +1,11 @@
+import { CandlestickChart } from './CandlestickChart';
+import type { InternalSeriesConfig } from '../../types/options';
+export declare class HeikinAshiChart extends CandlestickChart {
+    constructor(config: InternalSeriesConfig);
+    /**
+     * Transforms raw OHLC data into Heikin-Ashi candles before rendering.
+     * HA values smooth out price action by averaging open/close and
+     * adjusting high/low to the HA range.
+     */
+    processData(): void;
+}

package/dist/series/financial/HollowCandlestickChart.d.ts

@@ -0,0 +1,17 @@
+import { CandlestickChart, type CandleStyleContext } from './CandlestickChart';
+/**
+ * Hollow candlesticks: fill and stroke are driven by the trend direction
+ * (close vs the previous candle's close) rather than the intra-candle
+ * open/close relationship. Bullish (up-trend) candles are hollow.
+ *
+ * Reuses CandlestickChart's render pipeline entirely, overriding only the
+ * per-candle coloring rule.
+ */
+export declare class HollowCandlestickChart extends CandlestickChart {
+    protected getCandleStyle(ctx: CandleStyleContext): {
+        fill: string;
+        stroke: string;
+        wick: string;
+    };
+    protected getCandleClass(): string;
+}

package/dist/series/financial/KagiChart.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Kagi chart series. Direction-change line chart that shows supply/demand
+ * through thick (yang) and thin (yin) lines based on shoulder/waist breakouts.
+ */
+import { BaseSeries } from '../BaseSeries';
+import type { InternalSeriesConfig } from '../../types/options';
+export declare class KagiChart extends BaseSeries {
+    private segments;
+    constructor(config: InternalSeriesConfig);
+    /**
+     * Convert close prices into Kagi segments. Direction reverses when price
+     * moves against current trend by reversalAmount. Lines thicken (yang) when
+     * price exceeds a previous shoulder, thin (yin) when breaking a waist.
+     */
+    processData(): void;
+    render(): void;
+    getDataExtents(): {
+        xMin: number;
+        xMax: number;
+        yMin: number;
+        yMax: number;
+    };
+}

package/dist/series/financial/LineBreakChart.d.ts

@@ -0,0 +1,23 @@
+/**
+ * N-Line Break chart series. Draws blocks only when the close price
+ * exceeds the high or low of the previous N blocks, filtering noise.
+ */
+import { BaseSeries } from '../BaseSeries';
+import type { InternalSeriesConfig } from '../../types/options';
+export declare class LineBreakChart extends BaseSeries {
+    private blocks;
+    constructor(config: InternalSeriesConfig);
+    /**
+     * Implement N-line break logic: a new block is drawn only when the close
+     * exceeds the high of the last N up-blocks or breaks the low of the last
+     * N down-blocks. Otherwise the price point is ignored.
+     */
+    processData(): void;
+    render(): void;
+    getDataExtents(): {
+        xMin: number;
+        xMax: number;
+        yMin: number;
+        yMax: number;
+    };
+}

package/dist/series/financial/PointAndFigureChart.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Point & Figure chart series. Renders columns of X's (rising prices)
+ * and O's (falling prices) based on box-size quantized price movements.
+ */
+import { BaseSeries } from '../BaseSeries';
+import type { InternalSeriesConfig } from '../../types/options';
+export declare class PointAndFigureChart extends BaseSeries {
+    private columns;
+    constructor(config: InternalSeriesConfig);
+    /**
+     * Convert close prices into Point & Figure columns. Each column contains
+     * boxes quantized to boxSize. A new column starts when price reverses
+     * by at least reversalAmount boxes.
+     */
+    processData(): void;
+    render(): void;
+    private getTotalBoxCount;
+    getDataExtents(): {
+        xMin: number;
+        xMax: number;
+        yMin: number;
+        yMax: number;
+    };
+}

package/dist/series/financial/RenkoChart.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Renko brick chart series. Price-only chart that filters out time,
+ * drawing uniform bricks only when price moves by a fixed amount.
+ */
+import { BaseSeries } from '../BaseSeries';
+import type { InternalSeriesConfig } from '../../types/options';
+export declare class RenkoChart extends BaseSeries {
+    private bricks;
+    constructor(config: InternalSeriesConfig);
+    /**
+     * Convert raw close prices into Renko bricks. A new brick is created
+     * each time the close price moves brickSize away from the last brick's edge.
+     */
+    processData(): void;
+    render(): void;
+    getDataExtents(): {
+        xMin: number;
+        xMax: number;
+        yMin: number;
+        yMax: number;
+    };
+}

package/dist/series/financial/VBPChart.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Volume-by-Price renderer: horizontal bars anchored to the left edge of the
+ * plot, one per price bin, with width proportional to the volume traded in that
+ * band. Overlays the price chart on the shared price (y) axis and does not
+ * affect axis extents.
+ */
+import { BaseSeries } from '../BaseSeries';
+import type { InternalSeriesConfig } from '../../types/options';
+export declare class VBPChart extends BaseSeries {
+    constructor(config: InternalSeriesConfig);
+    render(): void;
+    getDataExtents(): {
+        xMin: number;
+        xMax: number;
+        yMin: number;
+        yMax: number;
+    };
+}

package/dist/series/financial/VolumeChart.d.ts

@@ -0,0 +1,15 @@
+import { BaseSeries } from '../BaseSeries';
+import type { InternalSeriesConfig } from '../../types/options';
+export declare class VolumeChart extends BaseSeries {
+    constructor(config: InternalSeriesConfig);
+    render(): void;
+    /**
+     * Volume always starts from zero on the y-axis.
+     */
+    getDataExtents(): {
+        xMin: number;
+        xMax: number;
+        yMin: number;
+        yMax: number;
+    };
+}

package/dist/series/flow/DependencyWheelChart.d.ts

@@ -0,0 +1,23 @@
+import 'd3-transition';
+import { BaseSeries } from '../BaseSeries';
+import type { InternalSeriesConfig } from '../../types/options';
+export declare class DependencyWheelChart extends BaseSeries {
+    constructor(config: InternalSeriesConfig);
+    render(): void;
+    /**
+     * Vertically distribute leader-line labels on one side of the wheel so they never overlap,
+     * dropping the lowest-ranked labels when the side runs out of room. Mirrors PieChart.distribute.
+     */
+    private distributeChordLabels;
+    private distributeBoxes;
+    private resolvePercent;
+    private normalizeChordWidths;
+    private sortChordEndpoints;
+    private buildMatrix;
+    getDataExtents(): {
+        xMin: number;
+        xMax: number;
+        yMin: number;
+        yMax: number;
+    };
+}

package/dist/series/flow/NetworkGraphChart.d.ts

@@ -0,0 +1,18 @@
+import 'd3-transition';
+import { BaseSeries } from '../BaseSeries';
+import type { InternalSeriesConfig } from '../../types/options';
+export declare class NetworkGraphChart extends BaseSeries {
+    private simulation;
+    constructor(config: InternalSeriesConfig);
+    render(): void;
+    private updatePositions;
+    private getDashArray;
+    private buildGraph;
+    getDataExtents(): {
+        xMin: number;
+        xMax: number;
+        yMin: number;
+        yMax: number;
+    };
+    destroy(): void;
+}

package/dist/series/flow/SankeyChart.d.ts

@@ -0,0 +1,24 @@
+import 'd3-transition';
+import { BaseSeries } from '../BaseSeries';
+import type { InternalSeriesConfig } from '../../types/options';
+export declare class SankeyChart extends BaseSeries {
+    private getBaseFlowDuration;
+    constructor(config: InternalSeriesConfig);
+    render(): void;
+    private applyExplicitColumnLayout;
+    /**
+     * Re-stack each column top-to-bottom by descending value while preserving
+     * d3-sankey's x-positions and per-node heights. Used when columns are
+     * inferred (no explicit `column` field) — gives a consistent value
+     * hierarchy so the most-important labels survive the overlap-hiding pass.
+     */
+    private reorderNodesByValueDesc;
+    private centerAndSpreadNodes;
+    private buildGraph;
+    getDataExtents(): {
+        xMin: number;
+        xMax: number;
+        yMin: number;
+        yMax: number;
+    };
+}

package/dist/series/gauge/GaugeChart.d.ts

@@ -0,0 +1,40 @@
+import 'd3-transition';
+import { BaseSeries } from '../BaseSeries';
+import type { InternalSeriesConfig } from '../../types/options';
+export declare class GaugeChart extends BaseSeries {
+    constructor(config: InternalSeriesConfig);
+    render(): void;
+    private buildNeedlePath;
+    private renderPaneBackground;
+    private renderPlotBands;
+    private renderTickMarks;
+    private generateTicks;
+    private renderValueLabel;
+    private resolvePercent;
+    getDataExtents(): {
+        xMin: number;
+        xMax: number;
+        yMin: number;
+        yMax: number;
+    };
+}
+export declare class SolidGaugeChart extends BaseSeries {
+    constructor(config: InternalSeriesConfig);
+    render(): void;
+    private renderSingleArc;
+    private resolveArcColor;
+    private getStopColor;
+    private resolveRadiusValue;
+    private renderPaneBackground;
+    private renderPlotBands;
+    private renderTickMarks;
+    private generateTicks;
+    private renderValueLabel;
+    private resolvePercent;
+    getDataExtents(): {
+        xMin: number;
+        xMax: number;
+        yMin: number;
+        yMax: number;
+    };
+}

package/dist/series/heatmap/HeatmapChart.d.ts

@@ -0,0 +1,18 @@
+import 'd3-transition';
+import { BaseSeries } from '../BaseSeries';
+import type { InternalSeriesConfig } from '../../types/options';
+export declare class HeatmapChart extends BaseSeries {
+    constructor(config: InternalSeriesConfig);
+    render(): void;
+    private renderInterpolated;
+    private buildColorScale;
+    private renderColorAxis;
+    private renderHeatmapLabels;
+    private getUniqueValues;
+    getDataExtents(): {
+        xMin: number;
+        xMax: number;
+        yMin: number;
+        yMax: number;
+    };
+}

package/dist/series/hierarchical/SunburstChart.d.ts

@@ -0,0 +1,44 @@
+import 'd3-transition';
+import { BaseSeries } from '../BaseSeries';
+import type { InternalSeriesConfig } from '../../types/options';
+export declare class SunburstChart extends BaseSeries {
+    private currentRoot;
+    constructor(config: InternalSeriesConfig);
+    render(): void;
+    private isAncestorOf;
+    /**
+     * Builds hierarchy from either nested children format or flat id/parent format.
+     */
+    private buildHierarchy;
+    private prepareNestedData;
+    private getMaxDepth;
+    /**
+     * Computes ring widths based on levels config (weight/percentage/pixels).
+     */
+    private computeRingWidths;
+    /**
+     * Applies custom radii (_y0, _y1) to each node based on computed ring widths.
+     * When levelIsConstant is true, levels keep their size regardless of traversal depth.
+     */
+    private applyCustomRadii;
+    /**
+     * Assigns colors following this pattern:
+     * - Root: transparent
+     * - Level with colorByPoint: each node gets a unique palette color
+     * - Deeper levels: inherit parent color with brightness variation across siblings
+     */
+    private assignColors;
+    private renderLabels;
+    /**
+     * Renders breadcrumb trail showing path from root to current traversed node.
+     */
+    private renderBreadcrumbs;
+    private resolvePercent;
+    private resolveBorderRadius;
+    getDataExtents(): {
+        xMin: number;
+        xMax: number;
+        yMin: number;
+        yMax: number;
+    };
+}

package/dist/series/hierarchical/TreegraphChart.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Tidy-tree layout for hierarchical node/edge data. Accepts either parent/id
+ * rows or nested children; emits circles for nodes and
+ * smooth paths for edges.
+ */
+import 'd3-transition';
+import { BaseSeries } from '../BaseSeries';
+import type { InternalSeriesConfig } from '../../types/options';
+export declare class TreegraphChart extends BaseSeries {
+    constructor(config: InternalSeriesConfig);
+    render(): void;
+    private buildRoot;
+    getDataExtents(): {
+        xMin: number;
+        xMax: number;
+        yMin: number;
+        yMax: number;
+    };
+}

package/dist/series/hierarchical/TreemapChart.d.ts

@@ -0,0 +1,20 @@
+import 'd3-transition';
+import { BaseSeries } from '../BaseSeries';
+import type { InternalSeriesConfig } from '../../types/options';
+export declare class TreemapChart extends BaseSeries {
+    private currentRoot;
+    constructor(config: InternalSeriesConfig);
+    render(): void;
+    private buildHierarchy;
+    /**
+     * Renders breadcrumb navigation trail showing the path from root to current node.
+     */
+    private renderBreadcrumbs;
+    private renderLabels;
+    getDataExtents(): {
+        xMin: number;
+        xMax: number;
+        yMin: number;
+        yMax: number;
+    };
+}

package/dist/series/hierarchical/WordcloudChart.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Wordcloud with Archimedean-spiral placement. Each word is scaled by weight
+ * into a font-size range and placed without overlapping any previously-placed
+ * word. Rotation angles cycle from a configurable list.
+ */
+import { BaseSeries } from '../BaseSeries';
+import type { InternalSeriesConfig } from '../../types/options';
+export declare class WordcloudChart extends BaseSeries {
+    constructor(config: InternalSeriesConfig);
+    render(): void;
+    private createMeasurer;
+    private findSpiralSpot;
+    getDataExtents(): {
+        xMin: number;
+        xMax: number;
+        yMin: number;
+        yMax: number;
+    };
+}

package/dist/series/index.d.ts

@@ -0,0 +1,45 @@
+export { BaseSeries, type SeriesContext } from './BaseSeries';
+export { LineChart } from './cartesian/LineChart';
+export { SplineChart } from './cartesian/SplineChart';
+export { AreaChart, AreaSplineChart } from './cartesian/AreaChart';
+export { ColumnChart, BarChart } from './cartesian/ColumnChart';
+export { ScatterChart } from './cartesian/ScatterChart';
+export { BubbleChart } from './cartesian/BubbleChart';
+export { WaterfallChart } from './cartesian/WaterfallChart';
+export { BoxPlotChart } from './cartesian/BoxPlotChart';
+export { PieChart, FunnelChart, PyramidChart } from './pie/PieChart';
+export { TreemapChart } from './hierarchical/TreemapChart';
+export { SunburstChart } from './hierarchical/SunburstChart';
+export { SankeyChart } from './flow/SankeyChart';
+export { NetworkGraphChart } from './flow/NetworkGraphChart';
+export { DependencyWheelChart } from './flow/DependencyWheelChart';
+export { GaugeChart, SolidGaugeChart } from './gauge/GaugeChart';
+export { PolarChart } from './polar/PolarChart';
+export { CandlestickChart, OHLCChart } from './financial/CandlestickChart';
+export { HeikinAshiChart } from './financial/HeikinAshiChart';
+export { HollowCandlestickChart } from './financial/HollowCandlestickChart';
+export { VolumeChart } from './financial/VolumeChart';
+export { AreaRangeChart } from './financial/AreaRangeChart';
+export { BaselineChart } from './financial/BaselineChart';
+export { FlagsChart } from './financial/FlagsChart';
+export { RenkoChart } from './financial/RenkoChart';
+export { KagiChart } from './financial/KagiChart';
+export { PointAndFigureChart } from './financial/PointAndFigureChart';
+export { LineBreakChart } from './financial/LineBreakChart';
+export { HeatmapChart } from './heatmap/HeatmapChart';
+export { TimelineChart, GanttChart } from './timeline/TimelineChart';
+export { MapChart } from './map/MapChart';
+export { VennChart } from './venn/VennChart';
+export { BarRaceChart } from './race/BarRaceChart';
+export { VolcanoChart } from './bioinformatics/VolcanoChart';
+export { ManhattanChart } from './bioinformatics/ManhattanChart';
+export { ViolinChart } from './bioinformatics/ViolinChart';
+export { KaplanMeierChart } from './bioinformatics/KaplanMeierChart';
+export { ForestPlotChart } from './bioinformatics/ForestPlotChart';
+export { SequenceLogoChart } from './bioinformatics/SequenceLogoChart';
+export { ClusteredHeatmapChart } from './bioinformatics/ClusteredHeatmapChart';
+export { PhyloTreeChart } from './bioinformatics/PhyloTreeChart';
+export { CircosChart } from './bioinformatics/CircosChart';
+export { CircosHeatmapChart } from './bioinformatics/circos/CircosHeatmapChart';
+export { CircosComparativeChart } from './bioinformatics/circos/CircosComparativeChart';
+export { CircosSpiralChart } from './bioinformatics/circos/CircosSpiralChart';

package/dist/series/map/FlowmapChart.d.ts

@@ -0,0 +1,33 @@
+import 'd3-transition';
+import { BaseSeries } from '../BaseSeries';
+import type { InternalSeriesConfig } from '../../types/options';
+/**
+ * `flowmap` series — draws directional, tapered, curved flow bands between two
+ * geographic endpoints. Endpoints (`from`/`to`) may be `[lon, lat]` pairs or
+ * the `id` of a point in a sibling `mappoint` series; either way they are
+ * projected through the same projection as the basemap. Band thickness scales
+ * with each link's `weight`, and an arrowhead marks the destination. Mirrors
+ * the `flowmap` series type.
+ */
+export declare class FlowmapChart extends BaseSeries {
+    constructor(config: InternalSeriesConfig);
+    private resolveMapData;
+    /** Maps point ids (from sibling `mappoint`/`map` series) to `[lon, lat]`. */
+    private buildIdMap;
+    private resolveEndpoint;
+    render(): void;
+    /**
+     * Builds a tapered, curved band from `S` (narrow origin) to `T` (full width
+     * at the destination). The centerline is a quadratic Bézier bowed sideways by
+     * `curveFactor`; the band outline samples that curve and offsets each sample
+     * along its normal by a half-width that grows from origin to destination.
+     */
+    private buildFlowPath;
+    private arrowHead;
+    getDataExtents(): {
+        xMin: number;
+        xMax: number;
+        yMin: number;
+        yMax: number;
+    };
+}

package/dist/series/map/MapChart.d.ts

@@ -0,0 +1,53 @@
+import 'd3-transition';
+import { BaseSeries } from '../BaseSeries';
+import type { InternalSeriesConfig } from '../../types/options';
+export declare class MapChart extends BaseSeries {
+    private zoomBehavior;
+    private mapGroup;
+    private featurePaths;
+    private dataMap;
+    private colorScale;
+    private globeProjection;
+    private globePathGen;
+    private autoRotateTimer;
+    constructor(config: InternalSeriesConfig);
+    destroy(): void;
+    render(): void;
+    /**
+     * Builds a 0‒1 value normalizer honoring `colorAxis.type`. A `'logarithmic'`
+     * axis maps values on a log scale; it degrades to linear when
+     * the domain includes non-positive values (log is undefined there).
+     */
+    private makeAxisNorm;
+    private getFeatureKey;
+    private getFeatureColor;
+    private attachMapHover;
+    private renderMapLabels;
+    private renderColorAxis;
+    private renderVerticalColorAxis;
+    private renderHorizontalColorAxis;
+    private setupMapNavigation;
+    /**
+     * Renders the map-navigation zoom buttons. Placement follows the standard
+     * `mapNavigation.buttonOptions` API: the +/− pair is stacked vertically and
+     * anchored top-left by default, honoring `align` ('left'|'right'),
+     * `verticalAlign` ('top'|'bottom') and the `x`/`y` pixel offsets. Button
+     * fill/border/symbol colors come from `buttonOptions.theme`/`symbolStroke`,
+     * and per-button label text from `mapNavigation.buttons.zoomIn|zoomOut.text`.
+     */
+    private renderNavButtons;
+    private setupGlobeMode;
+    /**
+     * Starts auto-rotation of the globe. Avoids overlapping timers that would
+     * cause stuttering; advances rotation by elapsed time rather than per-frame
+     * step so rotation remains smooth even under load.
+     */
+    private startAutoRotate;
+    private redrawGlobe;
+    getDataExtents(): {
+        xMin: number;
+        xMax: number;
+        yMin: number;
+        yMax: number;
+    };
+}