@timelinekit/core 1.0.0 → 1.0.5

package/dist/ganttchart/model/task-list-adapter.d.ts

@@ -2,27 +2,49 @@ import { Subject } from "rxjs";
 import { TableItemEventArgs, TreeTableDataSource } from "../../table/table-data-source";
 import { Task } from "./task";
 import { TaskList } from "./task-list";
+/** Adapts a TaskList to the TreeTableDataSource interface used by the sheet component. */
 export declare class TaskListAdapter implements TreeTableDataSource<Task> {
     #private;
+    /** Emits when a task property changes. */
     itemChanged$: Subject<TableItemEventArgs<Task>>;
+    /** Emits when a task is removed from the list. */
     itemRemoved$: Subject<TableItemEventArgs<Task>>;
+    /** Emits when a task's collapsed state changes. */
     itemCollapsedChanged$: Subject<TableItemEventArgs<Task>>;
+    /** Emits after a complex multi-step operation (e.g. paste) completes. */
     complexOperationFinished$: Subject<void>;
     constructor(list: TaskList);
+    destroy(): void;
+    /** Returns the underlying TaskList instance. */
     get list(): TaskList;
+    /** Returns the total number of tasks including empty rows. */
     get length(): number;
+    /** Returns the task at the given flat index. */
     getItem(index: number): Task;
+    /** Finds a task by its unique identifier, or returns null if not found. */
     getItemById(id: string): Task | null;
+    /** Returns the flat index of the given task. */
     indexOf(item: Task): number;
+    /** Appends an empty task row at the end of the list. */
     addEmptyItem(): Task;
+    /** Inserts an empty task row at the specified index. */
     insertEmptyItem(index: number): Task;
+    /** Removes the specified tasks from the list. */
     removeItems(items: Task[]): void;
+    /** Returns the display label (task number) for the given task. */
     getItemLabel(item: Task): string;
+    /** Returns true if the task is hidden (e.g. collapsed under a summary). */
     isItemHidden(item: Task): boolean;
+    /** Returns the next visible task after the given one, or null if none exists. */
     getNextVisible(item: Task): Task | null;
+    /** Returns the previous visible task before the given one, or null if none exists. */
     getPreviousVisible(item: Task): Task | null;
+    /** Increases the hierarchy level of the specified tasks by one. */
     indent(items: Task[]): void;
+    /** Decreases the hierarchy level of the specified tasks by one. */
     outdent(items: Task[]): void;
+    /** Moves the specified tasks one position up in the list. */
     moveUp(items: Task[]): void;
+    /** Moves the specified tasks one position down in the list. */
     moveDown(items: Task[]): void;
 }

package/dist/ganttchart/model/task-list.d.ts

@@ -4,62 +4,115 @@ import { Task, TaskEventArgs, TaskResourceAddingEventArgs, TaskTypeChangeEventAr
 import { WorkingCalendar } from "./working-calendar";
 import { TaskLink, TaskLinkEventArgs, TaskLinkType } from "./task-link";
 import { Resource } from "./resource";
-import { DateRange } from "../ganttchart-engine";
+import { DateRange } from "../../common/common";
 import { TimelineKitLocale } from "../locale";
+/** Central data store holding all tasks, links, and hierarchy for the Gantt chart. */
 export declare class TaskList {
     #private;
+    /** Emitted when a task is added. */
     taskAdded$: Subject<TaskEventArgs>;
+    /** Emitted when a task property changes. */
     taskChanged$: Subject<TaskEventArgs>;
+    /** Emitted when a task is removed. */
     taskRemoved$: Subject<TaskEventArgs>;
+    /** Emitted when a task's collapsed state changes. */
     taskCollapsedChanged$: Subject<TaskEventArgs>;
+    /** Emitted when a task's type changes. */
     taskTypeChanged$: Subject<TaskTypeChangeEventArgs>;
+    /** Emitted when a link is added. */
     linkAdded$: Subject<TaskLinkEventArgs>;
+    /** Emitted when a link is removed. */
     linkRemoved$: Subject<TaskLinkEventArgs>;
+    /** Emitted before a resource is added to a task. */
     resourceAdding$: Subject<TaskResourceAddingEventArgs>;
+    /** Emitted when the task filter changes. */
     filterChanged$: Subject<void>;
     constructor(calendar$: BehaviorSubject<WorkingCalendar>, projectTimeline$: BehaviorSubject<DateRange>, locale$?: BehaviorSubject<TimelineKitLocale>);
+    /** Total number of tasks (including Empty rows). */
     get length(): number;
+    /** Total number of links. */
     get linksLength(): number;
+    /** Whether link dependencies are currently being evaluated (prevents re-entrant updates). */
     get evaluatingDependencies(): boolean;
-    evaluatingDependenciesFinished$: Subject<void>;
+    /** Emitted after dependency evaluation completes. */
+    get evaluatingDependenciesFinished$(): Subject<void>;
+    /** Emitted after a bulk operation completes. */
     complexOperationFinished$: Subject<void>;
+    /** Active task filter function. Set to null to show all tasks. */
     get filter(): TaskFilterFn | null;
     set filter(value: TaskFilterFn | null);
+    /** Get a task by index. */
     getTask(index: number): Task;
+    /** Find a task by ID, or null if not found. */
     getTaskById(id: string): Task | null;
+    /** Get a link by index. */
     getLink(index: number): TaskLink;
+    /** Get the index of a task in the list. */
     indexOf(task: Task): number;
+    /** Append an empty placeholder row at the end of the list. */
     addEmptyTask(): Task;
+    /** Insert an empty placeholder row at the given index. */
     insertEmptyTask(index: number): Task;
+    /** Add a task to the end of the list. */
     addTask(task: Task): Task;
+    /** Insert a task at the given index. */
     insertTask(index: number, task: Task): Task;
+    /** Get the lowest index among the given tasks, or null if empty. */
     getFirstTaskIndex(tasks: Task[]): number | null;
+    /** Get the last non-empty task in the list. */
     getLastNonEmpty(includeHidden?: boolean): Task | null;
+    /** Get the previous non-empty task at the given level, or any level if null. */
     getPreviousNonEmpty(task: Task, level: number | null): Task | null;
+    /** Get the next visible (not hidden) task after the given task. */
     getNextVisible(task: Task): Task | null;
+    /** Get the previous visible (not hidden) task before the given task. */
     getPreviousVisible(task: Task): Task | null;
+    /** Get the next non-empty task after the given task. */
     getNextNonEmpty(task: Task): Task | null;
+    /** Indent tasks one level deeper (make them subtasks of the previous sibling). */
     indent(tasks: Task[]): void;
+    /** Outdent tasks one level (move them out of their parent summary). */
     outdent(tasks: Task[]): void;
+    /** Get the 1-based row number of a task. */
     getTaskNumber(task: Task): number;
+    /** Get the next sibling at the same hierarchy level. */
     getNextSibling(task: Task): Task | null;
+    /** Get all subsequent siblings at the same hierarchy level. */
     getNextSiblings(task: Task): Task[];
+    /** Get the next non-empty task at the specified hierarchy level. */
     getNextAtLevel(task: Task, level: number): Task | null;
+    /** Get the deepest last descendant of a task (used for move operations). */
     getLastDescendant(task: Task): Task;
+    /** Check whether a link exists between two tasks (in either direction). */
     existsLinkBetween(task1: Task, task2: Task): boolean;
+    /** Check whether a task type supports links (only Task and Milestone). */
     isValidTypeForLink(task: Task): boolean;
+    /** Check whether adding a link from → to would create a dependency cycle. */
     wouldCreateCycle(from: Task, to: Task): boolean;
+    /** Create a dependency link between two tasks. Validates against cycles, self-links, and parent-child links. */
     addLink(from: Task, to: Task, type: TaskLinkType, lag?: Lag): TaskLink;
+    /** Remove a task and all its links. */
     removeTask(task: Task): void;
+    /** Remove multiple tasks. */
     removeTasks(tasks: Task[]): void;
+    /** Remove a dependency link. Restores the successor's base start time if available. */
     removeLink(link: TaskLink): void;
+    /** Move tasks up one position in the list. */
     moveUp(tasks: Task[]): void;
+    /** Move tasks down one position in the list. */
     moveDown(tasks: Task[]): void;
+    /** Earliest start time across all non-empty tasks, or null if no tasks exist. */
     get minStartTime(): Date | null;
+    /** Latest end time across all non-empty tasks, or null if no tasks exist. */
     get maxEndTime(): Date | null;
+    /** Remove all tasks and links. */
     clear(): void;
+    /** Replace all tasks and links with a new set (bulk load). */
     assign(tasks: Task[], links: TaskLink[]): void;
+    /** Get all tasks that have the given resource assigned. */
     getTasksUsingResource(resource: Resource): Task[];
+    /** Rename a custom property across all tasks. */
     renameTaskProperty(oldName: string, newName: string): void;
 }
+/** Filter function that determines which tasks are visible. Return true to show, false to hide. */
 export type TaskFilterFn = (task: Task) => boolean;

package/dist/ganttchart/model/task-part.d.ts

@@ -2,38 +2,58 @@ import { Length } from "./length";
 import { Task } from "./task";
 import { BehaviorSubject, Subject } from "rxjs";
 import { WorkingCalendar } from "./working-calendar";
+/** A contiguous time segment of a split task. */
 export declare class TaskPart {
     #private;
+    /** Start date/time of this part. */
     get startTime(): Date;
     set startTime(value: Date);
+    /** End date/time of this part. */
     get endTime(): Date;
     set endTime(value: Date);
+    /** Duration of this part. */
     get length(): Length;
     set length(value: Length);
+    /** The owning task (assigned once, read-only after). */
     get task(): Task | null;
     set task(value: Task | null);
+    /** Active working calendar. */
     get calendar(): WorkingCalendar;
+    /** Emitted before the start time changes. */
     startTimeChanging: Subject<TaskPartDateEventArgs>;
+    /** Emitted before the end time changes. */
     endTimeChanging: Subject<TaskPartDateEventArgs>;
+    /** Emitted before the length changes. */
     lengthChanging: Subject<TaskPartLengthEventArgs>;
+    /** Emitted after the start time changes. */
     startTimeChanged: Subject<void>;
+    /** Emitted after the end time changes. */
     endTimeChanged: Subject<void>;
+    /** Emitted after the length changes. */
     lengthChanged: Subject<void>;
+    /** Emitted when the part's computed progress changes. */
     progressChanged: Subject<void>;
     constructor(startTime: Date, length: Length, calendar$: BehaviorSubject<WorkingCalendar>);
+    /** Duration in working hours. */
     get lengthInHours(): number;
+    /** Computed progress percentage for this part based on the owning task's progress. */
     get progress(): number | null;
+    /** Serialize to a plain object. */
     toAny(): any;
+    /** Create a TaskPart from a plain object. */
     static fromAny(obj: any, calendar$: BehaviorSubject<WorkingCalendar>): TaskPart;
 }
+/** Event args for start/end time changes. */
 export interface TaskPartDateEventArgs {
     part: TaskPart;
     value: Date;
 }
+/** Event args for length changes. */
 export interface TaskPartLengthEventArgs {
     part: TaskPart;
     value: Length;
 }
+/** Thrown when a task part validation fails. */
 export declare class ValidationError extends Error {
     constructor(message: string);
 }

package/dist/ganttchart/model/task-parts-manager.d.ts

@@ -0,0 +1,44 @@
+import { TaskPart } from "./task-part";
+import { WorkingCalendar } from "./working-calendar";
+import { LengthUnit } from "./length";
+export interface PartsChangedCallbacks {
+    onPartStartTimeChanged(): void;
+    onPartEndTimeChanged(): void;
+    onPartLengthChanged(): void;
+}
+/** Manages the array of TaskPart objects, their subscriptions, and merge/cleanup logic. */
+export declare class TaskPartsManager {
+    #private;
+    constructor(callbacks: PartsChangedCallbacks);
+    get length(): number;
+    get(i: number): TaskPart;
+    get last(): TaskPart;
+    get startTime(): Date;
+    get endTime(): Date;
+    indexOf(part: TaskPart): number;
+    includes(part: TaskPart): boolean;
+    /** Length unit of the first part, or null if no parts exist. */
+    get lengthUnit(): LengthUnit | null;
+    totalLengthInHours(calendar: WorkingCalendar): number;
+    /** Iterate over all parts. */
+    forEach(fn: (part: TaskPart, index: number) => void): void;
+    /** Insert a part in sorted order by startTime. */
+    insertSorted(part: TaskPart): void;
+    /** Remove a part by reference. Returns the index it was at, or -1 if not found. */
+    remove(part: TaskPart): number;
+    /** Remove all parts and unsubscribe all. */
+    clear(): void;
+    /** Bulk-set parts (for deserialization). Subscribes to each part's change events. */
+    assign(parts: TaskPart[]): void;
+    /** Subscribe to a part's change events. */
+    subscribe(part: TaskPart): void;
+    /** Unsubscribe a part's change events. */
+    unsubscribe(part: TaskPart): void;
+    /** Merge overlapping or adjacent parts. Requires working calendar for zero-gap detection. */
+    tryCombineAdjacent(calendar: WorkingCalendar): void;
+    /** Remove zero-length parts. Returns whether any were removed and whether all parts are now gone. */
+    removeEmpty(): {
+        changed: boolean;
+        allRemoved: boolean;
+    };
+}

package/dist/ganttchart/model/task-resource.d.ts

@@ -1,18 +1,29 @@
 import { Subject } from "rxjs";
 import { Resource } from "./resource";
 import { ResourceList } from "./resource-list";
+/** Assignment of a resource to a task with a capacity percentage. */
 export declare class TaskResource {
     #private;
+    /** Unique identifier (read-only). */
     get id(): string;
+    /** The underlying resource definition. */
     get resource(): Resource;
+    /** Allocation percentage (100 = full-time, 200 = double allocation). */
     get capacity(): number;
     set capacity(value: number);
+    /** Emitted when this assignment or its underlying resource changes. */
     changed$: Subject<TaskResourceEventArgs>;
     constructor(id: string | null, resource: Resource, capacity: number);
+    /** Clean up the subscription to the underlying resource. */
+    destroy(): void;
+    /** Format capacity as a display string (e.g. '1x' or '50%'). */
     formatCapacity(): string;
+    /** Serialize to a plain object. */
     toAny(): any;
+    /** Create a TaskResource from a plain object. */
     static fromAny(obj: any, resources: ResourceList): TaskResource;
 }
+/** Event args emitted when a task resource changes. */
 export interface TaskResourceEventArgs {
     resource: TaskResource;
 }

package/dist/ganttchart/model/task-serializer.d.ts

@@ -0,0 +1,5 @@
+import { Task } from "./task";
+/** Serializes a Task to a plain object for persistence. */
+export declare class TaskSerializer {
+    static serialize(task: Task): Record<string, any>;
+}

package/dist/ganttchart/model/task-warnings.d.ts

@@ -3,13 +3,17 @@ import { TimelineKitLocale } from "../locale";
 import { Task } from "./task";
 import { TaskList } from "./task-list";
 import { WorkingCalendar } from "./working-calendar";
+/** Computes and assigns warning messages to tasks (delay, constraint violations). */
 export declare class TaskWarnings {
     #private;
     get calendar(): WorkingCalendar;
     constructor(list: TaskList, calendar: BehaviorSubject<WorkingCalendar>, locale: BehaviorSubject<TimelineKitLocale>);
     private getTotalLength;
+    /** Calculate the date corresponding to the task's current progress. */
     getProgressTime(task: Task): Date;
+    /** Recompute warnings for a single task. */
     update(task: Task): void;
+    /** Recompute warnings for all tasks in the list. */
     updateAll(): void;
     private formatDelayedMessage;
 }

package/dist/ganttchart/model/task.d.ts

@@ -1,5 +1,4 @@
 import { TaskPart } from "./task-part";
-import { TaskList } from "./task-list";
 import { BehaviorSubject, Subject } from "rxjs";
 import { Length, LengthUnit } from "./length";
 import { WorkingCalendar } from "./working-calendar";
@@ -8,122 +7,196 @@ import { Resource } from "./resource";
 import { Work } from "./work";
 import { ResourceList } from "./resource-list";
 import { CustomProperty } from "./custom-property";
-import { DateRange } from "../ganttchart-engine";
+import { DateRange } from "../../common/common";
+import { ColorValue } from "../../common/base-theme";
+import type { ConstraintType } from "../../common/locale";
+/** A schedulable item in the Gantt chart. Can be a Task, Milestone, Summary, or Empty row. */
 export declare class Task {
     #private;
+    /** Unique identifier (read-only). Auto-generated if not provided in constructor. */
     get id(): string;
-    get color(): number;
-    set color(value: number);
+    /** Color index into the theme's taskColors array, or a custom color definition. */
+    get color(): ColorValue;
+    set color(value: ColorValue);
+    /** Display name of the task. Setting a name on an Empty row converts it to a Task. */
     get name(): string | null;
     set name(value: string | null);
+    /** Start date/time of the task. For Summary tasks this is computed from subtasks. */
     get startTime(): Date | null;
     set startTime(value: Date);
+    /** End date/time of the task. For Summary tasks this is computed from subtasks. */
     get endTime(): Date | null;
     set endTime(value: Date);
-    get number(): number;
+    /** Active working calendar used for date calculations. */
     get calendar(): WorkingCalendar;
+    /** Computed duration of the task. Null for Empty tasks. */
     get length(): Length | null;
     set length(value: Length);
+    /** Override for the length display unit. When null, the calendar's default unit is used. */
     get customLengthUnit(): LengthUnit | null;
     set customLengthUnit(value: LengthUnit | null);
+    /** Original start time before dependency evaluation shifted it. Used for link relaxation. */
     get baseStartTime(): Date | null;
+    /** The last (or only) part of a split task. */
     get lastPart(): TaskPart;
+    /** Current type of the task. Changing type resets type-specific properties. */
     get type(): TaskType;
     set type(value: TaskType);
+    /** Parent summary task, or null if this is a top-level task. */
     get parent(): Task | null;
-    get list(): TaskList | null;
-    set list(value: TaskList | null);
+    /** Completion percentage (0–100). Null for Empty and Milestone tasks. Computed for Summary tasks. */
     get progress(): number | null;
     set progress(value: number);
+    /** Whether a Summary task's subtasks are collapsed in the view. */
     get collapsed(): boolean;
     set collapsed(value: boolean);
+    /** Number of resources assigned to this task. */
     get resourcesLength(): number;
+    /** Get a resource assignment by index. */
     getResource(i: number): TaskResource;
+    /** Find a resource assignment by the underlying resource's ID. */
     getResourceByResourceId(id: string): TaskResource | null;
+    /** Find a resource assignment by its own ID. */
     getResourceById(id: string): TaskResource | null;
+    /** The manually set work value, or null if work is computed from resources. */
+    get customWork(): Work | null;
+    /** Total work effort. Computed from resources and duration, or set manually when no resources are assigned. */
     get work(): Work | null;
     set work(value: Work | null);
+    /** The manually set cost value, or null if cost is computed from resources. */
+    get customCost(): number | null;
+    /** Total cost. Computed from resources and rates, or set manually when no resources are assigned. */
     get cost(): number | null;
     set cost(value: number | null);
+    /** Free-form text note attached to the task. */
     get note(): string | null;
     set note(value: string | null);
+    /** Active warning messages for this task (e.g. behind schedule, constraint violations). */
     warnings: string[];
+    /** Scheduling constraint type. Default is ASAP (As Soon As Possible). */
     get constraintType(): ConstraintType;
     set constraintType(value: ConstraintType);
+    /** Date associated with the scheduling constraint. Null for ASAP/ALAP. */
     get constraintDate(): Date | null;
     set constraintDate(value: Date | null);
+    /** Baseline start time for variance tracking. */
     get baselineStartTime(): Date | null;
     set baselineStartTime(value: Date | null);
+    /** Baseline end time for variance tracking. */
     get baselineEndTime(): Date | null;
     set baselineEndTime(value: Date | null);
-    /**
-     * Critical Path Method (CPM) computed values.
-     * Calculated by CriticalPathCalculator when showCriticalPath is enabled.
-     * These are not persisted — they are recalculated dynamically.
-     */
+    /** CPM early start date (computed dynamically when critical path is enabled). */
     earlyStart: Date | null;
+    /** CPM early finish date. */
     earlyFinish: Date | null;
+    /** CPM late start date. */
     lateStart: Date | null;
+    /** CPM late finish date. */
     lateFinish: Date | null;
     /** Total float in working hours. Zero means the task is on the critical path. */
     totalFloat: number | null;
+    /** Free float in working hours. */
     freeFloat: number | null;
+    /** Whether this task is on the critical path. */
     isCritical: boolean;
+    /** Emitted when any property of this task changes. */
     changed$: Subject<TaskEventArgs>;
+    /** Emitted when the task type changes (e.g. Empty → Task). */
     typeChanged$: Subject<TaskTypeChangeEventArgs>;
+    /** Emitted when the start time changes. */
     startTimeChanged$: Subject<TaskEventArgs>;
+    /** Emitted when the end time changes. */
     endTimeChanged$: Subject<TaskEventArgs>;
+    /** Emitted when the collapsed state of a Summary task changes. */
     collapsedChanged$: Subject<TaskEventArgs>;
+    /** Emitted when a subtask is added to this Summary task. */
     subtaskAdded$: Subject<TaskEventArgs>;
+    /** Emitted before a resource is added to this task. */
     resourceAdding$: Subject<TaskResourceAddingEventArgs>;
-    constructor(id: string | null, calendar: BehaviorSubject<WorkingCalendar>, projectTimeline: BehaviorSubject<DateRange>);
+    constructor(id: string | null, calendar: BehaviorSubject<WorkingCalendar>, projectTimeline: BehaviorSubject<DateRange>, isEvaluatingDependencies?: () => boolean);
+    /** Add a new time segment (part) to this task. Adjacent or overlapping parts are merged automatically. */
     addPart(startTime: Date, length: Length): TaskPart;
+    /** Remove a time segment from this task. If no parts remain, the task becomes a Milestone. */
     removePart(part: TaskPart): void;
+    /** Number of time segments (parts) in this task. */
     get partsLength(): number;
+    /** Get a task part by index. */
     getPart(i: number): TaskPart;
+    /** Number of direct subtasks (only meaningful for Summary tasks). */
     get subtasksLength(): number;
+    /** Get a subtask by index. */
     getSubtask(i: number): Task;
+    /** Add a subtask, converting this task to Summary type if needed. */
     addSubtask(task: Task): void;
+    /** Remove a subtask. If no subtasks remain, the Summary reverts to a regular Task. */
     removeSubtask(task: Task): void;
+    /** Nesting depth (0 for top-level tasks, 1 for first-level subtasks, etc.). */
     get level(): number;
-    getNextSibling(): Task | null;
-    getNextAtLevel(level: number): Task | null;
+    /** Total duration of all parts in working hours. */
     get partsLengthInHours(): number;
+    /** Get the index of a part within this task. */
     indexOf(part: TaskPart): number;
+    /** Check whether this task is a descendant (at any depth) of the given task. */
     isDescendantOf(task: Task): boolean;
+    /** Toggle the collapsed state of a Summary task. */
     toggleCollapsed(): void;
+    /** Whether this task is excluded by the active filter. */
     get filtered(): boolean;
     set filtered(value: boolean);
+    /** Whether this task is hidden (filtered out or inside a collapsed Summary). */
     get hidden(): boolean;
+    /** Whether the length can be edited (not for multi-part or Summary tasks). */
     get isLengthEditable(): boolean;
+    /** Whether the start time can be edited. */
     get isStartTimeEditable(): boolean;
+    /** Whether the end time can be edited. */
     get isEndTimeEditable(): boolean;
+    /** Whether progress can be edited. */
     get isProgressEditable(): boolean;
+    /** Whether resources can be assigned. */
     get isResourcesEditable(): boolean;
+    /** Whether work can be set manually (only when no resources are assigned). */
     get isWorkEditable(): boolean;
+    /** Whether cost can be set manually (only when no resources are assigned). */
     get isCostEditable(): boolean;
-    serializeProperties(target: any): void;
+    /** Restore task properties from a plain object. */
     deserializeProperties(source: any, resources: ResourceList): void;
+    /** Restore parent/subtask hierarchy from a plain object (must be called after deserializeProperties). */
     deserializePropertiesHierarchy(source: any, allTasks: Task[]): void;
+    /** Assign a resource to this task with the given capacity percentage. */
     addResource(id: string | null, resource: Resource, capacity: number): TaskResource;
+    /** Remove a resource assignment from this task. */
     removeResource(resource: TaskResource): void;
+    /** Serialize custom properties to a plain array for persistence. */
+    serializeCustomProperties(): any[];
+    /** Add a custom property to this task. */
     addProperty(property: CustomProperty): void;
+    /** Remove a custom property from this task. */
     removeProperty(property: CustomProperty): void;
+    /** Rename a custom property across this task. */
     renameProperty(oldName: string, newName: string): void;
+    /** Get a custom property by name, or null if not found. */
     getPropertyByName(name: string): CustomProperty | null;
+    /** Get the value of a custom property by name. */
     getPropertyValue(name: string): any;
+    /** Set the value of a custom property by name. */
     setPropertyValue(name: string, value: any): void;
-    private arePartsOverlappingOrAdjacent;
+    /** Serialize to a plain object. */
+    toAny(): Record<string, any>;
 }
-export type TaskType = 'Task' | 'Milestone' | 'Summary' | 'Empty';
-export type ConstraintType = 'ASAP' | 'ALAP' | 'MSO' | 'MFO' | 'SNET' | 'SNLT' | 'FNET' | 'FNLT';
+/** The kind of a task row: regular Task, Milestone (zero duration), Summary (parent), or Empty (placeholder). */
+export type TaskType = 'task' | 'milestone' | 'summary' | 'empty';
+export type { ConstraintType } from "../../common/locale";
+/** Event args emitted when a task changes. */
 export interface TaskEventArgs {
     task: Task;
 }
+/** Event args emitted before a resource is added to a task. */
 export interface TaskResourceAddingEventArgs {
     task: Task;
     resource: Resource;
 }
+/** Event args emitted when a task's type changes. */
 export interface TaskTypeChangeEventArgs {
     task: Task;
     oldType: TaskType;

package/dist/ganttchart/model/work.d.ts

@@ -1,17 +1,30 @@
 import { WorkingCalendar } from "./working-calendar";
+/** Represents a work effort amount with a time unit (minutes, hours, or days). */
 export declare class Work {
     #private;
+    /** Time unit of the work amount. */
     get unit(): WorkUnit;
+    /** Numeric amount of work. */
     get value(): number;
     constructor(unit: WorkUnit, value: number);
+    /** Parse a work string (e.g. '8h', '2d', '30m'). Returns null if invalid. */
     static tryParse(value: string): Work | null;
+    /** Format as a display string (e.g. '8h', '2d'). */
     toString(): string;
+    /** Convert to hours using the given calendar for day-to-hour conversion. */
     toHours(calendar: WorkingCalendar): number;
+    /** Return the larger of two work units (Day > Hour > Minute). */
     static maxUnit(unit1: WorkUnit, unit2: WorkUnit): WorkUnit;
+    /** Create a Work value from hours, converting to the specified unit. */
     static fromHours(hours: number, unit: WorkUnit, calendar: WorkingCalendar): Work;
+    /** Add two Work values (must have the same unit). */
     static sum(work1: Work, work2: Work): Work;
+    /** Serialize to a plain object. */
     toAny(): any;
+    /** Create a Work from a plain object. */
     static fromAny(obj: any): Work;
+    /** Create a deep copy. */
     clone(): Work;
 }
-export type WorkUnit = 'Minute' | 'Hour' | 'Day';
+/** Time unit for work effort measurement. */
+export type WorkUnit = 'minute' | 'hour' | 'day';

package/dist/ganttchart/model/working-calendar.d.ts

@@ -1,32 +1,2 @@
-import { LengthUnit } from "./length";
-export declare class WorkingCalendar {
-    #private;
-    workingDays: DayOfWeek[];
-    nationalHolidays: Date[];
-    shifts: WorkingShift[];
-    startOfWeek: DayOfWeek;
-    defaultLengthUnit: LengthUnit;
-    constructor();
-    isWorkingDay(current: Date): boolean;
-    moveToStartShift(current: Date, keepTimeIfInsideShift: boolean): Date;
-    moveToEndShift(current: Date, keepTimeIfInsideShift: boolean): Date;
-    getHoursPerDay(): number;
-    isEndOfDay(current: Date): boolean;
-    getEndOfWorkingDay(current: Date): Date;
-    getHoursBetween(time1: Date, time2: Date): number;
-    getStartOfWeek(current: Date): Date;
-    addHours(current: Date, hours: number, moveToNextIfHoursZero?: boolean): Date;
-}
-export type DayOfWeek = 'Monday' | 'Tuesday' | 'Wednesday' | 'Thursday' | 'Friday' | 'Saturday' | 'Sunday';
-export declare class WorkingShift {
-    start: TimeOfDay;
-    end: TimeOfDay;
-    constructor(start: TimeOfDay, end: TimeOfDay);
-    contains(current: Date, excludeStart?: boolean): boolean;
-    getLengthInMinutes(): number;
-}
-export declare class TimeOfDay {
-    hour: number;
-    minute: number;
-    constructor(hour: number, minute: number);
-}
+export { WorkingCalendar, WorkingShift, TimeOfDay } from "../../common/working-calendar";
+export type { DayOfWeek, LengthUnit } from "../../common/working-calendar";

package/dist/ganttchart/sheet/renderers/sheet-icons-cell-renderer.d.ts

@@ -8,3 +8,5 @@ export declare class SheetIconsCellRenderer extends DefaultTableCellRenderer<Tas
     private addIconToCell;
     redraw(cell: any, valueFormatter: TableCellValueFormatter<Task>, item: Task): void;
 }
+export declare function drawIconsExportHeader(ctx: CanvasRenderingContext2D, x: number, y: number, width: number, height: number, color: string): void;
+export declare function drawIconsExportCell(ctx: CanvasRenderingContext2D, task: Task, x: number, y: number, _width: number, height: number): void;