katucharts.js 0.2.1

package/dist/__vite-optional-peer-dep_jspdf_katucharts-BDMct_Gn.js

@@ -0,0 +1,4 @@
+const t = {};
+export {
+  t as default
+};

package/dist/accessibility/A11yModule.d.ts

@@ -0,0 +1,26 @@
+import { Selection } from 'd3-selection';
+import type { AccessibilityOptions } from '../types/options';
+import type { BaseSeries } from '../series/BaseSeries';
+export declare class A11yModule {
+    private config;
+    constructor(config: AccessibilityOptions);
+    private lastSeriesCount;
+    private lastPointCounts;
+    apply(svg: Selection<SVGSVGElement, unknown, null, undefined>, series: BaseSeries[], chartTitle?: string): void;
+    private setupAnnounceNewData;
+    private renderScreenReaderSections;
+    private createScreenReaderDiv;
+    /**
+     * Substitutes placeholders in a developer-supplied section template. The
+     * template markup is preserved, but interpolated data values (chart title and
+     * series names) are HTML-escaped before reaching the section's innerHTML so a
+     * crafted series name or title cannot inject markup.
+     */
+    private formatSectionTemplate;
+    private applyLandmarks;
+    private generateDescription;
+    private setupKeyboardNav;
+    private announcePoint;
+    private announceSeries;
+    private announce;
+}

package/dist/axis/Axis.d.ts

@@ -0,0 +1,140 @@
+/**
+ * Axis classes wrapping D3 scales and d3-axis.
+ */
+import { type ScaleLinear, type ScaleLogarithmic, type ScaleTime, type ScaleBand } from 'd3-scale';
+import { type Axis as D3Axis } from 'd3-axis';
+import { Selection } from 'd3-selection';
+import 'd3-transition';
+import type { InternalAxisConfig, PlotArea } from '../types/options';
+export type AnyScale = ScaleLinear<number, number> | ScaleLogarithmic<number, number> | ScaleTime<number, number> | ScaleBand<string>;
+export interface AxisInstance {
+    config: InternalAxisConfig;
+    scale: AnyScale;
+    render(group: Selection<SVGGElement, unknown, null, undefined>, plotArea: PlotArea): void;
+    updateDomain(data: {
+        min: number;
+        max: number;
+        extraMinPadding?: number;
+        extraMaxPadding?: number;
+    } | string[]): void;
+    animateAxis(group: Selection<SVGGElement, unknown, null, undefined>, plotArea: PlotArea, duration: number): void;
+    getPixelForValue(value: any): number;
+    getValueForPixel(pixel: number): any;
+    destroy(): void;
+}
+export declare function createAxis(config: InternalAxisConfig, plotArea: PlotArea): AxisInstance;
+declare class BaseAxis {
+    config: InternalAxisConfig;
+    protected plotArea: PlotArea;
+    constructor(config: InternalAxisConfig, plotArea: PlotArea);
+    /** Readable axis text color when none is configured — adapts to the chart background. */
+    protected autoText(): string;
+    protected getRange(): [number, number];
+    /**
+     * Vertical sub-region (pane) this y-axis occupies, from `top`/`height`
+     * (pixels or '%' of plot height). Enables stacked stock panes (e.g. price on
+     * top, RSI/MACD below). Defaults to the full plot height.
+     */
+    protected getPaneBand(): {
+        top: number;
+        height: number;
+    };
+    protected createD3Axis(scale: any): D3Axis<any>;
+    protected applyAxisStyles(axisGroup: Selection<SVGGElement, unknown, null, undefined>, plotArea: PlotArea): void;
+    /**
+     * Truncates left-of-plot horizontal tick labels that are wider than `maxWidth`, appending an ellipsis
+     * and stashing the full text in a `<title>` so it stays readable on hover. Labels that already fit are
+     * left untouched. Measured live via getComputedTextLength so it follows the host page's actual font.
+     */
+    protected truncateSideLabels(axisGroup: Selection<SVGGElement, unknown, null, undefined>, maxWidth: number): void;
+    protected applyAutoRotation(axisGroup: Selection<SVGGElement, unknown, null, undefined>, rotations: number[], plotArea: PlotArea): void;
+    /**
+     * Detects whether adjacent tick labels overlap horizontally, using a 4px gap threshold.
+     */
+    protected hasLabelOverlap(ticks: SVGTextElement[], rotated?: boolean): boolean;
+    /**
+     * Hides every Nth label until labels no longer overlap, matching
+     * auto-step behavior for extreme ranges.
+     */
+    protected applyAutoStep(axisGroup: Selection<SVGGElement, unknown, null, undefined>, ticks: SVGTextElement[]): void;
+    protected renderGridLines(group: Selection<SVGGElement, unknown, null, undefined>, scale: any, plotArea: PlotArea, explicitTicks?: number[]): void;
+    protected renderAlternateGridColor(gridGroup: Selection<SVGGElement, unknown, null, undefined>, ticks: any[], scale: any, plotArea: PlotArea): void;
+    protected renderMinorGridLines(gridGroup: Selection<SVGGElement, unknown, null, undefined>, majorTicks: any[], scale: any, plotArea: PlotArea): void;
+    protected renderPlotBands(group: Selection<SVGGElement, unknown, null, undefined>, scale: any, plotArea: PlotArea): void;
+    protected renderPlotLines(group: Selection<SVGGElement, unknown, null, undefined>, scale: any, plotArea: PlotArea): void;
+    protected applyAxisBreaks(scale: any): void;
+    protected renderTitle(group: Selection<SVGGElement, unknown, null, undefined>, plotArea: PlotArea): void;
+    animateAxis(group: Selection<SVGGElement, unknown, null, undefined>, plotArea: PlotArea, duration: number): void;
+    protected animateGridLines(group: Selection<SVGGElement, unknown, null, undefined>, scale: any, plotArea: PlotArea, duration: number): void;
+    protected getDashArray(style?: string): string;
+    destroy(): void;
+}
+export declare class LinearAxis extends BaseAxis implements AxisInstance {
+    scale: ScaleLinear<number, number>;
+    constructor(config: InternalAxisConfig, plotArea: PlotArea);
+    updateDomain(data: {
+        min: number;
+        max: number;
+        extraMinPadding?: number;
+        extraMaxPadding?: number;
+    }): void;
+    render(group: Selection<SVGGElement, unknown, null, undefined>, plotArea: PlotArea): void;
+    private renderStackLabels;
+    /**
+     * Computes "nice" round tick values for clean axis labels:
+     * picks intervals from the sequence 1, 2, 2.5, 5 scaled by powers of 10,
+     * choosing the smallest interval that produces at most `maxTicks` ticks.
+     */
+    private computeNiceTicks;
+    getPixelForValue(value: number): number;
+    getValueForPixel(pixel: number): number;
+    /**
+     * SI suffixes (k, M, G, T) are applied only when
+     * the tick interval is >= 1000. Below that, plain numbers with thousands separators are used.
+     */
+    private linearTickFormat;
+    private getTransform;
+}
+export declare class LogarithmicAxis extends BaseAxis implements AxisInstance {
+    scale: ScaleLogarithmic<number, number>;
+    constructor(config: InternalAxisConfig, plotArea: PlotArea);
+    updateDomain(data: {
+        min: number;
+        max: number;
+    }): void;
+    /**
+     * Generates tick values at powers of 10 for logarithmic axes.
+     * tickInterval refers to the exponent interval (1 = every decade, 2 = every other decade).
+     * When no tickInterval is set, the axis uses tickPixelInterval to auto-compute the step.
+     */
+    private computeLogTicks;
+    render(group: Selection<SVGGElement, unknown, null, undefined>, plotArea: PlotArea): void;
+    getPixelForValue(value: number): number;
+    getValueForPixel(pixel: number): number;
+}
+export declare class DateTimeAxis extends BaseAxis implements AxisInstance {
+    scale: ScaleTime<number, number>;
+    constructor(config: InternalAxisConfig, plotArea: PlotArea);
+    updateDomain(data: {
+        min: number;
+        max: number;
+    }): void;
+    render(group: Selection<SVGGElement, unknown, null, undefined>, plotArea: PlotArea): void;
+    private pickDateFormat;
+    getPixelForValue(value: number): number;
+    getValueForPixel(pixel: number): number;
+}
+export declare class CategoryAxis extends BaseAxis implements AxisInstance {
+    scale: ScaleBand<string>;
+    constructor(config: InternalAxisConfig, plotArea: PlotArea);
+    updateDomain(data: string[] | {
+        min: number;
+        max: number;
+    }): void;
+    render(group: Selection<SVGGElement, unknown, null, undefined>, plotArea: PlotArea): void;
+    private applyAutoStepIfNeeded;
+    getPixelForValue(value: any): number;
+    getBandwidth(): number;
+    getValueForPixel(pixel: number): string;
+}
+export {};

package/dist/axis/AxisCoordinator.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Owns the cartesian-axis coordination concern: computing axis domains from the
+ * visible series (including stacking and bubble-radius padding), rendering the
+ * axes into the axis group, wiring category-tick hover highlighting, and syncing
+ * tooltip categories. Extracted from `Chart`; it reaches the chart's current
+ * state through a narrow host interface and mutates the axis instances in place
+ * (the chart still owns the `xAxes`/`yAxes` arrays).
+ */
+import 'd3-transition';
+import type { SVGRenderer } from '../core/SVGRenderer';
+import type { EventBus } from '../core/EventBus';
+import type { Tooltip } from '../components/Tooltip';
+import type { InternalConfig } from '../types/options';
+import type { LayoutResult } from '../layout/LayoutEngine';
+import type { BaseSeries } from '../series/BaseSeries';
+import type { AxisInstance } from './Axis';
+type AxisGroup = ReturnType<SVGRenderer['createGroup']>;
+export interface AxisHost {
+    getOptions(): InternalConfig;
+    getLayout(): LayoutResult;
+    getSeriesInstances(): BaseSeries[];
+    getXAxes(): AxisInstance[];
+    getYAxes(): AxisInstance[];
+    getAxisGroup(): AxisGroup;
+    getEvents(): EventBus;
+    getTooltip(): Tooltip | null;
+}
+export declare class AxisCoordinator {
+    private host;
+    constructor(host: AxisHost);
+    updateTooltipCategories(): void;
+    updateAxesDomains(): void;
+    private computeBubbleRadiusPadding;
+    renderAxes(): void;
+    private setupAxisLabelHover;
+    private hasSeriesForAxis;
+}
+export {};

package/dist/bio.d.ts

@@ -0,0 +1,22 @@
+/**
+ * KatuCharts — Bioinformatics charts plugin.
+ *
+ * Import this module to register all bioinformatics series types:
+ *   import 'katucharts/bio';
+ *
+ * Or import named exports for manual control:
+ *   import { registerBioSeriesTypes, VolcanoChart } from 'katucharts/bio';
+ */
+export { registerBioSeriesTypes } from './core/registerBio';
+export { VolcanoChart } from './series/bioinformatics/VolcanoChart';
+export { ManhattanChart } from './series/bioinformatics/ManhattanChart';
+export { ViolinChart } from './series/bioinformatics/ViolinChart';
+export { KaplanMeierChart } from './series/bioinformatics/KaplanMeierChart';
+export { ForestPlotChart } from './series/bioinformatics/ForestPlotChart';
+export { SequenceLogoChart } from './series/bioinformatics/SequenceLogoChart';
+export { ClusteredHeatmapChart } from './series/bioinformatics/ClusteredHeatmapChart';
+export { PhyloTreeChart } from './series/bioinformatics/PhyloTreeChart';
+export { CircosChart } from './series/bioinformatics/CircosChart';
+export { CircosHeatmapChart } from './series/bioinformatics/circos/CircosHeatmapChart';
+export { CircosComparativeChart } from './series/bioinformatics/circos/CircosComparativeChart';
+export { CircosSpiralChart } from './series/bioinformatics/circos/CircosSpiralChart';

package/dist/components/Credits.d.ts

@@ -0,0 +1,38 @@
+import { Selection } from 'd3-selection';
+import type { CreditsOptions } from '../types/options';
+export declare class Credits {
+    private element;
+    private observer;
+    private intervalId;
+    private svg;
+    private chartWidth;
+    private chartHeight;
+    private config;
+    private unsubscribe;
+    constructor(config: CreditsOptions, svg: Selection<SVGSVGElement, unknown, null, undefined>, chartWidth: number, chartHeight: number);
+    /**
+     * Renders or hides the credits to match the current license state.
+     */
+    private apply;
+    updatePosition(chartWidth: number, chartHeight: number): void;
+    private render;
+    /**
+     * Re-resolves the credit colour after the series have been painted, so it can
+     * account for chart shapes that end up behind it. Called once the plot is drawn.
+     */
+    refresh(): void;
+    /**
+     * Returns the fill of the topmost chart shape painted under the credit's
+     * centre, or null when the corner is empty (transparent background).
+     */
+    private resolveBehindColor;
+    /**
+     * Reads the first opaque background-color walking up from the SVG, which
+     * covers the common case of a transparent chart over a coloured page/card.
+     */
+    private resolvePageBackground;
+    private elementFill;
+    private startProtection;
+    private stopProtection;
+    destroy(): void;
+}

package/dist/components/Crosshair.d.ts

@@ -0,0 +1,15 @@
+import { Selection } from 'd3-selection';
+import type { CrosshairOptions, PlotArea } from '../types/options';
+import { EventBus } from '../core/EventBus';
+export declare class Crosshair {
+    private xLine;
+    private yLine;
+    private xLabel;
+    private yLabel;
+    private plotArea;
+    constructor(xConfig: boolean | CrosshairOptions | undefined, yConfig: boolean | CrosshairOptions | undefined, plotGroup: Selection<SVGGElement, unknown, null, undefined>, plotArea: PlotArea, events: EventBus);
+    private getDashArray;
+    private createLabel;
+    private updateLabel;
+    destroy(): void;
+}

package/dist/components/DataLabels.d.ts

@@ -0,0 +1,7 @@
+import { Selection } from 'd3-selection';
+import type { DataLabelOptions, PointOptions } from '../types/options';
+import type { AxisInstance } from '../axis/Axis';
+export declare class DataLabels {
+    static render(group: Selection<SVGGElement, unknown, null, undefined>, data: PointOptions[], config: DataLabelOptions, xAxis: AxisInstance, yAxis: AxisInstance, seriesName: string): void;
+    private static matchesFilter;
+}

package/dist/components/ExportButton.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Gear icon button with radial animated menu for chart export actions.
+ */
+import { Selection } from 'd3-selection';
+import type { ExportingOptions } from '../types/options';
+export declare class ExportButton {
+    private group;
+    private gearGroup;
+    private radialContainer;
+    private isOpen;
+    private onExport;
+    private container;
+    private config;
+    private chartWidth;
+    private chartHeight;
+    private outsideClickHandler;
+    private scrollHandler;
+    private btnCenterX;
+    private btnCenterY;
+    constructor(config: ExportingOptions, svg: Selection<SVGSVGElement, unknown, null, undefined>, container: HTMLElement, chartWidth: number, chartHeight: number, onExport: (type: string) => void);
+    toggle(): void;
+    repositionCenter(cx: number, cy: number): void;
+    private openMenu;
+    private closeMenu;
+    updatePosition(chartWidth: number, chartHeight: number): void;
+    destroy(): void;
+}

package/dist/components/Legend.d.ts

@@ -0,0 +1,53 @@
+import { Selection } from 'd3-selection';
+import type { LegendOptions } from '../types/options';
+import { EventBus } from '../core/EventBus';
+import type { BaseSeries } from '../series/BaseSeries';
+export declare class Legend {
+    private config;
+    private group;
+    private events;
+    private series;
+    private scrollOffset;
+    private contentHeight;
+    private visibleHeight;
+    constructor(config: LegendOptions, svg: Selection<SVGSVGElement, unknown, null, undefined>, events: EventBus);
+    /** Readable legend text color when none is configured — adapts to the chart background. */
+    private autoText;
+    private resolveLabel;
+    private computeAutoFontSize;
+    private estimateTextWidth;
+    static computeGridLayout(itemCount: number, labels: string[], availWidth: number, config: {
+        symbolWidth: number;
+        symbolPadding: number;
+        fontSize: string;
+        itemDistance: number;
+        padding: number;
+        itemWidth?: number;
+    }): {
+        columns: number;
+        itemWidth: number;
+    };
+    render(series: BaseSeries[], layoutArea: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }): void;
+    private renderNavigationArrows;
+    private applyScroll;
+    /**
+     * Draws the size-reference circles for a bubble series: nested circles sharing
+     * a common baseline, each with a connector line to its formatted z value. The
+     * radii come straight from the series' own size scale so the legend matches the
+     * rendered bubbles exactly.
+     */
+    private renderBubbleLegend;
+    /**
+     * Alternative bubble-legend layout: each size reference is its own circle with
+     * the value beside it, rather than nested concentric circles. Lays the items
+     * out as a vertical list for side legends and as a baseline-aligned row for
+     * bottom legends, so the size key reads cleanly in any placement.
+     */
+    private renderBubbleLegendSeparate;
+    destroy(): void;
+}

package/dist/components/TitleRenderer.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Renders the chart title and subtitle — as SVG `<text>` (with word wrapping)
+ * or, when `useHTML` is set, as absolutely-positioned HTML overlays. Extracted
+ * from `Chart` as pure functions over an explicit context so the rendering has
+ * no hidden dependency on chart internals.
+ */
+import type { SVGRenderer } from '../core/SVGRenderer';
+import type { LayoutResult } from '../layout/LayoutEngine';
+import type { InternalConfig } from '../types/options';
+type TitleGroup = ReturnType<SVGRenderer['createGroup']>;
+export interface TitleRenderContext {
+    titleGroup: TitleGroup;
+    container: HTMLElement;
+    options: InternalConfig;
+    layout: LayoutResult;
+    chartWidth: number;
+}
+export declare function renderTitles(ctx: TitleRenderContext): void;
+export {};

package/dist/components/Tooltip.d.ts

@@ -0,0 +1,61 @@
+import type { TooltipOptions, PointOptions, PlotArea } from '../types/options';
+import { EventBus } from '../core/EventBus';
+export interface TooltipPointData {
+    point: PointOptions;
+    series: {
+        name?: string;
+        color?: string;
+        config?: any;
+    };
+    plotX: number;
+    plotY: number;
+}
+export declare class Tooltip {
+    private config;
+    private container;
+    private plotArea;
+    private element;
+    private splitElements;
+    private hideTimeout;
+    private categories;
+    private isDatetime;
+    private sharedPoints;
+    private sharedProvider;
+    private static readonly DEFAULT_DATE_FORMAT;
+    private lastMouseEvent;
+    private boundHandlers;
+    constructor(config: TooltipOptions, container: HTMLElement, plotArea: PlotArea, events: EventBus);
+    show(rawData: any): void;
+    hide(): void;
+    private scheduleHide;
+    private showSplit;
+    private hideSplitElements;
+    private createSplitElement;
+    private createElement;
+    private formatValue;
+    private resolveKey;
+    private getPointCategory;
+    private buildFormatterPoint;
+    private buildFormatterContext;
+    private formatContent;
+    private formatValueWith;
+    private formatSharedContent;
+    private position;
+    private positionAtMouse;
+    updatePlotArea(plotArea: PlotArea): void;
+    setCategories(categories: string[]): void;
+    setDatetimeAxis(isDatetime: boolean): void;
+    /**
+     * Supplies a resolver that returns every series' point at a given x, used to
+     * populate a shared tooltip with the whole column on a single hover.
+     */
+    setSharedPointsProvider(fn: ((x: number | string) => TooltipPointData[]) | null): void;
+    /**
+     * Resolves the tooltip header label for a point, applying category names and
+     * datetime formatting. On a datetime axis the raw timestamp is formatted with
+     * the series/global `xDateFormat`, falling back to a sensible default so the
+     * header never shows a bare epoch.
+     */
+    private formatXKey;
+    destroy(): void;
+}

package/dist/core/Chart.d.ts

@@ -0,0 +1,156 @@
+/**
+ * Central chart orchestrator — owns container, SVG, and all subsystems.
+ */
+import type { KatuChartsOptions, InternalConfig, SeriesOptions, AxisOptions } from '../types/options';
+import { SVGRenderer } from './SVGRenderer';
+import { EventBus } from './EventBus';
+import { StateManager } from './StateManager';
+import { type AxisInstance } from '../axis/Axis';
+import { BaseSeries } from '../series/BaseSeries';
+import 'd3-transition';
+import type { ExportingOptions } from '../types/options';
+export declare class Chart {
+    container: HTMLElement;
+    renderer: SVGRenderer;
+    events: EventBus;
+    state: StateManager;
+    options: InternalConfig;
+    private layoutEngine;
+    private layout;
+    private xAxes;
+    private yAxes;
+    private seriesInstances;
+    private plotGroup;
+    private axisGroup;
+    private seriesGroup;
+    private tooltip;
+    private legend;
+    private crosshair;
+    private credits;
+    private exportButton;
+    private responsiveEngine;
+    private interactions;
+    private stock;
+    private clipPathId;
+    private chartWidth;
+    private chartHeight;
+    private resizeObserver;
+    private titleGroup;
+    private stackLabelsGroup;
+    private originalUserOptions;
+    private isResponsiveUpdate;
+    constructor(containerOrId: string | HTMLElement, options: KatuChartsOptions);
+    private scrollableInner;
+    private scrollableOuterWidth;
+    private scrollableOuterHeight;
+    private useVerticalScroll;
+    private useHorizontalScroll;
+    private fixedAxisOverlay;
+    private exporter;
+    private axes;
+    private createFixedAxisOverlay;
+    private getDefaultHeightAspectRatio;
+    private resolveHeight;
+    private applyChartStyles;
+    private computeLayout;
+    private createStructuralGroups;
+    private renderTitles;
+    private buildAxes;
+    private buildSeries;
+    /**
+     * For a shared tooltip: returns the nearest point in every tracked, visible
+     * series at the given x, so a single hover renders the whole column. Series
+     * with mouse tracking disabled (e.g. indicator band fills) are excluded.
+     */
+    private collectSharedPointsAt;
+    private renderAll;
+    private formatStackLabel;
+    private renderStackLabels;
+    private raiseplotLineLabels;
+    private updateTooltipCategories;
+    private updateAxesDomains;
+    private renderAxes;
+    private renderSeriesInstances;
+    private renderLegend;
+    private setupReflow;
+    private fireEvent;
+    /**
+     * Plot geometry exposed for custom `chart.events.render` callbacks.
+     */
+    get plotLeft(): number;
+    get plotTop(): number;
+    get plotWidth(): number;
+    get plotHeight(): number;
+    get plotRenderer(): {
+        rect(x: number, y: number, w: number, h: number): any;
+        circle(cx: number, cy: number, r: number): any;
+        ellipse(cx: number, cy: number, rx: number, ry: number): any;
+        path(d: string): any;
+        line(x1: number, y1: number, x2: number, y2: number): any;
+        text(str: string, x: number, y: number): any;
+        group(className?: string): any;
+        readonly plotArea: {
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+        };
+        readonly localPlotArea: {
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+        };
+        xAxis: {
+            toPixels(val: number, axisIdx?: number): number;
+        };
+        yAxis: {
+            toPixels(val: number, axisIdx?: number): number;
+        };
+    };
+    private setupResponsive;
+    private applyInitialResponsiveRules;
+    addSeries(options: SeriesOptions, redraw?: boolean): BaseSeries;
+    get(id: string): BaseSeries | AxisInstance | undefined;
+    private canReuseSeriesInstances;
+    private syncSeriesInstances;
+    update(options: Partial<KatuChartsOptions>, redraw?: boolean): void;
+    animatedRedraw(duration?: number): void;
+    redraw(): void;
+    reflow(): void;
+    setSize(width: number, height: number): void;
+    /** The current visible outer size — the scrollable viewport for scrollable charts, else the chart. */
+    getViewportSize(): {
+        width: number;
+        height: number;
+    };
+    /**
+     * Resize the chart to a new outer viewport (used for fullscreen). For scrollable charts this also
+     * grows the scrollable viewport box so the chart fills the screen instead of staying clipped to its
+     * original box; the content fills the viewport and only scrolls if the configured minimums still
+     * exceed it. The pinned axis/legend overlay is rebuilt at the new size so its axes/legend track the
+     * viewport; the export button is preserved across that rebuild (see createFixedAxisOverlay).
+     */
+    fitToViewport(viewportWidth: number, viewportHeight: number): void;
+    setTitle(titleOptions: {
+        text?: string;
+    } | null, subtitleOptions?: {
+        text?: string;
+    } | null): void;
+    addAxis(options: AxisOptions, isX?: boolean, redraw?: boolean): AxisInstance;
+    showLoading(text?: string): void;
+    hideLoading(): void;
+    destroy(): void;
+    getSVG(): string;
+    getSeriesInstances(): BaseSeries[];
+    get series(): BaseSeries[];
+    getXAxes(): AxisInstance[];
+    getYAxes(): AxisInstance[];
+    private handleExportAction;
+    getCSV(): string;
+    getTable(): string;
+    getDataRows(): (string | number | null)[][];
+    exportChart(exportingOptions?: Partial<ExportingOptions>, _chartOptions?: Partial<KatuChartsOptions>): void;
+    print(): void;
+    private optionsToExternal;
+}

package/dist/core/EventBus.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Central event system for KatuCharts.
+ */
+type EventCallback = (...args: any[]) => void;
+export declare class EventBus {
+    private listeners;
+    on(event: string, callback: EventCallback): this;
+    once(event: string, callback: EventCallback): this;
+    off(event: string, callback?: EventCallback): this;
+    emit(event: string, ...args: any[]): this;
+    removeAllListeners(): void;
+    static mapEvent(context: string, eventName: string): string;
+}
+export {};