katucharts.js 0.2.1

package/dist/core/InteractionController.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Owns the chart's user-interaction behaviors: drilldown (with its history
+ * stack and transition), zoom/pan, series hover-dimming, and the accessibility
+ * module. Extracted from `Chart`; it reaches chart state through a narrow host
+ * interface and performs rebuilds/re-renders via host callbacks so it never
+ * touches the chart's private render internals directly.
+ *
+ * Note: responsive rules, reflow and the ResizeObserver intentionally remain on
+ * `Chart` — they belong to the sizing lifecycle (the public `reflow()`/`setSize`
+ * path) and share the ResizeObserver with the export/full-screen feature.
+ */
+import type { SVGRenderer } from './SVGRenderer';
+import type { EventBus } from './EventBus';
+import type { LayoutResult } from '../layout/LayoutEngine';
+import type { BaseSeries } from '../series/BaseSeries';
+import type { AxisInstance } from '../axis/Axis';
+import type { InternalConfig, InternalSeriesConfig } from '../types/options';
+type Group = ReturnType<SVGRenderer['createGroup']>;
+export interface InteractionHost {
+    getOptions(): InternalConfig;
+    getContainer(): HTMLElement;
+    getEvents(): EventBus;
+    getRenderer(): SVGRenderer;
+    getSeriesGroup(): Group;
+    getPlotGroup(): Group;
+    getLayout(): LayoutResult;
+    getXAxes(): AxisInstance[];
+    getYAxes(): AxisInstance[];
+    getSeriesInstances(): BaseSeries[];
+    /** Replace the active (internal) series config — used by drilldown. */
+    setSeries(series: InternalSeriesConfig[]): void;
+    /** Destroy series instances, rebuild axes + series, and render everything. */
+    rebuild(): void;
+    /** Re-render axes, series and legend after a zoom/pan domain change. */
+    renderAfterZoom(): void;
+    fireEvent(name: string, ...args: any[]): void;
+}
+export declare class InteractionController {
+    private host;
+    private drilldown;
+    private zoom;
+    private a11yModule;
+    private origXDomains;
+    private origYDomains;
+    private isBoxZoomed;
+    constructor(host: InteractionHost);
+    setup(): void;
+    destroy(): void;
+    private setupSeriesDimming;
+    private setupDrilldown;
+    private performDrillSwap;
+    private setupZoom;
+    /**
+     * Converts a pixel rectangle from a drag-selection into axis domains and
+     * re-renders. Original domains are captured on the first zoom so the reset
+     * button can restore the unzoomed view.
+     */
+    private applyBoxZoom;
+    private resetBoxZoom;
+    private setupAccessibility;
+}
+export {};

package/dist/core/OptionsParser.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Pipeline: validate → deepMerge with defaults → normalize shorthands → toInternal.
+ */
+import type { KatuChartsOptions, InternalConfig } from '../types/options';
+export declare function setGlobalOptions(options: Partial<KatuChartsOptions>): void;
+export declare function getGlobalOptions(): Partial<KatuChartsOptions>;
+export declare class OptionsParser {
+    parse(userOptions: KatuChartsOptions): InternalConfig;
+    /**
+     * Layers, lowest to highest precedence: built-in defaults, global options, the
+     * resolved `theme` fragment, then the user's explicit options. A theme thus
+     * overwrites every default color surface while any option the caller sets
+     * directly still wins over it.
+     */
+    private mergeWithDefaults;
+    private normalize;
+    /**
+     * Derives a sensible chart height when the consumer left it unset (`null`/`undefined`):
+     * inverted (bar) charts with many categories grow their internal scroll area so rows stay
+     * legible instead of being crammed into a fixed height. Circular relationship charts
+     * (dependency wheel / network graph) are NOT forced to a fixed pixel height here — doing so
+     * overrode an explicitly sized container and overflowed it. They instead fall back to a
+     * square canvas via `Chart.getDefaultHeightAspectRatio()`, which only applies when the
+     * container itself has no measurable height.
+     */
+    private applyAutoHeight;
+    /**
+     * Bridges top-level map options onto the map series so a config that places
+     * them at the chart level works unchanged: `colorAxis`, `mapView.projection`,
+     * `mapNavigation`, and `chart.map`. Series-level options always take
+     * precedence; when `series.colorAxis` is an axis index (number/boolean)
+     * rather than a full config object we fall back to the top-level colorAxis.
+     */
+    private applyMapTopLevelOptions;
+    /**
+     * Merges `dataLabels` layers (least → most specific) preserving array form.
+     * Single-object layers broadcast across every entry, so a default such as
+     * `{enabled:true}` refines each label instead of replacing a user array.
+     */
+    private static mergeDataLabels;
+    private static mergeTwoDataLabels;
+    private normalizeSeries;
+    /**
+     * Series whose numeric-array shorthand maps onto OHLC fields rather than x/y/z.
+     */
+    private static readonly OHLC_TYPES;
+    /**
+     * Series whose numeric-array shorthand maps onto low/high range fields.
+     */
+    private static readonly RANGE_TYPES;
+    /**
+     * Array shorthand keys for OHLC and range series. The
+     * leading x value is optional, so the variant is chosen by the array length:
+     * `[o,h,l,c]`/`[x,o,h,l,c]` for OHLC, `[low,high]`/`[x,low,high]` for ranges.
+     */
+    private defaultArrayKeys;
+    private normalizeDataPoint;
+    private normalizeDataBulk;
+    private enforceCredits;
+    private toInternal;
+}

package/dist/core/Registry.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Plugin registry for chart types, enabling tree-shaking.
+ */
+import type { SeriesType } from '../types/options';
+export interface SeriesConstructor {
+    new (...args: any[]): any;
+}
+export interface ModuleDefinition {
+    name: string;
+    init: (katucharts: any) => void;
+}
+declare class ChartRegistryClass {
+    types: Map<string, SeriesConstructor>;
+    registerType(name: SeriesType | string, constructor: SeriesConstructor): void;
+    getType(name: string): SeriesConstructor | undefined;
+    hasType(name: string): boolean;
+    getRegisteredTypes(): string[];
+}
+export declare const ChartRegistry: ChartRegistryClass;
+declare class ModuleRegistryClass {
+    modules: Map<string, ModuleDefinition>;
+    register(module: ModuleDefinition): void;
+    get(name: string): ModuleDefinition | undefined;
+    getAll(): ModuleDefinition[];
+}
+export declare const ModuleRegistry: ModuleRegistryClass;
+export {};

package/dist/core/SVGRenderer.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Wraps d3-selection to manage the root SVG element and provide drawing primitives.
+ */
+import { Selection } from 'd3-selection';
+/**
+ * Thin chainable wrapper around a single SVG element, mirroring the subset of the
+ * `SVGElement` API (`attr`/`css`/`add`/`getBBox`/`destroy`) that consumers rely on inside
+ * custom `chart.events.render` callbacks (e.g. drawing corner labels). Elements are attached on
+ * creation, so `add()` is a no-op kept only for API compatibility.
+ */
+export declare class RendererElement {
+    private readonly el;
+    constructor(el: Selection<SVGElement, unknown, null, undefined>);
+    attr(attrs: Record<string, any>): this;
+    css(styles: Record<string, any>): this;
+    add(): this;
+    getBBox(): {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    destroy(): void;
+}
+export declare class SVGRenderer {
+    readonly svg: Selection<SVGSVGElement, unknown, null, undefined>;
+    readonly defs: Selection<SVGDefsElement, unknown, null, undefined>;
+    private static clipPathCounter;
+    private static gradientCounter;
+    constructor(container: HTMLElement, width: number, height: number);
+    setSize(width: number, height: number): void;
+    createGroup(className?: string, parent?: Selection<any, any, any, any>): Selection<SVGGElement, unknown, null, undefined>;
+    /**
+     * Text factory. Appends a `<text>` to the SVG root at absolute
+     * coordinates and returns a chainable {@link RendererElement}. Used by custom render callbacks.
+     */
+    text(str: string, x: number, y: number): RendererElement;
+    createClipPath(x: number, y: number, width: number, height: number): string;
+    updateClipPath(id: string, x: number, y: number, width: number, height: number): void;
+    createLinearGradient(id: string | null, x1: string, y1: string, x2: string, y2: string, stops: {
+        offset: string;
+        color: string;
+        opacity?: number;
+    }[]): string;
+    getSVGNode(): SVGSVGElement | null;
+    destroy(): void;
+    getSerializedSVG(): string;
+}

package/dist/core/ScrollablePlotOverlay.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Builds the fixed overlay that pins axes, title/subtitle, legend, export button
+ * and color axis in place while the plot area scrolls inside a scrollable
+ * container. Extracted from `Chart` as a pure function over an explicit context
+ * so it has no hidden dependency on chart internals; the caller owns the
+ * returned overlay element and its lifecycle.
+ */
+import type { SVGRenderer } from './SVGRenderer';
+import type { LayoutResult } from '../layout/LayoutEngine';
+import type { InternalConfig } from '../types/options';
+import type { ExportButton } from '../components/ExportButton';
+type PlotGroup = ReturnType<SVGRenderer['createGroup']>;
+export interface ScrollableOverlayContext {
+    container: HTMLElement;
+    renderer: SVGRenderer;
+    options: InternalConfig;
+    plotGroup: PlotGroup;
+    layout: LayoutResult;
+    chartWidth: number;
+    chartHeight: number;
+    scrollableInner: HTMLDivElement | null;
+    scrollableOuterWidth: number;
+    scrollableOuterHeight: number;
+    useVerticalScroll: boolean;
+    useHorizontalScroll: boolean;
+    exportButton: ExportButton | null;
+    /** The overlay created by a previous call, removed before rebuilding. */
+    previousOverlay: SVGSVGElement | null;
+}
+export declare function createFixedAxisOverlay(ctx: ScrollableOverlayContext): SVGSVGElement | null;
+export {};

package/dist/core/StackComputer.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Shared primitives for series stacking math. The chart computes per-stack
+ * totals and forward offsets in four places (series render, animated redraw,
+ * axis-domain updates and stack labels); these helpers keep the stack-key
+ * format and the accumulation loop in one place so the variants cannot drift.
+ */
+interface StackKeyConfig {
+    _internalType: string;
+    stack?: string | number;
+}
+interface StackPoint {
+    x?: number | string;
+    y?: number | null;
+}
+/**
+ * Identity of a stack group: series of the same internal type and `stack` name
+ * accumulate together.
+ */
+export declare function stackKey(cfg: StackKeyConfig): string;
+/**
+ * Adds each point's `y` into `totals`, keyed by `x` (defaulting to 0). Mutates
+ * and returns `totals` so callers can fold several series into one map.
+ */
+export declare function accumulateStackTotals(data: ReadonlyArray<StackPoint>, totals: Map<number | string, number>): Map<number | string, number>;
+export {};

package/dist/core/StateManager.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Holds normalized config and series data, routes mutations through events.
+ */
+import type { InternalConfig, InternalSeriesConfig, AxisOptions, SeriesOptions } from '../types/options';
+import { EventBus } from './EventBus';
+export declare class StateManager {
+    private config;
+    readonly events: EventBus;
+    constructor(config: InternalConfig, events: EventBus);
+    getConfig(): InternalConfig;
+    updateConfig(partial: Partial<InternalConfig>): void;
+    getSeries(): InternalSeriesConfig[];
+    getSeriesById(id: string): InternalSeriesConfig | undefined;
+    getSeriesByIndex(index: number): InternalSeriesConfig | undefined;
+    addSeries(series: InternalSeriesConfig): void;
+    removeSeries(index: number): InternalSeriesConfig | undefined;
+    updateSeries(index: number, updates: Partial<SeriesOptions>): void;
+    getXAxes(): AxisOptions[];
+    getYAxes(): AxisOptions[];
+    updateAxis(isX: boolean, index: number, updates: Partial<AxisOptions>): void;
+}

package/dist/core/UpdateScheduler.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Sits between data mutations and DOM rendering.
+ * Batches updates and flushes via requestAnimationFrame with configurable FPS cap.
+ */
+import type { StreamingOptions } from '../types/options';
+export type UpdateType = 'addPoint' | 'addPoints' | 'setData' | 'removePoint' | 'updateSeries';
+export interface UpdateEntry {
+    type: UpdateType;
+    payload: any;
+}
+export declare class UpdateBatch {
+    entries: UpdateEntry[];
+    add(type: UpdateType, payload: any): void;
+    get isEmpty(): boolean;
+}
+export declare class UpdateScheduler {
+    private pendingUpdates;
+    private rafId;
+    private lastFrameTime;
+    private maxFps;
+    private flushCallback;
+    constructor(options: StreamingOptions, flushCallback: () => void);
+    schedule(series: any, type: UpdateType, payload: any): void;
+    private requestFrame;
+    flush(): void;
+    destroy(): void;
+    get hasPending(): boolean;
+}

package/dist/core/animationConstants.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Centralized animation timings and easings used across every series.
+ * Entry duration is unified to match the heatmap reference; hover transitions
+ * are smoothed to a clearly perceivable ~300 ms with cubic-out easing.
+ */
+import { easeCubicOut, easeCubicInOut } from 'd3-ease';
+export declare const ENTRY_DURATION = 600;
+export declare const ENTRY_STAGGER_PER_ITEM = 8;
+export declare const ENTRY_DELAY_BASE = 0;
+export declare const ENTRY_DATALABEL_DELAY: number;
+/** Base animation duration for circos plot families. Sized so each staged
+ *  sweep (ideogram, tracks) lands near the standard entry duration. */
+export declare const ENTRY_CIRCOS_DURATION = 1600;
+/** Gap inserted between hierarchical animation stages. */
+export declare const ENTRY_STAGE_GAP = 120;
+export declare const HOVER_DURATION = 300;
+export declare const HOVER_INACTIVE_DURATION = 250;
+export declare const EASE_ENTRY: typeof easeCubicOut;
+export declare const EASE_HOVER: typeof easeCubicOut;
+export declare const EASE_UPDATE: typeof easeCubicInOut;

package/dist/core/chartTypes.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Canonical series-type classification sets shared across the chart, layout and
+ * axis subsystems. Previously each consumer maintained its own inline `Set`,
+ * which drifted out of sync (e.g. `treegraph`/`wordcloud` were missing from the
+ * layout engine's copy, causing it to reserve cartesian-axis space for them).
+ */
+/**
+ * Series types that do not use cartesian x/y axes. When every series in a chart
+ * is one of these, the chart skips axis construction and cartesian layout.
+ */
+export declare const NO_AXES_TYPES: ReadonlySet<string>;
+/**
+ * Series types that render their own data labels (or have no cartesian point
+ * geometry), and therefore must not receive the generic cartesian
+ * `DataLabels.render` pass.
+ */
+export declare const NON_CARTESIAN_TYPES: ReadonlySet<string>;
+/**
+ * Cartesian series types that draw their own data labels internally, so the
+ * generic `DataLabels.render` pass should skip them to avoid duplicate labels.
+ */
+export declare const SELF_RENDERED_DATALABEL_TYPES: ReadonlySet<string>;
+/**
+ * Series types whose geometry overflows the plot area and must not be clipped.
+ */
+export declare const NO_CLIP_TYPES: ReadonlySet<string>;
+/**
+ * Series types whose markers extend beyond data extents and need the plot clip
+ * region expanded by a margin.
+ */
+export declare const EXPAND_TYPES: ReadonlySet<string>;
+/**
+ * Cartesian series types that should anchor their value axis at zero by default.
+ */
+export declare const ZERO_BASE_TYPES: ReadonlySet<string>;
+/**
+ * Returns true when the given series type uses cartesian x/y axes.
+ */
+export declare function hasAxes(internalType: string): boolean;
+/**
+ * Returns true when a chart has series and every one of them is a non-cartesian
+ * type — i.e. the chart should skip axis construction and cartesian layout.
+ */
+export declare function isNonCartesianChart(series: ReadonlyArray<{
+    _internalType: string;
+}>): boolean;

package/dist/core/registerAll.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Registers all built-in series types with the ChartRegistry.
+ */
+export declare function registerAllSeriesTypes(): void;

package/dist/core/registerBio.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Registers bioinformatics series types as a plugin.
+ */
+export declare function registerBioSeriesTypes(): void;

package/dist/core/registerCore.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Registers only the most common series types for minimal bundle size.
+ */
+export declare function registerCoreSeriesTypes(): void;

package/dist/core/registerFinance.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Registers finance module series types as a plugin.
+ */
+export declare function registerFinanceSeriesTypes(): void;

package/dist/core/registerFinancial.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Registers financial series types as a plugin.
+ */
+export declare function registerFinancialSeriesTypes(): void;

package/dist/core/registerFlow.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Registers flow/network series types as a plugin.
+ */
+export declare function registerFlowSeriesTypes(): void;

package/dist/core/registerGeneral.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Registers general-purpose series types not covered by core/financial/flow.
+ */
+export declare function registerGeneralSeriesTypes(): void;

package/dist/datatable/DataTable.d.ts

@@ -0,0 +1,162 @@
+/**
+ * KatuCharts DataTable — main orchestrator.
+ */
+import type { DataTableOptions, InternalColumnDef, ColumnDefinition, PageInfo, SortState, SortDirection, PinDirection } from '../types/datatable-options';
+import { EventBus } from '../core/EventBus';
+import { type TableApi, type TableHost } from './api/TableApi';
+export declare class DataTable implements TableHost {
+    readonly container: HTMLElement;
+    readonly events: EventBus;
+    private options;
+    private resolvedLang;
+    private theme;
+    private dataSource;
+    private processor;
+    private columnManager;
+    private selectionManager;
+    private cellEditor;
+    private tableApi;
+    private tableRenderer;
+    private paginationRenderer;
+    private toolbarRenderer;
+    private rootEl;
+    private tableArea;
+    private columns;
+    private currentResult;
+    private currentPage;
+    private currentPageSize;
+    private searchQuery;
+    private sortState;
+    private filterState;
+    private groupExpanded;
+    private resizeObserver;
+    private destroyed;
+    private lastResponsiveWidth;
+    private refreshing;
+    private serverTotal;
+    private initialVisibility;
+    constructor(containerOrId: string | HTMLElement, options?: DataTableOptions);
+    /**
+     * Fold a TanStack-style `initialState` block into the matching option
+     * groups so the starting page size, sort, hidden columns and filters are
+     * honoured on first render.
+     */
+    private applyInitialState;
+    /** Apply theme variables, data flags, class hooks and explicit container style to the root. */
+    private applyRootStyling;
+    private init;
+    private initAsync;
+    private initColumns;
+    private renderFull;
+    private isFilteringEnabled;
+    /**
+     * Resolve which toolbar items to show. The column-toggle and export buttons
+     * are opt-out via their feature flags (`columnVisibility.enabled` /
+     * `exporting.enabled`), and a "reset filters" item is added automatically
+     * when filtering is active and not opted out.
+     */
+    private resolveToolbarItems;
+    private processData;
+    private isVirtualEnabled;
+    private computeBodyHeight;
+    private wireEvents;
+    private bindUserEvents;
+    private handleSort;
+    private handleFilter;
+    private handleSearch;
+    private refreshRows;
+    private getExportData;
+    private setupResponsive;
+    private showContextMenu;
+    getInternalColumns(): InternalColumnDef[];
+    getRawData(): any[];
+    toggleSort(field: string, desc?: boolean): void;
+    setSort(field: string, dir: SortDirection): void;
+    clearColumnSort(field: string): void;
+    getSortDirection(field: string): SortDirection;
+    getFilterValue(field: string): any;
+    setColumnFilter(field: string, value: any): void;
+    isColumnVisible(field: string): boolean;
+    setColumnVisible(field: string, visible: boolean): void;
+    isRowSelected(index: number): boolean;
+    setRowSelected(index: number, selected: boolean): void;
+    isAllPageSelected(): boolean;
+    isSomePageSelected(): boolean;
+    toggleAllPageSelected(selected: boolean): void;
+    setPageSizeValue(size: number): void;
+    /** The TanStack Table-compatible facade for use in custom integrations. */
+    getTableApi(): TableApi;
+    /**
+     * Replace all table data. Columns are re-detected if not explicitly set.
+     * Use this to feed data from any source (your own fetch, websocket, etc.)
+     */
+    setData(data: any[]): void;
+    /**
+     * Load data from a URL. Fetches JSON and calls setData().
+     * Supports GET/POST, custom headers, and response mapping.
+     */
+    loadFromUrl(url: string, options?: {
+        method?: 'GET' | 'POST';
+        headers?: Record<string, string>;
+        body?: any;
+        responseMapper?: (json: any) => {
+            data: any[];
+            total?: number;
+        };
+    }): Promise<void>;
+    getData(): any[];
+    getFilteredData(): any[];
+    getSelectedData(): any[];
+    addRow(row: any, index?: number): void;
+    removeRow(indexOrPredicate: number | ((row: any) => boolean)): void;
+    updateRow(index: number, data: Partial<any>): void;
+    updateCell(rowIndex: number, column: string, value: any): void;
+    getRow(index: number): any;
+    getRowCount(): number;
+    getFilteredRowCount(): number;
+    getColumns(): ColumnDefinition[];
+    updateColumn(field: string, updates: Partial<ColumnDefinition>): void;
+    showColumn(field: string): void;
+    hideColumn(field: string): void;
+    pinColumn(field: string, direction: PinDirection): void;
+    sort(column: string, direction?: SortDirection): void;
+    clearSort(): void;
+    getSortState(): SortState[];
+    setFilter(column: string, value: any): void;
+    clearFilter(column?: string): void;
+    getFilterState(): Record<string, any>;
+    search(query: string): void;
+    clearSearch(): void;
+    goToPage(page: number): void;
+    setPageSize(size: number): void;
+    getPageInfo(): PageInfo;
+    selectRow(index: number | number[]): void;
+    deselectRow(index: number | number[]): void;
+    selectAll(): void;
+    deselectAll(): void;
+    getSelectedRows(): any[];
+    getSelectedIndices(): number[];
+    groupBy(columns: string[]): void;
+    ungroup(): void;
+    expandGroup(value: any): void;
+    collapseGroup(value: any): void;
+    expandAll(): void;
+    collapseAll(): void;
+    exportCSV(opts?: any): void;
+    exportJSON(opts?: any): void;
+    copyToClipboard(): void;
+    getCSV(): string;
+    getJSON(): string;
+    getHTML(): string;
+    update(options: Partial<DataTableOptions>): void;
+    /** Switch the active locale at runtime and redraw. Existing `lang` overrides are kept. */
+    setLocale(locale: string): void;
+    redraw(): void;
+    showLoading(text?: string): void;
+    hideLoading(): void;
+    scrollToRow(index: number): void;
+    trigger(action: string, payload?: any): this;
+    on(event: string, callback: (...args: any[]) => void): this;
+    off(event: string, callback?: (...args: any[]) => void): this;
+    destroy(): void;
+}

package/dist/datatable/DataTableDefaults.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Default option values for DataTable.
+ */
+import type { DataTableOptions } from '../types/datatable-options';
+export declare const DATA_TABLE_DEFAULTS: DataTableOptions;
+export declare const DENSITY_ROW_HEIGHTS: Record<string, number>;
+export declare const DENSITY_HEADER_HEIGHTS: Record<string, number>;

package/dist/datatable/api/TableApi.d.ts

@@ -0,0 +1,35 @@
+/**
+ * TanStack Table-compatible facade.
+ *
+ * Column `header`/`cell` callbacks are written against TanStack's `table`,
+ * `column` and `row` objects (`row.getValue(id)`, `row.original`,
+ * `column.toggleSorting()`, `table.getIsAllPageRowsSelected()`, …). This module
+ * reproduces that surface on top of KatuCharts' own engine so familiar
+ * TanStack-style column definitions run unchanged.
+ */
+import type { InternalColumnDef, SortDirection, PageInfo, ProcessedRow, ColumnApi, RowApi, TableApi } from '../../types/datatable-options';
+export interface TableHost {
+    getInternalColumns(): InternalColumnDef[];
+    getRawData(): any[];
+    toggleSort(field: string, desc?: boolean): void;
+    setSort(field: string, dir: SortDirection): void;
+    clearColumnSort(field: string): void;
+    getSortDirection(field: string): SortDirection;
+    getFilterValue(field: string): any;
+    setColumnFilter(field: string, value: any): void;
+    isColumnVisible(field: string): boolean;
+    setColumnVisible(field: string, visible: boolean): void;
+    isRowSelected(index: number): boolean;
+    setRowSelected(index: number, selected: boolean): void;
+    isAllPageSelected(): boolean;
+    isSomePageSelected(): boolean;
+    toggleAllPageSelected(selected: boolean): void;
+    getPageInfo(): PageInfo;
+    goToPage(page: number): void;
+    setPageSizeValue(size: number): void;
+}
+export type { ColumnApi, RowApi, TableApi };
+declare function makeColumnApi(host: TableHost, col: InternalColumnDef): ColumnApi;
+export declare function makeRowApi(host: TableHost, row: ProcessedRow): RowApi;
+export declare function createTableApi(host: TableHost): TableApi;
+export { makeColumnApi };

package/dist/datatable/columns/ColumnDef.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Column type detection, normalization, and processing.
+ */
+import type { ColumnDefinition, ColumnType, FilterType, InternalColumnDef, AlignType } from '../../types/datatable-options';
+export declare function detectColumnType(values: any[]): ColumnType;
+export declare function inferColumnsFromData(data: any[]): ColumnDefinition[];
+export declare function defaultAlignForType(type?: ColumnType): AlignType;
+export declare function defaultFilterTypeForColumn(col: ColumnDefinition): FilterType;
+/**
+ * Resolve a column's value for a row, honouring an `accessorFn` (TanStack) when
+ * present and otherwise reading the flat `field`/`accessorKey`.
+ */
+export declare function resolveCellValue(row: any, col: ColumnDefinition): any;
+export declare function normalizeColumns(columns: ColumnDefinition[], containerWidth: number, sample?: any[], reservedWidth?: number): InternalColumnDef[];
+export declare function getVisibleColumns(columns: InternalColumnDef[]): InternalColumnDef[];
+export declare function computePinnedOffsets(columns: InternalColumnDef[]): void;