@timelinekit/core 1.0.0 → 1.0.3

package/dist/common/locale.d.ts

@@ -0,0 +1,101 @@
+/** Scheduling constraint type applied to a task. */
+export type ConstraintType = 'asap' | 'alap' | 'mso' | 'mfo' | 'snet' | 'snlt' | 'fnet' | 'fnlt';
+/** Dependency link type between two tasks. */
+export type TaskLinkType = 'finishToStart' | 'startToStart' | 'finishToFinish' | 'startToFinish';
+/** Localization strings for all TimelineKit components. */
+export interface TimelineKitLocale {
+    /** BCP 47 language tag for Intl formatting (dates, numbers), e.g. 'en-US', 'cs-CZ', 'de-DE' */
+    language: string;
+    columns: {
+        name: string;
+        length: string;
+        start: string;
+        end: string;
+        progress: string;
+        resources: string;
+        work: string;
+        cost: string;
+    };
+    columnTooltips: {
+        work: string;
+        cost: string;
+    };
+    tooltips: {
+        addTask: string;
+        addTaskPart: string;
+        moveTask: string;
+        moveTaskPart: string;
+        resizeTask: string;
+        resizeTaskPart: string;
+        moveMilestone: string;
+        setProgress: string;
+        addLink: string;
+    };
+    labels: {
+        start: string;
+        end: string;
+        length: string;
+        progress: string;
+        from: string;
+        to: string;
+        type: string;
+        lag: string;
+    };
+    constraints: Record<ConstraintType, string>;
+    linkTypes: Record<TaskLinkType, string>;
+    warnings: {
+        behindSchedule: string;
+        behindScheduleByOneDay: string;
+        behindScheduleByDays: (days: number) => string;
+        constraintViolation: (constraintLabel: string, date: string) => string;
+    };
+    export: {
+        tasksSheetName: string;
+        linksSheetName: string;
+        resourcesSheetName: string;
+        eventsSheetName: string;
+        calendarsSheetName: string;
+    };
+    scheduler: {
+        resource: string;
+        name: string;
+        type: string;
+        addEvent: string;
+        moveEvent: string;
+        resizeEvent: string;
+    };
+    calendar: {
+        today: string;
+        month: string;
+        week: string;
+        day: string;
+        agenda: string;
+        allDay: string;
+        noEvents: string;
+        more: (count: number) => string;
+        myCalendars: string;
+        addCalendar: string;
+        ariaCalendar?: string;
+        ariaSidebar?: string;
+        ariaNavigation?: string;
+        ariaViewMode?: string;
+        ariaGoToToday?: string;
+        ariaPrevious?: string;
+        ariaNext?: string;
+        ariaAllDayEvents?: string;
+        ariaCalendarGrid?: string;
+        ariaAgendaList?: string;
+        ariaSelectMonthYear?: string;
+        ariaToggleCalendar?: (name: string) => string;
+        ariaRemoveCalendar?: (name: string) => string;
+        ariaMoreEvents?: (count: number) => string;
+        /** Short label for week numbers (default: 'Wk'). Shown in headers when showWeekNumbers is enabled. */
+        weekNumberShort?: string;
+        /** Full label for week number (default: 'Week'). Used for aria-label. */
+        weekNumber?: string;
+    };
+    /** Optional custom date parser. Receives raw user input, returns Date or null. */
+    dateParser?: (value: string) => Date | null;
+}
+/** Default English (en-US) locale. */
+export declare const defaultLocale: TimelineKitLocale;

package/dist/common/marker.d.ts

@@ -0,0 +1,13 @@
+/** A vertical date marker displayed on the chart. */
+export interface Marker {
+    /** Date position of the marker line. */
+    date: Date;
+    /** Optional text label displayed alongside the marker. */
+    label?: string;
+    /** CSS color string for the marker line. */
+    color?: string;
+    /** Width of the marker line in pixels. */
+    lineWidth?: number;
+    /** Dash style of the marker line. */
+    lineStyle?: 'solid' | 'dashed' | 'dotted';
+}

package/dist/common/subscription-manager.d.ts

@@ -0,0 +1,17 @@
+import { Subscription } from "rxjs";
+/**
+ * Manages RxJS subscriptions keyed by an owner object.
+ * Provides add/remove/clear operations with automatic unsubscribe on removal.
+ *
+ * Replaces the repeated pattern of Map<T, any[]> + addXSubscription/removeXSubscriptions
+ * found across TaskList, Task, ResourceList, etc.
+ */
+export declare class SubscriptionManager<T> {
+    #private;
+    /** Store a subscription for the given key. */
+    add(key: T, subscription: Subscription): void;
+    /** Unsubscribe and remove all subscriptions for the given key. */
+    remove(key: T): void;
+    /** Unsubscribe and remove all subscriptions for all keys. */
+    clear(): void;
+}

package/dist/common/text.d.ts

@@ -1,24 +1,24 @@
 import { HorizontalAlign, HyperlinkRect, Rect, VerticalAlign } from "./common";
 export declare const lineSpacing = 2;
-export declare function getFontHeight(ctx: any): number;
-export declare function drawMultilineText(ctx: any, text: string, rect: Rect, horizAlign: HorizontalAlign, vertAlign: VerticalAlign, fillStyle?: string | null, withHyperlinks?: boolean, underline?: boolean): void;
-export declare function getMultilineTextHeight(ctx: any, text: string, width: number, maxHeight: number): number;
+export declare function getFontHeight(ctx: CanvasRenderingContext2D): number;
+export declare function drawMultilineText(ctx: CanvasRenderingContext2D, text: string, rect: Rect, horizAlign: HorizontalAlign, vertAlign: VerticalAlign, fillStyle?: string | null, withHyperlinks?: boolean, underline?: boolean): void;
+export declare function getMultilineTextHeight(ctx: CanvasRenderingContext2D, text: string, width: number, maxHeight: number): number;
 export declare function getMultilineHyperlinks(lines: MultitextLine[], rect: Rect, horizAlign: HorizontalAlign, vertAlign: VerticalAlign): HyperlinkRect[];
 export interface MultitextLine {
     text: string;
-    measure: any;
+    measure: TextMetrics;
     height: number;
     links: HyperlinkMeasure[];
 }
-export declare function getMultilineText(ctx: any, text: string, width: number, maxHeight: number, withHyperlinks?: boolean): MultitextLine[];
+export declare function getMultilineText(ctx: CanvasRenderingContext2D, text: string, width: number, maxHeight: number, withHyperlinks?: boolean): MultitextLine[];
 export interface HyperlinkMeasure {
     url: string;
     x: number;
     width: number;
 }
-export declare function drawSinglelineText(ctx: any, text: string, rect: Rect, horizAlign: HorizontalAlign, vertAlign: VerticalAlign, fillStyle?: string | null, underline?: boolean): void;
-export declare function getSinglelineText(ctx: any, text: string, maxWidth: number): {
+export declare function drawSinglelineText(ctx: CanvasRenderingContext2D, text: string, rect: Rect, horizAlign: HorizontalAlign, vertAlign: VerticalAlign, fillStyle?: string | null, underline?: boolean): void;
+export declare function getSinglelineText(ctx: CanvasRenderingContext2D, text: string, maxWidth: number): {
     text: string;
-    measure: any;
+    measure: TextMetrics;
 };
-export declare function drawTextMiniature(ctx: any, x: number, y: number, width: number): void;
+export declare function drawTextMiniature(ctx: CanvasRenderingContext2D, x: number, y: number, width: number): void;

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

@@ -0,0 +1,5 @@
+import { BaseTheme } from "./base-theme";
+/** Apply the standard set of CSS custom properties for timeline components (GanttChart, ResourceScheduler). */
+export declare function applyTimelineThemeCssProperties(element: HTMLElement, theme: BaseTheme): void;
+/** Apply the theme font to a wrapper element. */
+export declare function applyTimelineFont(element: HTMLElement, theme: BaseTheme): void;

package/dist/common/timeline-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 TimelineTaskColor {
+    borderColor: string | null;
+    color1: string;
+    color2: string;
+    highlightColor: string;
+    static create<T extends TimelineTaskColor>(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 TimelineTaskColor instance. */
+export declare function resolveTaskColor<T extends TimelineTaskColor>(color: ColorValue, taskColors: T[]): T;
+/** Style settings for the sheet header row. */
+export declare class TimelineSheetHeaderStyle {
+    backgroundColor: string;
+    cellBorderColor: string;
+    cellDividerColor: string | null;
+    textColor: string;
+}
+/** Style settings for the sheet (left panel). */
+export declare class TimelineSheetStyle {
+    header: TimelineSheetHeaderStyle;
+    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 TimelineChartHeaderStyle {
+    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 TimelineChartContentStyle {
+    backgroundColor: string;
+    taskHeight: number;
+    taskBorderRadius: number;
+    taskColors: TimelineTaskColor[];
+    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 TimelineChartStyle {
+    header: TimelineChartHeaderStyle;
+    content: TimelineChartContentStyle;
+}
+/** Base class for all timeline component themes. Extend to create custom themes. */
+export declare abstract class TimelineTheme {
+    /** 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: TimelineSheetStyle;
+    /** Chart (right panel) visual style. */
+    chart: TimelineChartStyle;
+}
+/** 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/undo-manager.d.ts

@@ -0,0 +1,22 @@
+import { BehaviorSubject } from "rxjs";
+/** Manages an undo/redo stack using serialized state snapshots. */
+export declare class UndoManager {
+    #private;
+    /** Observable indicating whether an undo operation is available. */
+    canUndo$: BehaviorSubject<boolean>;
+    /** Observable indicating whether a redo operation is available. */
+    canRedo$: BehaviorSubject<boolean>;
+    constructor(saveFn: () => string, loadFn: (s: string) => void);
+    /** Captures the initial state snapshot and resets the undo stack. */
+    initialize(): void;
+    /** Records a new state snapshot, or defers it until the current batch ends. */
+    requestSnapshot(): void;
+    /** Begins a batch so that multiple changes produce only one undo snapshot. */
+    beginBatch(): void;
+    /** Ends the current batch and takes a snapshot if any changes occurred within it. */
+    endBatch(): void;
+    /** Restores the previous state from the undo stack. */
+    undo(): void;
+    /** Re-applies the next state from the redo stack. */
+    redo(): void;
+}

package/dist/common/working-calendar.d.ts

@@ -0,0 +1,57 @@
+/** Time unit for task duration measurement. */
+export type LengthUnit = 'minute' | 'hour' | 'day' | 'week' | 'month';
+/** Defines working days, shifts, and holidays for scheduling calculations. */
+export declare class WorkingCalendar {
+    #private;
+    /** Days of the week that are working days. */
+    workingDays: DayOfWeek[];
+    /** Dates that are non-working regardless of the day of the week. */
+    nationalHolidays: Date[];
+    /** Working time ranges within each working day. */
+    shifts: WorkingShift[];
+    /** First day of the week for calendar display. */
+    startOfWeek: DayOfWeek;
+    /** Default unit for new task durations. */
+    defaultLengthUnit: LengthUnit;
+    constructor();
+    /** Check whether a date falls on a working day (not a holiday or non-working day). */
+    isWorkingDay(current: Date): boolean;
+    /** Move a date forward to the start of the nearest working shift. */
+    moveToStartShift(current: Date, keepTimeIfInsideShift: boolean): Date;
+    /** Move a date backward to the end of the nearest working shift. */
+    moveToEndShift(current: Date, keepTimeIfInsideShift: boolean): Date;
+    /** Total working hours in a day based on the configured shifts. */
+    getHoursPerDay(): number;
+    /** Check whether a time matches the end of the last working shift. */
+    isEndOfDay(current: Date): boolean;
+    /** Get the end time of the last shift on a working day (moves forward to the next working day if needed). */
+    getEndOfWorkingDay(current: Date): Date;
+    /** Calculate working hours between two dates, respecting shifts and non-working days. */
+    getHoursBetween(time1: Date, time2: Date): number;
+    /** Get the start of the week containing the given date. */
+    getStartOfWeek(current: Date): Date;
+    /** Add (or subtract) working hours to a date, skipping non-working time. */
+    addHours(current: Date, hours: number, moveToNextIfHoursZero?: boolean): Date;
+}
+/** Day of the week. */
+export type DayOfWeek = 'monday' | 'tuesday' | 'wednesday' | 'thursday' | 'friday' | 'saturday' | 'sunday';
+/** A working time range within a day (e.g. 8:00–12:00). */
+export declare class WorkingShift {
+    /** Start time of the shift. */
+    start: TimeOfDay;
+    /** End time of the shift. */
+    end: TimeOfDay;
+    constructor(start: TimeOfDay, end: TimeOfDay);
+    /** Check whether a time falls within this shift. */
+    contains(current: Date, excludeStart?: boolean): boolean;
+    /** Duration of this shift in minutes. */
+    getLengthInMinutes(): number;
+}
+/** A time of day represented as hour and minute. */
+export declare class TimeOfDay {
+    /** Hour (0–23). */
+    hour: number;
+    /** Minute (0–59). */
+    minute: number;
+    constructor(hour: number, minute: number);
+}

package/dist/ganttchart/chart/chart-scroll-handler.d.ts

@@ -1,5 +1,5 @@
 import { BaseChartScrollHandler } from "../../common/base-chart-scroll-handler";
 import { GanttChartContext } from "../ganttchart-engine";
-export declare class ChartScrollHandler extends BaseChartScrollHandler {
+export declare class GanttChartScrollHandler extends BaseChartScrollHandler {
     constructor(gc: GanttChartContext, chartElement: any, canvas: any, inner: any);
 }

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

@@ -1,32 +1,2 @@
-import { BehaviorSubject } from "rxjs";
-import { TimelineKitLocale } from "../locale";
-import { WorkingCalendar } from "../model/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';
+export { ChartTimeline, ChartTimeAxisZoom, ChartTimeAxis } from "../../common/chart-time-axis";
+export type { ChartTimeAxisUnit } from "../../common/chart-time-axis";

package/dist/ganttchart/chart/chart.d.ts

@@ -1,7 +1,13 @@
+import { Observable } from "rxjs";
 import { GanttChartContext } from "../ganttchart-engine";
-export declare class Chart {
+import { BaseChart } from "../../common/base-chart";
+export declare class GanttChart extends BaseChart<GanttChartContext> {
     #private;
-    constructor(gc: GanttChartContext, chartElement: any);
-    get chartWidth(): number;
-    destroy(): void;
+    constructor(gc: GanttChartContext, chartElement: HTMLElement);
+    protected initComponents(chartElement: HTMLElement, canvas: HTMLCanvasElement, inner: HTMLElement): void;
+    protected getRedrawObservables(): Observable<any>[];
+    protected canRedraw(): boolean;
+    protected onRedraw(canvasCtx: CanvasRenderingContext2D): void;
+    protected onResize(): void;
+    protected destroyComponents(): void;
 }

package/dist/ganttchart/chart/handlers/add-task-part.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 AddTaskPartHandler extends ChartHandler {
+import { GanttTooltipRenderer } from "../tooltip/chart-tooltip-renderer";
+import { GanttTasksRenderer } from "../renderers/chart-tasks-renderer";
+import { GanttDragHandler } from "./gantt-drag-handler";
+interface AddTarget {
+    task: Task;
+    startCell: number;
+}
+export declare class AddTaskPartHandler extends GanttDragHandler<AddTarget> {
     #private;
-    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>;
-    onRedrawn(): void;
+    constructor(gc: GanttChartContext, tasksRenderer: GanttTasksRenderer, tooltipRenderer: GanttTooltipRenderer);
+    protected hitTest(p: Point): AddTarget | null;
+    protected onDragEnd(target: AddTarget, p: Point): void;
+    protected onDragDraw(target: AddTarget): void;
 }
+export {};

package/dist/ganttchart/chart/handlers/connector-dots-handler.d.ts

@@ -2,15 +2,17 @@ import { BehaviorSubject } 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 ConnectorDotsHandler extends ChartHandler {
+import { GanttChartHandler, ChartHandlerResult } from "./handler";
+import { GanttTooltipRenderer } from "../tooltip/chart-tooltip-renderer";
+import { GanttTasksRenderer } from "../renderers/chart-tasks-renderer";
+export declare class ConnectorDotsHandler extends GanttChartHandler {
     #private;
     connectorDotsTask$: BehaviorSubject<Task | null>;
-    constructor(gc: GanttChartContext);
-    onMouseMove(p: Point, event: any): Promise<ChartHandlerResult>;
-    onMouseDown(p: Point, ctrl: boolean, event: any): Promise<ChartHandlerResult>;
-    onKeyDown(key: string, event: any): Promise<ChartHandlerResult>;
-    onMouseUp(p: Point, ctrl: boolean, event: any): Promise<ChartHandlerResult>;
-    onMouseLeave(p: Point, event: any): Promise<ChartHandlerResult>;
+    constructor(gc: GanttChartContext, tasksRenderer: GanttTasksRenderer, tooltipRenderer: GanttTooltipRenderer);
+    onMouseMove(p: Point, event: MouseEvent): Promise<ChartHandlerResult>;
+    onMouseDown(p: Point, ctrl: boolean, event: MouseEvent): Promise<ChartHandlerResult>;
+    onKeyDown(key: string, event: KeyboardEvent): Promise<ChartHandlerResult>;
+    onMouseUp(p: Point, ctrl: boolean, event: MouseEvent): Promise<ChartHandlerResult>;
+    onMouseLeave(p: Point, event: MouseEvent): Promise<ChartHandlerResult>;
     onRedrawn(): void;
 }

package/dist/ganttchart/chart/handlers/gantt-drag-handler.d.ts

@@ -0,0 +1,32 @@
+import { Point, Cursor } from "../../../common/common";
+import { ChartHandlerResult } from "../../../common/handler-result";
+import { GanttChartContext } from "../../ganttchart-engine";
+import { GanttChartHandler } from "./handler";
+import { GanttTasksRenderer } from "../renderers/chart-tasks-renderer";
+import { GanttTooltipRenderer } from "../tooltip/chart-tooltip-renderer";
+/**
+ * Abstract base class for Gantt chart drag-operation handlers.
+ *
+ * Encapsulates the common drag lifecycle: hit-test on mouseDown,
+ * track position on mouseMove, apply result on mouseUp, draw preview on redraw.
+ *
+ * Snap handlers (resize, progress) set `enableHoverDetection = true` to show
+ * a cursor when hovering over snap zones before the drag starts.
+ */
+export declare abstract class GanttDragHandler<TTarget> extends GanttChartHandler {
+    protected startX: number;
+    protected lastP: Point;
+    protected target: TTarget | null;
+    protected dragCursor: Cursor;
+    protected enableHoverDetection: boolean;
+    protected hoverCursor: Cursor;
+    constructor(gc: GanttChartContext, tasksRenderer: GanttTasksRenderer, tooltipRenderer: GanttTooltipRenderer);
+    protected abstract hitTest(p: Point): TTarget | null;
+    protected abstract onDragEnd(target: TTarget, p: Point): void;
+    protected abstract onDragDraw(target: TTarget): void;
+    protected onDragStart(target: TTarget, p: Point): void;
+    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>;
+    onRedrawn(): void;
+}

package/dist/ganttchart/chart/handlers/handler.d.ts

@@ -3,10 +3,13 @@ import { BaseChartHandlerBase } from "../../../common/base-chart-handler";
 import { Task } from "../../model/task";
 import { GanttChartContext } from "../../ganttchart-engine";
 import { TaskPart } from "../../model/task-part";
-import { ChartTooltipLine } from "../tooltip/chart-tooltip-renderer";
-export declare abstract class ChartHandler extends BaseChartHandlerBase {
+import { GanttTasksRenderer } from "../renderers/chart-tasks-renderer";
+import { GanttTooltipLine, GanttTooltipRenderer } from "../tooltip/chart-tooltip-renderer";
+/** Finds the task whose row contains the given point. Optional filter to skip certain tasks. */
+export declare function findTaskRowAtPoint(p: Point, gc: GanttChartContext, filter?: (task: Task) => boolean): Task | null;
+export declare abstract class GanttChartHandler extends BaseChartHandlerBase {
     #private;
-    constructor(gc: GanttChartContext);
+    constructor(gc: GanttChartContext, tasksRenderer: GanttTasksRenderer, tooltipRenderer: GanttTooltipRenderer);
     protected getTaskRowAt(p: Point): Task | null;
     protected getTaskAt(p: Point): TaskAt | null;
     protected getShapeHeight(task: Task): number;
@@ -16,7 +19,7 @@ export declare abstract class ChartHandler extends BaseChartHandlerBase {
     protected drawTaskProgressHighlight(task: Task, x1: number, x2: number): void;
     protected drawTaskHighlightX1X2(task: Task, x1: number, x2: number): void;
     protected drawTaskHighlight(task: Task): void;
-    protected drawTooltip(forTasks: Task[], startX: number, title: string, lines: ChartTooltipLine[]): void;
+    protected drawTooltip(forTasks: Task[], startX: number, title: string, lines: GanttTooltipLine[]): void;
 }
 export { ChartHandlerResult } from "../../../common/handler-result";
 export interface TaskAt {

package/dist/ganttchart/chart/handlers/handlers.d.ts

@@ -1,14 +1,9 @@
-import { Subject } from "rxjs";
 import { Point } from "../../../common/common";
+import { BaseChartHandlers } from "../../../common/base-chart-handlers";
 import { GanttChartContext } from "../../ganttchart-engine";
-import { ClassWithListeners } from "../../../common/class-with-listeners";
-export declare class ChartHandlers extends ClassWithListeners {
+import { GanttChartHandler } from "./handler";
+export declare class GanttChartHandlers extends BaseChartHandlers<GanttChartHandler> {
     #private;
-    operationComplete$: Subject<void>;
-    redraw$: Subject<void>;
-    constructor(gc: GanttChartContext, chartElement: any);
-    getMousePosition(event: any): Point;
-    init(chartElement: any, canvas: any): void;
-    clear(): void;
-    private isWithinScrollbar;
+    constructor(gc: GanttChartContext, chartElement: HTMLElement);
+    protected onAfterContextMenu(p: Point, event: MouseEvent): void;
 }

package/dist/ganttchart/chart/handlers/move-milestone.d.ts

@@ -1,11 +1,13 @@
 import { Point } from "../../../common/common";
 import { GanttChartContext } from "../../ganttchart-engine";
-import { ChartHandler, ChartHandlerResult } from "./handler";
-export declare class MoveMilestoneHandler extends ChartHandler {
+import { GanttTooltipRenderer } from "../tooltip/chart-tooltip-renderer";
+import { TaskAt } from "./handler";
+import { GanttTasksRenderer } from "../renderers/chart-tasks-renderer";
+import { GanttDragHandler } from "./gantt-drag-handler";
+export declare class MoveMilestoneHandler extends GanttDragHandler<TaskAt> {
     #private;
-    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>;
-    onRedrawn(): void;
+    constructor(gc: GanttChartContext, tasksRenderer: GanttTasksRenderer, tooltipRenderer: GanttTooltipRenderer);
+    protected hitTest(p: Point): TaskAt | null;
+    protected onDragEnd(target: TaskAt, p: Point): void;
+    protected onDragDraw(target: TaskAt): void;
 }

package/dist/ganttchart/chart/handlers/move-task-part.d.ts

@@ -1,11 +1,13 @@
 import { Point } from "../../../common/common";
 import { GanttChartContext } from "../../ganttchart-engine";
-import { ChartHandler, ChartHandlerResult } from "./handler";
-export declare class MoveTaskPartHandler extends ChartHandler {
+import { TaskAt } from "./handler";
+import { GanttTooltipRenderer } from "../tooltip/chart-tooltip-renderer";
+import { GanttTasksRenderer } from "../renderers/chart-tasks-renderer";
+import { GanttDragHandler } from "./gantt-drag-handler";
+export declare class MoveTaskPartHandler extends GanttDragHandler<TaskAt> {
     #private;
-    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>;
-    onRedrawn(): void;
+    constructor(gc: GanttChartContext, tasksRenderer: GanttTasksRenderer, tooltipRenderer: GanttTooltipRenderer);
+    protected hitTest(p: Point): TaskAt | null;
+    protected onDragEnd(target: TaskAt, p: Point): void;
+    protected onDragDraw(target: TaskAt): void;
 }

package/dist/ganttchart/chart/handlers/resize-task-part.d.ts

@@ -1,11 +1,22 @@
 import { Point } from "../../../common/common";
+import { Task } from "../../model/task";
+import { TaskPart } from "../../model/task-part";
 import { GanttChartContext } from "../../ganttchart-engine";
-import { ChartHandler, ChartHandlerResult } from "./handler";
-export declare class ResizeTaskPartHandler 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 ResizeTaskPartHandler extends GanttDragHandler<TaskSnapAt> {
     #private;
-    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>;
-    onRedrawn(): void;
+    constructor(gc: GanttChartContext, tasksRenderer: GanttTasksRenderer, tooltipRenderer: GanttTooltipRenderer);
+    protected hitTest(p: Point): TaskSnapAt | null;
+    protected onDragEnd(target: TaskSnapAt, p: Point): void;
+    protected onDragDraw(target: TaskSnapAt): void;
 }
+interface TaskSnapAt {
+    task: Task;
+    taskPart: TaskPart;
+    x1: number;
+    x2: number;
+    deltaX: number;
+}
+export {};