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

package/dist/time-axis.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"time-axis.js","names":[],"sources":["../src/time-axis.ts"],"sourcesContent":["import { createScrollLink, scrollPositionOf, useNow, useTouchScroll } from 'dou-ui'\nimport { computed, onMounted, ref, watch, type ComputedRef, type Ref, type ShallowRef } from 'vue'\nimport { offTime, type WorkCalendar } from './core/calendar'\nimport {\n  DAY_WIDTH_RANGE,\n  hourStep,\n  levelByName,\n  levelOf,\n  unitStart,\n  unitsBetween,\n  type GanttScale,\n  type TimeUnit,\n} from './core/scale'\nimport { MINUTES_PER_DAY, dayStart, parseTime, wallClockNow } from './core/time'\nimport { unitLabel } from './labels'\nimport type { GanttMessages } from './locale'\n\n/** Room around the visible part that is rendered too, in px. */\nconst OVERSCAN_X = 320\n/** The widest a day gets when fitting, so short plans don't zoom to hours. */\nconst FIT_MAX = 64\nconst ZOOM_STEP = 1.5\n/**\n * Room kept before the view on a touch screen, in screens and at least in\n * px, but no more time than `ROOM_BEFORE_TIME`. Time can only be added there\n * once a touch scroll is over, so it is enough for a long run of fast swipes\n * that never lets the momentum stop. Only what is in view is drawn, so room\n * costs nothing but scroll width.\n */\nconst ROOM_BEFORE = 300\nconst ROOM_BEFORE_MIN = 400_000\n/** Ten thousand years, in minutes: room for a run of swipes at the widest scale too. */\nconst ROOM_BEFORE_TIME = 10_000 * 365 * MINUTES_PER_DAY\n/** The earliest the timeline goes, some 190,000 years back, well within what a date can be. */\nconst EARLIEST = -1e11\n/**\n * Room kept before the view with a mouse or trackpad, in screens. It is\n * filled as soon as the view comes near the start, and stays small so the\n * scrollbar thumb still shows where the view is.\n */\nconst ROOM_BEFORE_POINTER = 4\n/** Room kept after the view, in screens; time is added there as you scroll. */\nconst ROOM_AFTER = 4\n\nfunction fingers(event: TouchEvent) {\n  const [a, b] = [event.touches[0]!, event.touches[1]!]\n  return { a, b, distance: Math.hypot(a.clientX - b.clientX, a.clientY - b.clientY) }\n}\n\nexport interface HeaderCell {\n  key: number\n  end: number\n  left: number\n  width: number\n  label: string\n}\n\nexport interface TimeAxisOptions {\n  /** The scrolling timeline. */\n  chart: Readonly<ShallowRef<HTMLElement | null>>\n  /** The table body, kept at the same vertical scroll. */\n  tableBody: Readonly<ShallowRef<HTMLElement | null>>\n  viewWidth: Ref<number>\n  scale: Ref<GanttScale | undefined>\n  range: () => [string, string] | undefined\n  today: () => boolean\n  weekStart: ComputedRef<0 | 1>\n  calendar: ComputedRef<WorkCalendar>\n  messages: ComputedRef<GanttMessages>\n  /** The time the content covers, or `null` when nothing is scheduled. */\n  content: ComputedRef<{ start: number; end: number } | null>\n  /** The width the timeline will have once laid out, for fitting. */\n  fitWidth: () => number\n}\n\n/**\n * The time axis the gantt chart and the scheduler share: zoom, the extent\n * that grows as you scroll, the header cells, days off and the today line.\n */\nexport function useTimeAxis(o: TimeAxisOptions) {\n  /** How wide a day is, in px; zooming changes it smoothly. */\n  const dayWidth = ref(levelByName(o.scale.value ?? 'day').base)\n  /** Without a `scale`, the first view picks the day width that fits the content. */\n  let fitPending = o.scale.value == null\n  const level = computed(() => levelOf(dayWidth.value))\n  /** px per minute. */\n  const ppm = computed(() => dayWidth.value / MINUTES_PER_DAY)\n\n  watch(level, (next) => {\n    if (o.scale.value !== next.name) o.scale.value = next.name\n  })\n  // a picked level zooms around now when it is in view, else around the middle\n  watch(o.scale, (name) => {\n    if (!name || level.value.name === name) return\n    const x = todayX.value == null ? null : todayX.value - scrollLeft.value\n    zoomTo(levelByName(name).base, x != null && x >= 0 && x <= o.viewWidth.value ? x : undefined)\n  })\n\n  const nowMs = useNow({ interval: 60_000 })\n  const now = computed(() => wallClockNow(new Date(nowMs.value)))\n\n  /** The content's time, or the coming month when nothing is scheduled. */\n  const content = computed(() => {\n    const known = o.content.value\n    if (known) return known\n    const start = dayStart(now.value)\n    return { start, end: start + 30 * MINUTES_PER_DAY }\n  })\n\n  /** The furthest the view has gone either way, so the timeline keeps it. */\n  const reach = ref<{ start: number; end: number } | null>(null)\n\n  /** px of room kept before the view. */\n  /** Whether there is a touch screen; read once mounted, so the server render matches. */\n  const coarse = ref(false)\n  const roomBefore = computed(() => {\n    const width = o.viewWidth.value || 800\n    if (!coarse.value) return ROOM_BEFORE_POINTER * width\n    return Math.min(Math.max(ROOM_BEFORE * width, ROOM_BEFORE_MIN), ROOM_BEFORE_TIME * ppm.value)\n  })\n\n  const touch = useTouchScroll()\n\n  /** Where the timeline would start, without a fixed range. */\n  const freeStart = computed(() => {\n    const start = Math.min(content.value.start, reach.value?.start ?? Infinity)\n    return Math.max(EARLIEST, dayStart(start - roomBefore.value / ppm.value))\n  })\n\n  /**\n   * The start held while a touch scroll goes on. A later start moves the\n   * content, and the scroll position has to follow it, which iOS drops then:\n   * content coming in earlier, the room changing as the screen turns. So the\n   * start stays where it was and moves once the scroll is over.\n   */\n  const heldStart = ref<number | null>(null)\n  watch(\n    touch.active,\n    (on) => {\n      heldStart.value = on ? freeStart.value : null\n    },\n    { flush: 'sync' },\n  )\n\n  /** The span the timeline covers. */\n  const extent = computed(() => {\n    const fixed = o.range()?.map((text) => parseTime(text))\n    if (fixed?.[0] && fixed[1])\n      return { start: dayStart(fixed[0].at), end: dayStart(fixed[1].at) + MINUTES_PER_DAY }\n    const width = o.viewWidth.value || 800\n    const after = Math.max((ROOM_AFTER * width) / ppm.value, 7 * MINUTES_PER_DAY)\n    const end = Math.max(content.value.end, reach.value?.end ?? -Infinity)\n    return {\n      start: heldStart.value ?? freeStart.value,\n      end: dayStart(end + after) + MINUTES_PER_DAY,\n    }\n  })\n  const origin = computed(() => extent.value.start)\n  const totalWidth = computed(() => Math.ceil((extent.value.end - extent.value.start) * ppm.value))\n  const xOf = (at: number) => (at - origin.value) * ppm.value\n\n  // Scrolling ---------------------------------------------------------------------\n\n  const scrollTop = ref(0)\n  const scrollLeft = ref(0)\n  /**\n   * The time at the left edge of the view. It is what stays put: when the\n   * extent grows or the zoom changes, the scroll position follows it.\n   */\n  const viewStart = ref(0)\n  const scrollbar = ref(0)\n\n  const link = createScrollLink('y')\n\n  function onChartScroll() {\n    const el = o.chart.value!\n    const body = o.tableBody.value\n    // iOS reports positions past either end while the content bounces back\n    const { top, left } = scrollPositionOf(el)\n    scrollTop.value = top\n    scrollLeft.value = left\n    viewStart.value = origin.value + left / ppm.value\n    if (body) link.follow(el, body)\n    grow()\n  }\n\n  /** Keeps time `at` on the timeline, adding room around it. */\n  function keep(at: number, until = at) {\n    const known = reach.value\n    const start = Math.min(known?.start ?? at, at)\n    const end = Math.max(known?.end ?? until, until)\n    if (known?.start !== start || known.end !== end) reach.value = { start, end }\n  }\n\n  /**\n   * Adds time at the end the view comes near. After the end that is safe at\n   * any time. Before the start it moves the content right, and the scroll\n   * position has to follow it; iOS drops that move while a touch scroll or\n   * its momentum goes on, and the next scroll event would read the old\n   * position against the new start. So the room before is wide enough for a\n   * run of swipes, and is filled again once the scroll is over.\n   */\n  function grow() {\n    const el = o.chart.value\n    if (!el || o.range()) return\n    const width = o.viewWidth.value\n    const left = scrollPositionOf(el).left\n    if (left + width > totalWidth.value - ROOM_AFTER * width)\n      keep(viewStart.value, viewStart.value + ((ROOM_AFTER + 1) * width) / ppm.value)\n    if (touch.active.value) touch.whenSettled(growBefore)\n    // without a finger it is filled right away, but only near the start: a\n    // scrollbar thumb dragged there would jump back under the pointer\n    else if (left < 2 * width) growBefore()\n  }\n\n  function growBefore() {\n    const el = o.chart.value\n    // an end bouncing back reports positions past it\n    if (!el || o.range() || el.scrollLeft < 0) return\n    if (scrollPositionOf(el).left < roomBefore.value - o.viewWidth.value) keep(viewStart.value)\n  }\n\n  function onTableScroll() {\n    const body = o.tableBody.value!\n    const el = o.chart.value\n    if (el) link.follow(body, el)\n  }\n\n  // keep the time at the left edge in place as the axis changes under it\n  watch(\n    [origin, ppm, totalWidth],\n    () => {\n      const el = o.chart.value\n      if (!el) return\n      const target = Math.round((viewStart.value - origin.value) * ppm.value)\n      if (Math.abs(el.scrollLeft - target) >= 1) el.scrollLeft = target\n      scrollLeft.value = scrollPositionOf(el).left\n    },\n    { flush: 'post' },\n  )\n\n  function measureScrollbar() {\n    const el = o.chart.value\n    if (el) scrollbar.value = el.offsetHeight - el.clientHeight\n  }\n\n  function scrollToTime(at: number, offset = 48) {\n    // start the view on a whole header cell, so its label isn't cut at the edge\n    const target = at - offset / ppm.value\n    viewStart.value = unitStart(level.value.bottom, target, o.weekStart.value, headerStep.value)\n    if (!o.range()) keep(viewStart.value, viewStart.value + o.viewWidth.value / ppm.value)\n    const el = o.chart.value\n    if (!el) return\n    el.scrollLeft = Math.round((viewStart.value - origin.value) * ppm.value)\n    scrollLeft.value = scrollPositionOf(el).left\n  }\n\n  function fit() {\n    const width = o.fitWidth()\n    if (!width) return\n    const days = Math.max(1, (content.value.end - content.value.start) / MINUTES_PER_DAY)\n    dayWidth.value = Math.min(FIT_MAX, Math.max(DAY_WIDTH_RANGE[0], (width - 96) / days))\n    scrollToTime(content.value.start)\n  }\n\n  onMounted(() => {\n    coarse.value = window.matchMedia?.('(any-pointer: coarse)').matches ?? false\n    measureScrollbar()\n    scrollToTime(content.value.start)\n  })\n\n  /** Fits the content once the timeline has a width, unless a `scale` was given. */\n  function fitWhenSized() {\n    if (!fitPending || !o.fitWidth() || !o.viewWidth.value) return\n    fitPending = false\n    fit()\n  }\n\n  // Zoom --------------------------------------------------------------------------\n\n  /** Changes the day width, keeping the time under `anchor` (px from the view's left) in place. */\n  function zoomTo(width: number, anchor = o.viewWidth.value / 2) {\n    const next = Math.min(DAY_WIDTH_RANGE[1], Math.max(DAY_WIDTH_RANGE[0], width))\n    const at = viewStart.value + anchor / ppm.value\n    dayWidth.value = next\n    viewStart.value = at - anchor / ppm.value\n    // what was scrolled past at the old zoom could be very wide at the new one\n    if (reach.value && !o.range()) {\n      reach.value = null\n      keep(viewStart.value, viewStart.value + o.viewWidth.value / ppm.value)\n    }\n    // a pinch moves the scroll position anyway, so the start moves with it\n    if (heldStart.value != null) heldStart.value = freeStart.value\n  }\n\n  function onWheel(event: WheelEvent) {\n    if (!(event.ctrlKey || event.metaKey)) return\n    event.preventDefault()\n    const rect = o.chart.value!.getBoundingClientRect()\n    zoomTo(dayWidth.value * Math.exp(-event.deltaY * 0.01), event.clientX - rect.left)\n  }\n\n  const zoomIn = () => zoomTo(dayWidth.value * ZOOM_STEP)\n  const zoomOut = () => zoomTo(dayWidth.value / ZOOM_STEP)\n\n  /** Two fingers on the timeline zoom it, as a held Ctrl and the wheel do. */\n  let pinch: { distance: number; dayWidth: number } | null = null\n\n  /** Starts a pinch when two fingers rest on the timeline; `true` when one began. */\n  function pinchStart(event: TouchEvent) {\n    const el = o.chart.value\n    if (event.touches.length !== 2 || !el) return false\n    const { a, b, distance } = fingers(event)\n    if (!el.contains(a.target as Node) || !el.contains(b.target as Node)) return false\n    pinch = { distance: Math.max(1, distance), dayWidth: dayWidth.value }\n    return true\n  }\n\n  /** Zooms with the fingers; `true` while a pinch is going on. */\n  function pinchMove(event: TouchEvent) {\n    if (!pinch || event.touches.length !== 2) return false\n    event.preventDefault()\n    const { a, b, distance } = fingers(event)\n    const rect = o.chart.value!.getBoundingClientRect()\n    zoomTo(pinch.dayWidth * (distance / pinch.distance), (a.clientX + b.clientX) / 2 - rect.left)\n    return true\n  }\n\n  function pinchEnd(event: TouchEvent) {\n    if (event.touches.length < 2) pinch = null\n  }\n\n  // What is in view ---------------------------------------------------------------\n\n  /** The time in view, with some room either side. */\n  const timeWindow = computed(() => ({\n    start: origin.value + (scrollLeft.value - OVERSCAN_X) / ppm.value,\n    end: origin.value + (scrollLeft.value + (o.viewWidth.value || 800) + OVERSCAN_X) / ppm.value,\n  }))\n\n  function cells(unit: TimeUnit, step = 1): HeaderCell[] {\n    const { start, end } = timeWindow.value\n    return unitsBetween(unit, Math.max(start, origin.value), end, o.weekStart.value, step).map(\n      (cell) => ({\n        key: cell.start,\n        end: cell.end,\n        left: xOf(cell.start),\n        width: (cell.end - cell.start) * ppm.value,\n        label: unitLabel(unit, cell.start, o.messages.value, dayWidth.value),\n      }),\n    )\n  }\n\n  const headerStep = computed(() => (level.value.bottom === 'hour' ? hourStep(dayWidth.value) : 1))\n  const topCells = computed(() => cells(level.value.top))\n  const bottomCells = computed(() => cells(level.value.bottom, headerStep.value))\n\n  /** Days off, shaded; at hour level the hours outside work too. */\n  const shaded = computed(() => {\n    if (dayWidth.value < 8) return []\n    const { start, end } = timeWindow.value\n    return offTime(o.calendar.value, start, end, level.value.name === 'hour').map((range) => ({\n      key: range.start,\n      left: xOf(range.start),\n      width: (range.end - range.start) * ppm.value,\n    }))\n  })\n\n  const todayX = computed(() =>\n    o.today() && now.value >= extent.value.start && now.value <= extent.value.end\n      ? xOf(now.value)\n      : null,\n  )\n\n  /** A pointer's x on screen as timeline px. */\n  const contentX = (clientX: number) =>\n    clientX - o.chart.value!.getBoundingClientRect().left + o.chart.value!.scrollLeft\n\n  function scrollToDate(date: string) {\n    const parsed = parseTime(date)\n    if (parsed) scrollToTime(parsed.at)\n  }\n\n  function scrollToToday() {\n    scrollToTime(now.value, o.viewWidth.value / 3)\n  }\n\n  return {\n    dayWidth,\n    level,\n    ppm,\n    now,\n    extent,\n    origin,\n    totalWidth,\n    xOf,\n    contentX,\n    scrollTop,\n    scrollLeft,\n    scrollbar,\n    measureScrollbar,\n    onChartScroll,\n    onTableScroll,\n    scrollToTime,\n    scrollToDate,\n    scrollToToday,\n    fit,\n    fitWhenSized,\n    zoomTo,\n    zoomIn,\n    zoomOut,\n    onWheel,\n    pinchStart,\n    pinchMove,\n    pinchEnd,\n    timeWindow,\n    topCells,\n    bottomCells,\n    shaded,\n    todayX,\n  }\n}\n\nexport type TimeAxis = ReturnType<typeof useTimeAxis>\n"],"mappings":"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"}

package/dist/types/collaboration/index.d.ts

@@ -0,0 +1,39 @@
+import { collaborationColors } from 'dou-ui';
+import * as Y from 'yjs';
+import { type GanttExtension } from '../core/extension';
+import type { GanttDocument } from '../core/transaction';
+import { type AwarenessLike, type GanttPresence } from './peers';
+/** How the people editing together see each other. */
+export interface CollaborationUser {
+    name: string;
+    /** The color of this user's outlines, any CSS color. Picked from the client id when left out. */
+    color?: string;
+}
+export interface CollaborationOptions {
+    /** Where the tasks live, e.g. `ydoc.getMap('tasks')`. */
+    tasks: Y.Map<unknown>;
+    /** Where the links live, e.g. `ydoc.getMap('links')`; in the same `Y.Doc` as `tasks`. */
+    links: Y.Map<unknown>;
+    /** Shares what each person selects and drags (`y-protocols/awareness`). */
+    awareness?: AwarenessLike;
+    /** This user, shown to the others. Needs `awareness`. */
+    user?: CollaborationUser;
+}
+export { collaborationColors };
+/**
+ * Writes tasks and links into empty maps, e.g. when a plan that so far was
+ * saved as JSON starts being edited together. Every task gets an `order`
+ * key. Do it once, where the shared document is created.
+ */
+export declare function fillMaps(maps: {
+    tasks: Y.Map<unknown>;
+    links: Y.Map<unknown>;
+}, doc: GanttDocument): void;
+/**
+ * Edit a Gantt chart together through a Yjs document. The tasks and links
+ * live in two `Y.Map`s: the chart's `v-model` only mirrors them, and
+ * changes made to `v-model` from outside are not written back. Undo only
+ * takes back this user's own changes. Folding a summary stays local.
+ */
+export declare function collaboration(options: CollaborationOptions): GanttExtension;
+export type { AwarenessLike, GanttPresence };

package/dist/types/collaboration/peers.d.ts

@@ -0,0 +1,22 @@
+import { type Component } from 'vue';
+/** The part of an `Awareness` (`y-protocols/awareness`) the chart uses. */
+export interface AwarenessLike {
+    clientID: number;
+    getLocalState(): Record<string, unknown> | null;
+    setLocalStateField(field: string, value: unknown): void;
+    getStates(): Map<number, Record<string, unknown>>;
+    on(event: 'change', listener: (...args: unknown[]) => void): void;
+    off(event: 'change', listener: (...args: unknown[]) => void): void;
+}
+/** What each person shares under the awareness field `gantt`. */
+export interface GanttPresence {
+    /** The tasks they are dragging, with the dates they would get. */
+    moving: {
+        id: string;
+        start?: string;
+        end?: string;
+    }[];
+    selection: string[];
+}
+/** A layer that outlines the tasks other people are dragging or have selected, in their colors. */
+export declare function createPeers(awareness: AwarenessLike): Component;

package/dist/types/components/cell-editor.vue.d.ts

@@ -0,0 +1,21 @@
+type __VLS_Props = {
+    kind: 'text' | 'number' | 'date' | 'datetime';
+    value: string;
+    label: string;
+    placeholder?: string;
+    /** Keep editing after Enter, with the field emptied: for adding tasks one after another. */
+    repeat?: boolean;
+    /** Whether a value can be saved. */
+    check?: (value: string) => boolean;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    done: (value: string | null) => any;
+    tab: (back: boolean) => any;
+    invalid: (value: string) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onDone?: ((value: string | null) => any) | undefined;
+    onTab?: ((back: boolean) => any) | undefined;
+    onInvalid?: ((value: string) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/components/gantt-menu.vue.d.ts

@@ -0,0 +1,18 @@
+import type { ContextMenuItem } from 'dou-ui';
+type __VLS_Props = {
+    items: ContextMenuItem[];
+};
+type __VLS_ModelProps = {
+    'open'?: boolean;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {
+    open: (x: number, y: number) => void | undefined;
+    close: () => void | undefined;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:open": (value: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/components/time-grid.vue.d.ts

@@ -0,0 +1,12 @@
+import type { HeaderCell } from '../time-axis';
+type __VLS_Props = {
+    cells: HeaderCell[];
+    shaded: {
+        key: number;
+        left: number;
+        width: number;
+    }[];
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/components/time-header.vue.d.ts

@@ -0,0 +1,23 @@
+import type { WorkCalendar } from '../core/calendar';
+import type { TimeUnit } from '../core/scale';
+import type { HeaderCell } from '../time-axis';
+type __VLS_Props = {
+    topCells: HeaderCell[];
+    bottomCells: HeaderCell[];
+    bottomUnit: TimeUnit;
+    calendar: WorkCalendar;
+    now: number;
+    todayX: number | null;
+};
+type __VLS_Slots = {
+    default?: () => unknown;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, 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;
+    };
+};

package/dist/types/context.d.ts

@@ -0,0 +1,64 @@
+import { type ComputedRef, type InjectionKey, type Ref } from 'vue';
+import type { GanttLink, GanttTask } from './core/model';
+import type { GanttCriticalPath } from './core/schedule';
+import type { GanttScale } from './core/scale';
+import type { GanttDocument } from './core/transaction';
+import type { GanttRow } from './core/tree';
+import type { GanttExpose } from './types';
+import type { GanttMessages } from './locale';
+/** The surrounding Gantt chart, as `useGantt()` and extensions see it. */
+export interface GanttContext {
+    /** The whole document as it is now; change it with `transact`. */
+    doc: ComputedRef<GanttDocument>;
+    /** The document's tasks and links, as a shortcut. */
+    tasks: ComputedRef<GanttTask[]>;
+    links: ComputedRef<GanttLink[]>;
+    selection: Ref<string[]>;
+    /** The task the keyboard is on. */
+    active: Ref<string | null>;
+    readonly: ComputedRef<boolean>;
+    messages: ComputedRef<GanttMessages>;
+    scale: ComputedRef<GanttScale>;
+    /** How wide a day is, in px. */
+    dayWidth: Ref<number>;
+    /** Height of a row, in px. */
+    rowHeight: ComputedRef<number>;
+    /** The rows as laid out, with spans and summaries worked out. */
+    rows: ComputedRef<GanttRow[]>;
+    /**
+     * While a bar is dragged: the tasks it would change, with the ones it
+     * would push, as they would be written. `null` otherwise.
+     */
+    preview: ComputedRef<Map<string, Partial<GanttTask>> | null>;
+    transact: GanttExpose['transact'];
+    /** The critical path when `critical` is on, `null` otherwise. */
+    critical: ComputedRef<GanttCriticalPath | null>;
+    /** Links not kept by the dates as they are. */
+    brokenLinks: ComputedRef<Set<string>>;
+    schedule: GanttExpose['schedule'];
+    editCell: GanttExpose['editCell'];
+    insertTask: GanttExpose['insertTask'];
+    indentTask: GanttExpose['indentTask'];
+    outdentTask: GanttExpose['outdentTask'];
+    undo: () => boolean;
+    redo: () => boolean;
+    canUndo: Ref<boolean>;
+    canRedo: Ref<boolean>;
+    fit: () => void;
+    zoomIn: () => void;
+    zoomOut: () => void;
+    scrollToDate: GanttExpose['scrollToDate'];
+    scrollToTask: GanttExpose['scrollToTask'];
+    scrollToToday: () => void;
+    /** Puts the keyboard on a task, scrolls it into view and focuses its bar. */
+    focusTask: (id: string) => void;
+    /** Where a time (a date string or minutes) is on the timeline, in px from its start. */
+    xOf: (time: string | number) => number | null;
+    /** Where a task's row is on the timeline, in px from the top of the rows. */
+    rowTop: (id: string) => number | null;
+    /** Says `text` to screen readers. */
+    announce: (text: string) => void;
+}
+export declare const ganttKey: InjectionKey<GanttContext>;
+/** The surrounding Gantt chart; for layers, overlays and the chart's slots. */
+export declare function useGantt(): GanttContext;

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

@@ -0,0 +1,14 @@
+import { type GanttTask, type TaskSpan } from './model';
+/** A task's dates as planned, to compare the current ones with. */
+export interface GanttBaselineItem {
+    id: string;
+    start: string;
+    end?: string;
+}
+/**
+ * Saves the current dates of every task as a baseline, summaries included
+ * (with the dates their children cover). Tasks without dates are left out.
+ */
+export declare function takeBaseline(tasks: readonly GanttTask[]): GanttBaselineItem[];
+/** The planned span of each task in a baseline, read as the task's own dates are. */
+export declare function baselineSpans(baseline: readonly GanttBaselineItem[], milestones: (id: string) => boolean): Map<string, TaskSpan>;

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

@@ -0,0 +1,75 @@
+/** Which days and hours are worked. */
+export interface GanttCalendar {
+    /** Days of the week off, `0` is Sunday. Defaults to `[0, 6]`. */
+    weekends?: number[];
+    /** Days off besides the weekend, as `YYYY-MM-DD`. */
+    holidays?: string[];
+    /** Weekend days that are worked anyway, as `YYYY-MM-DD`. They win over `weekends`. */
+    workdays?: string[];
+    /**
+     * The working hours of a working day, as `HH:mm`: one stretch such as
+     * `['09:00', '18:00']` (the default), or several to leave out a break,
+     * such as `[['09:00', '12:00'], ['13:00', '18:00']]`.
+     */
+    hours?: [string, string] | [string, string][];
+}
+/** A calendar with its strings read, for fast lookups. */
+export interface WorkCalendar {
+    isWorkday: (day: number) => boolean;
+    /** Working stretches of a day as minutes since midnight, in order and apart. */
+    hours: [number, number][];
+}
+export declare function resolveCalendar(calendar?: GanttCalendar): WorkCalendar;
+/** Working days that start in `[from, to)`. */
+export declare function workdaysBetween(calendar: WorkCalendar, from: number, to: number): number;
+/** Working minutes in `[from, to)`: the working hours of working days. */
+export declare function workingMinutes(calendar: WorkCalendar, from: number, to: number): number;
+export interface TimeRange {
+    start: number;
+    end: number;
+}
+/**
+ * The stretches of `[from, to)` that are not worked: whole days off, and
+ * with `hours`, the hours outside work on working days too. Adjacent
+ * stretches are merged.
+ */
+export declare function offTime(calendar: WorkCalendar, from: number, to: number, hours?: boolean): TimeRange[];
+/**
+ * The midnight `count` working days away from the midnight `at`: forward
+ * it ends after the last of them, backward it is the start of the last
+ * one. A fraction rounds to whole days.
+ */
+export declare function shiftWorkdays(calendar: WorkCalendar, at: number, count: number): number;
+/**
+ * The moment `count` working minutes away from `at`, forward or backward.
+ * It lands inside working hours, or at the end of a stretch going forward.
+ */
+export declare function shiftWorkMinutes(calendar: WorkCalendar, at: number, count: number): number;
+/** Working days, or working minutes, in `[from, to)`. */
+export declare const workIn: (calendar: WorkCalendar, from: number, to: number, dateOnly: boolean) => number;
+/**
+ * Whether work can start at `at`: the start of a working day for whole
+ * days, a moment inside working hours otherwise.
+ */
+export declare function isWorkTime(calendar: WorkCalendar, at: number, dateOnly: boolean): boolean;
+/**
+ * The first moment at or after `at` when work can start: the next working
+ * midnight for whole days, the next working minute otherwise.
+ */
+export declare function nextWorkTime(calendar: WorkCalendar, at: number, dateOnly: boolean): number;
+/**
+ * The end of a span moved to start at `start`, keeping its working time:
+ * as many working days for a date-only span, as many working minutes
+ * otherwise. A span with no working time keeps its length.
+ */
+export declare function endKeepingWork(calendar: WorkCalendar, span: {
+    start: number;
+    end: number;
+    dateOnly: boolean;
+}, start: number): number;
+/** The start of a span moved to end at `end`, keeping its working time. */
+export declare function startKeepingWork(calendar: WorkCalendar, span: {
+    start: number;
+    end: number;
+    dateOnly: boolean;
+}, end: number): number;

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

@@ -0,0 +1,77 @@
+import type { GanttColumn } from '../types';
+import { type GanttMessages } from '../locale';
+import { type WorkCalendar } from './calendar';
+import { type GanttTask } from './model';
+import type { GanttTransaction } from './transaction';
+/** A value `readCSV` couldn't read; the task keeps what it had, or goes without it. */
+export interface GanttCSVWarning {
+    /** The row of the file it is on, the header being row 1. */
+    row: number;
+    /** The column's `key`; `id` and `parent` for the columns `ids` adds. */
+    column: string;
+    /** The text in the cell. */
+    text: string;
+}
+/** What `readCSV` and `importCSV` give back. */
+export interface GanttCSVResult {
+    /** In the order of the file. */
+    tasks: GanttTask[];
+    /** Values that couldn't be read. */
+    warnings: GanttCSVWarning[];
+    /**
+     * The keys of the columns the file has, in its order; `id` and `parent`
+     * for the columns `ids` adds.
+     */
+    columns: string[];
+    /** Headers that are no field and no column of the chart; their values are left out. */
+    unknownColumns: string[];
+}
+/** Why a file can't be read as tasks, as the `code` of a `GanttCSVError`. */
+export type GanttCSVErrorCode = 'noTitleColumn';
+/** Thrown when a file can't be read as tasks: for developers in `message`, for people in `reason`. */
+export declare class GanttCSVError extends Error {
+    readonly code: GanttCSVErrorCode;
+    readonly reason: string;
+    name: string;
+    constructor(message: string, code: GanttCSVErrorCode, reason: string);
+}
+/** How `importCSV` puts the tasks of a file into the chart. */
+export interface GanttCSVImportOptions {
+    /**
+     * `replace` (the default): the file's tasks become the chart's. A task
+     * whose id is already in the chart is updated with what the file has
+     * and keeps the rest, links too; the tasks the file doesn't have are
+     * removed. It is the default as the usual way back is the file the
+     * chart wrote, edited in a spreadsheet. `append`: the file's tasks are
+     * added after the chart's, with new ids where theirs are taken.
+     */
+    mode?: 'replace' | 'append';
+}
+/**
+ * Splits CSV into rows of fields (RFC 4180); a byte order mark at the start
+ * is dropped. `delimiter` defaults to the one the text most likely uses.
+ */
+export declare function splitCSV(text: string, delimiter?: string): string[][];
+/**
+ * A date as tasks write it, from the ways spreadsheets save one:
+ * `2026/3/2`, `2026-3-2`, `2026.3.2`, with `9:30` or `09:30:00` after it.
+ * `null` when it isn't a date.
+ */
+export declare function readCSVDate(text: string): string | null;
+export interface ReadCSVContext {
+    columns: GanttColumn[];
+    messages: GanttMessages;
+    calendar: WorkCalendar;
+    /** Tasks outside the file that a task of it may be under, as when appending. */
+    outer?: (id: string) => boolean;
+}
+/**
+ * Reads the tasks of a CSV file. Throws when no header is the title
+ * column, as the file then isn't a list of tasks.
+ */
+export declare function readGanttCSV(text: string, context: ReadCSVContext): GanttCSVResult;
+/**
+ * Puts the tasks `readGanttCSV` read into a transaction, as
+ * `GanttCSVImportOptions.mode` says.
+ */
+export declare function applyGanttCSV(tr: GanttTransaction, result: GanttCSVResult, mode: 'replace' | 'append', calendar: WorkCalendar): void;

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

@@ -0,0 +1,51 @@
+import { type GanttExtension } from './extension';
+import type { GanttDocument } from './transaction';
+export interface DocumentProblem {
+    code: 'version' | 'shape' | 'missing-id' | 'duplicate-id' | 'missing-parent' | 'parent-cycle' | 'bad-date' | 'missing-task' | 'bad-lag' | 'self-link' | 'nested-link' | 'duplicate-link' | 'link-cycle' | 'refused-link';
+    /** The task at fault, or the task a link points at. */
+    taskId?: string;
+    /** The link at fault. */
+    linkId?: string;
+    /**
+     * Where the problem is, as a path into the document, e.g. `tasks[2].start`
+     * or `links[0].to`; `version` for the version.
+     */
+    path: string;
+    /** The id, date or lag at fault, for the editor's message. */
+    text: string;
+    /** An English description, for logs. */
+    message: string;
+}
+export interface CheckDocumentOptions {
+    /** The chart's `canLink`, to check the links against it too. */
+    canLink?: GanttRule;
+    /** The chart's extensions, to check the links against their `canLink` too. */
+    extensions?: readonly (GanttExtension | readonly GanttExtension[])[];
+}
+type GanttRule = NonNullable<GanttExtension['canLink']>;
+/**
+ * The problems of a Gantt document, before it is saved or shown: an
+ * unknown version, tasks and links without an id or sharing one, `parent`
+ * pointing nowhere or in a circle, dates and lags that can't be read, and
+ * links to missing tasks, to the task itself, between a summary and its
+ * own task, twice between the same tasks, or in a circle; with `canLink`
+ * or `extensions`, links their rules refuse too.
+ */
+export declare function checkDocument(document: GanttDocument, options?: CheckDocumentOptions): DocumentProblem[];
+/**
+ * Brings a saved document up to the current version, and fills what an
+ * older or hand-written one may lack (`version`, `tasks`, `links`). Tasks
+ * and links that are not objects are dropped; anything else is kept as it
+ * is. Throws for data that is not an object
+ * (an array, `null`, a string) and for a version it does not know.
+ */
+export declare function migrateDocument(input: unknown): GanttDocument;
+/**
+ * The `v-model` as the chart reads it. A document of the wrong shape (not an
+ * object, without `tasks` or `links`, without a known `version`) gets a
+ * warning in development and is read with what is missing left empty and the
+ * version as 1, so the chart still opens and what it writes back carries
+ * `version: 1`. The scheduler doesn't use `links` and doesn't need them.
+ */
+export declare function readDocument(value: unknown, needsLinks?: boolean): GanttDocument;
+export {};

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

@@ -0,0 +1,88 @@
+import type { ContextMenuItem } from 'dou-ui';
+import type { Component } from 'vue';
+import type { GanttContext } from '../context';
+import type { GanttColumn, GanttMarker, GanttMove } from '../types';
+import type { GanttMenuTarget } from './menu';
+import type { GanttLink } from './model';
+import type { GanttDocument, GanttTransaction } from './transaction';
+/** What an extension's hooks receive; the same as `useGantt()`. */
+export type GanttExtensionContext = GanttContext;
+/**
+ * A key handler: return `false` to let the key through to the next handler
+ * and the chart's own keys; anything else means it was handled.
+ */
+export type GanttKeyHandler = (event: KeyboardEvent) => boolean | void;
+/** An undo history that replaces the chart's own, e.g. one that only undoes this user's changes. */
+export interface GanttHistoryHandler {
+    /** `false` when there is nothing to undo. */
+    undo: () => boolean;
+    redo: () => boolean;
+    canUndo: () => boolean;
+    canRedo: () => boolean;
+}
+/**
+ * A piece of the Gantt chart: table columns, rules for links and moves,
+ * keys, marker lines and extra layers. A third-party extension can do
+ * anything the chart's own props can.
+ */
+export interface GanttExtension {
+    name: string;
+    /** Higher runs first: its keys and rules are asked before others. Defaults to 100. */
+    priority?: number;
+    /** Columns added after the table's own. */
+    columns?: GanttColumn[];
+    /** A link rule, asked with `can-link`. Return `true` to allow, or a sentence saying why not. */
+    canLink?: (link: Pick<GanttLink, 'from' | 'to' | 'type'>, doc: GanttDocument) => boolean | string;
+    /** A rule for new dates, asked with `can-move`. */
+    canMove?: (move: GanttMove, doc: GanttDocument) => boolean | string;
+    /** Keys, written as in `useHotkey` (e.g. `mod+d`, `shift+t`), while the chart has focus. */
+    keymap?: (context: GanttExtensionContext) => Record<string, GanttKeyHandler>;
+    /**
+     * Items for the context menu, which opens on a right click, the menu key
+     * or a long press. They come before the built-in ones.
+     */
+    contextMenu?: (context: GanttExtensionContext, target: GanttMenuTarget) => ContextMenuItem[];
+    /** Vertical marker lines, such as a release day; worked out again when what they read changes. */
+    markers?: (context: GanttExtensionContext) => GanttMarker[];
+    /**
+     * Components drawn on the timeline, in its own coordinates: `below` under
+     * the dependency lines, `above` over the bars. They scroll with it.
+     */
+    layers?: {
+        below?: Component[];
+        above?: Component[];
+    };
+    /** Components drawn over the chart, not scrolled, e.g. a panel. They can call `useGantt()`. */
+    overlays?: Component[];
+    /** Runs once the chart is mounted. Return a function to run when it unmounts. */
+    setup?: (context: GanttExtensionContext) => void | (() => void);
+    /**
+     * Sees every change before it reaches the tasks and links, in priority
+     * order, and may add steps to it. Undo and redo come through here too.
+     */
+    transaction?: (tr: GanttTransaction, context: GanttExtensionContext) => void;
+    /** Replaces the chart's undo history; the first extension that has one wins. */
+    history?: (context: GanttExtensionContext) => GanttHistoryHandler;
+}
+/** Declares an extension; only gives it a type. */
+export declare function defineGanttExtension(extension: GanttExtension): GanttExtension;
+/** Everything the extensions contribute, gathered once per list. */
+export interface ResolvedGanttExtensions {
+    extensions: GanttExtension[];
+    columns: GanttColumn[];
+    linkRules: NonNullable<GanttExtension['canLink']>[];
+    moveRules: NonNullable<GanttExtension['canMove']>[];
+    keymaps: NonNullable<GanttExtension['keymap']>[];
+    markers: NonNullable<GanttExtension['markers']>[];
+    menus: NonNullable<GanttExtension['contextMenu']>[];
+    setups: NonNullable<GanttExtension['setup']>[];
+    transactions: NonNullable<GanttExtension['transaction']>[];
+    history: GanttExtension['history'];
+    below: Component[];
+    above: Component[];
+    overlays: Component[];
+}
+type ExtensionList = readonly (GanttExtension | readonly GanttExtension[])[];
+/** Sorts the extensions by priority and collects what they add. */
+export declare function resolveGanttExtensions(list?: ExtensionList): ResolvedGanttExtensions;
+export {};

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

@@ -0,0 +1,33 @@
+import type { GanttLinkType } from './model';
+export interface Point {
+    x: number;
+    y: number;
+}
+/**
+ * A path through `points` with straight segments and corners rounded by
+ * up to `radius`; a corner never takes more than half of either segment.
+ */
+export declare function roundedPath(points: readonly Point[], radius?: number): string;
+/** Where a bar sits on screen, in px. */
+export interface BarBox {
+    /** Left and right edges; equal for a milestone's centre. */
+    left: number;
+    right: number;
+    /** Vertical centre. */
+    y: number;
+}
+export interface LinkRoute {
+    points: Point[];
+    /** The arrow's tip, and which way it points: `1` right, `-1` left. */
+    tip: Point;
+    direction: 1 | -1;
+}
+/**
+ * The route of a dependency line: out of one end of `from`, into one end
+ * of `to`. It leaves and arrives horizontally, `gap` px clear of the bars,
+ * and takes a single vertical run when one fits; otherwise it turns back
+ * along the boundary between the rows (`rowHeight` apart).
+ */
+export declare function routeLink(from: BarBox, to: BarBox, type?: GanttLinkType, rowHeight?: number, gap?: number): LinkRoute;
+/** A small solid arrowhead with its tip at `tip`. */
+export declare function arrowPath(tip: Point, direction: 1 | -1, size?: number): string;

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

@@ -0,0 +1,19 @@
+import { type GanttDocument, type GanttTransaction } from './transaction';
+export declare class GanttHistory {
+    private depth;
+    private done;
+    private undone;
+    constructor(depth?: number);
+    get canUndo(): boolean;
+    get canRedo(): boolean;
+    record(tr: GanttTransaction, selectionBefore: string[], selectionAfter: string[], now?: number): void;
+    undo(doc: GanttDocument): {
+        tr: GanttTransaction;
+        selection: string[];
+    } | null;
+    redo(doc: GanttDocument): {
+        tr: GanttTransaction;
+        selection: string[];
+    } | null;
+    clear(): void;
+}

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

@@ -0,0 +1,20 @@
+import type { GanttLink, GanttLinkType, GanttTask } from './model';
+/** Why a new link was refused. */
+export type GanttLinkRefusal = 'self' | 'nested' | 'duplicate' | 'cycle' | 'custom';
+/** Whether `to` can be reached from `from` along the links. */
+export declare function reaches(links: readonly GanttLink[], from: string, to: string): boolean;
+/**
+ * Why a link from `from` to `to` can't be made, or `null` when it can: a
+ * task can't depend on itself, on its own parent or child, on a task it
+ * already depends on, or on a task that waits for it.
+ */
+export declare function linkRefusal(tasks: ReadonlyMap<string, GanttTask>, links: readonly GanttLink[], from: string, to: string): GanttLinkRefusal | null;
+/** The link type for a line drawn from one end of a task to one end of another. */
+export declare function linkTypeOf(fromEnd: 'start' | 'end', toEnd: 'start' | 'end'): GanttLinkType;
+/** A link's lag, read: an amount of working days, or of working minutes. */
+export interface GanttLag {
+    amount: number;
+    unit: 'day' | 'minute';
+}
+/** Reads a `lag`: a number of working days, or `'2d'`, `'4h'`, `'30m'`; `null` when unreadable. */
+export declare function parseLag(lag: number | string | undefined): GanttLag | null;