katucharts.js 0.2.1

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

@@ -0,0 +1,26 @@
+import 'd3-transition';
+import { BaseSeries } from '../BaseSeries';
+import type { InternalSeriesConfig } from '../../types/options';
+/**
+ * `mappoint` series — renders point markers (and optional data labels) at
+ * geographic `lat`/`lon` coordinates, projected through the *same* projection
+ * as the choropleth basemap so markers land exactly on top of it. Mirrors the
+ * The `mappoint` series type.
+ */
+export declare class MapPointChart extends BaseSeries {
+    constructor(config: InternalSeriesConfig);
+    /**
+     * Resolves the map topology this series projects against: its own bridged
+     * `mapData` (from `chart.map`), or failing that the topology of a sibling
+     * map-family series in the same chart.
+     */
+    private resolveMapData;
+    render(): void;
+    private formatLabel;
+    getDataExtents(): {
+        xMin: number;
+        xMax: number;
+        yMin: number;
+        yMax: number;
+    };
+}

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

@@ -0,0 +1,46 @@
+/**
+ * Shared geographic projection helpers for the map series family
+ * (`map`, `mappoint`, `flowmap`). Centralizing projection construction here
+ * guarantees that every map-family series in a chart resolves the *identical*
+ * projection from the same `mapData` + `plotArea`, so point markers and flow
+ * lines land exactly on top of the choropleth basemap.
+ */
+import { type GeoProjection, type GeoPath } from 'd3-geo';
+import type { PlotArea } from '../../types/options';
+export declare const projectionMap: Record<string, () => GeoProjection>;
+/**
+ * Normalizes `mapData` into a flat array of GeoJSON features. Accepts a
+ * GeoJSON FeatureCollection, a bare feature array, or a TopoJSON topology —
+ * TopoJSON is converted on the fly so the same `mapData` option works for
+ * either format. `objectName` selects the topology object (defaults to a
+ * `countries` object when present, otherwise the first one).
+ */
+export declare function resolveFeatures(mapData: any, objectName?: string): any[];
+/** True when the projection should be rendered as an interactive 3D globe. */
+export declare function isGlobeProjection(projName: string, cfg?: any): boolean;
+export interface ResolvedMapProjection {
+    projection: GeoProjection;
+    pathGen: GeoPath;
+    features: any[];
+    projName: string;
+}
+/**
+ * Builds the d3-geo projection + path generator for a map-family series from
+ * its `projection` config, fitting the supplied `mapData` to `plotArea`
+ * exactly as the choropleth basemap does. The result is deterministic for a
+ * given (mapData, projection, plotArea), so sibling series stay aligned.
+ */
+export declare function createMapProjection(mapData: any, projectionCfg: any, plotArea: PlotArea, mapDataObject?: string): ResolvedMapProjection;
+/**
+ * Reconfigures a projection into globe (orthographic) mode — centered, scaled
+ * to the plot radius and clipped to the visible hemisphere. Returns the radius
+ * so callers can size the ocean/atmosphere/specular layers consistently.
+ */
+export declare function applyGlobeProjection(projection: GeoProjection, plotArea: PlotArea): number;
+/**
+ * Resolves a single point's geographic coordinate to `[lon, lat]`, accepting
+ * the shapes used by `mappoint`/`flowmap`: `{ lat, lon }`,
+ * `{ geometry: { coordinates: [lon, lat] } }`, a bare `[lon, lat]` pair, or a
+ * `{ x: lon, y: lat }` fallback. Returns null when no coordinate is present.
+ */
+export declare function pointLonLat(p: any): [number, number] | null;

package/dist/series/pie/PieChart.d.ts

@@ -0,0 +1,53 @@
+import 'd3-transition';
+import { BaseSeries, type SeriesContext } from '../BaseSeries';
+import type { InternalSeriesConfig } from '../../types/options';
+export declare class PieChart extends BaseSeries {
+    private selectedIndices;
+    constructor(config: InternalSeriesConfig);
+    /**
+     * Returns the enabled data-label configs in array form. The API allows a
+     * pie point to carry several label sets (e.g. the name outside the slice plus
+     * the percentage inside it), passed as an array; this normalises the single-
+     * object and array forms to one list so the rest of the chart can treat them
+     * uniformly.
+     */
+    private dataLabelConfigs;
+    init(context: SeriesContext): void;
+    render(): void;
+    private renderPieLabels;
+    /**
+     * Rank-based label distribution. Packs the side's labels into the available
+     * vertical span using rank-based priority (higher percentage = higher rank)
+     * and greedy placement with relaxation. A label is dropped only when it cannot
+     * fit the plot height (capacity) or when packing would slide it further than
+     * `maxDisplacement` from its slice — the latter thins densely clustered
+     * regions instead of fanning every label out on a long leader line.
+     */
+    private distribute;
+    private distributeBoxes;
+    /**
+     * Renders pseudo-3D side effect below pie slices using the depth config.
+     */
+    private render3DEffect;
+    private resolvePercent;
+    private resolveBorderRadius;
+    getDataExtents(): {
+        xMin: number;
+        xMax: number;
+        yMin: number;
+        yMax: number;
+    };
+}
+export declare class FunnelChart extends BaseSeries {
+    constructor(config: InternalSeriesConfig);
+    render(): void;
+    getDataExtents(): {
+        xMin: number;
+        xMax: number;
+        yMin: number;
+        yMax: number;
+    };
+}
+export declare class PyramidChart extends FunnelChart {
+    constructor(config: InternalSeriesConfig);
+}

package/dist/series/polar/PolarChart.d.ts

@@ -0,0 +1,18 @@
+import 'd3-transition';
+import { BaseSeries } from '../BaseSeries';
+import type { InternalSeriesConfig } from '../../types/options';
+export declare class PolarChart extends BaseSeries {
+    constructor(config: InternalSeriesConfig);
+    render(): void;
+    private resolvePolarSubType;
+    private renderLineAreaPolar;
+    private renderColumnPolar;
+    private renderPolarDataLabels;
+    private renderGrid;
+    getDataExtents(): {
+        xMin: number;
+        xMax: number;
+        yMin: number;
+        yMax: number;
+    };
+}

package/dist/series/race/BarRaceChart.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Bar Chart Race series — animated horizontal bars ranked by value through time keyframes.
+ * Includes play/pause button and range slider.
+ */
+import 'd3-transition';
+import { BaseSeries } from '../BaseSeries';
+import type { InternalSeriesConfig } from '../../types/options';
+export declare class BarRaceChart extends BaseSeries {
+    private keyframes;
+    private currentFrameIndex;
+    private colorMap;
+    private timer;
+    private playing;
+    private axisGroup;
+    private barsGroup;
+    private tickerText;
+    private valueScale;
+    private controlsEl;
+    private playBtn;
+    private rangeInput;
+    private rangeLabel;
+    constructor(config: InternalSeriesConfig);
+    processData(): void;
+    render(): void;
+    private renderControls;
+    private updateControls;
+    private playIcon;
+    private pauseIcon;
+    private renderFrame;
+    private renderAxis;
+    private attachBarHoverEffects;
+    play(): void;
+    pause(): void;
+    restart(): void;
+    goToFrame(index: number): void;
+    getDataExtents(): {
+        xMin: number;
+        xMax: number;
+        yMin: number;
+        yMax: number;
+    };
+    destroy(): void;
+    private brightenColor;
+}

package/dist/series/timeline/TimelineChart.d.ts

@@ -0,0 +1,23 @@
+import 'd3-transition';
+import { BaseSeries } from '../BaseSeries';
+import type { InternalSeriesConfig } from '../../types/options';
+export declare class TimelineChart extends BaseSeries {
+    constructor(config: InternalSeriesConfig);
+    render(): void;
+    getDataExtents(): {
+        xMin: number;
+        xMax: number;
+        yMin: number;
+        yMax: number;
+    };
+}
+export declare class GanttChart extends BaseSeries {
+    constructor(config: InternalSeriesConfig);
+    render(): void;
+    getDataExtents(): {
+        xMin: number;
+        xMax: number;
+        yMin: number;
+        yMax: number;
+    };
+}

package/dist/series/venn/VennChart.d.ts

@@ -0,0 +1,28 @@
+import 'd3-transition';
+import { BaseSeries } from '../BaseSeries';
+import type { InternalSeriesConfig } from '../../types/options';
+export declare class VennChart extends BaseSeries {
+    private selectedIndices;
+    constructor(config: InternalSeriesConfig);
+    render(): void;
+    private resolveDashStyle;
+    private attachEvents;
+    private renderLabels;
+    private layoutSets;
+    private optimizePositions;
+    private circlePath;
+    private lensPath;
+    private triIntersectionPath;
+    private circleIntersectionPoints;
+    private insideCircle;
+    private findArcCircle;
+    private blendColors;
+    private findDistance;
+    private lensArea;
+    getDataExtents(): {
+        xMin: number;
+        xMax: number;
+        yMin: number;
+        yMax: number;
+    };
+}

package/dist/stock/DataGrouping.d.ts

@@ -0,0 +1,21 @@
+import type { PointOptions } from '../types/options';
+export type GroupingApproximation = 'average' | 'sum' | 'open' | 'high' | 'low' | 'close' | 'ohlc' | 'range';
+export interface DataGroupingOptions {
+    enabled?: boolean;
+    approximation?: GroupingApproximation;
+    groupPixelWidth?: number;
+    forced?: boolean;
+    smoothed?: boolean;
+    anchor?: 'start' | 'middle' | 'end';
+    units?: [string, number[] | null][];
+    groupAll?: boolean;
+}
+export declare class DataGrouping {
+    static group(data: PointOptions[], interval: number, approximation?: GroupingApproximation, options?: DataGroupingOptions, visibleRange?: {
+        min: number;
+        max: number;
+    }): PointOptions[];
+    private static applyAnchor;
+    private static smooth;
+    private static approximate;
+}

package/dist/stock/Navigator.d.ts

@@ -0,0 +1,25 @@
+import { Selection } from 'd3-selection';
+import type { NavigatorOptions, PlotArea } from '../types/options';
+import { EventBus } from '../core/EventBus';
+export declare class Navigator {
+    private group;
+    private config;
+    private events;
+    private width;
+    private height;
+    private brush;
+    private brushGroup;
+    private programmatic;
+    constructor(config: NavigatorOptions, svg: Selection<SVGSVGElement, unknown, null, undefined>, plotArea: PlotArea, chartHeight: number, events: EventBus, seriesData: {
+        x: number;
+        y: number;
+    }[]);
+    private renderSeriesLine;
+    private updateSeriesLine;
+    /**
+     * Sets the brush selection to reflect a visible window (fractions 0..1 of full range).
+     * A full or empty range clears the selection. Guarded to prevent re-emitting brush events.
+     */
+    setSelection(x0Frac: number, x1Frac: number): void;
+    destroy(): void;
+}

package/dist/stock/RangeSelector.d.ts

@@ -0,0 +1,9 @@
+import type { RangeSelectorOptions } from '../types/options';
+import { EventBus } from '../core/EventBus';
+export declare class RangeSelector {
+    private container;
+    private config;
+    private events;
+    constructor(config: RangeSelectorOptions, parentContainer: HTMLElement, events: EventBus);
+    destroy(): void;
+}

package/dist/stock/StockController.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Wires the stock UI — RangeSelector buttons/inputs and the Navigator brush —
+ * to the chart's x-axis. Both translate user intent into an x-domain change and
+ * trigger a re-render, a standard stock-chart interaction. Kept separate from
+ * Chart so the stock concern stays self-contained.
+ */
+import type { Selection } from 'd3-selection';
+import type { EventBus } from '../core/EventBus';
+import type { LayoutResult } from '../layout/LayoutEngine';
+import type { AxisInstance } from '../axis/Axis';
+import type { BaseSeries } from '../series/BaseSeries';
+import type { InternalConfig } from '../types/options';
+export interface StockHost {
+    getOptions(): InternalConfig;
+    getContainer(): HTMLElement;
+    getEvents(): EventBus;
+    getSvg(): Selection<SVGSVGElement, unknown, null, undefined>;
+    getLayout(): LayoutResult;
+    getChartHeight(): number;
+    getXAxes(): AxisInstance[];
+    getSeriesInstances(): BaseSeries[];
+    rerender(): void;
+}
+export declare class StockController {
+    private host;
+    private navigator;
+    private rangeSelector;
+    private xMin;
+    private xMax;
+    constructor(host: StockHost);
+    setup(): void;
+    /**
+     * Extracts {x, y} data from the base series, using close price for OHLC points.
+     */
+    private getBaseSeriesData;
+    private placeRangeSelectorOnTop;
+    /**
+     * Resolves a range-selector button (type/count) to an x-axis domain range.
+     */
+    private applyButton;
+    private applyXRange;
+    /**
+     * Syncs the navigator brush to reflect the current visible [min, max] x-axis window.
+     */
+    private syncNavigator;
+    destroy(): void;
+}

package/dist/stockcharts.d.ts

@@ -0,0 +1,8 @@
+/**
+ * KatuCharts Stock Chart entrypoint — adds navigator, range selector, data grouping.
+ */
+import { KatuCharts, Chart } from './index';
+import type { KatuChartsOptions } from './types/options';
+export declare function stockChart(containerOrId: string | HTMLElement, options: KatuChartsOptions): Chart;
+export default KatuCharts;
+export { KatuCharts, Chart };

package/dist/streaming/StreamAdapter.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Thin wrappers for connecting WebSocket, SSE, and polling data sources
+ * to KatuCharts series instances.
+ */
+import type { PointOptions } from '../types/options';
+export interface StreamSubscription {
+    unsubscribe(): void;
+}
+export declare class StreamAdapter {
+    /**
+     * Connect a WebSocket to a series, parsing each message into points.
+     */
+    static fromWebSocket(ws: WebSocket, series: {
+        addPoint(p: PointOptions, redraw?: boolean, shift?: boolean): void;
+        addPoints?(pts: PointOptions[], redraw?: boolean, shift?: boolean): void;
+    }, parseMessage: (data: any) => PointOptions | PointOptions[], options?: {
+        shift?: boolean;
+    }): StreamSubscription;
+    /**
+     * Connect an EventSource (SSE) to a series.
+     */
+    static fromEventSource(source: EventSource, series: {
+        addPoint(p: PointOptions, redraw?: boolean, shift?: boolean): void;
+    }, eventName: string, parseMessage: (data: string) => PointOptions, options?: {
+        shift?: boolean;
+    }): StreamSubscription;
+    /**
+     * Create a polling adapter that fetches new data at a regular interval.
+     */
+    static fromPolling(fetchFn: () => Promise<PointOptions | PointOptions[]>, series: {
+        addPoint(p: PointOptions, redraw?: boolean, shift?: boolean): void;
+        addPoints?(pts: PointOptions[], redraw?: boolean, shift?: boolean): void;
+    }, intervalMs: number, options?: {
+        shift?: boolean;
+    }): StreamSubscription;
+}