graphein 0.20.0 → 0.22.0

package/dist/runtime/gantt.js

@@ -0,0 +1,647 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import { accessor, inferType, toDate, toKey, toNumber } from "../util/data.js";
+import { ticks as numericTicks, timeTicks } from "../ticks/index.js";
+import { linearScale, timeScale } from "../scales/index.js";
+import { formatDate, formatNumber, formatValue, prettyDate } from "../format/index.js";
+import { computeFrame, NO_PADDING } from "../layout/index.js";
+import { fontString, measureText } from "../render/text.js";
+import { resolveSketch } from "../spec/sketch.js";
+import { ordinalColorScale, rgbaToCss } from "../color/index.js";
+import { resolvePalette } from "./categories.js";
+const MINUTE = 6e4;
+const HOUR = 60 * MINUTE;
+const DAY = 24 * HOUR;
+const YEAR = 365 * DAY;
+const MIN_BAR_WIDTH = 3;
+const MAX_BAR_HEIGHT = 26;
+const MAX_MILESTONE_RADIUS = 11;
+function isFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+function labelFor(value) {
+  if (value == null || value === "") return "(blank)";
+  if (value instanceof Date) return Number.isFinite(value.getTime()) ? formatDate(value, "%b %e, %Y") : String(value);
+  return String(value);
+}
+function titleInput(spec) {
+  if (typeof spec.title === "string") return { text: spec.title };
+  if (spec.title) return { text: spec.title.text, subtitle: spec.title.subtitle, align: spec.title.align };
+  return void 0;
+}
+function ganttScaleKind(spec, data) {
+  const { start, end } = spec.encoding;
+  const declared = start.type ?? end.type;
+  if (declared === "quantitative") return "linear";
+  if (declared === "temporal") return "time";
+  const inferred = inferType(data, start.field);
+  if (inferred === "quantitative") return "linear";
+  if (inferred === "temporal") return "time";
+  return inferType(data, end.field) === "quantitative" ? "linear" : "time";
+}
+function ganttValue(kind, value) {
+  if (kind === "linear") return toNumber(value);
+  const date = toDate(value);
+  return date ? date.getTime() : NaN;
+}
+function parseRows(spec, data, kind) {
+  const enc = spec.encoding;
+  const readTask = accessor(enc.task.field);
+  const readStart = accessor(enc.start.field);
+  const readEnd = accessor(enc.end.field);
+  const readGroup = enc.group ? accessor(enc.group.field) : null;
+  const readProgress = enc.progress ? accessor(enc.progress.field) : null;
+  const tasks = [];
+  let skipped = 0;
+  data.forEach((row, sourceIndex) => {
+    const start = ganttValue(kind, readStart(row));
+    const end = ganttValue(kind, readEnd(row));
+    if (!isFiniteNumber(start) || !isFiniteNumber(end) || end < start) {
+      skipped++;
+      return;
+    }
+    const raw = readTask(row);
+    const groupRaw = readGroup ? readGroup(row) : void 0;
+    const progressValue = readProgress ? toNumber(readProgress(row)) : NaN;
+    tasks.push({
+      key: toKey(raw),
+      raw,
+      label: labelFor(raw),
+      start,
+      end,
+      milestone: end === start,
+      groupKey: readGroup ? toKey(groupRaw) : void 0,
+      groupLabel: readGroup ? labelFor(groupRaw) : void 0,
+      groupRaw,
+      color: "",
+      progress: isFiniteNumber(progressValue) ? clamp(progressValue, 0, 1) : void 0,
+      sourceIndex,
+      row,
+      lane: 0,
+      rect: { x: 0, y: 0, width: 0, height: 0 }
+    });
+  });
+  return { tasks, skipped };
+}
+function orderLanes(tasks, sort) {
+  const byKey = /* @__PURE__ */ new Map();
+  const lanes = [];
+  tasks.forEach((task, index) => {
+    let lane = byKey.get(task.key);
+    if (!lane) {
+      lane = { key: task.key, raw: task.raw, label: task.label, first: index, minStart: task.start, minEnd: task.end, total: 0, tasks: [] };
+      byKey.set(task.key, lane);
+      lanes.push(lane);
+    }
+    lane.minStart = Math.min(lane.minStart, task.start);
+    lane.minEnd = Math.min(lane.minEnd, task.end);
+    lane.total += task.end - task.start;
+    lane.tasks.push(task);
+  });
+  const metric = {
+    start: (lane) => lane.minStart,
+    end: (lane) => lane.minEnd,
+    duration: (lane) => -lane.total
+  };
+  const by = sort ? metric[sort] : void 0;
+  return by ? lanes.slice().sort((a, b) => by(a) - by(b) || a.first - b.first) : lanes;
+}
+function resolveGroups(spec, tokens, tasks, colorSource) {
+  const palette = resolvePalette(spec.palette, tokens);
+  const plain = spec.palette !== void 0 && palette.length > 0 ? palette[0] : tokens.color.accent;
+  const groupDef = spec.encoding.group;
+  if (!groupDef) return { groups: [], colorOf: () => plain, grouped: false, plain, plainMilestone: tokens.color.text };
+  const explicit = groupDef.scale?.domain;
+  const order = /* @__PURE__ */ new Map();
+  const note = (key) => {
+    if (!order.has(key)) order.set(key, order.size);
+  };
+  if (Array.isArray(explicit)) for (const value of explicit) note(toKey(value));
+  const read = accessor(groupDef.field);
+  for (const row of colorSource) note(toKey(read(row)));
+  for (const task of tasks) note(task.groupKey);
+  const scale = ordinalColorScale({ domain: [...order.keys()], palette });
+  const cache = /* @__PURE__ */ new Map();
+  const colorOf = (key) => {
+    let color = cache.get(key);
+    if (!color) cache.set(key, color = rgbaToCss(scale.map(key)));
+    return color;
+  };
+  const present = /* @__PURE__ */ new Map();
+  for (const task of tasks) {
+    const key = task.groupKey;
+    if (!present.has(key)) present.set(key, { key, label: task.groupLabel, raw: task.groupRaw, color: colorOf(key) });
+  }
+  const groups = [...present.values()].sort((a, b) => (order.get(a.key) ?? 0) - (order.get(b.key) ?? 0));
+  return { groups, colorOf, grouped: true, plain, plainMilestone: tokens.color.text };
+}
+function legendShown(spec, count) {
+  const cfg = spec.legend;
+  if (cfg === false) return false;
+  if (typeof cfg === "object" && cfg.show === false) return false;
+  return count > 1;
+}
+function annotationValues(spec, kind) {
+  const list = Array.isArray(spec.annotations) ? spec.annotations : [];
+  const out = [];
+  const add = (value) => {
+    const n = ganttValue(kind, value);
+    if (isFiniteNumber(n)) out.push(n);
+  };
+  for (const ann of list) {
+    if (!ann || typeof ann !== "object") continue;
+    if (ann.type === "point") add(ann.x);
+    else if (ann.axis === "x") {
+      if (ann.value !== void 0) add(ann.value);
+      if (ann.from !== void 0) add(ann.from);
+      if (ann.to !== void 0) add(ann.to);
+    }
+  }
+  return out;
+}
+function explicitDomain(spec, kind) {
+  const domain = spec.encoding.start.scale?.domain ?? spec.encoding.end.scale?.domain;
+  if (!Array.isArray(domain) || domain.length !== 2) return null;
+  const lo = ganttValue(kind, domain[0]);
+  const hi = ganttValue(kind, domain[1]);
+  return isFiniteNumber(lo) && isFiniteNumber(hi) && hi > lo ? [lo, hi] : null;
+}
+function dataExtent(spec, kind, tasks) {
+  let lo = Infinity;
+  let hi = -Infinity;
+  for (const task of tasks) {
+    lo = Math.min(lo, task.start);
+    hi = Math.max(hi, task.end);
+  }
+  if (tasks.length > 0) {
+    for (const value of annotationValues(spec, kind)) {
+      lo = Math.min(lo, value);
+      hi = Math.max(hi, value);
+    }
+  }
+  if (!isFiniteNumber(lo) || !isFiniteNumber(hi)) return kind === "time" ? [0, DAY] : [0, 1];
+  if (!isFiniteNumber(hi - lo)) return [lo, hi];
+  if (hi === lo) {
+    const pad = kind === "time" ? DAY : Math.abs(lo) > 0 ? Math.abs(lo) * 0.1 : 1;
+    return [lo - pad, hi + pad];
+  }
+  return [lo, hi];
+}
+function rawTicks(kind, lo, hi, count) {
+  return kind === "time" ? timeTicks(lo, hi, count) : numericTicks(lo, hi, count);
+}
+function axisTicks(spec, kind, extent, explicit, count) {
+  const [lo, hi] = explicit ?? extent;
+  const values = rawTicks(kind, lo, hi, count).filter(isFiniteNumber);
+  const userTicks = spec.axes?.x?.tickValues;
+  const parsed = Array.isArray(userTicks) ? userTicks.map((v) => ganttValue(kind, v)).filter(isFiniteNumber).sort((a, b) => a - b) : [];
+  const ticks = parsed.length > 0 ? parsed : values;
+  if (explicit) return { domain: explicit, values: ticks };
+  const span = hi - lo;
+  if (!(span > 0) || !isFiniteNumber(span) || values.length < 2) return { domain: [lo, hi], values: ticks };
+  const first = values[0];
+  const last = values[values.length - 1];
+  return {
+    domain: [
+      first <= lo && lo - first <= span * 0.08 ? first : lo,
+      last >= hi && last - hi <= span * 0.08 ? last : hi
+    ],
+    values: ticks
+  };
+}
+function tickCountFor(spec, width) {
+  const explicit = spec.axes?.x?.ticks;
+  if (typeof explicit === "number" && Number.isFinite(explicit) && explicit >= 1) return Math.round(explicit);
+  return clamp(Math.round(width / 80), 2, 10);
+}
+function annotationStrips(spec, tokens, height) {
+  const list = Array.isArray(spec.annotations) ? spec.annotations : [];
+  const strip = Math.ceil(tokens.font.size.small * 1.2 + 6);
+  let top = 0;
+  let bottom = 0;
+  for (const ann of list) {
+    if (!ann || typeof ann !== "object" || !ann.label || ann.type === "point" || ann.axis !== "x") continue;
+    const position = ann.labelPosition ?? "end";
+    if (position === "end") top = strip;
+    else if (position === "start") bottom = strip;
+  }
+  return height >= (top + bottom) * 3 ? { top, bottom } : { top: 0, bottom: 0 };
+}
+function ganttTimeTickLabels(values, format) {
+  if (format) return values.map((value) => formatValue(value, format));
+  let step = Infinity;
+  for (let i = 1; i < values.length; i++) step = Math.min(step, Math.abs(values[i] - values[i - 1]));
+  if (!Number.isFinite(step)) step = DAY;
+  return values.map((value, i) => {
+    const date = new Date(value);
+    if (step >= YEAR * 0.9) return formatDate(date, "%Y");
+    if (step >= 27 * DAY) return i === 0 || date.getMonth() === 0 ? formatDate(date, "%b %Y") : formatDate(date, "%b");
+    if (step >= DAY * 0.9) return formatDate(date, "%b %e");
+    const midnight = date.getHours() === 0 && date.getMinutes() === 0;
+    if (midnight) return formatDate(date, "%b %e");
+    return i === 0 ? formatDate(date, "%b %e %H:%M") : formatDate(date, "%H:%M");
+  });
+}
+function linearTickLabels(values, format) {
+  return values.map((value) => format ? formatValue(value, format) : formatNumber(value, ","));
+}
+function axisFormat(spec) {
+  return spec.axes?.x?.format ?? spec.encoding.start.format;
+}
+function tickLabels(spec, kind, values) {
+  return kind === "time" ? ganttTimeTickLabels(values, axisFormat(spec)) : linearTickLabels(values, axisFormat(spec));
+}
+function ganttFrame(spec, tokens, opts, xLabels, inputs, position) {
+  const axes = spec.axes;
+  const legendAt = position ?? inputs.legendPosition;
+  return computeFrame({
+    width: Math.max(0, opts.width),
+    height: Math.max(0, opts.height),
+    originX: opts.originX,
+    originY: opts.originY,
+    titleGap: opts.titleGap,
+    minimumPlotSize: opts.minimumPlotSize,
+    padding: { ...NO_PADDING, ...spec.padding },
+    font: tokens.font,
+    title: titleInput(spec),
+    legend: legendAt && inputs.legendItems.length > 0 ? { items: inputs.legendItems, position: legendAt } : void 0,
+    xAxis: {
+      show: axes?.x?.show !== false,
+      labels: axes?.x?.labels === false ? [] : xLabels,
+      title: axes?.x?.title,
+      edgeAnchored: true
+    },
+    yAxis: {
+      show: axes?.y?.show !== false,
+      labels: axes?.y?.labels === false ? [] : inputs.laneLabels,
+      title: axes?.y?.title ?? spec.encoding.task.title
+    }
+  });
+}
+function chooseLegendFrame(spec, tokens, opts, xLabels, inputs) {
+  if (!inputs.legendPosition || inputs.legendItems.length === 0) return ganttFrame(spec, tokens, opts, xLabels, inputs);
+  const explicit = typeof spec.legend === "object" ? spec.legend.position : void 0;
+  if (explicit) return ganttFrame(spec, tokens, opts, xLabels, inputs, explicit);
+  const order = inputs.legendItems.length > 8 ? ["right", "top"] : ["top", "right"];
+  let best = null;
+  for (const position of order) {
+    const frame = ganttFrame(spec, tokens, opts, xLabels, inputs, position);
+    const complete = frame.legendOverflow === 0 && !frame.dropped.includes("legend");
+    if (complete) return frame;
+    if (!best || hiddenGroups(frame, inputs) < hiddenGroups(best, inputs)) best = frame;
+  }
+  return best;
+}
+function hiddenGroups(frame, inputs) {
+  return frame.dropped.includes("legend") ? inputs.legendItems.length : frame.legendOverflow;
+}
+function placeTasks(tasks, lanes, xScale, plot, barHeight, radius) {
+  const right = plot.x + plot.width;
+  for (const task of tasks) {
+    const lane = lanes[task.lane];
+    const x0 = xScale.map(task.start);
+    if (task.milestone) {
+      task.rect = { x: x0 - radius, y: lane.center - radius, width: radius * 2, height: radius * 2 };
+      continue;
+    }
+    const x1 = xScale.map(task.end);
+    let width = x1 - x0;
+    let x = x0;
+    if (width < MIN_BAR_WIDTH) {
+      width = MIN_BAR_WIDTH;
+      if (x + width > right && x <= right) x = Math.max(plot.x, right - width);
+    }
+    task.rect = { x, y: lane.center - barHeight / 2, width, height: barHeight };
+  }
+}
+function finiteRect(rect) {
+  return isFiniteNumber(rect.x) && isFiniteNumber(rect.y) && isFiniteNumber(rect.width) && isFiniteNumber(rect.height) && isFiniteNumber(rect.x + rect.width) && isFiniteNumber(rect.y + rect.height);
+}
+function ganttLabelSize(tokens, extent) {
+  return extent >= 18 ? tokens.font.size.small : tokens.font.size.tiny;
+}
+function lowerBound(values, value) {
+  let lo = 0;
+  let hi = values.length;
+  while (lo < hi) {
+    const mid = lo + hi >> 1;
+    if (values[mid] < value) lo = mid + 1;
+    else hi = mid;
+  }
+  return lo;
+}
+const NARROW_SPAN = 128;
+class LaneSpans {
+  constructor(tasks, xScale, radius) {
+    __publicField(this, "lefts", []);
+    __publicField(this, "rights", []);
+    __publicField(this, "owners", []);
+    __publicField(this, "reach", 0);
+    __publicField(this, "wide", []);
+    const narrow = [];
+    for (const task of tasks) {
+      const pad = task.milestone ? radius : 0;
+      const left = xScale.map(task.start) - pad;
+      const right = xScale.map(task.end) + pad;
+      if (!isFiniteNumber(left) || !isFiniteNumber(right)) continue;
+      (right - left <= NARROW_SPAN ? narrow : this.wide).push({ left, right, task });
+    }
+    narrow.sort((a, b) => a.left - b.left);
+    for (const span of narrow) {
+      this.lefts.push(span.left);
+      this.rights.push(span.right);
+      this.owners.push(span.task);
+      this.reach = Math.max(this.reach, span.right - span.left);
+    }
+  }
+  /** Whether a mark other than `self` overlaps the open interval (lo, hi). */
+  hits(lo, hi, self) {
+    if (this.wide.some((span) => span.task !== self && span.left < hi && span.right > lo)) return true;
+    for (let i = lowerBound(this.lefts, lo - this.reach); i < this.lefts.length && this.lefts[i] < hi; i++) {
+      if (this.rights[i] > lo && this.owners[i] !== self) return true;
+    }
+    return false;
+  }
+}
+function milestoneLabelRoom(tasks, xScale, plot, radius, laneHeight, tokens, textOf) {
+  const size = ganttLabelSize(tokens, laneHeight);
+  if (laneHeight < size * 1.2 + 1) return 0;
+  const font = fontString(size, tokens.font.family, tokens.font.weight.medium);
+  const right = plot.x + plot.width;
+  const members = /* @__PURE__ */ new Map();
+  for (const task of tasks) {
+    const lane = members.get(task.key);
+    if (lane) lane.push(task);
+    else members.set(task.key, [task]);
+  }
+  const lanes = /* @__PURE__ */ new Map();
+  const spansOf = (key) => {
+    let spans = lanes.get(key);
+    if (!spans) lanes.set(key, spans = new LaneSpans(members.get(key) ?? [], xScale, radius));
+    return spans;
+  };
+  let need = 0;
+  for (const task of tasks) {
+    if (!task.milestone) continue;
+    const x = xScale.map(task.start);
+    const text = textOf(task);
+    if (!isFiniteNumber(x) || !text) continue;
+    const width = measureText(text, font).width;
+    const overflow = x + radius + 4 + width + 2 - right;
+    if (overflow <= need) continue;
+    const leftEdge = x - radius - 4 - width;
+    const leftFree = leftEdge >= plot.x + 1 && !spansOf(task.key).hits(leftEdge - 1, x - radius - 3, task);
+    if (!leftFree) need = overflow;
+  }
+  return need;
+}
+function buildXModel(spec, kind, xScale) {
+  return {
+    kind,
+    field: spec.encoding.start.field,
+    type: kind === "time" ? "temporal" : "quantitative",
+    continuous: xScale,
+    bandwidth: 0,
+    pixel: (value) => {
+      const n = ganttValue(kind, value);
+      if (!isFiniteNumber(n)) return void 0;
+      const px = xScale.map(n);
+      return isFiniteNumber(px) ? px : void 0;
+    }
+  };
+}
+function buildYModel(spec, lanes, area, plot) {
+  const centers = new Map(lanes.map((lane) => [lane.key, lane.center]));
+  const scale = linearScale({ domain: [0, Math.max(1, lanes.length)], range: [area.y, area.y + area.height] });
+  return {
+    field: spec.encoding.task.field,
+    scale,
+    baseline: plot.y + plot.height,
+    // Lanes are keyed by task: a task (string, number or date) lands on its lane center.
+    pixel: (value) => centers.get(toKey(value)) ?? NaN
+  };
+}
+function baseSpec(spec, data) {
+  const axes = spec.axes;
+  return {
+    type: "bar",
+    data,
+    encoding: {
+      x: { field: spec.encoding.start.field },
+      y: { field: spec.encoding.task.field, title: spec.encoding.task.title }
+    },
+    // Lanes carry their own separators; horizontal gridlines at lane centers would strike through bars.
+    axes: { ...axes, x: { ...axes?.x }, y: { ...axes?.y, grid: false } },
+    title: spec.title,
+    padding: spec.padding,
+    legend: spec.legend,
+    tooltip: spec.tooltip,
+    background: spec.background,
+    annotations: spec.annotations
+  };
+}
+function buildGanttModel(spec, tokens, opts) {
+  const data = Array.isArray(spec.data) ? spec.data : [];
+  const sketch = resolveSketch(spec);
+  const kind = ganttScaleKind(spec, data);
+  const { tasks: parsed, skipped: invalid } = parseRows(spec, data, kind);
+  const laneOrder = orderLanes(parsed, spec.sort);
+  const groupInfo = resolveGroups(spec, tokens, parsed, opts.colorSource ?? data);
+  for (const task of parsed) {
+    task.color = groupInfo.grouped ? groupInfo.colorOf(task.groupKey) : task.milestone ? groupInfo.plainMilestone : groupInfo.plain;
+  }
+  const explicit = explicitDomain(spec, kind);
+  const extent = explicit ?? dataExtent(spec, kind, parsed);
+  const legendItems = legendShown(spec, groupInfo.groups.length) ? groupInfo.groups.map((group) => ({ label: group.label, color: group.color, symbol: "square" })) : [];
+  const inputs = {
+    laneLabels: laneOrder.map((lane) => lane.label),
+    legendItems,
+    legendPosition: legendItems.length > 0 ? "top" : null
+  };
+  let count = tickCountFor(spec, Math.max(0, opts.width) * 0.75);
+  let axis = axisTicks(spec, kind, extent, explicit, count);
+  let frame = chooseLegendFrame(spec, tokens, opts, tickLabels(spec, kind, axis.values), inputs);
+  const refined = tickCountFor(spec, frame.plot.width);
+  if (refined !== count) {
+    count = refined;
+    axis = axisTicks(spec, kind, extent, explicit, count);
+    frame = chooseLegendFrame(spec, tokens, opts, tickLabels(spec, kind, axis.values), inputs);
+  }
+  const { domain } = axis;
+  const plot = frame.plot;
+  const laneCount = Math.max(1, laneOrder.length);
+  const strips = annotationStrips(spec, tokens, plot.height);
+  const laneArea = { y: plot.y + strips.top, height: Math.max(0, plot.height - strips.top - strips.bottom) };
+  const laneHeight = laneArea.height / laneCount;
+  const barHeight = laneHeight >= 6 ? Math.min(laneHeight * 0.62, MAX_BAR_HEIGHT) : laneHeight * 0.8;
+  const milestoneRadius = Math.max(2, Math.min(barHeight * 0.62, laneHeight * 0.46, MAX_MILESTONE_RADIUS));
+  const lanes = laneOrder.map((lane, index) => {
+    const top = laneArea.y + index * laneHeight;
+    return { key: lane.key, raw: lane.raw, label: lane.label, index, top, height: laneHeight, center: top + laneHeight / 2, tasks: lane.tasks };
+  });
+  for (const lane of lanes) for (const task of lane.tasks) task.lane = lane.index;
+  const laneAxis = spec.axes?.y?.show !== false && spec.axes?.y?.labels !== false;
+  const showLabels = spec.labels !== false;
+  const inset = Math.min(milestoneRadius + 3, plot.width * 0.08);
+  const scaleWith = (right) => {
+    const range = [plot.x + inset, plot.x + plot.width - right];
+    return kind === "time" ? timeScale({ domain, range }) : linearScale({ domain, range });
+  };
+  let xScale = scaleWith(inset);
+  if (showLabels) {
+    const room = milestoneLabelRoom(
+      parsed,
+      xScale,
+      plot,
+      milestoneRadius,
+      laneHeight,
+      tokens,
+      (task) => ganttLabelText({ laneAxis, kind, spec, extent }, task)
+    );
+    if (room > 0) xScale = scaleWith(Math.min(inset + room, Math.max(inset, plot.width * 0.3)));
+  }
+  placeTasks(parsed, lanes, xScale, plot, barHeight, milestoneRadius);
+  const tasks = parsed.filter((task) => finiteRect(task.rect));
+  const skipped = invalid + (parsed.length - tasks.length);
+  const labels = tickLabels(spec, kind, axis.values);
+  const xTicks = [];
+  axis.values.forEach((value, i) => {
+    const pos = xScale.map(value);
+    if (isFiniteNumber(pos) && pos >= plot.x - 0.5 && pos <= plot.x + plot.width + 0.5) xTicks.push({ value, pos, label: labels[i] });
+  });
+  const yTicks = lanes.map((lane) => ({ value: lane.key, pos: lane.center, label: lane.label }));
+  const shownGroups = frame.legendItems ? groupInfo.groups.slice(0, frame.legendItems.length) : [];
+  const groupRows = /* @__PURE__ */ new Map();
+  for (const task of tasks) {
+    if (task.groupKey === void 0) continue;
+    const list = groupRows.get(task.groupKey);
+    if (list) list.push(task.row);
+    else groupRows.set(task.groupKey, [task.row]);
+  }
+  const series = shownGroups.map((group) => ({
+    key: group.key,
+    label: group.label,
+    color: group.color,
+    value: group.raw,
+    rows: groupRows.get(group.key) ?? []
+  }));
+  const base = {
+    spec: baseSpec(spec, data),
+    tokens,
+    frame,
+    plot,
+    x: buildXModel(spec, kind, xScale),
+    y: buildYModel(spec, lanes, laneArea, plot),
+    series,
+    seriesField: spec.encoding.group?.field,
+    stacked: false,
+    orientation: "vertical",
+    project: (c, v) => ({ x: c, y: v }),
+    xTicks,
+    yTicks,
+    colorOf: (key) => groupInfo.colorOf(key),
+    colorDomain: groupInfo.groups.map((group) => group.key),
+    sketch
+  };
+  return {
+    spec,
+    tokens,
+    frame,
+    plot,
+    kind,
+    tasks,
+    lanes,
+    groups: groupInfo.groups,
+    grouped: groupInfo.grouped,
+    domain,
+    extent,
+    xScale,
+    laneHeight,
+    barHeight,
+    milestoneRadius,
+    cornerRadius: Math.max(0, spec.cornerRadius ?? 3),
+    showLabels,
+    laneAxis,
+    skipped,
+    base,
+    sketch
+  };
+}
+function round1(value) {
+  return Math.round(value * 10) / 10;
+}
+function plural(value, unit) {
+  return `${formatNumber(value, ",")} ${unit}${value === 1 ? "" : "s"}`;
+}
+function isNextCalendarDay(start, end) {
+  const a = new Date(start);
+  const b = new Date(end);
+  if (a.getHours() !== b.getHours() || a.getMinutes() !== b.getMinutes() || a.getSeconds() !== b.getSeconds() || a.getMilliseconds() !== b.getMilliseconds()) return false;
+  const next = new Date(a.getFullYear(), a.getMonth(), a.getDate() + 1);
+  return b.getFullYear() === next.getFullYear() && b.getMonth() === next.getMonth() && b.getDate() === next.getDate();
+}
+function ganttDuration(model, task) {
+  const span = task.end - task.start;
+  if (model.kind === "linear") {
+    const text = formatValue(span, model.spec.encoding.end.format ?? model.spec.encoding.start.format ?? ",");
+    return { short: text, long: text };
+  }
+  if (span < HOUR) {
+    const minutes = round1(span / MINUTE);
+    return { short: `${formatNumber(minutes, ",")}m`, long: `${formatNumber(minutes, ",")} min` };
+  }
+  if (span < DAY) {
+    if (isNextCalendarDay(task.start, task.end)) return { short: "1d", long: plural(1, "day") };
+    const hours = round1(span / HOUR);
+    return { short: `${formatNumber(hours, ",")}h`, long: plural(hours, "hour") };
+  }
+  if (span < YEAR) {
+    const exact = span / DAY;
+    const days = Math.abs(exact - Math.round(exact)) < 0.05 ? Math.round(exact) : round1(exact);
+    return { short: `${formatNumber(days, ",")}d`, long: plural(days, "day") };
+  }
+  const years = round1(span / (365.25 * DAY));
+  return { short: `${formatNumber(years, ",")}y`, long: plural(years, "year") };
+}
+function ganttInstant(model, value, which) {
+  const def = which === "start" ? model.spec.encoding.start : model.spec.encoding.end;
+  const format = def.format ?? (which === "end" ? model.spec.encoding.start.format : void 0);
+  if (model.kind === "linear") return format ? formatValue(value, format) : formatNumber(value, ",");
+  return format ? formatValue(value, format) : prettyDate(value);
+}
+function ganttShortInstant(model, value) {
+  const format = model.spec.encoding.start.format;
+  if (model.kind === "linear") return format ? formatValue(value, format) : formatNumber(value, ",");
+  if (format) return formatValue(value, format);
+  const date = new Date(value);
+  const [lo, hi] = model.extent;
+  const span = hi - lo;
+  const midnight = date.getHours() === 0 && date.getMinutes() === 0;
+  if (!midnight && span <= 2 * DAY) return formatDate(date, "%H:%M");
+  const crossesYears = span > 31 * DAY && new Date(lo).getFullYear() !== new Date(hi).getFullYear();
+  const day = crossesYears ? "%b %e, %Y" : "%b %e";
+  return midnight ? formatDate(date, day) : formatDate(date, `${day} %H:%M`);
+}
+function ganttLabelText(model, task) {
+  if (!model.laneAxis) return task.label;
+  if (task.milestone) return ganttShortInstant(model, task.start);
+  if (task.progress !== void 0) return `${Math.round(task.progress * 100)}%`;
+  return ganttDuration(model, task).short;
+}
+export {
+  buildGanttModel,
+  ganttDuration,
+  ganttInstant,
+  ganttLabelSize,
+  ganttLabelText,
+  ganttScaleKind,
+  ganttShortInstant,
+  ganttTimeTickLabels,
+  ganttValue,
+  lowerBound
+};
+//# sourceMappingURL=gantt.js.map