schedulant 1.0.0-alpha.1

package/dist/types/base.d.ts

@@ -0,0 +1,41 @@
+import { default as React } from 'react';
+import { MenuProps } from 'antd';
+export type MenuItems = MenuProps["items"];
+export type Dictionary = Record<string, unknown>;
+export type Position = {
+    left: number;
+    right: number;
+};
+export type TimeStage = {
+    isPast: boolean;
+    isFuture: boolean;
+    isProcess: boolean;
+};
+export type MenuArg<ContentArg> = ContentArg & {
+    key: string;
+    keyPath: string[];
+    domEvent: React.MouseEvent<HTMLElement> | React.KeyboardEvent<HTMLElement>;
+};
+export type MountArg<ContentArg> = ContentArg & {
+    el: HTMLElement;
+};
+export type MoveHandler<TheMountArg extends {
+    el: HTMLElement;
+}> = (mountArg: TheMountArg) => void;
+export type SelectHandler<TheMountArg extends {
+    el: HTMLElement;
+}> = (mountArg: TheMountArg) => void;
+export type ResizeHandler<TheMountArg extends {
+    el: HTMLElement;
+}> = (mountArg: TheMountArg) => void;
+export type DidMountHandler<TheMountArg extends {
+    el: HTMLElement;
+}> = (mountArg: TheMountArg) => void;
+export type WillUnmountHandler<TheMountArg extends {
+    el: HTMLElement;
+}> = (mountArg: TheMountArg) => void;
+export type ContextMenuClickHandler<TheMenuArg extends {
+    key: string;
+    keyPath: string[];
+    domEvent: React.MouseEvent<HTMLElement> | React.KeyboardEvent<HTMLElement>;
+}> = (menuArg: TheMenuArg) => void;

package/dist/types/checkpoint.d.ts

@@ -0,0 +1,47 @@
+import { Dayjs } from 'dayjs';
+import { ReactNode } from 'react';
+import { Option } from './option.ts';
+import { ResourceApi } from './resource.ts';
+import { PublicSchedulantApi } from './schedulant.ts';
+import { Dictionary, MenuArg, MenuItems, MountArg, TimeStage } from './base.ts';
+export type CheckpointArg = {
+    checkpointApi: PublicCheckpointApi;
+    schedulantApi: PublicSchedulantApi;
+};
+export type CheckpointContextMenuItems = MenuItems;
+export type CheckpointMountArg = MountArg<CheckpointArg & TimeStage>;
+export type CheckpointContextMenuArg = MenuArg<CheckpointArg & TimeStage>;
+export type CheckpointMoveMountArg = MountArg<CheckpointArg & {
+    date: Dayjs;
+}>;
+export type Checkpoint = {
+    id: string;
+    time: Dayjs;
+    title: string;
+    resourceId: string;
+    color?: string;
+    tooltip?: ReactNode;
+    extendedProps?: Dictionary;
+};
+export declare class CheckpointApi {
+    private checkpoint;
+    private resourceApi?;
+    constructor(checkpoint: Checkpoint);
+    setId(id: string): void;
+    getId(): string;
+    setTitle(title: string): void;
+    getTitle(): string;
+    setTime(time: Dayjs): void;
+    getTime(): Dayjs;
+    setResourceId(resourceId: string): void;
+    getResourceId(): string;
+    setResourceApi(resourceApi: ResourceApi): void;
+    getResourceApi(): ResourceApi;
+    setColor(color: string): void;
+    getColor(): Option<string>;
+    setTooltip(tooltip: ReactNode): void;
+    getTooltip(): ReactNode;
+    setExtendedProps(extendedProps: Dictionary): void;
+    getExtendProps(): Option<Dictionary>;
+}
+export type PublicCheckpointApi = Pick<CheckpointApi, "getId" | "getTitle" | "getTime" | "getResourceId" | "getResourceApi" | "getColor" | "getTooltip" | "getExtendProps">;

package/dist/types/day-timeline-view.d.ts

@@ -0,0 +1,12 @@
+import { ReactNode } from 'react';
+import { TimelineView } from './timeline-view.tsx';
+import { Position } from './base';
+import { Dayjs } from 'dayjs';
+export declare class DayTimelineView extends TimelineView {
+    renderColgroup(): ReactNode;
+    renderBodySlots(): ReactNode;
+    renderHeaderSlots(): ReactNode;
+    calculateDate(timelineWidth: number, point: number): Dayjs;
+    calculateSlotWidth(timelineWidth: number): number;
+    calculatePosition(timelineWidth: number, start: Dayjs, end: Dayjs): Position;
+}

package/dist/types/event.d.ts

@@ -0,0 +1,66 @@
+import { Dayjs } from 'dayjs';
+import { ReactNode } from 'react';
+import { Option } from './option.ts';
+import { ResourceApi } from './resource.ts';
+import { PublicSchedulantApi } from './schedulant.ts';
+import { Dictionary, MenuArg, MenuItems, MountArg, TimeStage } from './base.ts';
+export type EventArg = {
+    eventApi: PublicEventApi;
+    schedulantApi: PublicSchedulantApi;
+};
+export type EventContextMenuItems = MenuItems;
+export type EventMountArg = MountArg<EventArg & TimeStage>;
+export type EventContextMenuArg = MenuArg<EventArg & TimeStage>;
+export type EventResizeMountArg = MountArg<EventArg & {
+    date: Dayjs;
+}>;
+export type EventMoveMountArg = MountArg<EventArg & {
+    startDate: Dayjs;
+    endDate: Dayjs;
+}>;
+export type Event = {
+    id: string;
+    start: Dayjs;
+    title: string;
+    color: string;
+    resourceId: string;
+    end?: Dayjs;
+    url?: string;
+    tooltip?: ReactNode;
+    textColor?: string;
+    borderColor?: string;
+    backgroundColor?: string;
+    extendedProps?: Dictionary;
+};
+export declare class EventApi {
+    private event;
+    private resourceApi?;
+    constructor(event: Event);
+    setId(id: string): void;
+    getId(): string;
+    setTitle(title: string): void;
+    getTitle(): string;
+    setColor(color: string): void;
+    getColor(): string;
+    setStart(start: Dayjs): void;
+    getStart(): Dayjs;
+    setEnd(end: Dayjs): void;
+    getEnd(): Option<Dayjs>;
+    setResourceId(resourceId: string): void;
+    getResourceId(): string;
+    setResourceApi(resourceApi: ResourceApi): void;
+    getResourceApi(): ResourceApi;
+    setUrl(url: string): void;
+    getUrl(): Option<string>;
+    setTooltip(tooltip: React.ReactNode): void;
+    getTooltip(): React.ReactNode;
+    setTextColor(textColor: string): void;
+    getTextColor(): Option<string>;
+    setBorderColor(borderColor: string): void;
+    getBorderColor(): Option<string>;
+    setBackgroundColor(backgroundColor: string): void;
+    getBackgroundColor(): Option<string>;
+    setExtendedProps(extendedProps: Dictionary): void;
+    getExtendProps(): Option<Dictionary>;
+}
+export type PublicEventApi = Pick<EventApi, "getId" | "getTitle" | "getColor" | "getStart" | "getEnd" | "getResourceId" | "getResourceApi" | "getUrl" | "getTooltip" | "getTextColor" | "getBorderColor" | "getBackgroundColor" | "getExtendProps">;

package/dist/types/index.d.ts

@@ -0,0 +1,7 @@
+export type { SchedulantProps, SchedulantMountArg, PublicSchedulantApi } from './schedulant.ts';
+export type { Event, EventArg, EventMountArg, PublicEventApi, EventMoveMountArg, EventContextMenuArg, EventResizeMountArg, EventContextMenuItems } from './event.ts';
+export type { Milestone, MilestoneArg, MilestoneStatus, MilestoneMountArg, PublicMilestoneApi, MilestoneMoveMountArg, MilestoneContextMenuArg, MilestoneContextMenuItems } from './milestone.ts';
+export type { Checkpoint, CheckpointArg, CheckpointMountArg, PublicCheckpointApi, CheckpointMoveMountArg, CheckpointContextMenuArg, CheckpointContextMenuItems } from './checkpoint.ts';
+export type { Resource, ResourceLaneArg, ResourceLabelArg, PublicResourceApi, ResourceAreaColumn, ResourceLaneMountArg, ResourceLabelMountArg, ResourceContextMenuItems, ResourceLaneContextMenuArg, ResourceLabelContextMenuArg } from './resource.ts';
+export type { TimelineSlotArg, TimelineSlotLaneMountArg, TimelineSlotLabelMountArg } from './timeline.ts';
+export type { SelectInfoArg } from './misc.ts';

package/dist/types/milestone.d.ts

@@ -0,0 +1,51 @@
+import { Dayjs } from 'dayjs';
+import { ReactNode } from 'react';
+import { Option } from './option.ts';
+import { ResourceApi } from './resource.ts';
+import { PublicSchedulantApi } from './schedulant.ts';
+import { Dictionary, MenuArg, MenuItems, MountArg, TimeStage } from './base.ts';
+export type MilestoneArg = {
+    milestoneApi: PublicMilestoneApi;
+    schedulantApi: PublicSchedulantApi;
+};
+export type MilestoneContextMenuItems = MenuItems;
+export type MilestoneStatus = "Success" | "Failure" | "Warning";
+export type MilestoneMountArg = MountArg<MilestoneArg & TimeStage>;
+export type MilestoneContextMenuArg = MenuArg<MilestoneArg & TimeStage>;
+export type MilestoneMoveMountArg = MountArg<MilestoneArg & {
+    date: Dayjs;
+}>;
+export type Milestone = {
+    id: string;
+    time: Dayjs;
+    title: string;
+    status: MilestoneStatus;
+    resourceId: string;
+    color?: string;
+    tooltip?: ReactNode;
+    extendedProps?: Dictionary;
+};
+export declare class MilestoneApi {
+    private milestone;
+    private resourceApi?;
+    constructor(milestone: Milestone);
+    setId(id: string): void;
+    getId(): string;
+    setTitle(title: string): void;
+    getTitle(): string;
+    setTime(timestamp: Dayjs): void;
+    getTime(): Dayjs;
+    setStatus(status: MilestoneStatus): void;
+    getStatus(): MilestoneStatus;
+    setResourceApi(resourceApi: ResourceApi): void;
+    getResourceApi(): ResourceApi;
+    setResourceId(resourceId: string): void;
+    getResourceId(): string;
+    setColor(color: string): void;
+    getColor(): Option<string>;
+    setTooltip(tooltip: ReactNode): void;
+    getTooltip(): ReactNode;
+    setExtendedProps(extendedProps: Dictionary): void;
+    getExtendProps(): Option<Dictionary>;
+}
+export type PublicMilestoneApi = Pick<MilestoneApi, "getId" | "getTitle" | "getTime" | "getStatus" | "getResourceApi" | "getResourceId" | "getColor" | "getTooltip" | "getExtendProps">;

package/dist/types/misc.d.ts

@@ -0,0 +1,8 @@
+import { Dayjs } from 'dayjs';
+import { MountArg } from './base.ts';
+import { PublicResourceApi } from './resource.ts';
+export type SelectInfoArg = MountArg<{
+    resourceApi: PublicResourceApi;
+    startDate: Dayjs;
+    endDate: Dayjs;
+}>;

package/dist/types/month-timeline-view.d.ts

@@ -0,0 +1,12 @@
+import { TimelineView } from './timeline-view.tsx';
+import { Position } from './base.ts';
+import { Dayjs } from 'dayjs';
+import { ReactNode } from 'react';
+export declare class MonthTimelineView extends TimelineView {
+    renderColgroup(): ReactNode;
+    renderBodySlots(): ReactNode;
+    renderHeaderSlots(): ReactNode;
+    calculateDate(timelineWidth: number, point: number): Dayjs;
+    calculateSlotWidth(timelineWidth: number): number;
+    calculatePosition(timelineWidth: number, start: Dayjs, end: Dayjs): Position;
+}

package/dist/types/option.d.ts

@@ -0,0 +1,10 @@
+export declare class Option<T> {
+    private readonly value;
+    private constructor();
+    static Some<T>(value: T): Option<T>;
+    static None<T>(): Option<T>;
+    static fromNullable<T>(value: T | null | undefined): Option<T>;
+    isDefined(): boolean;
+    get(): T;
+    getOrElse(defaultValue: T): T;
+}

package/dist/types/quarter-timeline-view.d.ts

@@ -0,0 +1,12 @@
+import { TimelineView } from './timeline-view.tsx';
+import { ReactNode } from 'react';
+import { Dayjs } from 'dayjs';
+import { Position } from './base.ts';
+export declare class QuarterTimelineView extends TimelineView {
+    renderColgroup(): ReactNode;
+    renderBodySlots(): ReactNode;
+    renderHeaderSlots(): ReactNode;
+    calculateDate(timelineWidth: number, point: number): Dayjs;
+    calculateSlotWidth(timelineWidth: number): number;
+    calculatePosition(timelineWidth: number, start: Dayjs, end: Dayjs): Position;
+}

package/dist/types/resource.d.ts

@@ -0,0 +1,85 @@
+import { ReactNode } from 'react';
+import { Option } from './option.ts';
+import { EventApi } from './event.ts';
+import { MilestoneApi } from './milestone';
+import { CheckpointApi } from './checkpoint';
+import { PublicSchedulantApi } from './schedulant.ts';
+import { Dictionary, MenuArg, MenuItems, MountArg } from './base.ts';
+export type ResourceLaneArg = {
+    label: ResourceAreaColumn;
+    resourceApi: PublicResourceApi;
+    schedulantApi: PublicSchedulantApi;
+};
+export interface ResourceLabelArg {
+    label: ResourceAreaColumn;
+}
+export type ResourceContextMenuItems = MenuItems;
+export type ResourceAreaColumn = {
+    field: string;
+    headerContent: string;
+};
+export type ResourceLaneMountArg = MountArg<ResourceLaneArg>;
+export type ResourceLabelMountArg = MountArg<ResourceLabelArg>;
+export type ResourceLaneContextMenuArg = MenuArg<ResourceLaneArg>;
+export type ResourceLabelContextMenuArg = MenuArg<ResourceLabelArg>;
+export type Resource = {
+    id: string;
+    title: string;
+    tooltip?: ReactNode;
+    parentId?: string;
+    eventColor?: string;
+    eventTextColor?: string;
+    eventBorderColor?: string;
+    eventBackgroundColor?: string;
+    extendedProps?: Dictionary;
+};
+export declare class ResourceApi {
+    private depth;
+    private readonly resource;
+    private parent?;
+    private children;
+    private eventApis?;
+    private milestoneApis?;
+    private checkpointApis?;
+    constructor(resource: Resource);
+    setId(id: string): void;
+    getId(): string;
+    setTitle(title: string): void;
+    getTitle(): string;
+    setDepth(depth: number): void;
+    getDepth(): number;
+    setTooltip(tooltip: ReactNode): void;
+    getTooltip(): ReactNode;
+    setParent(parent?: ResourceApi): void;
+    getParent(): Option<ResourceApi>;
+    setParentId(parentId: string): void;
+    getParentId(): Option<string>;
+    setChildren(children: ResourceApi[]): void;
+    getChildren(): ResourceApi[];
+    setEventColor(color: string): void;
+    getEventColor(): Option<string>;
+    setEventTextColor(color: string): void;
+    getEventTextColor(): Option<string>;
+    setEventBorderColor(color: string): void;
+    getEventBorderColor(): Option<string>;
+    setEventBackgroundColor(color: string): void;
+    getEventBackgroundColor(): Option<string>;
+    getResource(): Resource;
+    setEventApis(eventApis: EventApi[]): void;
+    getEventApis(): EventApi[];
+    setMilestoneApis(milestoneApis: MilestoneApi[]): void;
+    getMilestoneApis(): MilestoneApi[];
+    setCheckpointApis(checkpointApis: CheckpointApi[]): void;
+    getCheckpointApis(): CheckpointApi[];
+    setExtendedProps(extendedProps: Dictionary): void;
+    getExtendProps(): Option<Dictionary>;
+}
+export declare class ResourceApiHelper {
+    static compare(prev: ResourceApi, next: ResourceApi): number;
+    static createTree(resources: Resource[], eventApis: EventApi[], milestoneApis: MilestoneApi[], checkpointApis: CheckpointApi[]): ResourceApi[];
+    static flatMapTree(resourceApis: ResourceApi[]): ResourceApi[];
+}
+export declare class ResourceUtils {
+    static createEmptyResources(count: number): Resource[];
+}
+export type PublicResourceApi = Pick<ResourceApi, "getId" | "getTitle" | "getDepth" | "getTooltip" | "getParent" | "getParentId" | "getChildren" | "getEventColor" | "getEventTextColor" | "getEventBorderColor" | "getEventBackgroundColor" | "getResource" | "getEventApis" | "getMilestoneApis" | "getCheckpointApis" | "getExtendProps">;

package/dist/types/schedulant-view.d.ts

@@ -0,0 +1,20 @@
+import { SchedulantApi, SchedulantProps } from './schedulant';
+import { TimelineView } from './timeline-view.tsx';
+import { MutableRefObject, ReactNode } from 'react';
+export type SchedulantViewType = "Day" | "Week" | "Month" | "Quarter" | "Year";
+export declare class SchedulantView {
+    private readonly schedulantApi;
+    private readonly timelineView;
+    private readonly schedulantElRef;
+    constructor(props: SchedulantProps, schedulantElRef: MutableRefObject<HTMLDivElement | null>);
+    renderTimelineTableColgroup(): ReactNode;
+    renderTimelineBodyTableSlots(): ReactNode;
+    renderTimelineHeaderTableSlots(): ReactNode;
+    renderTimelineDrawingBoardTable(collapseIds: Array<string>, timelineWidth: number): ReactNode;
+    renderResourceTableColgroup(): ReactNode;
+    renderResourceLabel(): ReactNode;
+    renderResourceLane(collapseIds: Array<string>): ReactNode;
+    getTimelineView(): TimelineView;
+    getScheduleApi(): SchedulantApi;
+    getScheduleElRef(): MutableRefObject<HTMLDivElement | null>;
+}

package/dist/types/schedulant.d.ts

@@ -0,0 +1,143 @@
+import { Dayjs } from 'dayjs';
+import { EventApi, Event, EventContextMenuArg, EventContextMenuItems, EventMountArg, EventMoveMountArg, EventResizeMountArg } from './event.ts';
+import { Resource, ResourceApi, ResourceAreaColumn, ResourceContextMenuItems, ResourceLabelContextMenuArg, ResourceLabelMountArg, ResourceLaneContextMenuArg, ResourceLaneMountArg } from './resource.ts';
+import { MilestoneApi, Milestone, MilestoneContextMenuArg, MilestoneContextMenuItems, MilestoneMountArg, MilestoneMoveMountArg } from './milestone.ts';
+import { CheckpointApi, Checkpoint, CheckpointContextMenuArg, CheckpointContextMenuItems, CheckpointMountArg, CheckpointMoveMountArg } from './checkpoint.ts';
+import { ContextMenuClickHandler, DidMountHandler, MountArg, MoveHandler, ResizeHandler, SelectHandler, WillUnmountHandler } from './base.ts';
+import { Option } from './option.ts';
+import { SelectInfoArg } from './misc';
+import { SchedulantView, SchedulantViewType } from './schedulant-view.tsx';
+import { TimelineApi, TimelineSlotLabelMountArg, TimelineSlotLaneMountArg } from './timeline';
+import { MutableRefObject } from 'react';
+export type SchedulantProps = {
+    end: Dayjs;
+    start: Dayjs;
+    editable: boolean;
+    selectable: boolean;
+    lineHeight: number;
+    slotMinWidth: number;
+    schedulantMaxHeight: number;
+    schedulantViewType: SchedulantViewType;
+    events: Event[];
+    resources: Resource[];
+    milestones?: Milestone[];
+    checkpoints?: Checkpoint[];
+    companyHolidays?: Dayjs[];
+    specialWorkdays?: Dayjs[];
+    nationalHolidays?: Dayjs[];
+    defaultEmptyLanes?: number;
+    resourceAreaWidth?: string;
+    resourceAreaColumns?: Array<ResourceAreaColumn>;
+    selectAllow?: SelectHandler<SelectInfoArg>;
+    enableEventContextMenu?: boolean;
+    eventContextMenuClick?: ContextMenuClickHandler<EventContextMenuArg>;
+    eventContextMenuItems?: EventContextMenuItems;
+    eventDidMount?: DidMountHandler<EventMountArg>;
+    eventWillUnmount?: WillUnmountHandler<EventMountArg>;
+    eventMove?: MoveHandler<EventMoveMountArg>;
+    eventResizeStart?: ResizeHandler<EventResizeMountArg>;
+    eventResizeEnd?: ResizeHandler<EventResizeMountArg>;
+    enableMilestoneContextMenu?: boolean;
+    milestoneContextMenuClick?: ContextMenuClickHandler<MilestoneContextMenuArg>;
+    milestoneContextMenuItems?: MilestoneContextMenuItems;
+    milestoneDidMount?: DidMountHandler<MilestoneMountArg>;
+    milestoneWillUnmount?: WillUnmountHandler<MilestoneMountArg>;
+    milestoneMove?: MoveHandler<MilestoneMoveMountArg>;
+    enableCheckpointContextMenu?: boolean;
+    checkpointContextMenuClick?: ContextMenuClickHandler<CheckpointContextMenuArg>;
+    checkpointContextMenuItems?: CheckpointContextMenuItems;
+    checkpointDidMount?: DidMountHandler<CheckpointMountArg>;
+    checkpointWillUnmount?: WillUnmountHandler<CheckpointMountArg>;
+    checkpointMove?: MoveHandler<CheckpointMoveMountArg>;
+    enableResourceLaneContextMenu?: boolean;
+    resourceLaneContextMenuClick?: ContextMenuClickHandler<ResourceLaneContextMenuArg>;
+    resourceLaneContextMenuItems?: ResourceContextMenuItems;
+    resourceLaneDidMount?: DidMountHandler<ResourceLaneMountArg>;
+    resourceLaneWillUnmount?: WillUnmountHandler<ResourceLaneMountArg>;
+    enableResourceLabelContextMenu?: boolean;
+    resourceLabelContextMenuClick?: ContextMenuClickHandler<ResourceLabelContextMenuArg>;
+    resourceLabelContextMenuItems?: ResourceContextMenuItems;
+    resourceLabelDidMount?: DidMountHandler<ResourceLabelMountArg>;
+    resourceLabelWillUnmount?: WillUnmountHandler<ResourceLabelMountArg>;
+    timelineSlotLabelDidMount?: DidMountHandler<TimelineSlotLabelMountArg>;
+    timelineSlotLabelWillUnmount?: WillUnmountHandler<TimelineSlotLabelMountArg>;
+    timelineSlotLaneDidMount?: DidMountHandler<TimelineSlotLaneMountArg>;
+    timelineSlotLaneWillUnmount?: WillUnmountHandler<TimelineSlotLaneMountArg>;
+    schedulantDidMount?: DidMountHandler<SchedulantMountArg>;
+    schedulantWillUnmount?: DidMountHandler<SchedulantMountArg>;
+};
+export declare class SchedulantApi implements PublicSchedulantApi {
+    private readonly schedulantProps;
+    private readonly schedulantView;
+    private readonly timelineApi;
+    private readonly eventApis;
+    private readonly resourceApis;
+    private readonly flatMapResourceApis;
+    private readonly milestoneApis;
+    private readonly checkpointApis;
+    private generateTimelineApi;
+    constructor(schedulantView: SchedulantView, props: SchedulantProps);
+    getProps(): SchedulantProps;
+    getStart(): Dayjs;
+    getEnd(): Dayjs;
+    getLineHeight(): number;
+    getSlotMinWidth(): number;
+    getSchedulantMaxHeight(): number;
+    getScheduleView(): SchedulantView;
+    getSchedulantViewType(): SchedulantViewType;
+    getResourceAreaColumns(): ResourceAreaColumn[];
+    getTimelineApi(): TimelineApi;
+    getEventApis(): EventApi[];
+    getEventApiById(eventId: string): Option<EventApi>;
+    getResourceApis(): ResourceApi[];
+    getResourceApiById(resourceId: string): Option<ResourceApi>;
+    getFlatMapResourceApis(): ResourceApi[];
+    isEditable(): boolean;
+    isSelectable(): boolean;
+    getMilestoneApis(): MilestoneApi[];
+    getMilestoneApiById(milestoneId: string): Option<MilestoneApi>;
+    getCheckpointApis(): CheckpointApi[];
+    getCheckpointApiById(checkpointId: string): Option<CheckpointApi>;
+    getSchedulantElRef(): MutableRefObject<HTMLDivElement | null>;
+    eventDidMount(arg: EventMountArg): void;
+    eventWillUnmount(arg: EventMountArg): void;
+    eventMove(arg: EventMoveMountArg): void;
+    eventResizeStart(arg: EventResizeMountArg): void;
+    eventResizeEnd(arg: EventResizeMountArg): void;
+    selectAllow(arg: SelectInfoArg): void;
+    isEnableEventContextMenu(): boolean;
+    getEventContextMenuItems(): import('antd/es/menu/interface').ItemType[] | undefined;
+    onEventContextMenuClick(arg: EventContextMenuArg): void;
+    resourceLaneDidMount(arg: ResourceLaneMountArg): void;
+    resourceLaneWillUnmount(arg: ResourceLaneMountArg): void;
+    isEnableResourceLaneContextMenu(): boolean;
+    getResourceLaneContextMenuItems(): import('antd/es/menu/interface').ItemType[] | undefined;
+    onResourceLaneContextMenuClick(arg: ResourceLaneContextMenuArg): void;
+    resourceLabelDidMount(arg: ResourceLabelMountArg): void;
+    resourceLabelWillUnmount(arg: ResourceLabelMountArg): void;
+    isEnableResourceLabelContextMenu(): boolean;
+    getResourceLabelContextMenuItems(): import('antd/es/menu/interface').ItemType[] | undefined;
+    onResourceLabelContextMenuClick(arg: ResourceLabelContextMenuArg): void;
+    milestoneDidMount(arg: MilestoneMountArg): void;
+    milestoneWillUnmount(arg: MilestoneMountArg): void;
+    isEnableMilestoneContextMenu(): boolean;
+    getMilestoneContextMenuItems(): import('antd/es/menu/interface').ItemType[] | undefined;
+    onMilestoneContextMenuClick(arg: MilestoneContextMenuArg): void;
+    milestoneMove(arg: MilestoneMoveMountArg): void;
+    checkpointDidMount(arg: CheckpointMountArg): void;
+    checkpointWillUnmount(arg: CheckpointMountArg): void;
+    isEnableCheckpointContextMenu(): boolean;
+    getCheckpointContextMenuItems(): import('antd/es/menu/interface').ItemType[] | undefined;
+    onCheckpointContextMenuClick(arg: CheckpointContextMenuArg): void;
+    checkpointMove(arg: CheckpointMoveMountArg): void;
+    timelineSlotLaneDidMount(arg: TimelineSlotLaneMountArg): void;
+    timelineSlotLaneWillUnmount(arg: TimelineSlotLaneMountArg): void;
+    timelineSlotLabelDidMount(arg: TimelineSlotLabelMountArg): void;
+    timelineSlotLabelWillUnmount(arg: TimelineSlotLabelMountArg): void;
+    schedulantDidMount(arg: SchedulantMountArg): void;
+    schedulantWillUnmount(arg: SchedulantMountArg): void;
+}
+export type PublicSchedulantApi = Pick<SchedulantApi, "getEnd" | "getStart" | "isEditable" | "isSelectable" | "getLineHeight" | "getSlotMinWidth" | "getSchedulantMaxHeight">;
+export type SchedulantMountArg = MountArg<{
+    schedulantApi: PublicSchedulantApi;
+}>;

package/dist/types/timeline-view.d.ts

@@ -0,0 +1,24 @@
+import { SchedulantApi } from './schedulant.ts';
+import { ResourceApi } from './resource.ts';
+import { TimelineApi } from './timeline.ts';
+import { ReactNode } from 'react';
+import { Dayjs } from 'dayjs';
+import { Position } from './base.ts';
+export declare abstract class TimelineView {
+    private readonly schedulantApi;
+    constructor(schedulantApi: SchedulantApi);
+    getSchedulantApi(): SchedulantApi;
+    getTimelineApi(): TimelineApi;
+    renderLane(resourceApi: ResourceApi, timelineWidth: number): ReactNode;
+    renderEvents(resourceApi: ResourceApi, timelineWidth: number): ReactNode;
+    renderMilestones(resource: ResourceApi, timelineWidth: number): ReactNode;
+    renderCheckpoints(resource: ResourceApi, timelineWidth: number): ReactNode;
+    calculateLaneHeight(resourceApi: ResourceApi): number;
+    calculateEventHeight(): number;
+    abstract renderColgroup(): ReactNode;
+    abstract renderBodySlots(): ReactNode;
+    abstract renderHeaderSlots(): ReactNode;
+    abstract calculateDate(timelineWidth: number, point: number): Dayjs;
+    abstract calculateSlotWidth(timelineWidth: number): number;
+    abstract calculatePosition(timelineWidth: number, start: Dayjs, end: Dayjs): Position;
+}

package/dist/types/timeline.d.ts

@@ -0,0 +1,75 @@
+import { Dayjs } from 'dayjs';
+import { MountArg, TimeStage } from './base.ts';
+import { PublicSchedulantApi } from './schedulant.ts';
+import { SchedulantViewType } from './schedulant-view.tsx';
+export type TimelineSlotArg = {
+    schedulantApi: PublicSchedulantApi;
+    date: Dayjs;
+    level?: number;
+    timeText?: string;
+    slotType: SchedulantViewType;
+};
+export type TimelineSlotLaneMountArg = MountArg<TimelineSlotArg & TimeStage>;
+export type TimelineSlotLabelMountArg = MountArg<TimelineSlotArg & TimeStage>;
+export type TimelineData = {
+    days: Dayjs[];
+    weeks: Record<string, Dayjs[]>;
+    months: Record<string, Dayjs[]>;
+    quarters: Record<string, Dayjs[]>;
+    years: Record<string, Dayjs[]>;
+};
+export declare class TimelineApi {
+    private start;
+    private end;
+    private timelineData;
+    private specialWorkdays?;
+    private companyHolidays?;
+    private nationalHolidays?;
+    private generateTimelineData;
+    constructor(start: Dayjs, end: Dayjs);
+    setStart(start: Dayjs): void;
+    getStart(): Dayjs;
+    setEnd(end: Dayjs): void;
+    getEnd(): Dayjs;
+    getDays(): Dayjs[];
+    getWeeks(): Dayjs[];
+    getMonths(): Dayjs[];
+    getQuarters(): Dayjs[];
+    getYears(): Dayjs[];
+    setSpecialWorkdays(specialWorkdays: Dayjs[]): void;
+    getSpecialWorkdays(): Dayjs[];
+    setCompanyHolidays(companyHolidays: Dayjs[]): void;
+    getCompanyHolidays(): Dayjs[];
+    setNationalHolidays(nationalHolidays: Dayjs[]): void;
+    getNationalHolidays(): Dayjs[];
+    isWeekend(target: Dayjs): boolean;
+    isHoliday(target: Dayjs): boolean;
+    isSpecialWorkday(target: Dayjs): boolean;
+    isCompanyHoliday(target: Dayjs): boolean;
+    isNationalHoliday(target: Dayjs): boolean;
+    getDayPosition(target: Dayjs): number;
+    getWeekPosition(target: Dayjs): number;
+    getMonthPosition(target: Dayjs): number;
+    getQuarterPosition(target: Dayjs): number;
+    getYearPosition(target: Dayjs): number;
+    populateMonthsWithDays(): Array<{
+        month: Dayjs;
+        days: Dayjs[];
+    }>;
+    populateYearsWithDays(): Array<{
+        year: Dayjs;
+        days: Dayjs[];
+    }>;
+    populateYearsWithWeeks(): Array<{
+        year: Dayjs;
+        weeks: Dayjs[];
+    }>;
+    populateYearsWithMonths(): Array<{
+        year: Dayjs;
+        months: Dayjs[];
+    }>;
+    populateYearsWithQuarters(): Array<{
+        year: Dayjs;
+        quarters: Dayjs[];
+    }>;
+}

package/dist/types/week-timeline-view.d.ts

@@ -0,0 +1,12 @@
+import { TimelineView } from './timeline-view.tsx';
+import { ReactNode } from 'react';
+import { Dayjs } from 'dayjs';
+import { Position } from './base.ts';
+export declare class WeekTimelineView extends TimelineView {
+    renderColgroup(): ReactNode;
+    renderBodySlots(): ReactNode;
+    renderHeaderSlots(): ReactNode;
+    calculateDate(timelineWidth: number, point: number): Dayjs;
+    calculateSlotWidth(timelineWidth: number): number;
+    calculatePosition(timelineWidth: number, start: Dayjs, end: Dayjs): Position;
+}

package/dist/types/year-timeline-view.d.ts

@@ -0,0 +1,12 @@
+import { ReactNode } from 'react';
+import { TimelineView } from './timeline-view';
+import { Dayjs } from 'dayjs';
+import { Position } from './base.ts';
+export declare class YearTimelineView extends TimelineView {
+    renderColgroup(): ReactNode;
+    renderBodySlots(): ReactNode;
+    renderHeaderSlots(): ReactNode;
+    calculateDate(timelineWidth: number, point: number): Dayjs;
+    calculateSlotWidth(timelineWidth: number): number;
+    calculatePosition(timelineWidth: number, start: Dayjs, end: Dayjs): Position;
+}

package/dist/utils/array.d.ts

@@ -0,0 +1 @@
+export declare const groupBy: <T>(arr: T[], func: (item: T) => string) => Record<string, T[]>;

package/dist/utils/dom.d.ts

@@ -0,0 +1,3 @@
+export declare const extractNumber: (value: string) => number;
+export declare const numberToPixels: (value: number) => string;
+export declare const pixelsToNumber: (value: string) => number;