@timelinekit/core 1.0.0 → 1.0.3

package/dist/calendar/model/recurrence-rule.d.ts

@@ -0,0 +1,42 @@
+export type RecurrenceFrequency = 'daily' | 'weekly' | 'monthly' | 'yearly';
+export type Weekday = 'mo' | 'tu' | 'we' | 'th' | 'fr' | 'sa' | 'su';
+export interface WeekdayOrdinal {
+    day: Weekday;
+    ordinal?: number;
+}
+export interface RecurrenceRuleInit {
+    frequency: RecurrenceFrequency;
+    interval?: number;
+    until?: Date | null;
+    count?: number | null;
+    byDay?: WeekdayOrdinal[];
+    byMonthDay?: number[];
+    byMonth?: number[];
+    bySetPos?: number[];
+    weekStart?: Weekday;
+}
+export declare class RecurrenceRule {
+    #private;
+    readonly frequency: RecurrenceFrequency;
+    readonly interval: number;
+    readonly until: Date | null;
+    readonly count: number | null;
+    readonly byDay: readonly WeekdayOrdinal[];
+    readonly byMonthDay: readonly number[];
+    readonly byMonth: readonly number[];
+    readonly bySetPos: readonly number[];
+    readonly weekStart: Weekday;
+    constructor(init: RecurrenceRuleInit);
+    static fromString(rrule: string): RecurrenceRule;
+    toString(): string;
+    toAny(): any;
+    static fromAny(data: any): RecurrenceRule;
+    /**
+     * Generates occurrence dates within a time range.
+     * @param dtStart - master event start time (first occurrence)
+     * @param rangeStart - beginning of the visible window
+     * @param rangeEnd - end of the visible window
+     * @returns sorted array of occurrence start dates
+     */
+    expandBetween(dtStart: Date, rangeStart: Date, rangeEnd: Date): Date[];
+}

package/dist/calendar/sidebar/calendar-list.d.ts

@@ -0,0 +1,13 @@
+import type { EventCalendarContext } from "../eventcalendar-context";
+/**
+ * Calendar list widget for the sidebar.
+ *
+ * Renders a checklist of all calendars with color indicators, visibility
+ * toggles, remove buttons, and an "Add calendar" action.
+ */
+export declare class CalendarList {
+    #private;
+    constructor(ec: EventCalendarContext, container: HTMLElement);
+    render(): void;
+    destroy(): void;
+}

package/dist/calendar/sidebar/mini-calendar.d.ts

@@ -0,0 +1,20 @@
+import type { EventCalendarContext } from "../eventcalendar-context";
+/**
+ * Compact month calendar for the sidebar.
+ *
+ * Two display modes:
+ *   1. Day grid — 6×7 grid of day numbers with selection highlight.
+ *   2. Month picker — 4×3 grid of month names (activated by clicking the year).
+ *
+ * Selection highlight adapts to the current viewMode:
+ *   - day   → single day circled
+ *   - week  → full week row highlighted
+ *   - month → all days of the current month highlighted
+ */
+export declare class MiniCalendar {
+    #private;
+    constructor(ec: EventCalendarContext, container: HTMLElement);
+    render(): void;
+    navigateToMonth(year: number, month: number): void;
+    destroy(): void;
+}

package/dist/calendar/themes/dark-theme.d.ts

@@ -0,0 +1,4 @@
+import { EventCalendarTheme } from "./eventcalendar-theme";
+export declare class DarkEventCalendarTheme extends EventCalendarTheme {
+    constructor();
+}

package/dist/calendar/themes/eventcalendar-theme.d.ts

@@ -0,0 +1,156 @@
+import { Font } from "../../common/common";
+import { BaseTaskColor } from "../../common/base-theme";
+export type { ColorDefinition, ColorValue } from "../../common/base-theme";
+/** Color palette for a single calendar entry color. */
+export declare class EventCalendarEntryColor extends BaseTaskColor {
+    /** Background color for compact "chip" display (single-line entries in month view). */
+    chipBackgroundColor: string;
+    /** Text color for compact "chip" display. */
+    chipTextColor: string;
+    /** Text color for full-block entries (multi-day bars, timed blocks). */
+    textColor: string;
+}
+/** Style settings for the calendar toolbar area. */
+export declare class EventCalendarToolbarStyle {
+    backgroundColor: string;
+    textColor: string;
+    borderColor: string;
+    buttonColor: string;
+    buttonHoverBackgroundColor: string;
+    activeViewButtonBackgroundColor: string;
+    activeViewButtonTextColor: string;
+    height: number;
+}
+/** Style settings for the calendar header (day names in month view, day headers in week/day view). */
+export declare class EventCalendarHeaderStyle {
+    backgroundColor: string;
+    textColor: string;
+    borderColor: string;
+    todayTextColor: string;
+    todayBackgroundColor: string;
+    weekendTextColor: string;
+}
+/** Style settings for the main calendar content area. */
+export declare class EventCalendarContentStyle {
+    backgroundColor: string;
+    textColor: string;
+    gridLineColor: string;
+    /** Background color for the entire today cell/column. */
+    todayBackgroundColor: string;
+    /** Background color for weekend cells/columns. */
+    weekendBackgroundColor: string;
+    /** Background color for days belonging to a different month (month view only). */
+    otherMonthBackgroundColor: string;
+    /** Text color for day numbers of a different month. */
+    otherMonthTextColor: string;
+    /** Color of the horizontal hour separator lines (week/day view). */
+    hourLineColor: string;
+    /** Color of the half-hour separator lines (week/day view). */
+    halfHourLineColor: string;
+    /** Color of the current time indicator line and dot (week/day view). */
+    currentTimeLineColor: string;
+    /** Thickness of the current time indicator line in pixels (week/day view). */
+    currentTimeLineHeight: number;
+    /** Height of one time slot in pixels (week/day view). Each slot = slotDuration minutes. */
+    slotHeight: number;
+    /** Height of the day number header inside each day cell (month view). */
+    dayHeaderHeight: number;
+    /** Height of an entry bar/chip in month view. */
+    entryHeight: number;
+    /** Vertical gap between entries. */
+    entryGap: number;
+    /** Border radius for entry elements. */
+    entryBorderRadius: number;
+    /** Width of the left accent border on entries. */
+    entryAccentBorderWidth: number;
+    /** Minimum height of an entry in week/day view. */
+    entryMinHeight: number;
+    /** Opacity for declined meetings. */
+    declinedOpacity: number;
+    /** Color of the "+N more" text in month view when entries overflow. */
+    moreTextColor: string;
+    /** Color palette for entry colors. Entries reference these by index or custom ColorDefinition. */
+    entryColors: EventCalendarEntryColor[];
+    /** Color of the hover overlay on day cells. */
+    hoverBackgroundColor: string;
+    /** Background color for the selected entry. */
+    selectedEntryOutlineColor: string;
+    /** Background overlay during drag-to-create. */
+    dragHighlightColor: string;
+    /** Scrollbar colors for the scrollable content area. */
+    scrollbarThumbColor: string;
+    scrollbarTrackColor: string;
+    /** Background color for day headers in agenda view. */
+    agendaDayHeaderBackgroundColor: string;
+    /** Text color for day headers in agenda view. */
+    agendaDayHeaderTextColor: string;
+    /** Height of each entry row in agenda view (px). */
+    agendaEntryHeight: number;
+    /** Vertical gap between entry rows in agenda view (px). */
+    agendaEntryGap: number;
+    /** Hover background color for entries in agenda view. */
+    agendaEntryHoverBackgroundColor: string;
+    /** Text color for the empty state message in agenda view. */
+    agendaEmptyTextColor: string;
+    /** Width of the time column in agenda view (px). */
+    agendaTimeWidth: number;
+    /** Color of the focus ring when an entry or interactive element is focused via keyboard. */
+    focusOutlineColor: string;
+    /** Width of the focus ring in pixels. */
+    focusOutlineWidth: number;
+    /** Offset of the focus ring from the element edge in pixels. */
+    focusOutlineOffset: number;
+    constructor();
+}
+/** Style settings for the sidebar (mini calendar + calendar list). */
+export declare class EventCalendarSidebarStyle {
+    backgroundColor: string;
+    textColor: string;
+    borderColor: string;
+    width: number;
+    /** Mini-calendar styles. */
+    miniCalendarTodayTextColor: string;
+    miniCalendarTodayBackgroundColor: string;
+    miniCalendarTodayDotColor: string;
+    miniCalendarSelectedBackgroundColor: string;
+    miniCalendarSelectedTextColor: string;
+    miniCalendarOtherMonthTextColor: string;
+    miniCalendarWeekendTextColor: string;
+    miniCalendarHoverBackgroundColor: string;
+    miniCalendarDayWithEventsColor: string;
+    /** Calendar list styles. */
+    calendarListHeaderTextColor: string;
+    calendarListCheckboxColor: string;
+}
+/** Style settings for the all-day section (week/day view). */
+export declare class EventCalendarAllDayStyle {
+    backgroundColor: string;
+    borderColor: string;
+    textColor: string;
+    minHeight: number;
+    maxHeight: number;
+    maxVisibleRows: number;
+    rowHeight: number;
+}
+/** Style settings for the time gutter (week/day view). */
+export declare class EventCalendarTimeGutterStyle {
+    backgroundColor: string;
+    textColor: string;
+    borderColor: string;
+    width: number;
+    fontSize: number;
+}
+/** Base class for EventCalendar visual themes. Extend to create custom themes. */
+export declare abstract class EventCalendarTheme {
+    /** Default font used throughout the component. */
+    font: Font;
+    /** Color scheme hint for browser-native elements (scrollbars, inputs). */
+    colorScheme: 'light' | 'dark';
+    toolbar: EventCalendarToolbarStyle;
+    header: EventCalendarHeaderStyle;
+    content: EventCalendarContentStyle;
+    sidebar: EventCalendarSidebarStyle;
+    allDay: EventCalendarAllDayStyle;
+    timeGutter: EventCalendarTimeGutterStyle;
+    constructor();
+}

package/dist/calendar/themes/light-theme.d.ts

@@ -0,0 +1,4 @@
+import { EventCalendarTheme } from "./eventcalendar-theme";
+export declare class LightEventCalendarTheme extends EventCalendarTheme {
+    constructor();
+}

package/dist/calendar/tooltip/calendar-tooltip-renderer.d.ts

@@ -0,0 +1,8 @@
+import type { EventCalendarContext } from "../eventcalendar-context";
+/** DOM-based tooltip renderer for EventCalendar entries. */
+export declare class CalendarTooltipRenderer {
+    #private;
+    constructor(ec: EventCalendarContext, container: HTMLElement);
+    hide(): void;
+    destroy(): void;
+}

package/dist/calendar/views/agenda-view.d.ts

@@ -0,0 +1,12 @@
+import { BaseCalendarView } from "./base-view";
+import type { EventCalendarContext } from "../eventcalendar-context";
+/** Agenda/list view — chronological list of entries grouped by day. */
+export declare class AgendaView extends BaseCalendarView {
+    #private;
+    constructor(ec: EventCalendarContext, container: HTMLElement);
+    getVisibleRange(currentDate: Date): {
+        start: Date;
+        end: Date;
+    };
+    render(): void;
+}

package/dist/calendar/views/base-view.d.ts

@@ -0,0 +1,23 @@
+import { Subscription } from "rxjs";
+import type { EventCalendarContext } from "../eventcalendar-context";
+/** Base class for all calendar views (month, week, day). */
+export declare abstract class BaseCalendarView {
+    protected ec: EventCalendarContext;
+    protected element: HTMLElement;
+    protected subscriptions: Subscription;
+    constructor(ec: EventCalendarContext, container: HTMLElement);
+    /** Show this view and trigger rendering. */
+    show(): void;
+    /** Hide this view. */
+    hide(): void;
+    /** Whether this view is currently visible. */
+    get isVisible(): boolean;
+    /** Full re-render of the view content. */
+    abstract render(): void;
+    /** Returns the visible date range for this view given the current date. */
+    abstract getVisibleRange(currentDate: Date): {
+        start: Date;
+        end: Date;
+    };
+    destroy(): void;
+}

package/dist/calendar/views/day-view.d.ts

@@ -0,0 +1,11 @@
+import { WeekView } from "./week-view";
+import type { EventCalendarContext } from "../eventcalendar-context";
+/** Day calendar view — single day column with time slots. */
+export declare class DayView extends WeekView {
+    constructor(ec: EventCalendarContext, container: HTMLElement);
+    protected get dayCount(): number;
+    getVisibleRange(currentDate: Date): {
+        start: Date;
+        end: Date;
+    };
+}

package/dist/calendar/views/handlers/allday-drag-handler.d.ts

@@ -0,0 +1,14 @@
+import type { EventCalendarContext } from "../../eventcalendar-context";
+/** Handles drag-to-create interaction on the all-day section of week/day views. */
+export declare class AllDayDragHandler {
+    #private;
+    constructor(ec: EventCalendarContext);
+    /** Whether the last pointerdown resulted in a drag (moved to a different cell). */
+    get didDrag(): boolean;
+    /** Attach drag-to-create to the all-day row. Call during render. */
+    attach(allDayRow: HTMLElement, days: Date[]): void;
+    /** Cancel any active drag. Call before re-render. */
+    cancel(): void;
+    /** Full cleanup. */
+    destroy(): void;
+}

package/dist/calendar/views/handlers/allday-entry-drag-handler.d.ts

@@ -0,0 +1,18 @@
+import type { EventCalendarContext } from "../../eventcalendar-context";
+import type { CalendarEntry } from "../../model/calendar-entry";
+/**
+ * Handles drag-to-move interaction on existing all-day entries
+ * in the week/day views.
+ */
+export declare class AllDayEntryDragHandler {
+    #private;
+    constructor(ec: EventCalendarContext);
+    get didDrag(): boolean;
+    /**
+     * Start dragging an all-day entry.
+     * Call from the entry's pointerdown handler.
+     */
+    startDrag(e: PointerEvent, entry: CalendarEntry, entryEl: HTMLElement, allDayRow: HTMLElement, days: Date[]): void;
+    cancel(): void;
+    destroy(): void;
+}

package/dist/calendar/views/handlers/month-drag-handler.d.ts

@@ -0,0 +1,14 @@
+import type { EventCalendarContext } from "../../eventcalendar-context";
+/** Handles drag-to-create interaction on month view day cells. */
+export declare class MonthDragHandler {
+    #private;
+    constructor(ec: EventCalendarContext);
+    /** Whether the last pointerdown resulted in a drag (moved to a different cell). */
+    get didDrag(): boolean;
+    /** Attach drag-to-create to the month grid. Call during render. */
+    attach(gridElement: HTMLElement, gridStartDate: Date): void;
+    /** Cancel any active drag. Call before re-render. */
+    cancel(): void;
+    /** Full cleanup. */
+    destroy(): void;
+}

package/dist/calendar/views/handlers/month-entry-drag-handler.d.ts

@@ -0,0 +1,18 @@
+import type { EventCalendarContext } from "../../eventcalendar-context";
+import type { CalendarEntry } from "../../model/calendar-entry";
+/**
+ * Handles drag-to-move interaction on existing entries in the month view.
+ * Drags an entry from one day cell to another.
+ */
+export declare class MonthEntryDragHandler {
+    #private;
+    constructor(ec: EventCalendarContext);
+    get didDrag(): boolean;
+    /**
+     * Start dragging an entry from a specific cell.
+     * Call from the entry's pointerdown handler.
+     */
+    startDrag(e: PointerEvent, entry: CalendarEntry, entryEl: HTMLElement, cells: HTMLElement[], gridStartDate: Date): void;
+    cancel(): void;
+    destroy(): void;
+}

package/dist/calendar/views/handlers/swipe-navigation-handler.d.ts

@@ -0,0 +1,14 @@
+/** Handles horizontal swipe gestures for view navigation on touch devices. */
+export declare class SwipeNavigationHandler {
+    #private;
+    /** Minimum horizontal distance (px) to recognize a swipe. */
+    static SWIPE_THRESHOLD: number;
+    /** Maximum |deltaY| / |deltaX| ratio — rejects diagonal/vertical gestures. */
+    static MAX_VERTICAL_RATIO: number;
+    /** Maximum gesture duration (ms). */
+    static MAX_DURATION: number;
+    /** Maximum visual translate offset (px) during swipe. */
+    static PEEK_MAX: number;
+    constructor(element: HTMLElement, onSwipeLeft: () => void, onSwipeRight: () => void);
+    destroy(): void;
+}

package/dist/calendar/views/handlers/time-grid-drag-handler.d.ts

@@ -0,0 +1,14 @@
+import type { EventCalendarContext } from "../../eventcalendar-context";
+/** Handles drag-to-create interaction on time grid day columns. */
+export declare class TimeGridDragHandler {
+    #private;
+    constructor(ec: EventCalendarContext);
+    /** Whether the last pointerdown resulted in a drag (moved at least one slot). */
+    get didDrag(): boolean;
+    /** Attach drag-to-create to a day column. Call for each column during render. */
+    attach(column: HTMLElement, day: Date, pxPerMinute: number, slotDuration: number): void;
+    /** Cancel any active drag. Call before re-render. */
+    cancel(): void;
+    /** Full cleanup. */
+    destroy(): void;
+}

package/dist/calendar/views/handlers/time-grid-entry-drag-handler.d.ts

@@ -0,0 +1,18 @@
+import type { EventCalendarContext } from "../../eventcalendar-context";
+import type { CalendarEntry } from "../../model/calendar-entry";
+export type EntryDragMode = 'move' | 'resize-start' | 'resize-end';
+/**
+ * Handles drag-to-move and drag-to-resize interactions on existing entries
+ * in the time grid (week/day views).
+ */
+export declare class TimeGridEntryDragHandler {
+    #private;
+    constructor(ec: EventCalendarContext);
+    /**
+     * Attach move/resize handling to an entry element.
+     * Call for each rendered timed entry during render.
+     */
+    attach(entryEl: HTMLElement, entry: CalendarEntry, column: HTMLElement, day: Date, pxPerMinute: number, slotDuration: number, allColumns?: HTMLElement[], allDays?: Date[]): void;
+    cancel(): void;
+    destroy(): void;
+}

package/dist/calendar/views/month-view.d.ts

@@ -0,0 +1,13 @@
+import { BaseCalendarView } from "./base-view";
+import type { EventCalendarContext } from "../eventcalendar-context";
+/** Monthly calendar view — 6-row × 7-column grid of day cells. */
+export declare class MonthView extends BaseCalendarView {
+    #private;
+    constructor(ec: EventCalendarContext, container: HTMLElement);
+    getVisibleRange(currentDate: Date): {
+        start: Date;
+        end: Date;
+    };
+    render(): void;
+    destroy(): void;
+}

package/dist/calendar/views/time-grid-helper.d.ts

@@ -0,0 +1,36 @@
+import type { CalendarEntry } from "../model/calendar-entry";
+/** Layout info for a single timed entry after overlap resolution. */
+export interface EntryLayout {
+    entry: CalendarEntry;
+    /** 0-based column index within the overlap group. */
+    column: number;
+    /** Total number of columns in this overlap group. */
+    totalColumns: number;
+}
+/** An entry assigned to a specific day column. */
+export interface DayEntries {
+    date: Date;
+    allDay: CalendarEntry[];
+    timed: CalendarEntry[];
+}
+/** Static helpers shared by WeekView and DayView. */
+export declare class TimeGridHelper {
+    /** Returns hour labels for the gutter (0–23 full range). */
+    static getHourLabels(locale: string): string[];
+    /** Converts a time to a vertical pixel offset from midnight. */
+    static timeToY(time: Date, pxPerMinute: number): number;
+    /** Returns the pixel height for a duration. */
+    static durationToHeight(startTime: Date, endTime: Date, pxPerMinute: number): number;
+    /**
+     * Splits entries into per-day buckets, separating all-day from timed entries.
+     * An entry is considered all-day if isAllDay is true OR if it spans more than 24 hours.
+     */
+    static splitByDay(entries: CalendarEntry[], days: Date[]): DayEntries[];
+    /**
+     * Resolves overlapping timed entries into side-by-side columns.
+     *
+     * Algorithm: sweep-line grouping → greedy column assignment.
+     * Returns entries with their column index and total column count.
+     */
+    static resolveOverlaps(entries: CalendarEntry[]): EntryLayout[];
+}

package/dist/calendar/views/view-utils.d.ts

@@ -0,0 +1,38 @@
+import type { CalendarEntry } from "../model/calendar-entry";
+import type { CalendarData } from "../model/calendar-data";
+import type { EventCalendarEntryColor } from "../themes/eventcalendar-theme";
+import type { EventCalendarTheme } from "../themes/eventcalendar-theme";
+import type { EventCalendarContext } from "../eventcalendar-context";
+/** Resolves an entry's effective color from theme palette. */
+export declare function resolveEntryColor(entry: CalendarEntry, data: CalendarData, theme: EventCalendarTheme): EventCalendarEntryColor;
+/**
+ * Applies responseStatus-based visual styling to an entry element.
+ *
+ * Only affects meetings. Non-meeting types always get the default (accepted) look.
+ *
+ * - accepted:    solid fill (default)
+ * - tentative:   diagonal stripes
+ * - needsAction: outline only (transparent background)
+ * - declined:    outline only, muted, strikethrough text
+ */
+export declare function applyResponseStatusStyle(entryEl: HTMLElement, entry: CalendarEntry, color: EventCalendarEntryColor): void;
+/**
+ * Invokes the custom entry rendering callback if set.
+ * If the callback returns true, the element's default content is replaced.
+ */
+export declare function applyEntryRendering(entryEl: HTMLElement, entry: CalendarEntry, isAllDay: boolean, ec: EventCalendarContext): void;
+/**
+ * Appends type/recurring icons to an entry element and then the title text.
+ * Replaces direct `textContent` assignment for entry elements.
+ */
+export declare function appendEntryContent(el: HTMLElement, entry: CalendarEntry): void;
+/**
+ * Attaches focus/blur listeners that show a keyboard focus ring via CSS custom properties.
+ * The ring is suppressed during mouse interaction to avoid visual noise.
+ */
+export declare function applyFocusRing(el: HTMLElement): void;
+/**
+ * Updates aria-selected and visual outline on entry elements to reflect current selection.
+ * Call from selectedEntries$ subscription in each view.
+ */
+export declare function updateSelectionVisuals(container: HTMLElement, selectedEntries: CalendarEntry[]): void;

package/dist/calendar/views/week-view.d.ts

@@ -0,0 +1,16 @@
+import { BaseCalendarView } from "./base-view";
+import type { EventCalendarContext } from "../eventcalendar-context";
+/** Weekly calendar view — 7 day columns with time slots. */
+export declare class WeekView extends BaseCalendarView {
+    #private;
+    constructor(ec: EventCalendarContext, container: HTMLElement);
+    protected get dayCount(): number;
+    protected getDays(currentDate: Date): Date[];
+    show(): void;
+    getVisibleRange(currentDate: Date): {
+        start: Date;
+        end: Date;
+    };
+    render(): void;
+    destroy(): void;
+}

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

@@ -1,17 +1,20 @@
 import { BehaviorSubject } from "rxjs";
-import { ChartTimeline } from "../ganttchart/chart/chart-time-axis";
-import { GanttChartTheme } from "../ganttchart/themes/theme";
-import { WorkingCalendar } from "../ganttchart/model/working-calendar";
+import { CanvasLike } from "./common";
+import { ChartTimeline } from "./chart-time-axis";
+import { BaseTheme } from "./base-theme";
+import { WorkingCalendar } from "./working-calendar";
 export interface BackgroundRendererContext {
     timeline: ChartTimeline;
-    theme$: BehaviorSubject<GanttChartTheme>;
+    theme$: {
+        getValue(): BaseTheme;
+    };
     showGridLines$: BehaviorSubject<boolean>;
     calendar: WorkingCalendar;
 }
 export declare abstract class BaseBackgroundRenderer {
     #private;
     constructor(ctx: BackgroundRendererContext);
-    render(canvas: any): void;
+    render(canvas: CanvasLike): void;
     protected abstract getContentBottom(canvasHeight: number): number;
-    protected abstract drawHorizontalGridLines(canvas: any, ctx: any): void;
+    protected abstract drawHorizontalGridLines(canvas: CanvasLike, ctx: CanvasRenderingContext2D): void;
 }

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

@@ -1,8 +1,10 @@
 import { Subject } from "rxjs";
 import { Cursor, Point } from "./common";
 import { ChartHandlerResult } from "./handler-result";
-import { ChartTimeline } from "../ganttchart/chart/chart-time-axis";
-import { WorkingCalendar } from "../ganttchart/model/working-calendar";
+import { ChartTimeline } from "./chart-time-axis";
+import { WorkingCalendar } from "./working-calendar";
+/** Pixel tolerance for snapping to edges during resize/progress operations. */
+export declare const SNAP_WIDTH = 6;
 /**
  * Interface for the context needed by chart handlers.
  * Both GanttChartContext and ResourceSchedulerContext satisfy this.
@@ -27,27 +29,31 @@ export declare abstract class BaseChartHandlerBase {
     ignoreRightButton: boolean;
     ignoreWhenCannotEdit: boolean;
     alwaysHandleEvents: boolean;
-    protected canvas: any;
+    protected canvas: HTMLCanvasElement;
     operationComplete$: Subject<void>;
     get canEdit(): boolean;
     constructor(ctx: ChartHandlerContext);
     set isInOperation(value: boolean);
     get isInOperation(): boolean;
-    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;
-    onDocumentMouseMove(p: Point, event: any): ChartHandlerResult;
-    onDocumentMouseUp(p: Point, event: any): ChartHandlerResult;
+    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;
+    onDocumentMouseMove(p: Point, event: MouseEvent): ChartHandlerResult;
+    onDocumentMouseUp(p: Point, event: MouseEvent): ChartHandlerResult;
     clear(): void;
-    init(canvas: any): void;
+    init(canvas: HTMLCanvasElement): void;
     onRedrawn(): void;
     onBackgroundRedrawn(): void;
+    /** Converts a date to an X pixel coordinate (floored) relative to the current visible start. */
+    protected dateToX(date: Date): number;
     protected getCellAt(p: Point): number;
     protected getCellEndAligned(p: Point): number;
     protected getEndTimeAligned(cellEndAligned: number): Date;
+    /** Converts a rounded cell index to a Date via the current timeline axis. */
+    protected cellToDate(cell: number): Date;
     protected setCursor(cursor: Cursor): void;
 }

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

@@ -0,0 +1,34 @@
+import { Subject } from "rxjs";
+import { Point } from "./common";
+import { BaseChartHandlerBase } from "./base-chart-handler";
+import { ClassWithListeners } from "./class-with-listeners";
+import { AutoScrollHelper } from "./auto-scroll";
+import { ChartTimeline } from "./chart-time-axis";
+export interface BaseHandlersContext {
+    timeline: ChartTimeline;
+    canEdit: boolean;
+    autoScrolling: boolean;
+    chartRedrawn$: Subject<void>;
+    chartBackgroundRedrawn$: Subject<void>;
+}
+export declare abstract class BaseChartHandlers<THandler extends BaseChartHandlerBase> extends ClassWithListeners {
+    #private;
+    operationComplete$: Subject<void>;
+    redraw$: Subject<void>;
+    constructor(ctx: BaseHandlersContext, chartElement: HTMLElement);
+    protected get chartElement(): HTMLElement;
+    protected addHandler(handler: THandler): void;
+    protected addSubscription(sub: any): void;
+    /** Call from subclass constructor after all handlers are registered. */
+    protected wireHandlers(): void;
+    getMousePosition(event: MouseEvent): Point;
+    init(chartElement: HTMLElement, canvas: HTMLCanvasElement): void;
+    protected createAutoScroll(chartElement: HTMLElement): AutoScrollHelper;
+    protected onAutoScroll(dx: number, dy: number): void;
+    protected registerKeydownListener(_chartElement: HTMLElement): void;
+    protected handleKeyDown(event: KeyboardEvent): Promise<void>;
+    protected onBeforeMouseDown(): void;
+    protected onAfterContextMenu(p: Point, event: MouseEvent): void;
+    destroy(): void;
+    clear(): void;
+}