gantt headless API

declare function axisFromPointer(clientX: number, track: GanttRectLike, columnCount: number): number;

declare function blockedGanttIds(input: GanttInput): ReadonlySet<string>;

declare function clampGanttRange(start: number, end: number, columnCount: number): {
  readonly start: number;
  readonly end: number;
} | null;

declare function columnCountOf(input: GanttInput): number;

declare function connectGantt(service: GanttService, scope: PartScope, options?: GanttConnectOptions): GanttApi;

declare function createGanttController(host: GanttControllerHost): GanttController;

export declare const GANTT_DEFAULT_COLUMN_COUNT: 4;

export declare const GANTT_DEFAULT_STEP: 1;

export declare const ganttAnatomy: {
  readonly scope: "gantt";
  readonly parts: readonly ["root", "list", "row", "track", "bar"];
};

interface GanttApi {
  rootProps(): PartProps;
  listProps(): PartProps;
  rowProps(id: string): PartProps;
  trackProps(id: string): PartProps;
  barProps(id: string): PartProps;
  rangeFor(id: string): GanttBarRange | undefined;
  readonly value: GanttStateValue;
  readonly interactive: boolean;
}

type GanttBarRange = {
  readonly id: string;
  readonly start: number;
  readonly end: number;
};

type GanttChangeReason = "pointer" | "keyboard";

type GanttCommand = CommandObject & {
  readonly type: "BAR_RANGE_CHANGE_REQUEST";
  readonly id: string;
  readonly start: number;
  readonly end: number;
  readonly reason: GanttChangeReason;
};

interface GanttConnectOptions {
  onRangeChange?: (detail: GanttRangeChangeDetail) => void;
  beginPointer?: (detail: {
    readonly id: string;
    readonly start: number;
    readonly end: number;
    readonly clientX: number;
  }) => void;
}

type GanttContext = {
  readonly focusedId: string | null;
  readonly activeId: string | null;
  readonly originStart: number | null;
  readonly originEnd: number | null;
  readonly draftStart: number | null;
  readonly draftEnd: number | null;
  readonly reason: GanttChangeReason | null;
};

interface GanttController {
  attach(service: GanttService): void;
  beginPointer(detail: GanttPointerBegin): void;
  destroy(): void;
}

interface GanttControllerHost {
  readonly getTrack: (id: string) => GanttRectTarget | null;
  readonly getWindow?: () => GanttWindowLike | null;
}

type GanttEvent = {
  readonly type: "FOCUS";
  readonly id: string;
} | {
  readonly type: "BLUR";
  readonly id: string;
} | {
  readonly type: "GRAB";
  readonly id: string;
  readonly start: number;
  readonly end: number;
  readonly reason: GanttChangeReason;
} | {
  readonly type: "NUDGE";
  readonly direction: -1 | 1;
} | {
  readonly type: "DRAG";
  readonly start: number;
  readonly end: number;
} | {
  readonly type: "DROP";
} | {
  readonly type: "CANCEL";
};

type GanttInput = {
  /** Host-owned ranges. The machine never writes these back. */
  readonly bars?: readonly GanttBarRange[];
  /** Axis unit count. @default 4 */
  readonly columnCount?: number;
  /** Positive finite axis unit. @default 1 */
  readonly step?: number;
  /**
   * When false, the shell is inert (live default). Styled callers without
   * `getRowId` and a range callback pass false.
   */
  readonly interactive?: boolean;
};

export declare const ganttMachine: GanttMachine;

interface GanttMount {
  readonly service: GanttService;
  readonly connector: GanttApi;
  readonly root: HTMLElement;
  destroy(): void;
}

type GanttPart = (typeof ganttAnatomy.parts)[number];

interface GanttPointerBegin {
  readonly id: string;
  readonly start: number;
  readonly end: number;
  readonly clientX: number;
}

interface GanttPointerLike {
  readonly clientX: number;
}

interface GanttRangeChangeDetail {
  readonly id: string;
  readonly start: number;
  readonly end: number;
  readonly reason: "pointer" | "keyboard";
}

interface GanttRectLike {
  readonly left: number;
  readonly width: number;
}

interface GanttRectTarget {
  getBoundingClientRect(): GanttRectLike;
}

export declare const ganttSelectors: {
  value: (snapshot: GanttSnapshot) => GanttStateValue;
  focusedId: (snapshot: GanttSnapshot) => string | null;
  activeId: (snapshot: GanttSnapshot) => string | null;
  draftStart: (snapshot: GanttSnapshot) => number | null;
  draftEnd: (snapshot: GanttSnapshot) => number | null;
};

type GanttService = Service<GanttInput, GanttStateValue, GanttContext, GanttEvent, GanttCommand>;

type GanttSnapshot = Snapshot<GanttStateValue, GanttContext>;

type GanttStateValue = "idle" | "grabbed" | "dragging";

interface GanttWindowLike {
  addEventListener(type: string, listener: (event: GanttPointerLike) => void): void;
  removeEventListener(type: string, listener: (event: GanttPointerLike) => void): void;
}

declare function isGanttIdInteractive(input: GanttInput, id: string): boolean;

declare function isGanttInteractive(input: GanttInput): boolean;

declare function isGanttStepValid(step: number | undefined): boolean;

declare function mountGantt(container: HTMLElement, options: MountGanttOptions): GanttMount;

interface MountGanttOptions extends GanttInput {
  readonly onRangeChange?: (detail: GanttRangeChangeDetail) => void;
  readonly renderBar?: (element: HTMLElement, bar: GanttBarRange) => void;
}

declare function projectGanttBars<T extends {
  readonly start: number;
  readonly end: number;
}>(rows: readonly T[], getRowId?: (row: T, index: number) => string): GanttBarRange[];

declare function roundGanttUnit(value: number): number;

declare function runGanttCommand(command: GanttCommand, _scope: PartScope, options?: GanttConnectOptions): void;

declare function stepOf(input: GanttInput): number;