@timelinekit/core 1.0.0 → 1.0.5

package/dist/ganttchart/chart/handlers/select-link.d.ts

@@ -1,11 +1,13 @@
 import { Point } from "../../../common/common";
 import { GanttChartContext } from "../../ganttchart-engine";
-import { ChartHandler, ChartHandlerResult } from "./handler";
-export declare class SelectLinkHandler extends ChartHandler {
+import { GanttChartHandler, ChartHandlerResult } from "./handler";
+import { GanttTasksRenderer } from "../renderers/chart-tasks-renderer";
+import { GanttTooltipRenderer } from "../tooltip/chart-tooltip-renderer";
+export declare class SelectLinkHandler extends GanttChartHandler {
     #private;
-    constructor(gc: GanttChartContext);
-    onMouseDown(p: Point, ctrl: boolean, event: any): Promise<ChartHandlerResult>;
-    onMouseUp(p: Point, ctrl: boolean, event: any): Promise<ChartHandlerResult>;
-    onKeyDown(key: string, event: any): Promise<ChartHandlerResult>;
+    constructor(gc: GanttChartContext, tasksRenderer: GanttTasksRenderer, tooltipRenderer: GanttTooltipRenderer);
+    onMouseDown(p: Point, ctrl: boolean, event: MouseEvent): Promise<ChartHandlerResult>;
+    onMouseUp(p: Point, ctrl: boolean, event: MouseEvent): Promise<ChartHandlerResult>;
+    onKeyDown(key: string, event: KeyboardEvent): Promise<ChartHandlerResult>;
     onRedrawn(): void;
 }

package/dist/ganttchart/chart/handlers/select-task.d.ts

@@ -2,21 +2,23 @@ import { Subject } from "rxjs";
 import { Point } from "../../../common/common";
 import { Task } from "../../model/task";
 import { GanttChartContext } from "../../ganttchart-engine";
-import { ChartHandler, ChartHandlerResult } from "./handler";
-export declare class SelectTaskHandler extends ChartHandler {
+import { GanttChartHandler, ChartHandlerResult } from "./handler";
+import { GanttTasksRenderer } from "../renderers/chart-tasks-renderer";
+import { GanttTooltipRenderer } from "../tooltip/chart-tooltip-renderer";
+export declare class SelectTaskHandler extends GanttChartHandler {
     #private;
     dblClick$: Subject<Task>;
     contextMenu$: Subject<TaskContextMenuArgs>;
-    constructor(gc: GanttChartContext);
-    onMouseMove(p: Point, event: any): Promise<ChartHandlerResult>;
-    onMouseDown(p: Point, ctrl: boolean, event: any): Promise<ChartHandlerResult>;
-    onMouseUp(p: Point, ctrl: boolean, event: any): Promise<ChartHandlerResult>;
-    onKeyDown(key: string, event: any): Promise<ChartHandlerResult>;
-    onMouseLeave(p: Point, event: any): Promise<ChartHandlerResult>;
-    onContextMenu(p: Point, event: any): ChartHandlerResult;
-    onDblClick(p: Point, event: any): ChartHandlerResult;
+    constructor(gc: GanttChartContext, tasksRenderer: GanttTasksRenderer, tooltipRenderer: GanttTooltipRenderer);
+    onMouseMove(p: Point, event: MouseEvent): Promise<ChartHandlerResult>;
+    onMouseDown(p: Point, ctrl: boolean, event: MouseEvent): Promise<ChartHandlerResult>;
+    onMouseUp(p: Point, ctrl: boolean, event: MouseEvent): Promise<ChartHandlerResult>;
+    onKeyDown(key: string, event: KeyboardEvent): Promise<ChartHandlerResult>;
+    onMouseLeave(p: Point, event: MouseEvent): Promise<ChartHandlerResult>;
+    onContextMenu(p: Point, event: MouseEvent): ChartHandlerResult;
+    onDblClick(p: Point, event: MouseEvent): ChartHandlerResult;
 }
 export interface TaskContextMenuArgs {
     task: Task;
-    mouseEvent: any;
+    mouseEvent: MouseEvent;
 }

package/dist/ganttchart/chart/handlers/set-task-progress.d.ts

@@ -1,11 +1,18 @@
 import { Point } from "../../../common/common";
+import { Task } from "../../model/task";
 import { GanttChartContext } from "../../ganttchart-engine";
-import { ChartHandler, ChartHandlerResult } from "./handler";
-export declare class SetTaskProgressHandler extends ChartHandler {
+import { GanttTooltipRenderer } from "../tooltip/chart-tooltip-renderer";
+import { GanttTasksRenderer } from "../renderers/chart-tasks-renderer";
+import { GanttDragHandler } from "./gantt-drag-handler";
+export declare class SetTaskProgressHandler extends GanttDragHandler<TaskProgressAt> {
     #private;
-    constructor(gc: GanttChartContext);
-    onMouseDown(p: Point, ctrl: boolean, event: any): Promise<ChartHandlerResult>;
-    onMouseMove(p: Point, event: any): Promise<ChartHandlerResult>;
-    onMouseUp(p: Point, ctrl: boolean, event: any): Promise<ChartHandlerResult>;
-    onRedrawn(): void;
+    constructor(gc: GanttChartContext, tasksRenderer: GanttTasksRenderer, tooltipRenderer: GanttTooltipRenderer);
+    protected hitTest(p: Point): TaskProgressAt | null;
+    protected onDragEnd(target: TaskProgressAt, p: Point): void;
+    protected onDragDraw(target: TaskProgressAt): void;
 }
+interface TaskProgressAt {
+    task: Task;
+    deltaX: number;
+}
+export {};

package/dist/ganttchart/chart/renderers/chart-background-renderer.d.ts

@@ -1,8 +1,9 @@
+import { CanvasLike } from "../../../common/common";
 import { BaseBackgroundRenderer } from "../../../common/base-background-renderer";
 import { GanttChartContext } from "../../ganttchart-engine";
-export declare class ChartBackgroundRenderer extends BaseBackgroundRenderer {
+export declare class GanttBackgroundRenderer extends BaseBackgroundRenderer {
     #private;
     constructor(gc: GanttChartContext);
     protected getContentBottom(canvasHeight: number): number;
-    protected drawHorizontalGridLines(canvas: any, ctx: any): void;
+    protected drawHorizontalGridLines(canvas: CanvasLike, ctx: CanvasRenderingContext2D): void;
 }

package/dist/ganttchart/chart/renderers/chart-header-renderer.d.ts

@@ -1,6 +1,6 @@
 import { GanttChartContext } from "../../ganttchart-engine";
-import { RendererBase } from "./renderer-base";
-export declare class ChartHeaderRenderer extends RendererBase {
+import { GanttRendererBase } from "./renderer-base";
+export declare class GanttHeaderRenderer extends GanttRendererBase {
     #private;
     constructor(gc: GanttChartContext);
     render(canvas: any): void;

package/dist/ganttchart/chart/renderers/chart-links-renderer.d.ts

@@ -1,7 +1,8 @@
+import { CanvasLike } from "../../../common/common";
 import { GanttChartContext } from "../../ganttchart-engine";
-import { RendererBase } from "./renderer-base";
-export declare class ChartLinksRenderer extends RendererBase {
+import { GanttRendererBase } from "./renderer-base";
+export declare class GanttLinksRenderer extends GanttRendererBase {
     #private;
     constructor(gc: GanttChartContext);
-    render(canvas: any): void;
+    render(canvas: CanvasLike): void;
 }

package/dist/ganttchart/chart/renderers/chart-markers-renderer.d.ts

@@ -1,6 +1,6 @@
 import { GanttChartContext } from "../../ganttchart-engine";
-import { RendererBase } from "./renderer-base";
-export declare class ChartMarkersRenderer extends RendererBase {
+import { GanttRendererBase } from "./renderer-base";
+export declare class GanttMarkersRenderer extends GanttRendererBase {
     #private;
     constructor(gc: GanttChartContext);
     render(canvas: any): void;

package/dist/ganttchart/chart/renderers/chart-tasks-renderer.d.ts

@@ -1,14 +1,14 @@
-import { Rect } from "../../../common/common";
+import { CanvasLike } from "../../../common/common";
 import { Task } from "../../model/task";
 import { GanttChartContext } from "../../ganttchart-engine";
-import { RendererBase } from "./renderer-base";
-export declare class ChartTasksRenderer extends RendererBase {
+import { GanttRendererBase } from "./renderer-base";
+export declare class GanttTasksRenderer extends GanttRendererBase {
     #private;
     constructor(gc: GanttChartContext);
-    render(canvas: any): void;
-    drawTaskHighlightX1X2(ctx: any, task: Task, x1: number, x2: number): void;
-    drawTaskProgressHighlight(ctx: any, task: Task, x1: number, x2: number): void;
-    drawTaskHighlight(ctx: any, task: Task): void;
+    render(canvas: CanvasLike): void;
+    drawTaskHighlightX1X2(ctx: CanvasRenderingContext2D, task: Task, x1: number, x2: number): void;
+    drawTaskProgressHighlight(ctx: CanvasRenderingContext2D, task: Task, x1: number, x2: number): void;
+    drawTaskHighlight(ctx: CanvasRenderingContext2D, task: Task): void;
 }
-export declare function createGradientVertical(ctx: any, rect: Rect, color1: string, color2: string): any;
-export declare function createGradientHorizontal(ctx: any, rect: Rect, color1: string, color2: string): any;
+export { createGradientVertical, createGradientHorizontal } from "../../../common/drawing";
+export declare function getLabelText(task: Task, content: string): string | null;

package/dist/ganttchart/chart/renderers/renderer-base.d.ts

@@ -1,9 +1,10 @@
 import { Task } from "../../model/task";
 import { GanttChartContext } from "../../ganttchart-engine";
-export declare class RendererBase {
+export declare class GanttRendererBase {
     #private;
     constructor(gc: GanttChartContext);
     get rowHeight(): number;
     protected getRowY(task: Task): number;
     protected getContentBottom(canvasHeight: number): number;
+    protected drawRowHighlight(ctx: CanvasRenderingContext2D, canvasWidth: number, rowY: number, rowHeight: number): void;
 }

package/dist/ganttchart/chart/tooltip/chart-tooltip-renderer.d.ts

@@ -1,11 +1,9 @@
 import { Task } from "../../model/task";
 import { GanttChartContext } from "../../ganttchart-engine";
-export declare class ChartTooltipRenderer {
+import { TooltipLine } from "../../../common/base-tooltip-renderer";
+export type GanttTooltipLine = TooltipLine;
+export declare class GanttTooltipRenderer {
     #private;
     constructor(gc: GanttChartContext);
-    drawTooltip(canvas: any, forTasks: Task[], startX: number, title: string, lines: ChartTooltipLine[]): void;
-}
-export interface ChartTooltipLine {
-    name: string;
-    value: string;
+    drawTooltip(canvas: any, forTasks: Task[], startX: number, title: string, lines: GanttTooltipLine[]): void;
 }

package/dist/ganttchart/clipboard.d.ts

@@ -4,29 +4,36 @@ import { TaskLink, TaskLinkType } from "./model/task-link";
 import { ResourceList } from "./model/resource-list";
 import { WorkingCalendar } from "./model/working-calendar";
 import { BehaviorSubject } from "rxjs";
-export interface ClipboardContext {
+/** Shared dependencies required by the clipboard for task serialization and insertion. */
+export interface GanttClipboardContext {
     list: TaskList;
     resources: ResourceList;
     calendar$: BehaviorSubject<WorkingCalendar>;
     projectTimeline$: BehaviorSubject<any>;
     sheetSelectedTasks$: BehaviorSubject<Task[]>;
 }
+/** Event arguments emitted after a paste operation completes. */
 export interface TasksPastedEventArgs {
     tasks: Task[];
     links: TaskLink[];
     taskIdMap: Map<string, Task>;
     droppedLinks: DroppedLinkInfo[];
 }
+/** Describes a dependency link that could not be recreated because one end is outside the pasted set. */
 export interface DroppedLinkInfo {
     type: TaskLinkType;
     fromId: string;
     toId: string;
     externalSide: 'from' | 'to';
 }
-export declare class ClipboardManager {
+/** Handles copy, cut, and paste of tasks using both internal serialization and system clipboard TSV. */
+export declare class GanttClipboardManager {
     #private;
-    constructor(gc: ClipboardContext);
+    constructor(gc: GanttClipboardContext);
+    /** Serializes the given tasks and writes a TSV representation to the system clipboard. */
     copy(tasks: Task[]): Promise<void>;
+    /** Copies the given tasks and then removes them from the task list. */
     cut(tasks: Task[]): Promise<void>;
+    /** Inserts tasks from internal clipboard data or falls back to parsing TSV from the system clipboard. */
     paste(): Promise<TasksPastedEventArgs | null>;
 }

package/dist/ganttchart/divider/divider.d.ts

@@ -1,5 +1,5 @@
 import { BaseDivider } from "../../common/base-divider";
 import { GanttChartContext } from "../ganttchart-engine";
-export declare class Divider extends BaseDivider {
+export declare class GanttDivider extends BaseDivider {
     constructor(gc: GanttChartContext, wrapperElement: any, sheetElement: any, dividerElement: any, chartElement: any);
 }

package/dist/ganttchart/export/data-exporter.d.ts

@@ -1,6 +1,7 @@
 import { GanttChartContext } from "../ganttchart-engine";
-import { Sheet } from "../sheet/sheet";
-export interface CsvExportOptions {
+import { GanttSheet } from "../sheet/sheet";
+/** Options for CSV export of task data. */
+export interface GanttCsvExportOptions {
     /** Column delimiter. Default: ',' */
     delimiter?: ',' | ';' | '\t';
     /** Include column headers? Default: true */
@@ -10,7 +11,8 @@ export interface CsvExportOptions {
     /** Append dependency links as a separate section? Default: false */
     includeLinks?: boolean;
 }
-export interface ExcelExportOptions {
+/** Options for Excel (XLSX) export of task, link, and resource data. */
+export interface GanttExcelExportOptions {
     /** Name of the tasks sheet. Default: 'Tasks' */
     sheetName?: string;
     /** Include a sheet with dependency links? Default: true */
@@ -22,9 +24,12 @@ export interface ExcelExportOptions {
     /** Which columns to export (by code). Default: all visible columns */
     columns?: string[];
 }
-export declare class DataExporter {
+/** Exports Gantt chart task data to CSV and Excel formats. */
+export declare class GanttDataExporter {
     #private;
-    constructor(gc: GanttChartContext, sheet: Sheet);
-    exportToCsv(options?: CsvExportOptions): string;
-    exportToExcel(options?: ExcelExportOptions): Promise<Blob>;
+    constructor(gc: GanttChartContext, sheet: GanttSheet);
+    /** Generates a CSV string from visible tasks and optionally dependency links. */
+    exportToCsv(options?: GanttCsvExportOptions): string;
+    /** Generates an Excel workbook with tasks, links, and resources as separate sheets. */
+    exportToExcel(options?: GanttExcelExportOptions): Promise<Blob>;
 }

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

@@ -1,23 +1,23 @@
-import { BaseExportDimensions } from "../../common/export-utils";
+import { SheetExportDimensions, ExportColumn } from "../../common/export-utils";
+import { BaseExportRenderer } from "../../common/base-export-renderer";
 import { GanttChartContext } from "../ganttchart-engine";
-import { Sheet } from "../sheet/sheet";
+import { GanttSheet } from "../sheet/sheet";
 import { GanttChartTheme } from "../themes/theme";
-export interface ExportColumn {
-    code: string;
-    name: string;
-    width: number;
-    align: string | null;
-    valueFormatter: (task: any) => string;
-}
-export interface ExportDimensions extends BaseExportDimensions {
-    visibleColumns: ExportColumn[];
+export type { ExportColumn };
+/** Calculated layout dimensions for a Gantt chart export, extending the base with column and row info. */
+export interface GanttExportDimensions extends SheetExportDimensions {
     visibleRowCount: number;
 }
-export declare class ExportRenderer {
+/** Renders the Gantt chart sheet and timeline into a canvas context for image/PDF export. */
+export declare class GanttExportRenderer extends BaseExportRenderer<GanttExportDimensions> {
     #private;
-    constructor(gc: GanttChartContext, sheet: Sheet);
+    constructor(gc: GanttChartContext, sheet: GanttSheet);
+    /** Returns the current Gantt chart theme. */
     get theme(): GanttChartTheme;
-    calculateDimensions(): ExportDimensions;
-    renderSheet(ctx: any, dims: ExportDimensions): void;
-    renderChart(ctx: any, sheetWidth: number, dims: ExportDimensions, scale?: number): void;
+    /** Computes the pixel dimensions of the sheet and chart areas based on visible columns and rows. */
+    calculateDimensions(): GanttExportDimensions;
+    /** Draws the data rows onto the given canvas context. */
+    protected renderSheetRows(ctx: any, dims: GanttExportDimensions): void;
+    /** Draws the timeline chart (header, tasks, links, markers) onto the given canvas context. */
+    renderChart(ctx: any, sheetWidth: number, dims: GanttExportDimensions, scale?: number): void;
 }

package/dist/ganttchart/export/image-exporter.d.ts

@@ -1,7 +1,8 @@
 import { GanttChartContext } from "../ganttchart-engine";
-import { Sheet } from "../sheet/sheet";
-import { ExportDimensions } from "./export-common";
+import { GanttSheet } from "../sheet/sheet";
+import { GanttExportDimensions } from "./export-common";
 import { BaseImageExporter } from "../../common/base-image-exporter";
-export declare class ImageExporter extends BaseImageExporter<ExportDimensions> {
-    constructor(gc: GanttChartContext, sheet: Sheet);
+/** Exports the Gantt chart as a raster image (PNG). */
+export declare class GanttImageExporter extends BaseImageExporter<GanttExportDimensions> {
+    constructor(gc: GanttChartContext, sheet: GanttSheet);
 }

package/dist/ganttchart/export/pdf-exporter.d.ts

@@ -1,11 +1,12 @@
 import { GanttChartContext } from "../ganttchart-engine";
-import { Sheet } from "../sheet/sheet";
-import { ExportDimensions } from "./export-common";
+import { GanttSheet } from "../sheet/sheet";
+import { GanttExportDimensions } from "./export-common";
 import { BasePdfExporter } from "../../common/base-pdf-exporter";
-export type { BasePdfExportOptions as PdfExportOptions } from "../../common/export-utils";
-export declare class PdfExporter extends BasePdfExporter<ExportDimensions> {
-    constructor(gc: GanttChartContext, sheet: Sheet);
-    protected computeVerticalPageBreaks(dims: ExportDimensions, contentHeightPx: number, headerHeight: number): {
+export type { BasePdfExportOptions as GanttPdfExportOptions } from "../../common/export-utils";
+/** Exports the Gantt chart as a multi-page PDF document. */
+export declare class GanttPdfExporter extends BasePdfExporter<GanttExportDimensions> {
+    constructor(gc: GanttChartContext, sheet: GanttSheet);
+    protected computeVerticalPageBreaks(dims: GanttExportDimensions, contentHeightPx: number, headerHeight: number): {
         srcY: number;
         height: number;
     }[];