katucharts.js 0.2.1

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

@@ -0,0 +1,31 @@
+/**
+ * Column state management: visibility, reordering, pinning.
+ */
+import type { InternalColumnDef, PinDirection } from '../../types/datatable-options';
+import type { EventBus } from '../../core/EventBus';
+export declare class ColumnManager {
+    private columns;
+    private events;
+    private responsiveHidden;
+    constructor(columns: InternalColumnDef[], events: EventBus);
+    getColumns(): InternalColumnDef[];
+    setColumns(columns: InternalColumnDef[]): void;
+    getVisibleColumns(): InternalColumnDef[];
+    showColumn(field: string): void;
+    hideColumn(field: string): void;
+    toggleColumn(field: string, visible: boolean): void;
+    pinColumn(field: string, direction: PinDirection): void;
+    reorderColumn(fromField: string, toIndex: number): void;
+    resizeColumn(field: string, width: number): void;
+    updateColumn(field: string, updates: Partial<InternalColumnDef>): void;
+    applyResponsiveHiding(containerWidth: number): string[];
+    setSortState(sort: Array<{
+        column: string;
+        direction: 'asc' | 'desc' | null;
+    }>): void;
+    setFilterValue(field: string, value: any): void;
+    clearFilters(): void;
+    private find;
+    private recalcPinning;
+    destroy(): void;
+}

package/dist/datatable/data/DataProcessor.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Data processing pipeline: search → filter → group → sort → aggregate → paginate → virtual window.
+ */
+import type { InternalColumnDef, ProcessedResult, SortState, TreeDataOptions } from '../../types/datatable-options';
+type DirtyStage = 'search' | 'filter' | 'group' | 'sort' | 'aggregate' | 'paginate' | 'window';
+export interface ProcessorState {
+    search: string;
+    searchColumns: string[] | undefined;
+    caseSensitive: boolean;
+    filters: Record<string, any>;
+    sort: SortState[];
+    groupBy: string[];
+    groupExpanded: Map<string, boolean>;
+    page: number;
+    pageSize: number;
+    paginationEnabled: boolean;
+    scrollTop: number;
+    viewportHeight: number;
+    virtualEnabled: boolean;
+    virtualRowHeight: number;
+    virtualOverscan: number;
+    treeData?: TreeDataOptions;
+}
+export declare class DataProcessor {
+    private caches;
+    private dirtyFrom;
+    invalidate(fromStage: DirtyStage): void;
+    invalidateAll(): void;
+    process(rawData: any[], columns: InternalColumnDef[], state: ProcessorState): ProcessedResult;
+    private shouldRun;
+    private applySearch;
+    private applyFilters;
+    private matchesFilter;
+    private inferFilterType;
+    private applySorting;
+    private defaultCompare;
+    private reinterlaceGrouped;
+    private applyGrouping;
+    private flattenTree;
+    private applyPagination;
+    private applyVirtualWindow;
+    private computeAggregates;
+    private extractGroups;
+    private makeDataRow;
+}
+export {};

package/dist/datatable/data/DataSource.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Data loading and normalization from various sources.
+ */
+import type { DataTableOptions, ServerSideRequestParams } from '../../types/datatable-options';
+export interface DataSourceResult {
+    data: any[];
+    total: number;
+}
+export declare class DataSource {
+    private rawData;
+    private options;
+    constructor(options: DataTableOptions);
+    loadSync(): DataSourceResult;
+    load(): Promise<DataSourceResult>;
+    loadServerSide(params: ServerSideRequestParams): Promise<DataSourceResult>;
+    setData(data: any[]): DataSourceResult;
+    getData(): any[];
+    addRow(row: any, index?: number): void;
+    removeRow(index: number): any | undefined;
+    updateRow(index: number, data: Partial<any>): void;
+    updateCell(rowIndex: number, field: string, value: any): void;
+    private normalizeData;
+    private normalizeRow;
+    private extractChartData;
+    updateOptions(options: DataTableOptions): void;
+}

package/dist/datatable/editing/CellEditor.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Inline cell editing with built-in and custom editors.
+ */
+import type { InternalColumnDef, EditingOptions } from '../../types/datatable-options';
+import type { EventBus } from '../../core/EventBus';
+import type { TableTheme } from '../themes/TableTheme';
+export declare class CellEditor {
+    private events;
+    private theme;
+    private options;
+    private activeEditor;
+    constructor(events: EventBus, theme: TableTheme, options: EditingOptions);
+    startEditing(td: HTMLTableCellElement, value: any, row: any, column: InternalColumnDef, rowIndex: number): void;
+    private createEditor;
+    private createTextEditor;
+    private createNumberEditor;
+    private createSelectEditor;
+    private createDateEditor;
+    private createCheckboxEditor;
+    private styleEditorInput;
+    private attachEditorEvents;
+    commit(): void;
+    cancel(): void;
+    private commitOrCancel;
+    private showValidationError;
+    isEditing(): boolean;
+    private inferEditorType;
+    destroy(): void;
+}

package/dist/datatable/export/TableExport.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Table data export to CSV, JSON, clipboard, and HTML.
+ */
+import type { ExportTableOptions, InternalColumnDef } from '../../types/datatable-options';
+export declare class TableExport {
+    static exportCSV(data: any[], columns: InternalColumnDef[], options?: ExportTableOptions['csv'], filename?: string): void;
+    static exportJSON(data: any[], columns: InternalColumnDef[], options?: ExportTableOptions['json'], filename?: string): void;
+    static copyToClipboard(data: any[], columns: InternalColumnDef[]): void;
+    static exportHTML(data: any[], columns: InternalColumnDef[], filename?: string): void;
+    static toCSV(data: any[], columns: InternalColumnDef[], options?: ExportTableOptions['csv']): string;
+    static toJSON(data: any[], columns: InternalColumnDef[], options?: ExportTableOptions['json']): string;
+    static toHTML(data: any[], columns: InternalColumnDef[]): string;
+    /**
+     * Escapes a CSV field: neutralizes spreadsheet formula injection by prefixing
+     * cells that begin with =, +, -, @, tab or CR with a single quote (plain
+     * numbers exempted), then quotes per RFC 4180 when the field contains the
+     * delimiter, a double quote, or a line break.
+     */
+    private static escapeCSV;
+    private static escapeHTML;
+    private static downloadBlob;
+    private static fallbackCopy;
+}

package/dist/datatable/locales/en.d.ts

@@ -0,0 +1,9 @@
+/**
+ * English locale pack — the base/fallback for every other locale.
+ *
+ * This pack is complete: it populates every key in DataTableLangOptions and is
+ * the single source of truth for English defaults. resolveLocale always starts
+ * from this pack, so partial packs only need to list the strings they translate.
+ */
+import type { DataTableLangOptions } from '../../types/datatable-options';
+export declare const enLocale: Required<DataTableLangOptions>;

package/dist/datatable/locales/es.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Spanish locale pack. Partial: any key not listed here falls back to the
+ * English base. Language-neutral pagination glyphs are intentionally omitted.
+ */
+import type { DataTableLangOptions } from '../../types/datatable-options';
+export declare const esLocale: Partial<DataTableLangOptions>;

package/dist/datatable/locales/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Built-in locale registry and lookup for the DataTable.
+ *
+ * Ships English (base), Brazilian Portuguese, Spanish and Simplified Chinese.
+ * `registerLocale` lets callers add or override packs for additional languages.
+ */
+import type { DataTableLangOptions } from '../../types/datatable-options';
+import { enLocale } from './en';
+import { ptBRLocale } from './pt-BR';
+import { esLocale } from './es';
+import { zhLocale } from './zh';
+/**
+ * Register (or replace) a locale pack so it can be selected via the `locale`
+ * option or matched during auto-detection.
+ *
+ * @param code  BCP 47 language tag, e.g. `'fr'` or `'de-DE'`.
+ * @param pack  Strings for that locale; omitted keys fall back to English.
+ */
+export declare function registerLocale(code: string, pack: Partial<DataTableLangOptions>): void;
+/** Return the registered pack for a locale code, or `undefined` when unknown. */
+export declare function getLocalePack(code: string): Partial<DataTableLangOptions> | undefined;
+export { enLocale, ptBRLocale, esLocale, zhLocale };

package/dist/datatable/locales/pt-BR.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Brazilian Portuguese locale pack. Partial: any key not listed here falls back
+ * to the English base. Language-neutral pagination glyphs are intentionally omitted.
+ */
+import type { DataTableLangOptions } from '../../types/datatable-options';
+export declare const ptBRLocale: Partial<DataTableLangOptions>;

package/dist/datatable/locales/resolveLocale.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Resolve the effective set of UI strings for a DataTable instance.
+ *
+ * Precedence (lowest to highest): English base pack, the matched locale pack,
+ * then per-key `lang` overrides. When no locale is given (or `'auto'`), the
+ * browser language is detected; an explicit locale pins the language and skips
+ * detection entirely.
+ */
+import type { DataTableLangOptions } from '../../types/datatable-options';
+export interface ResolveLocaleOptions {
+    /** Explicit locale code, or `'auto'`/omitted to detect from the browser. */
+    locale?: string;
+    /** Per-key string overrides that win over the resolved locale pack. */
+    langOverrides?: Partial<DataTableLangOptions>;
+}
+export declare function resolveLocale(opts?: ResolveLocaleOptions): Required<DataTableLangOptions>;

package/dist/datatable/locales/zh.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Simplified Chinese locale pack. Partial: any key not listed here falls back to
+ * the English base. Language-neutral pagination glyphs are intentionally omitted.
+ */
+import type { DataTableLangOptions } from '../../types/datatable-options';
+export declare const zhLocale: Partial<DataTableLangOptions>;

package/dist/datatable/render/CellRenderer.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Cell value formatting and rendering.
+ */
+import type { InternalColumnDef, ProcessedRow } from '../../types/datatable-options';
+import type { TableTheme } from '../themes/TableTheme';
+import type { TableApi } from '../api/TableApi';
+import type { TableHost } from '../api/TableApi';
+export declare class CellRenderer {
+    private theme;
+    private formatters;
+    private api;
+    private host;
+    constructor(theme: TableTheme, formatters?: Record<string, (value: any) => string>);
+    setApi(api: TableApi | null, host: TableHost | null): void;
+    createCell(tr: HTMLTableRowElement, value: any, row: ProcessedRow, col: InternalColumnDef, rowIndex: number): HTMLTableCellElement;
+    private formatValue;
+    private defaultNumberFormat;
+    private defaultDateFormat;
+    private defaultBooleanFormat;
+    private computeClass;
+    private computeTooltip;
+    updateFormatters(formatters: Record<string, (value: any) => string>): void;
+    resolveValue(row: any, col: InternalColumnDef): any;
+}

package/dist/datatable/render/HeaderRenderer.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Table header rendering with sort indicators, filter inputs, and resize handles.
+ */
+import type { InternalColumnDef, HeaderGroupDefinition, DataTableLangOptions } from '../../types/datatable-options';
+import type { TableTheme } from '../themes/TableTheme';
+import type { EventBus } from '../../core/EventBus';
+import type { TableApi, TableHost } from '../api/TableApi';
+interface HeaderOptions {
+    sortingEnabled: boolean;
+    filteringEnabled: boolean;
+    filterPosition: string;
+    resizingEnabled: boolean;
+    selectionCheckbox: boolean;
+    headerGroups?: HeaderGroupDefinition[];
+    api?: TableApi | null;
+    host?: TableHost | null;
+}
+export declare class HeaderRenderer {
+    private theme;
+    private events;
+    private lang;
+    private thead;
+    private filterRow;
+    private resizing;
+    private api;
+    private host;
+    constructor(theme: TableTheme, events: EventBus, lang?: DataTableLangOptions);
+    /** Swap the active locale strings; takes effect on the next render. */
+    setLang(lang: DataTableLangOptions): void;
+    render(table: HTMLTableElement, columns: InternalColumnDef[], options: HeaderOptions): HTMLTableSectionElement;
+    private createHeaderCell;
+    private createSortIcon;
+    private createResizeHandle;
+    private createCheckboxHeader;
+    private createFilterRow;
+    private createFilterInput;
+    private createTextFilter;
+    private createNumberFilter;
+    private createDateFilter;
+    private createSelectFilter;
+    private createBooleanFilter;
+    /** A single-select column filter rendered as a themed dropdown (not a native <select>). */
+    private createSingleSelectFilter;
+    /** A faceted multi-select filter: button + checkbox menu. */
+    private createFacetedFilter;
+    private renderHeaderGroups;
+    private inferFilterType;
+    updateSelectAllCheckbox(allSelected: boolean, someSelected: boolean): void;
+    destroy(): void;
+}
+export {};

package/dist/datatable/render/PaginationRenderer.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Pagination controls rendering and state.
+ */
+import type { PaginationOptions, PageInfo, DataTableLangOptions } from '../../types/datatable-options';
+import type { TableTheme } from '../themes/TableTheme';
+import type { EventBus } from '../../core/EventBus';
+export declare class PaginationRenderer {
+    private theme;
+    private events;
+    private container;
+    private lang;
+    private pageSizePopover;
+    constructor(theme: TableTheme, events: EventBus, lang?: DataTableLangOptions);
+    /** Swap the active locale strings; takes effect on the next render. */
+    setLang(lang: DataTableLangOptions): void;
+    render(parent: HTMLElement, pageInfo: PageInfo, options: PaginationOptions): HTMLDivElement;
+    private createButton;
+    private createIconButton;
+    private createTextButton;
+    private createPageSizeSelector;
+    private closePageSizeMenu;
+    private getPageNumbers;
+    private formatPageInfo;
+    update(pageInfo: PageInfo, options: PaginationOptions, parent: HTMLElement): void;
+    destroy(): void;
+}

package/dist/datatable/render/SearchRenderer.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Global search input rendering.
+ */
+import type { SearchOptions, DataTableLangOptions } from '../../types/datatable-options';
+import type { TableTheme } from '../themes/TableTheme';
+import type { EventBus } from '../../core/EventBus';
+export declare class SearchRenderer {
+    private theme;
+    private events;
+    private lang;
+    private input;
+    private container;
+    constructor(theme: TableTheme, events: EventBus, lang?: DataTableLangOptions);
+    /** Swap the active locale strings; takes effect on the next render. */
+    setLang(lang: DataTableLangOptions): void;
+    render(parent: HTMLElement, options: SearchOptions): HTMLDivElement;
+    setValue(query: string): void;
+    getValue(): string;
+    focus(): void;
+    destroy(): void;
+}

package/dist/datatable/render/TableRenderer.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Main HTML table rendering engine with virtual scrolling support.
+ */
+import type { InternalColumnDef, ProcessedResult, GroupingOptions, MasterDetailOptions, TreeDataOptions, VirtualScrollOptions, SelectionMode, DataTableLangOptions } from '../../types/datatable-options';
+import type { TableTheme } from '../themes/TableTheme';
+import type { EventBus } from '../../core/EventBus';
+import type { TableApi, TableHost } from '../api/TableApi';
+import { HeaderRenderer } from './HeaderRenderer';
+interface RenderOptions {
+    height?: number | string;
+    sortingEnabled: boolean;
+    filteringEnabled: boolean;
+    filterPosition: string;
+    resizingEnabled: boolean;
+    selectionMode: SelectionMode;
+    selectionCheckbox: boolean;
+    grouping?: GroupingOptions;
+    masterDetail?: MasterDetailOptions;
+    treeData?: TreeDataOptions;
+    virtualScroll?: VirtualScrollOptions;
+    headerGroups?: any[];
+    selectedIndices: Set<number>;
+    noDataText: string;
+    loadingText: string;
+    api?: TableApi | null;
+    host?: TableHost | null;
+    bodyClass?: string;
+    tableClass?: string;
+}
+interface UpdateOptions {
+    selectionMode: SelectionMode;
+    selectionCheckbox: boolean;
+    grouping?: GroupingOptions;
+    masterDetail?: MasterDetailOptions;
+    treeData?: TreeDataOptions;
+    selectedIndices: Set<number>;
+    noDataText: string;
+    api?: TableApi | null;
+    host?: TableHost | null;
+}
+export declare class TableRenderer {
+    private theme;
+    private events;
+    private lang;
+    private cellRenderer;
+    private headerRenderer;
+    private tableContainer;
+    private headerScrollContainer;
+    private bodyScrollContainer;
+    private headerTable;
+    private bodyTable;
+    private tbody;
+    private colgroup;
+    private headerColgroup;
+    private spacer;
+    private loadingOverlay;
+    private currentRows;
+    private virtualEnabled;
+    private virtualRowHeight;
+    private virtualOverscan;
+    private totalRows;
+    constructor(theme: TableTheme, events: EventBus, formatters?: Record<string, (value: any) => string>, lang?: DataTableLangOptions);
+    /** Swap the active locale strings; takes effect on the next render. */
+    setLang(lang: DataTableLangOptions): void;
+    render(parent: HTMLElement, columns: InternalColumnDef[], result: ProcessedResult, options: RenderOptions): void;
+    updateRows(result: ProcessedResult, columns: InternalColumnDef[], options: UpdateOptions): void;
+    private renderRows;
+    private renderGroupHeader;
+    private renderDetailRow;
+    private renderNoData;
+    private createColgroup;
+    updateVirtualPosition(scrollTop: number): void;
+    showLoading(text?: string): void;
+    hideLoading(): void;
+    scrollToRow(index: number): void;
+    getHeaderRenderer(): HeaderRenderer;
+    getBodyScrollContainer(): HTMLDivElement | null;
+    private cleanup;
+    destroy(): void;
+}
+export {};

package/dist/datatable/render/ToolbarRenderer.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Toolbar rendering with search, column toggle, export, density and reset controls.
+ */
+import type { ToolbarOptions, SearchOptions, ExportTableOptions, InternalColumnDef, DataTableLangOptions } from '../../types/datatable-options';
+import type { TableTheme } from '../themes/TableTheme';
+import type { EventBus } from '../../core/EventBus';
+import { SearchRenderer } from './SearchRenderer';
+export declare class ToolbarRenderer {
+    private theme;
+    private events;
+    private container;
+    private searchRenderer;
+    private lang;
+    private popover;
+    private hasActiveFilters;
+    private resetButton;
+    constructor(theme: TableTheme, events: EventBus, lang?: DataTableLangOptions);
+    /** Swap the active locale strings; takes effect on the next render. */
+    setLang(lang: DataTableLangOptions): void;
+    setActiveFilters(active: boolean): void;
+    /** Toggle the reset button live, without re-rendering the toolbar. */
+    setResetVisible(visible: boolean): void;
+    render(parent: HTMLElement, options: ToolbarOptions, searchOptions: SearchOptions, exportOptions: ExportTableOptions, columns: InternalColumnDef[]): HTMLDivElement;
+    private button;
+    private createResetButton;
+    private toggleMenu;
+    private createColumnToggle;
+    private createExportDropdown;
+    private createDensityToggle;
+    private createFullscreenButton;
+    private closeDropdown;
+    getSearchRenderer(): SearchRenderer;
+    destroy(): void;
+}

package/dist/datatable/render/icons.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Inline SVG icons (Lucide-style) used across the DataTable chrome.
+ * Returned as markup strings so they can be dropped into `innerHTML`.
+ */
+export declare const ICONS: {
+    readonly sortAsc: string;
+    readonly sortDesc: string;
+    readonly sortNone: string;
+    readonly search: string;
+    readonly columns: string;
+    readonly download: string;
+    readonly sliders: string;
+    readonly expand: string;
+    readonly check: string;
+    readonly x: string;
+    readonly chevronLeft: string;
+    readonly chevronRight: string;
+    readonly chevronDown: string;
+    readonly chevronsUpDown: string;
+    readonly chevronsLeft: string;
+    readonly chevronsRight: string;
+    readonly plusCircle: string;
+};
+export type IconName = keyof typeof ICONS;

package/dist/datatable/render/popover.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Lightweight body-level popover positioning.
+ *
+ * Dropdowns and faceted filters are portalled to <body> so they are never
+ * clipped by the table's `overflow:hidden` scroll containers. Because the menu
+ * then lives outside the themed root, the active `--kdt-*` custom properties
+ * are copied onto it so dark/branded themes are preserved.
+ */
+export interface PopoverHandle {
+    element: HTMLElement;
+    close(): void;
+}
+export declare function openPopover(anchor: HTMLElement, content: HTMLElement, opts?: {
+    align?: 'left' | 'right';
+}): PopoverHandle;

package/dist/datatable/selection/SelectionManager.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Row selection state management.
+ */
+import type { SelectionMode, ProcessedRow } from '../../types/datatable-options';
+import type { EventBus } from '../../core/EventBus';
+export declare class SelectionManager {
+    private mode;
+    private selectedIndices;
+    private events;
+    private preserveOnFilter;
+    private lastClickedIndex;
+    constructor(mode: SelectionMode, events: EventBus, preserveOnFilter?: boolean);
+    handleRowClick(rowIndex: number, row: any, event: MouseEvent): void;
+    handleCheckboxToggle(rowIndex: number, row: any, checked: boolean): void;
+    selectAll(rows: ProcessedRow[]): void;
+    deselectAll(): void;
+    selectRow(index: number | number[]): void;
+    deselectRow(index: number | number[]): void;
+    isSelected(index: number): boolean;
+    getSelectedIndices(): number[];
+    getSelectedData(allData: any[]): any[];
+    getCount(): number;
+    isAllSelected(totalVisible: number): boolean;
+    isSomeSelected(): boolean;
+    clearOnFilter(): void;
+    setMode(mode: SelectionMode): void;
+    private emitChange;
+    destroy(): void;
+}

package/dist/datatable/themes/TableTheme.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Theme resolution for the DataTable.
+ *
+ * Visuals live in the injected stylesheet (see styleSheet.ts). This class only
+ * translates `DataTableStyleOptions` into the two override channels CSS reads:
+ *  - `cssVariables()` — `--kdt-*` custom properties set on the root element.
+ *  - `rootDataset()`  — `data-*` flags (theme, density, borders, striping).
+ * Explicit per-part style objects the user supplies (headerCellStyle,
+ * cellStyle, rowStyle, …) are surfaced verbatim so renderers can apply them
+ * inline as the highest-priority override.
+ */
+import type { CSSObject, DataTableStyleOptions, DensityMode, LayoutStyle, RowStyleContext } from '../../types/datatable-options';
+export declare class TableTheme {
+    private style;
+    private layout;
+    constructor(style?: DataTableStyleOptions);
+    get density(): DensityMode;
+    get rowHeight(): number;
+    get headerHeight(): number;
+    getLayout(): LayoutStyle;
+    /**
+     * CSS custom properties applied to the root element, derived from style
+     * options. Anything left unset falls back to the stylesheet defaults.
+     */
+    cssVariables(width?: number | string, height?: number | string): Record<string, string>;
+    /** `data-*` flags applied to the root element. */
+    rootDataset(): Record<string, string>;
+    get userContainerStyle(): CSSObject | undefined;
+    get userTableStyle(): CSSObject | undefined;
+    get userHeaderRowStyle(): CSSObject | undefined;
+    get userHeaderCellStyle(): CSSObject | undefined;
+    get userBodyStyle(): CSSObject | undefined;
+    get userCellStyle(): CSSObject | undefined;
+    rowStyle(ctx: RowStyleContext): CSSObject | undefined;
+    update(style: DataTableStyleOptions): void;
+}

package/dist/datatable/themes/styleSheet.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Injected default stylesheet for the DataTable.
+ *
+ * The whole visual layer is expressed through low-specificity class selectors
+ * driven by `--kdt-*` custom properties. This is what makes the table both
+ * good-looking out of the box (a modern, neutral theme) and
+ * trivially overridable: consumers can re-theme by setting a single CSS
+ * variable, or restyle any part by targeting its stable class name — no
+ * `!important` required, because the renderers no longer hard-code visuals
+ * as inline styles.
+ */
+export declare const DATATABLE_STYLE_ID = "katucharts-datatable-styles";
+/**
+ * Injects the shared stylesheet into <head> exactly once per document.
+ */
+export declare function injectDataTableStyles(doc?: Document): void;

package/dist/datatable.d.ts

@@ -0,0 +1,19 @@
+/**
+ * KatuCharts DataTable module.
+ *
+ * Standalone usage:
+ *   import { DataTable } from 'katucharts/datatable';
+ *   const table = new DataTable('#container', { data: [...] });
+ *
+ * With KatuCharts:
+ *   import { DataTableModule } from 'katucharts/datatable';
+ *   KatuCharts.use(DataTableModule);
+ *   KatuCharts.dataTable('#container', { ... });
+ */
+import { DataTable } from './datatable/DataTable';
+import type { ModuleDefinition } from './core/Registry';
+export declare const DataTableModule: ModuleDefinition;
+export { DataTable };
+export { registerLocale } from './datatable/locales';
+export { resolveLocale } from './datatable/locales/resolveLocale';
+export type { DataTableOptions, ColumnDefinition, ColumnType, SortDirection, FilterType, SelectionMode, PinDirection, DensityMode, LayoutStyle, DataTableEventsOptions, PaginationOptions, SearchOptions, ToolbarOptions, ExportTableOptions, ServerSideOptions, VirtualScrollOptions, GroupingOptions, MasterDetailOptions, TreeDataOptions, ContextMenuOptions, ContextMenuItem, DataTableStyleOptions, DataTableClassNames, DataTableLangOptions, SortingOptions, FilteringOptions, SelectionOptions, EditingOptions, HeaderGroupDefinition, InternalColumnDef, ProcessedRow, ProcessedResult, PageInfo, SortState, FormatterContext, CellStyleContext, RowStyleContext, CustomEditorFn, CustomEditorResult, ColumnApi, RowApi, TableApi, HeaderContext, CellContext, HeaderRenderFn, CellRenderFn, ColumnFilterFn, } from './types/datatable-options';