@timelinekit/core 1.0.0 → 1.0.5

package/dist/common/base-chart-scroll-handler.d.ts

@@ -1,7 +1,7 @@
 import { BehaviorSubject } from "rxjs";
 import { DateRange } from "./common";
-import { ChartTimeline } from "../ganttchart/chart/chart-time-axis";
-import { GanttChartTheme } from "../ganttchart/themes/theme";
+import { ChartTimeline } from "./chart-time-axis";
+import { BaseTheme } from "./base-theme";
 /**
  * Interface for the context needed by the scroll handler.
  * Both GanttChartContext and ResourceSchedulerContext satisfy this.
@@ -9,7 +9,9 @@ import { GanttChartTheme } from "../ganttchart/themes/theme";
 export interface ScrollHandlerContext {
     timeline: ChartTimeline;
     projectTimeline$: BehaviorSubject<DateRange>;
-    theme$: BehaviorSubject<GanttChartTheme>;
+    theme$: {
+        getValue(): BaseTheme;
+    };
     dividerResizing$: BehaviorSubject<boolean>;
     autoScrolling: boolean;
 }

package/dist/common/base-chart.d.ts

@@ -0,0 +1,98 @@
+import { Observable, Subject } from "rxjs";
+import { BehaviorSubject } from "rxjs";
+import { Cursor } from "./common";
+import { ChartTimeline } from "./chart-time-axis";
+import { BaseTheme } from "./base-theme";
+/**
+ * Minimal context interface that both GanttChartContext and ResourceSchedulerContext satisfy.
+ *
+ * Uses a structural type for theme$ (only getValue is needed) to avoid
+ * BehaviorSubject variance issues when the concrete theme extends BaseTheme.
+ */
+export interface BaseChartContext {
+    timeline: ChartTimeline;
+    theme$: {
+        getValue(): BaseTheme;
+    };
+    chartCursor$: Subject<Cursor>;
+    chartMouseWheel$: Subject<any>;
+    chartRedrawn$: Subject<void>;
+    chartBackgroundRedrawn$: Subject<void>;
+    dividerResizing$: BehaviorSubject<boolean>;
+}
+/** Simple renderer interface — anything with a render(canvas) method. */
+export interface ChartRenderer {
+    render(canvas: HTMLCanvasElement): void;
+}
+/**
+ * Shared base class for chart (right-panel) components.
+ *
+ * Handles:
+ * - Canvas and inner DOM element setup
+ * - ResizeObserver and responsive redraw scheduling
+ * - Ctrl+wheel zoom
+ * - Cursor CSS class management
+ * - Divider resizing overlay
+ * - Font loading
+ * - Redraw pipeline skeleton (clear → onRedraw → watermark → chartRedrawn$)
+ * - Destroy / cleanup
+ *
+ * Subclasses implement:
+ * - initComponents() — create renderers, scroll handler, and interaction handlers
+ * - getRedrawObservables() — observables that trigger a redraw
+ * - onRedraw() — the full rendering pipeline (header, background, markers, content)
+ * - destroyComponents() — clean up scroll handler and interaction handlers
+ *
+ * Optional overrides:
+ * - canRedraw() — return false to skip a redraw cycle (e.g. during dependency evaluation)
+ *
+ * Generic TContext allows subclasses to access their full context type via this.ctx.
+ */
+export declare abstract class BaseChart<TContext extends BaseChartContext> {
+    #private;
+    /** The full-typed context, accessible to subclasses. */
+    protected get ctx(): TContext;
+    protected get canvas(): HTMLCanvasElement;
+    constructor(ctx: TContext, chartElement: HTMLElement);
+    /**
+     * Must be called from subclass constructors after super().
+     * Separated from the constructor because ES private fields (#field) of
+     * subclasses are only installed after super() returns, so calling
+     * initComponents() from the base constructor would fail.
+     */
+    protected init(): void;
+    /**
+     * Create renderers, scroll handler, and interaction handlers.
+     * Called once from the BaseChart constructor after canvas and inner elements are created.
+     * this.ctx is available at this point.
+     */
+    protected abstract initComponents(chartElement: HTMLElement, canvas: HTMLCanvasElement, inner: HTMLElement): void;
+    /** Return observables that should trigger a chart redraw when they emit. */
+    protected abstract getRedrawObservables(): Observable<any>[];
+    /**
+     * Render all chart content onto the canvas.
+     * Called inside the redraw pipeline after clear and before watermark.
+     * Subclass is responsible for header, clipping, background, markers, and content rendering.
+     */
+    protected abstract onRedraw(canvasCtx: CanvasRenderingContext2D): void;
+    /** Clean up component-specific resources (scroll handler, interaction handlers). */
+    protected abstract destroyComponents(): void;
+    /**
+     * Override to skip redraw cycles (e.g. during dependency evaluation).
+     * Default: always allow redraw.
+     */
+    protected canRedraw(): boolean;
+    /**
+     * Render the standard pipeline: header → clip content area → background → markers →
+     * chartBackgroundRedrawn$ → contentFn() → restore clip.
+     *
+     * Convenience helper so subclasses don't duplicate the clip/restore boilerplate.
+     */
+    protected renderPipeline(canvasCtx: CanvasRenderingContext2D, headerRenderer: ChartRenderer, backgroundRenderer: ChartRenderer, markersRenderer: ChartRenderer, contentFn: () => void): void;
+    protected scheduleRedraw(): void;
+    /** Called on resize after canvas size is updated. Override to handle scroll handler resize. */
+    protected onResize(): void;
+    get chartElement(): HTMLElement;
+    get chartWidth(): number;
+    destroy(): void;
+}

package/dist/common/base-divider.d.ts

@@ -18,4 +18,6 @@ export declare class BaseDivider extends ClassWithListeners {
     #private;
     constructor(ctx: DividerContext, wrapperElement: any, sheetElement: any, dividerElement: any, chartElement: any, options: DividerOptions);
     destroy(): void;
+    /** Update the calculated (automatic) sheet width. Only takes effect if the user has not manually resized. */
+    updateCalculatedWidth(width: number): void;
 }

package/dist/common/base-engine.d.ts

@@ -0,0 +1,112 @@
+import { BehaviorSubject, Subject, Subscription } from "rxjs";
+import { ChartTimeline } from "./chart-time-axis";
+import { DateRange } from "./common";
+import { BaseTheme } from "./base-theme";
+import { WorkingCalendar } from "./working-calendar";
+import { UndoManager } from "./undo-manager";
+import type { Marker } from "./marker";
+import type { ColumnState } from "../table/table";
+/** Minimal context interface shared by all engine context types. */
+export interface BaseEngineContext {
+    timeline: ChartTimeline;
+    markers$: BehaviorSubject<Marker[]>;
+    canEdit$: BehaviorSubject<boolean>;
+    readonly canEdit: boolean;
+    showGridLines$: BehaviorSubject<boolean>;
+    showTodayLine$: BehaviorSubject<boolean>;
+    projectTimeline$: BehaviorSubject<DateRange>;
+    calendar$: BehaviorSubject<WorkingCalendar>;
+    autoScrolling: boolean;
+}
+/** Base class for timeline engine implementations (GanttChart, ResourceScheduler). */
+export declare abstract class BaseTimelineEngine {
+    #private;
+    protected _hostElement: HTMLElement;
+    protected _wrapperElement: HTMLElement;
+    protected _subscriptions: Subscription;
+    protected _undoManager: UndoManager;
+    constructor(hostElement: HTMLElement);
+    protected abstract get ctx(): BaseEngineContext;
+    protected abstract get engineEvents(): {
+        undone$: Subject<void>;
+        redone$: Subject<void>;
+        destroy(): void;
+    };
+    protected abstract getChartWidth(): number;
+    protected abstract getChartElement(): HTMLElement;
+    protected abstract getTheme(): BaseTheme;
+    protected abstract subscribeThemeChange(callback: () => void): Subscription;
+    protected abstract isCellEditing(): boolean;
+    protected abstract saveColumnsImpl(): ColumnState[];
+    protected abstract loadColumnsImpl(states: ColumnState[]): void;
+    protected abstract destroyComponents(): void;
+    protected abstract restoreState(text: string): void;
+    protected abstract hasData(): boolean;
+    abstract save(): string;
+    abstract copy(): Promise<void>;
+    abstract cut(): Promise<void>;
+    abstract paste(): Promise<any>;
+    abstract zoomToFit(...args: any[]): void;
+    protected createDom(): {
+        sheetElement: HTMLElement;
+        dividerElement: HTMLElement;
+        chartElement: HTMLElement;
+    };
+    protected addWrapperClasses(_wrapperElement: HTMLElement): void;
+    protected wireTheme(): void;
+    protected wireKeyboard(): void;
+    /** Timeline markers (vertical indicator lines). */
+    get markers(): Marker[];
+    set markers(value: Marker[]);
+    /** Add a timeline marker. */
+    addMarker(marker: Marker): void;
+    /** Remove a timeline marker. */
+    removeMarker(marker: Marker): void;
+    /** Remove all timeline markers. */
+    clearMarkers(): void;
+    /** Whether editing is enabled. When false, all mutations are disabled. */
+    get canEdit(): boolean;
+    set canEdit(value: boolean);
+    /** Automatically zoom to fit all data when project timeline is set. Default: true. */
+    get autoZoomToFit(): boolean;
+    set autoZoomToFit(value: boolean);
+    /** Show or hide grid lines on the chart. */
+    get showGridLines(): boolean;
+    set showGridLines(value: boolean);
+    /** Show or hide the today indicator line. */
+    get showTodayLine(): boolean;
+    set showTodayLine(value: boolean);
+    /** Whether undo is available (observable). */
+    get canUndo$(): BehaviorSubject<boolean>;
+    /** Whether redo is available (observable). */
+    get canRedo$(): BehaviorSubject<boolean>;
+    /** Undo the last action. */
+    undo(): void;
+    /** Redo the last undone action. */
+    redo(): void;
+    /** Zoom in one level. Returns false if already at maximum zoom. */
+    zoomIn(): boolean;
+    /** Zoom out one level. Returns false if already at minimum zoom. */
+    zoomOut(): boolean;
+    /** Shared zoom-to-fit logic: finds best zoom level for given date range. */
+    protected zoomToFitRange(minStart: Date | null, maxEnd: Date | null): void;
+    /** Scroll the timeline to the project start date. */
+    goToProjectStart(): void;
+    /** Scroll the timeline to a specific date. */
+    scrollToDate(date: Date): void;
+    /** Project start/end date bounds. */
+    get projectTimeline(): DateRange;
+    set projectTimeline(value: DateRange);
+    /** Working calendar observable. */
+    get calendar$(): BehaviorSubject<WorkingCalendar>;
+    /** @param value New working calendar to apply. */
+    set calendar$(value: WorkingCalendar);
+    /** Save current column widths and order for later restoration. */
+    saveColumns(): ColumnState[];
+    /** Restore previously saved column widths and order. */
+    loadColumns(states: ColumnState[]): void;
+    /** Load state from a JSON string. Automatically zooms to fit if data is present and autoZoomToFit is enabled. */
+    load(text: string): void;
+    /** Destroy the component and release all DOM resources. */
+    destroy(): void;
+}

package/dist/common/base-export-renderer.d.ts

@@ -0,0 +1,26 @@
+import { SheetExportDimensions, ExportColumn } from "./export-utils";
+import { BaseTheme } from "./base-theme";
+import { ChartTimeline } from "./chart-time-axis";
+export interface ChartLayoutResult {
+    visibleColumns: ExportColumn[];
+    sheetWidth: number;
+    chartStart: Date;
+    chartWidth: number;
+    headerHeight: number;
+}
+export declare abstract class BaseExportRenderer<TDims extends SheetExportDimensions> {
+    abstract get theme(): BaseTheme;
+    protected calculateChartLayout(timeline: ChartTimeline, sheet: {
+        columnsLength: number;
+        getColumn(index: number): any;
+    }, minStartTime: Date | null, maxEndTime: Date | null, projectTimeline: {
+        startDate: Date;
+        endDate: Date;
+    }): ChartLayoutResult;
+    renderSheet(ctx: any, dims: TDims): void;
+    protected renderSheetHeader(ctx: any, dims: TDims): void;
+    protected abstract renderSheetRows(ctx: any, dims: TDims): void;
+    protected renderSheetRightBorder(ctx: any, dims: TDims): void;
+    abstract calculateDimensions(): TDims;
+    abstract renderChart(ctx: any, sheetWidth: number, dims: TDims, scale?: number): void;
+}

package/dist/common/base-header-renderer.d.ts

@@ -1,15 +1,17 @@
-import { BehaviorSubject } from "rxjs";
-import { ChartTimeline } from "../ganttchart/chart/chart-time-axis";
-import { GanttChartTheme } from "../ganttchart/themes/theme";
+import { CanvasLike } from "./common";
+import { ChartTimeline } from "./chart-time-axis";
+import { BaseTheme } from "./base-theme";
 /**
  * Interface for the context needed by the header renderer.
  * Both GanttChartContext and ResourceSchedulerContext satisfy this.
  */
 export interface HeaderRendererContext {
     timeline: ChartTimeline;
-    theme$: BehaviorSubject<GanttChartTheme>;
+    theme$: {
+        getValue(): BaseTheme;
+    };
     settings: {
-        theme: GanttChartTheme;
+        theme: BaseTheme;
     };
 }
 /**
@@ -19,5 +21,5 @@ export interface HeaderRendererContext {
 export declare class BaseHeaderRenderer {
     #private;
     constructor(ctx: HeaderRendererContext);
-    render(canvas: any): void;
+    render(canvas: CanvasLike): void;
 }

package/dist/common/base-markers-renderer.d.ts

@@ -1,15 +1,18 @@
 import { BehaviorSubject } from "rxjs";
-import { ChartTimeline } from "../ganttchart/chart/chart-time-axis";
-import { GanttChartTheme } from "../ganttchart/themes/theme";
-import { Marker } from "../ganttchart/model/marker";
+import { CanvasLike } from "./common";
+import { ChartTimeline } from "./chart-time-axis";
+import { BaseTheme } from "./base-theme";
+import { Marker } from "./marker";
 export interface MarkersRendererContext {
     timeline: ChartTimeline;
-    theme$: BehaviorSubject<GanttChartTheme>;
+    theme$: {
+        getValue(): BaseTheme;
+    };
     showTodayLine$: BehaviorSubject<boolean>;
     markers$: BehaviorSubject<Marker[]>;
 }
 export declare class BaseMarkersRenderer {
     #private;
-    constructor(ctx: MarkersRendererContext, getBottom: (canvas: any) => number);
-    render(canvas: any): void;
+    constructor(ctx: MarkersRendererContext, getBottom: (canvas: CanvasLike) => number);
+    render(canvas: CanvasLike): void;
 }

package/dist/common/base-theme.d.ts

@@ -0,0 +1,107 @@
+import { Font } from "./common";
+/** Base color palette for a single task/event color index. Shared by all timeline components. */
+export declare class BaseTaskColor {
+    borderColor: string | null;
+    color1: string;
+    color2: string;
+    highlightColor: string;
+    static create<T extends BaseTaskColor>(this: new () => T, props: Partial<T>): T;
+}
+/** Custom color definition that can be used instead of a theme color index. */
+export interface ColorDefinition {
+    color1: string;
+    color2: string;
+    highlightColor?: string;
+    borderColor?: string | null;
+}
+/** Color value: either a theme color index (number) or a custom color definition. */
+export type ColorValue = number | ColorDefinition;
+/** Resolves a ColorValue to a concrete BaseTaskColor instance. */
+export declare function resolveTaskColor<T extends BaseTaskColor>(color: ColorValue, taskColors: T[]): T;
+/** Style settings for the sheet header row. */
+export declare class BaseSheetHeaderStyle {
+    backgroundColor: string;
+    cellBorderColor: string;
+    cellDividerColor: string | null;
+    textColor: string;
+}
+/** Style settings for the sheet (left panel). */
+export declare class BaseSheetStyle {
+    header: BaseSheetHeaderStyle;
+    backgroundColor: string;
+    textColor: string;
+    hoverBackgroundColor: string;
+    selectedBackgroundColor: string;
+    selectedRowHeaderColor: string;
+    focusBorderColor: string;
+    highlightBorderColor: string;
+    treeIconColor: string;
+    editorBackgroundColor: string;
+    editorTextColor: string;
+    scrollbarThumbColor: string;
+    scrollbarTrackColor: string;
+    gridLineColor: string;
+    colorScheme: 'light' | 'dark';
+}
+/** Style settings for the chart header area. */
+export declare class BaseChartHeaderStyle {
+    backgroundColor: string;
+    cellBorderColor: string;
+    cellDividerColor: string | null;
+    cellDividerPadding: number;
+    textColor: string;
+}
+/** Style settings for the chart content area shared across all timeline components. */
+export declare class BaseChartContentStyle {
+    backgroundColor: string;
+    taskHeight: number;
+    taskBorderRadius: number;
+    taskColors: BaseTaskColor[];
+    nonWorkingTimeStyle: string;
+    tier2SeparatorLineStyle: string;
+    gridLineColor: string;
+    tooltipFont: Font;
+    tooltipTextColor: string;
+    tooltipBackgroundColor1: string;
+    tooltipBackgroundColor2: string;
+    tooltipBorderColor: string;
+    todayLineColor: string;
+    todayLineWidth: number;
+    todayLineStyle: 'solid' | 'dashed' | 'dotted';
+    markerLineColor: string;
+    markerLineWidth: number;
+    markerLineStyle: 'solid' | 'dashed' | 'dotted';
+    markerLabelColor: string;
+    markerLabelFont: Font;
+    taskLabelPosition: TaskLabelPosition;
+    taskLabelContent: TaskLabelContent;
+    taskLabelColor: string;
+    taskLabelFont: Font;
+    taskLabelPadding: number;
+    taskLabelOutsideMargin: number;
+    constructor();
+}
+/** Style settings for the chart area (right panel). */
+export declare class BaseChartStyle {
+    header: BaseChartHeaderStyle;
+    content: BaseChartContentStyle;
+}
+/** Base class for all timeline component themes. Extend to create custom themes. */
+export declare abstract class BaseTheme {
+    /** Default font used throughout the component. */
+    font: Font;
+    /** Height of each row in pixels. */
+    rowHeight: number;
+    /** Height of the header area in pixels. */
+    headerHeight: number;
+    /** Y coordinate where the chart content area begins (below the header and its borders). */
+    get contentTop(): number;
+    /** Sheet (left panel) visual style. */
+    sheet: BaseSheetStyle;
+    /** Chart (right panel) visual style. */
+    chart: BaseChartStyle;
+}
+/** Where task labels are rendered relative to the bar. */
+export type TaskLabelPosition = 'none' | 'inside' | 'right' | 'insideOrRight';
+/** What content is displayed in task labels. */
+export type TaskLabelContent = 'name' | 'resource' | 'progress' | 'nameAndProgress' | 'nameAndResource';

package/dist/common/base-tooltip-renderer.d.ts

@@ -0,0 +1,7 @@
+import { CanvasLike } from "./common";
+import { BaseTheme } from "./base-theme";
+export interface TooltipLine {
+    name: string;
+    value: string;
+}
+export declare function drawTooltipAt(canvas: CanvasLike, rowY: number, rowHeight: number, startX: number, title: string, lines: TooltipLine[], theme: BaseTheme): void;

package/dist/common/chart-time-axis.d.ts

@@ -0,0 +1,32 @@
+import { BehaviorSubject } from "rxjs";
+import { TimelineKitLocale } from "./locale";
+import { WorkingCalendar } from "./working-calendar";
+export declare class ChartTimeline {
+    #private;
+    zoomIndex$: BehaviorSubject<number>;
+    visibleStartTime$: BehaviorSubject<Date>;
+    get currentZoom(): ChartTimeAxisZoom;
+    constructor(calendar$: BehaviorSubject<WorkingCalendar>, locale$: BehaviorSubject<TimelineKitLocale>);
+    createDefaultZooms(): ChartTimeAxisZoom[];
+    assignZooms(zooms: ChartTimeAxisZoom[], defaultZoomIndex: number): void;
+    zoomIn(): boolean;
+    zoomOut(): boolean;
+    findBestZoomIndex(minDate: Date, maxDate: Date, availableWidth: number): number;
+}
+export declare class ChartTimeAxisZoom {
+    axis: ChartTimeAxis[];
+    baseCellWidth: number;
+    constructor(axis: ChartTimeAxis[], baseCellWidth: number);
+}
+export declare class ChartTimeAxis {
+    #private;
+    unit: ChartTimeAxisUnit;
+    unitsPerCell: number;
+    formatter: (date: Date) => string;
+    constructor(unit: ChartTimeAxisUnit, unitsPerCell: number, calendar: BehaviorSubject<WorkingCalendar>, formatter: (date: Date) => string);
+    getCellStartTime(time: Date): Date;
+    getCellStartX(time: Date, visibleStart: Date, zoom: ChartTimeAxisZoom): number;
+    getAdd(time: Date, amount: number): Date;
+    getX(time: Date, visibleStart: Date, zoom: ChartTimeAxisZoom): number;
+}
+export type ChartTimeAxisUnit = 'minute' | 'hour' | 'day' | 'week' | 'month' | 'quarter' | 'half' | 'year';

package/dist/common/common.d.ts

@@ -29,8 +29,8 @@ export declare class Rect {
     static fromString(str: string): Rect;
     moveToRaster(): Rect;
 }
-export type HorizontalAlign = 'Left' | 'Center' | 'Right';
-export type VerticalAlign = 'Top' | 'Center' | 'Bottom';
+export type HorizontalAlign = 'left' | 'center' | 'right';
+export type VerticalAlign = 'top' | 'center' | 'bottom';
 export interface HyperlinkRect {
     x: number;
     y: number;
@@ -51,6 +51,16 @@ export declare class Font {
     clone(): Font;
 }
 export type Cursor = 'default' | 'pointer' | 'all-scroll' | 'ew-resize' | 'ns-resize' | 'nwse-resize' | 'nesw-resize' | 'crosshair' | 'grabbing';
+/**
+ * Minimal interface for objects that behave like an HTMLCanvasElement.
+ * Satisfied by real HTMLCanvasElement and by the lightweight mock objects
+ * created during image/PDF export (see export-utils.ts).
+ */
+export interface CanvasLike {
+    width: number;
+    height: number;
+    getContext(contextId: string): CanvasRenderingContext2D | null;
+}
 export declare const seriesPalette: string[];
 export declare class DateRange {
     #private;

package/dist/common/custom-properties-container.d.ts

@@ -0,0 +1,14 @@
+import { CustomProperty } from "./custom-property";
+export declare class CustomPropertiesContainer {
+    #private;
+    constructor(onChanged: (property: CustomProperty) => void);
+    addProperty(property: CustomProperty): void;
+    removeProperty(property: CustomProperty): void;
+    renameProperty(oldName: string, newName: string): void;
+    getPropertyByName(name: string): CustomProperty | null;
+    getPropertyValue(name: string): any;
+    setPropertyValue(name: string, value: any): void;
+    get hasProperties(): boolean;
+    serializeProperties(): any[];
+    loadProperties(serialized: any[] | undefined | null): void;
+}

package/dist/common/drawing.d.ts

@@ -1,2 +1,8 @@
-import { Point } from "./common";
-export declare function drawSelectionPoint(ctx: any, p: Point, fillStyle?: string): void;
+import { Point, Rect } from "./common";
+export declare function drawSelectionPoint(ctx: CanvasRenderingContext2D, p: Point, fillStyle?: string): void;
+export declare function createGradientVertical(ctx: CanvasRenderingContext2D, rect: Rect, color1: string, color2: string): CanvasGradient;
+export declare function createGradientHorizontal(ctx: CanvasRenderingContext2D, rect: Rect, color1: string, color2: string): CanvasGradient;
+export declare function addRoundedRect(ctx: CanvasRenderingContext2D, rect: Rect, borderRadius: number): void;
+export declare function drawGradientBar(ctx: CanvasRenderingContext2D, rect: Rect, color1: string, color2: string, borderRadius?: number): void;
+export declare function drawBarBorder(ctx: CanvasRenderingContext2D, rect: Rect, borderColor: string, borderRadius?: number): void;
+export declare function drawClippedLabel(ctx: CanvasRenderingContext2D, text: string, rect: Rect, font: string, color: string, padding?: number): void;

package/dist/common/export-utils.d.ts

@@ -1,5 +1,9 @@
 import { BehaviorSubject } from "rxjs";
-import { GanttChartTheme } from "../ganttchart/themes/theme";
+import { CanvasLike } from "./common";
+import { BaseTheme } from "./base-theme";
+export declare const sheetCellPadding = 10;
+export declare const sheetRowNumberWidth = 40;
+export declare const sheetMarginCells = 3;
 export declare const defaultPdfMargin = 10;
 export declare const pxPerMm: number;
 export declare const defaultPdfScale = 2;
@@ -11,11 +15,31 @@ export interface BaseExportDimensions {
     headerHeight: number;
     totalHeight: number;
 }
+export interface SheetExportDimensions extends BaseExportDimensions {
+    visibleColumns: ExportColumn[];
+}
+/** Describes a single sheet column included in an image/PDF export. */
+export interface ExportColumn {
+    code: string;
+    name: string;
+    width: number;
+    align: string | null;
+    valueFormatter: (item: any) => string;
+    exportHeaderRenderer?: (ctx: any, x: number, y: number, width: number, height: number, color: string) => void;
+    exportCellRenderer?: (ctx: any, item: any, x: number, y: number, width: number, height: number) => void;
+}
+/** Maps visible columns from a table (or tree-table) into ExportColumn descriptors. */
+export declare function getVisibleExportColumns(table: {
+    columnsLength: number;
+    getColumn(index: number): any;
+}): ExportColumn[];
 export interface ExportRendererBase<TDims extends BaseExportDimensions> {
-    theme: GanttChartTheme;
+    theme: BaseTheme;
     calculateDimensions(): TDims;
-    renderSheet(ctx: any, dims: TDims): void;
-    renderChart(ctx: any, sheetWidth: number, dims: TDims, scale?: number): void;
+    /** Optional async preloading step (e.g. loading avatar images) called before rendering. */
+    preload?(): Promise<void>;
+    renderSheet(ctx: CanvasRenderingContext2D, dims: TDims): void;
+    renderChart(ctx: CanvasRenderingContext2D, sheetWidth: number, dims: TDims, scale?: number): void;
 }
 export interface BasePdfExportOptions {
     /** Page format. Default: 'A4' */
@@ -50,11 +74,14 @@ export interface PageSlice {
     srcW: number;
     contentSrcH: number;
 }
+export declare function buildCsvRow(values: string[], delimiter: string): string;
 export declare function escapeCsv(value: string, delimiter: string): string;
 export declare function formatExcelHeaderRow(ws: any): void;
 export declare function freezeExcelHeaderRow(ws: any): void;
-export declare function renderExportChart(mainCtx: any, sheetWidth: number, dims: BaseExportDimensions, scale: number, theme: GanttChartTheme, visibleStartTime$: BehaviorSubject<Date>, scrollTop$: BehaviorSubject<number>, headerRenderer: {
-    render(canvas: any): void;
+export declare function importExcelJS(): Promise<any>;
+export declare function workbookToBlob(workbook: any): Promise<Blob>;
+export declare function renderExportChart(mainCtx: CanvasRenderingContext2D, sheetWidth: number, dims: BaseExportDimensions, scale: number, theme: BaseTheme, visibleStartTime$: BehaviorSubject<Date>, scrollTop$: BehaviorSubject<number>, headerRenderer: {
+    render(canvas: CanvasLike): void;
 }, contentRenderers: {
-    render(canvas: any): void;
+    render(canvas: CanvasLike): void;
 }[]): void;

package/dist/common/functions.d.ts

@@ -20,6 +20,6 @@ export declare function getMinDate(d1: Date, d2: Date): Date;
 export declare function uuidv4(): string;
 export declare function generateRandomId(length: number): string;
 export declare function formatCurrency(amount: number, currencySymbol: string, displayMode: CurrencySymbolDisplayMode, locale: string): string;
-export type CurrencySymbolDisplayMode = 'BeforeAmount' | 'AfterAmount' | 'BeforeAmountWithSpace' | 'AfterAmountWithSpace';
+export type CurrencySymbolDisplayMode = 'beforeAmount' | 'afterAmount' | 'beforeAmountWithSpace' | 'afterAmountWithSpace';
 export declare function sanitizeString(input: string): string;
 export declare function isDeleteKeyPressed(event: any): boolean;