@dou-ui/gantt 0.0.0-stage → 0.1.0-alpha.0

package/dist/types/core/menu.d.ts

@@ -0,0 +1,27 @@
+import type { GanttLink, GanttTask } from './model';
+/** A point on the timeline, in px from its start and from the top of the rows. */
+export interface GanttPoint {
+    x: number;
+    y: number;
+}
+/**
+ * What a context menu was opened on: a task (bar or row), a link, or an
+ * empty part of the timeline. `point` is where, in timeline coordinates,
+ * and `time` the moment under it, in minutes; from the table or the
+ * keyboard they are at the task's start.
+ */
+export type GanttMenuTarget = {
+    kind: 'task';
+    task: GanttTask;
+    point: GanttPoint;
+    time: number;
+} | {
+    kind: 'link';
+    link: GanttLink;
+    point: GanttPoint;
+    time: number;
+} | {
+    kind: 'canvas';
+    point: GanttPoint;
+    time: number;
+};

package/dist/types/core/model.d.ts

@@ -0,0 +1,72 @@
+import type { Tone } from 'dou-ui';
+export type GanttData = Record<string, unknown>;
+export interface GanttTask<Data extends GanttData = GanttData> {
+    id: string;
+    title: string;
+    /** The parent task's id. A task with children is a summary task. */
+    parent?: string;
+    /**
+     * Sort key among siblings, compared as a string. Siblings without one
+     * keep their order in the array.
+     */
+    order?: string;
+    /** A milestone is a point in time: it only reads `start`. */
+    type?: 'task' | 'milestone';
+    /** `YYYY-MM-DD` or `YYYY-MM-DD HH:mm`. Without it the task is not scheduled yet. */
+    start?: string;
+    /**
+     * `YYYY-MM-DD` for the last day of the task, or `YYYY-MM-DD HH:mm` for the
+     * moment it ends. Defaults to one day, or one hour after a timed `start`.
+     */
+    end?: string;
+    /** From `0` to `1`. */
+    progress?: number;
+    tone?: Tone;
+    /** Hide the children. */
+    collapsed?: boolean;
+    /** Can't be moved or resized. */
+    locked?: boolean;
+    /** The id of the resource it is assigned to, for `DouScheduler`. */
+    resource?: string;
+    /** Your own fields, e.g. for columns. */
+    data?: Data;
+}
+export type GanttLinkType = 'fs' | 'ss' | 'ff' | 'sf';
+/** A dependency: `to` waits for `from`. */
+export interface GanttLink {
+    id: string;
+    from: string;
+    to: string;
+    /**
+     * `fs` finish to start (the default): `to` starts after `from` finishes;
+     * `ss` start to start; `ff` finish to finish; `sf` start to finish.
+     */
+    type?: GanttLinkType;
+    /**
+     * Working time between the two ends; may be negative. A number counts
+     * working days; a string gives a unit: `'2d'` working days, `'4h'`
+     * working hours, `'30m'` working minutes.
+     */
+    lag?: number | string;
+}
+/** Where a task sits in time, in minutes since the epoch. `end` is exclusive. */
+export interface TaskSpan {
+    start: number;
+    end: number;
+    /** Both ends are whole days, written without a time. */
+    dateOnly: boolean;
+}
+/**
+ * Reads a task's dates. A date-only `end` covers its whole day; a missing or
+ * early one makes the task one day (or one hour) long. A milestone's span
+ * is empty: `start` and `end` are the same moment, the middle of its day
+ * when it has no time.
+ */
+export declare function spanOf(task: GanttTask): TaskSpan | null;
+/**
+ * The `start` and `end` strings for a span, in the task's own style: whole
+ * days stay date-only, anything else is written with times.
+ */
+export declare function writeSpan(task: GanttTask, start: number, end: number): Pick<GanttTask, 'start' | 'end'>;
+export declare const clampProgress: (value: number | undefined) => number;
+export declare const createId: () => string;

package/dist/types/core/order.d.ts

@@ -0,0 +1,9 @@
+/** Whether a key is made of the characters `orderBetween` uses. */
+export declare const isOrderKey: (key: string) => boolean;
+/**
+ * A key that sorts after `before` and before `after`; leave either out for
+ * the start or the end. `before` must sort before `after`.
+ */
+export declare function orderBetween(before?: string, after?: string): string;
+/** `count` keys in order, spread out so that later insertions stay short. */
+export declare function orderKeys(count: number): string[];

package/dist/types/core/scale.d.ts

@@ -0,0 +1,33 @@
+export type GanttScale = 'hour' | 'day' | 'week' | 'month' | 'quarter' | 'year';
+/** A step of the time header. */
+export type TimeUnit = 'hour' | 'day' | 'week' | 'month' | 'quarter' | 'half' | 'year';
+export interface ScaleLevel {
+    name: GanttScale;
+    /** The narrowest a day gets at this level, in px; below it the next level takes over. */
+    min: number;
+    /** How wide a day is when the level is picked, in px. */
+    base: number;
+    /** The two rows of the header. */
+    top: TimeUnit;
+    bottom: TimeUnit;
+}
+/** From the widest days to the narrowest. */
+export declare const scaleLevels: readonly ScaleLevel[];
+/** The widest and narrowest a day may be, in px. */
+export declare const DAY_WIDTH_RANGE: [number, number];
+export declare const levelByName: (name: GanttScale) => ScaleLevel;
+/** The level that shows days `dayWidth` px wide. */
+export declare const levelOf: (dayWidth: number) => ScaleLevel;
+/** Hours per header cell, so that labels have room. */
+export declare function hourStep(dayWidth: number): number;
+/** The step that drags and new dates snap to, in minutes. */
+export declare function snapStep(dayWidth: number): 60 | 1440 | 15 | 30;
+/** The start of the `unit` that holds `at`. */
+export declare function unitStart(unit: TimeUnit, at: number, weekStart?: 0 | 1, step?: number): number;
+/** The start of the `unit` after the one that starts at `at`. */
+export declare function nextUnit(unit: TimeUnit, at: number, step?: number): number;
+/** The units that overlap `[from, to)`, as their start and end. */
+export declare function unitsBetween(unit: TimeUnit, from: number, to: number, weekStart?: 0 | 1, step?: number): {
+    start: number;
+    end: number;
+}[];

package/dist/types/core/schedule.d.ts

@@ -0,0 +1,44 @@
+import { type GanttCalendar, type WorkCalendar } from './calendar';
+import { type GanttTask } from './model';
+import type { GanttDocument } from './transaction';
+export interface GanttScheduleOptions {
+    /** Which days and hours are worked; the chart's `calendar`. */
+    calendar?: GanttCalendar | WorkCalendar;
+    /** Also bring tasks earlier, to the earliest their links allow. Only tasks with links in move. */
+    pull?: boolean;
+    /** Tasks to leave where they are, e.g. the ones just moved by hand; `locked` tasks always stay. */
+    fixed?: Iterable<string>;
+}
+export interface GanttSchedule {
+    /** The new dates of the tasks that move, written in each task's own style. */
+    moves: Map<string, Pick<GanttTask, 'start' | 'end'>>;
+    /** Links still not kept afterwards: into a locked or fixed task, or on a loop. */
+    violated: Set<string>;
+    /** Tasks on a loop of links, or after one; they are left where they are. */
+    cycle: string[];
+}
+export interface GanttCriticalPath {
+    /** Tasks with no slack: any delay to them delays the end of the plan. */
+    tasks: Set<string>;
+    /** Links between critical tasks that drive the later one. */
+    links: Set<string>;
+}
+/**
+ * Moves tasks so that every link is kept: each task starts no earlier than
+ * its links allow, keeping its working time. By default tasks are only
+ * pushed later; `pull` also brings linked tasks earlier. Locked and fixed
+ * tasks stay, and links into them may stay broken.
+ *
+ * Takes time in proportion to the tasks and links. Nothing is changed:
+ * apply `moves` in a transaction, or call the chart's `schedule()`.
+ */
+export declare function computeSchedule(doc: GanttDocument, options?: GanttScheduleOptions): GanttSchedule;
+/** Links whose `to` side starts (or ends) before the link allows; for manual scheduling. */
+export declare function findBrokenLinks(doc: GanttDocument, options?: Pick<GanttScheduleOptions, 'calendar'>): Set<string>;
+/**
+ * The tasks that decide when the plan ends: working back from the last
+ * end, each task gets the latest end its successors allow, and the ones
+ * with no working time to spare are critical. Reads the dates as they
+ * are; tasks on a loop of links are left out.
+ */
+export declare function computeCriticalPath(doc: GanttDocument, options?: Pick<GanttScheduleOptions, 'calendar'>): GanttCriticalPath;

package/dist/types/core/time.d.ts

@@ -0,0 +1,39 @@
+export declare const MINUTES_PER_HOUR = 60;
+export declare const MINUTES_PER_DAY = 1440;
+export interface ParsedTime {
+    /** Minutes since the epoch. */
+    at: number;
+    /** The string had no time of day. */
+    dateOnly: boolean;
+}
+/**
+ * Reads `YYYY-MM-DD` or `YYYY-MM-DD HH:mm`; seconds (`HH:mm:ss`) are
+ * accepted and dropped. `null` for anything else.
+ */
+export declare function parseTime(text: string | undefined | null): Readonly<ParsedTime> | null;
+/** Minutes since the epoch for a wall-clock date; `month` counts from 1. */
+export declare function fromParts(year: number, month: number, day: number, hour?: number, minute?: number): number;
+export interface TimeParts {
+    year: number;
+    /** From 1. */
+    month: number;
+    day: number;
+    /** `0` is Sunday. */
+    weekday: number;
+    hour: number;
+    minute: number;
+}
+export declare function partsOf(at: number): TimeParts;
+/** `YYYY-MM-DD`. */
+export declare function formatDate(at: number): string;
+/** `YYYY-MM-DD HH:mm`, or `YYYY-MM-DD` when `dateOnly`. */
+export declare function formatTime(at: number, dateOnly?: boolean): string;
+/** `HH:mm` as minutes since midnight, or `null`. */
+export declare function parseClock(text: string | undefined): number | null;
+/** The midnight that starts the day of `at`. */
+export declare const dayStart: (at: number) => number;
+/** Days since the epoch. */
+export declare const dayIndex: (at: number) => number;
+export declare const isMidnight: (at: number) => boolean;
+/** The current wall-clock time, in minutes since the epoch. */
+export declare function wallClockNow(now?: Date): number;

package/dist/types/core/transaction.d.ts

@@ -0,0 +1,134 @@
+import { type GanttLink, type GanttTask } from './model';
+/** An empty document, the chart's `v-model` when none is bound. */
+export declare const emptyDocument: () => GanttDocument;
+type Patch<T> = {
+    [K in keyof T]?: T[K] | undefined;
+};
+/** The tasks and links together, as a transaction sees them. */
+export interface GanttDocument {
+    /** The version of the format; see `migrateDocument`. */
+    version: 1;
+    tasks: GanttTask[];
+    links: GanttLink[];
+}
+export type GanttStep = {
+    type: 'addTask';
+    task: GanttTask;
+    index?: number;
+} | {
+    type: 'removeTask';
+    id: string;
+} | {
+    type: 'updateTask';
+    id: string;
+    patch: Patch<GanttTask>;
+} | {
+    type: 'addLink';
+    link: GanttLink;
+    index?: number;
+} | {
+    type: 'removeLink';
+    id: string;
+} | {
+    type: 'updateLink';
+    id: string;
+    patch: Patch<GanttLink>;
+};
+export interface GanttTransactionMeta {
+    /** Keep out of the undo history, e.g. folding a summary or a change from another client. */
+    history?: boolean;
+    /**
+     * Consecutive transactions in the same group within a second undo as
+     * one, e.g. repeated arrow key nudges.
+     */
+    group?: string;
+    /**
+     * With `scheduling="auto"`, set to `false` to leave the waiting tasks
+     * where they are, e.g. for a change from another client.
+     */
+    schedule?: boolean;
+    /** Who made the change, passed on to the `transaction` event. */
+    origin?: string;
+}
+/**
+ * A batch of changes. Steps apply as they are added, so later calls see
+ * earlier ones; `doc` is the result.
+ */
+export declare class GanttTransaction {
+    readonly before: GanttDocument;
+    readonly steps: GanttStep[];
+    /** The steps that undo this transaction, in the order to apply them. */
+    readonly inverse: GanttStep[];
+    meta: GanttTransactionMeta;
+    private tasks;
+    private links;
+    private copied;
+    /** Where each task and link is in its list; built on first use, dropped when a list changes length. */
+    private at;
+    constructor(before: GanttDocument);
+    get doc(): GanttDocument;
+    /** Whether the change makes any change: it has steps and wasn't cancelled. */
+    get changed(): boolean;
+    private stopped;
+    /**
+     * Stops the change: none of it is applied or kept for undo, and the
+     * editor fires `transactionCancel` and says why. For an extension's `transaction`
+     * hook, e.g. to keep people from changing what they may not; hooks after
+     * it don't run. A change kept out of the history (`meta.history: false`),
+     * such as undo, redo or another person's, can't be cancelled and goes ahead.
+     */
+    cancel(reason?: string): this;
+    /** Whether `cancel` stopped it. */
+    get cancelled(): boolean;
+    /** What `cancel` was given, to tell people why. */
+    get cancelReason(): string | undefined;
+    /** Whether the tasks, or the links, changed. */
+    touches(kind: 'tasks' | 'links'): boolean;
+    getTask(id: string): GanttTask<import("./model").GanttData> | undefined;
+    getLink(id: string): GanttLink | undefined;
+    /**
+     * A task's or link's position in its list, `-1` when there is none. The
+     * positions are kept as tasks and links come and go, and checked when
+     * read: one that moved since is found again with the rest.
+     */
+    private indexOf;
+    /** Links into or out of a task. */
+    linksOf(id: string): GanttLink[];
+    setMeta(meta: GanttTransactionMeta): this;
+    step(step: GanttStep): this;
+    addTask(task: GanttTask, index?: number): this;
+    /** Removes a task with its subtasks and every link attached to them. */
+    removeTask(id: string): this;
+    updateTask(id: string, patch: Patch<GanttTask>): this;
+    /**
+     * Sets a task's dates, written back in the task's own style. Takes
+     * minutes, or strings read like the task's own: a date-only `end` is the
+     * last day of the task.
+     */
+    setSpan(id: string, start: number | string, end: number | string): this;
+    /**
+     * Moves a task, with its subtasks, under `parent` (or to the top level)
+     * at `index` among its new siblings, the end by default. Only the task's
+     * `parent` and `order` change, unless its new siblings have no room
+     * between them: then they all get new `order` keys. Links between the
+     * task's subtasks and its new parents go, since a task can't depend on
+     * its own parent. A move into the task itself is ignored.
+     */
+    moveTask(id: string, parent: string | undefined, index?: number): this;
+    /** Merges `patch` into the task's `data`. */
+    updateData(id: string, patch: Record<string, unknown>): this;
+    addLink(link: GanttLink, index?: number): this;
+    removeLink(id: string): this;
+    updateLink(id: string, patch: Patch<GanttLink>): this;
+    private writable;
+    /** Applies a step and returns its inverse, or `null` when it changes nothing. */
+    private apply;
+}
+/** Applies steps to a document; steps that no longer apply are skipped. */
+export declare function applyGanttSteps(doc: GanttDocument, steps: readonly GanttStep[]): GanttTransaction;
+/**
+ * Folds updates of the same task or link into one, as long as nothing
+ * adds or removes it in between.
+ */
+export declare function compactSteps(steps: readonly GanttStep[]): GanttStep[];
+export {};

package/dist/types/core/tree.d.ts

@@ -0,0 +1,30 @@
+import { type GanttTask, type TaskSpan } from './model';
+export interface GanttRow {
+    task: GanttTask;
+    /** Nesting level, from 0. */
+    depth: number;
+    /** Position among the shown rows; `-1` when a collapsed parent hides it. */
+    index: number;
+    /** Number of direct children. */
+    children: number;
+    /** Has children, so its dates and progress come from them. */
+    summary: boolean;
+    milestone: boolean;
+    /** Its own dates, or for a summary the dates its children cover. */
+    span: TaskSpan | null;
+    progress: number;
+}
+export interface GanttTree {
+    /** The rows to show, top to bottom. */
+    rows: GanttRow[];
+    /** Every task's row, shown or not. */
+    byId: Map<string, GanttRow>;
+    /** Children in display order; roots under `undefined`. */
+    childrenOf: Map<string | undefined, GanttTask[]>;
+}
+/**
+ * Lays the flat task list out as a tree: rows in display order, summaries
+ * worked out from their children. A `parent` that doesn't exist, or that
+ * would make a loop, is ignored and the task becomes a root.
+ */
+export declare function buildTree(tasks: readonly GanttTask[]): GanttTree;

package/dist/types/export/draw.d.ts

@@ -0,0 +1,76 @@
+import type { Tone } from 'dou-ui';
+import { type WorkCalendar } from '../core/calendar';
+import type { GanttLink, TaskSpan } from '../core/model';
+import type { GanttRow } from '../core/tree';
+import type { GanttMessages } from '../locale';
+import type { GanttBarLabel } from '../types';
+import type { ExportTheme } from './theme';
+/** Height of the time header, in px, as on screen. */
+export declare const HEADER = 56;
+/** More room before a side title where a link leaves the bar's end, in px. */
+export declare const LINKED_END_ROOM = 14;
+export interface ExportColumn {
+    title: string;
+    width: number;
+    align: 'start' | 'center' | 'end';
+    /** The title column: indented by depth, summaries in medium weight. */
+    isTitle: boolean;
+    text: (row: GanttRow) => string;
+}
+export interface DrawInput {
+    /** The rows to draw, top to bottom. */
+    rows: readonly GanttRow[];
+    links: readonly GanttLink[];
+    /** Columns of the table; none to leave the table out. */
+    columns: readonly ExportColumn[];
+    rowHeight: number;
+    dayWidth: number;
+    /** The time drawn, in minutes. */
+    start: number;
+    end: number;
+    calendar: WorkCalendar;
+    messages: GanttMessages;
+    weekStart: 0 | 1;
+    /** The current time, or `null` to leave the today line out. */
+    now: number | null;
+    markers: readonly {
+        at: number;
+        label?: string;
+        tone?: Tone;
+    }[];
+    critical: {
+        tasks: ReadonlySet<string>;
+        links: ReadonlySet<string>;
+    } | null;
+    broken: ReadonlySet<string>;
+    baseline: ReadonlyMap<string, TaskSpan> | null;
+    barLabel: GanttBarLabel;
+    /** Fill the header and the rows with the page colors; `false` leaves them transparent. */
+    background: boolean;
+    /** Tasks with a link at their end, whose side titles start further out. */
+    linkedEnds: ReadonlySet<string>;
+    /** Width of a text in px, at the given weight. */
+    textWidth: (text: string, bold?: boolean) => number;
+}
+/** The chart drawn as SVG markup, in two parts so the header can repeat on every printed page. */
+export interface GanttDrawing {
+    width: number;
+    /** Height of the rows, below the header. */
+    bodyHeight: number;
+    header: string;
+    body: string;
+}
+/** The time the content covers, widened to whole header cells with one more on either side. */
+export declare function paddedRange(start: number, end: number, dayWidth: number, weekStart: 0 | 1): {
+    start: number;
+    end: number;
+};
+export declare function drawGantt(input: DrawInput, theme: ExportTheme): GanttDrawing;
+/**
+ * A whole SVG document: the header, then the rows; `window` keeps only
+ * some of the rows, for a printed page.
+ */
+export declare function svgDocument(drawing: GanttDrawing, window?: {
+    top: number;
+    height: number;
+}): string;

package/dist/types/export/theme.d.ts

@@ -0,0 +1,49 @@
+import type { Tone } from 'dou-ui';
+export type BarTone = Tone | 'default' | 'critical';
+export interface BarColors {
+    fill: string;
+    stroke: string;
+    progress: string;
+}
+/** The chart's colors and font, read from the page, for drawing it elsewhere. */
+export interface ExportTheme {
+    fontFamily: string;
+    /** Size of the header, bar and cell text, in px. */
+    fontSize: number;
+    fontWeight: string;
+    surface: string;
+    headerBg: string;
+    line: string;
+    lineStrong: string;
+    off: string;
+    text: string;
+    textSecondary: string;
+    textTertiary: string;
+    today: string;
+    link: string;
+    linkCritical: string;
+    linkBroken: string;
+    baseline: string;
+    bar: Record<BarTone, BarColors>;
+    summary: Record<BarTone, string>;
+    milestone: Record<BarTone, {
+        fill: string;
+        stroke: string;
+    }>;
+    marker: Record<Tone, {
+        line: string;
+        text: string;
+    }>;
+}
+/**
+ * A computed color as `#rrggbb` or `rgba(…)`, which every SVG reader
+ * understands. A canvas converts most colors as it parses them; colors
+ * it keeps in another space (`oklab(…)`, `color(…)`) are painted on a
+ * pixel and read back.
+ */
+export declare function plain(color: string): string;
+/**
+ * Reads the colors from elements made like the chart's own, inside `root`
+ * so its theme and tokens apply, and removes them after.
+ */
+export declare function readTheme(root: HTMLElement): ExportTheme;

package/dist/types/gantt.vue.d.ts

@@ -0,0 +1,54 @@
+import { type GanttLink, type GanttTask } from './core/model';
+import { GanttTransaction, type GanttDocument } from './core/transaction';
+import { type GanttScale } from './core/scale';
+import type { GanttExpose, GanttProps, GanttSlots } from './types';
+type __VLS_Props = GanttProps;
+type __VLS_Slots = GanttSlots;
+type __VLS_ModelProps = {
+    modelValue?: GanttDocument;
+    'selection'?: string[];
+    'scale'?: GanttScale;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, GanttExpose, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    link: (link: GanttLink) => any;
+    transaction: (tr: GanttTransaction) => any;
+    "update:modelValue": (value: GanttDocument) => any;
+    transactionCancel: (tr: GanttTransaction) => any;
+    taskClick: (task: GanttTask<import(".").GanttData>, event: MouseEvent) => any;
+    taskDblclick: (task: GanttTask<import(".").GanttData>, event: MouseEvent) => any;
+    taskContextmenu: (task: GanttTask<import(".").GanttData>, event: MouseEvent) => any;
+    linkClick: (link: GanttLink, event: MouseEvent) => any;
+    linkContextmenu: (link: GanttLink, event: MouseEvent) => any;
+    "update:selection": (value: string[]) => any;
+    "update:scale": (value: GanttScale | undefined) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onLink?: ((link: GanttLink) => any) | undefined;
+    onTransaction?: ((tr: GanttTransaction) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: GanttDocument) => any) | undefined;
+    onTransactionCancel?: ((tr: GanttTransaction) => any) | undefined;
+    onTaskClick?: ((task: GanttTask<import(".").GanttData>, event: MouseEvent) => any) | undefined;
+    onTaskDblclick?: ((task: GanttTask<import(".").GanttData>, event: MouseEvent) => any) | undefined;
+    onTaskContextmenu?: ((task: GanttTask<import(".").GanttData>, event: MouseEvent) => any) | undefined;
+    onLinkClick?: ((link: GanttLink, event: MouseEvent) => any) | undefined;
+    onLinkContextmenu?: ((link: GanttLink, event: MouseEvent) => any) | undefined;
+    "onUpdate:selection"?: ((value: string[]) => any) | undefined;
+    "onUpdate:scale"?: ((value: GanttScale | undefined) => any) | undefined;
+}>, {
+    today: boolean;
+    addRow: boolean;
+    menu: boolean;
+    table: boolean;
+    rowHeight: number;
+    tableWidth: number;
+    barLabel: import("./types").GanttBarLabel;
+    scheduling: "auto" | "manual";
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};