@affino/datagrid-gantt 0.1.1

package/dist/runtime.js

@@ -0,0 +1,784 @@
+import { addDataGridWorkingDays, resolveDataGridWorkingCalendar, snapDataGridDateToWorkingDay, startOfUtcDay, startOfUtcWeek, } from "./calendar.js";
+import { DAY_MS, clampDataGridTimelineScrollLeft, resolveDataGridTimelineDateToPixel, resolveDataGridTimelineRange, resolveDataGridTimelineScrollLeftForDate, } from "./timeline.js";
+const DEFAULT_GANTT_OPTIONS = {
+    startKey: "start",
+    endKey: "end",
+    baselineStartKey: null,
+    baselineEndKey: null,
+    progressKey: "progress",
+    dependencyKey: "dependencies",
+    labelKey: "task",
+    idKey: "id",
+    criticalKey: null,
+    computedCriticalPath: false,
+    paneWidth: 520,
+    pixelsPerDay: 24,
+    zoomLevel: "day",
+    timelineStart: null,
+    timelineEnd: null,
+    rangePaddingDays: 0,
+    workingCalendar: resolveDataGridWorkingCalendar(null),
+    rowBarHeight: 18,
+    minBarWidth: 6,
+    resizeHandleWidth: 8,
+};
+const PIXELS_PER_DAY_BY_ZOOM = {
+    day: 24,
+    week: 8,
+    month: 3,
+};
+function normalizeNumericOption(value, fallback, min) {
+    if (!Number.isFinite(value)) {
+        return fallback;
+    }
+    return Math.max(min, Number(value));
+}
+function readRowCell(row, key) {
+    if (!row || !key) {
+        return undefined;
+    }
+    const record = row.row;
+    return record[key];
+}
+function resolveTaskId(row, options) {
+    const explicit = readRowCell(row, options.idKey);
+    if (explicit != null && String(explicit).trim().length > 0) {
+        return String(explicit).trim();
+    }
+    if (row.rowId != null) {
+        return String(row.rowId);
+    }
+    return "";
+}
+function resolveLabel(row, options) {
+    var _a;
+    const explicit = readRowCell(row, options.labelKey);
+    if (explicit != null && String(explicit).trim().length > 0) {
+        return String(explicit);
+    }
+    if (row.kind === "group") {
+        const groupValue = (_a = row.groupMeta) === null || _a === void 0 ? void 0 : _a.groupValue;
+        if (groupValue != null && String(groupValue).trim().length > 0) {
+            return String(groupValue);
+        }
+    }
+    return resolveTaskId(row, options);
+}
+function createResolvedGanttRowSnapshotReader(options) {
+    const cache = new WeakMap();
+    return row => {
+        const cached = cache.get(row);
+        if (cached) {
+            return cached;
+        }
+        const snapshot = {
+            startMs: resolveDataGridGanttDateMs(readRowCell(row, options.startKey)),
+            endMs: resolveDataGridGanttDateMs(readRowCell(row, options.endKey)),
+            baselineStartMs: resolveDataGridGanttDateMs(readRowCell(row, options.baselineStartKey)),
+            baselineEndMs: resolveDataGridGanttDateMs(readRowCell(row, options.baselineEndKey)),
+            progress: resolveDataGridGanttProgress(readRowCell(row, options.progressKey)),
+            dependencies: resolveDataGridGanttDependencies(readRowCell(row, options.dependencyKey)),
+            dependencyRefs: resolveDataGridGanttDependencyRefs(readRowCell(row, options.dependencyKey)),
+            critical: Boolean(options.criticalKey
+                && readRowCell(row, options.criticalKey)),
+            taskId: resolveTaskId(row, options),
+            label: resolveLabel(row, options),
+        };
+        cache.set(row, snapshot);
+        return snapshot;
+    };
+}
+export function resolveDataGridGanttDateMs(value) {
+    if (value instanceof Date) {
+        const ms = value.getTime();
+        return Number.isFinite(ms) ? ms : null;
+    }
+    if (typeof value === "number") {
+        return Number.isFinite(value) ? value : null;
+    }
+    if (typeof value === "string" && value.trim().length > 0) {
+        const ms = Date.parse(value);
+        return Number.isFinite(ms) ? ms : null;
+    }
+    return null;
+}
+export function resolveDataGridGanttProgress(value) {
+    const numeric = typeof value === "number"
+        ? value
+        : (typeof value === "string" && value.trim().length > 0 ? Number(value) : NaN);
+    if (!Number.isFinite(numeric)) {
+        return 0;
+    }
+    const normalized = numeric > 1 ? numeric / 100 : numeric;
+    return Math.min(1, Math.max(0, normalized));
+}
+export function resolveDataGridGanttSnapDays(zoomLevel) {
+    return zoomLevel === "week" || zoomLevel === "month" ? 7 : 1;
+}
+export function snapDataGridGanttDateMs(dateMs, zoomLevel, workingCalendar) {
+    if (!Number.isFinite(dateMs)) {
+        return dateMs;
+    }
+    if (resolveDataGridGanttSnapDays(zoomLevel) === 7) {
+        return startOfUtcWeek(dateMs);
+    }
+    return workingCalendar
+        ? snapDataGridDateToWorkingDay(dateMs, workingCalendar)
+        : startOfUtcDay(dateMs);
+}
+export function snapDataGridGanttDayDelta(dayDelta, zoomLevel) {
+    if (!Number.isFinite(dayDelta) || dayDelta === 0) {
+        return 0;
+    }
+    const snapDays = resolveDataGridGanttSnapDays(zoomLevel);
+    if (snapDays === 1) {
+        return Math.round(dayDelta);
+    }
+    return Math.round(dayDelta / snapDays) * snapDays;
+}
+export function resolveDataGridGanttDependencies(value) {
+    if (Array.isArray(value)) {
+        return value
+            .map(entry => String(entry !== null && entry !== void 0 ? entry : "").trim())
+            .filter(entry => entry.length > 0);
+    }
+    if (typeof value === "string") {
+        return value
+            .split(",")
+            .map(entry => entry.trim())
+            .filter(entry => entry.length > 0);
+    }
+    return [];
+}
+function resolveDataGridGanttDependencyType(value) {
+    const normalized = value.trim().toUpperCase();
+    return normalized === "FS" || normalized === "SS" || normalized === "FF" || normalized === "SF"
+        ? normalized
+        : null;
+}
+function parseDataGridGanttDependencyRef(token) {
+    var _a, _b, _c, _d, _e, _f;
+    const trimmed = token.trim();
+    if (trimmed.length === 0) {
+        return null;
+    }
+    const delimitedMatch = trimmed.match(/^(.+?)(?::|->|\s+)(FS|SS|FF|SF)$/i);
+    if (delimitedMatch) {
+        const taskId = (_b = (_a = delimitedMatch[1]) === null || _a === void 0 ? void 0 : _a.trim()) !== null && _b !== void 0 ? _b : "";
+        const type = resolveDataGridGanttDependencyType((_c = delimitedMatch[2]) !== null && _c !== void 0 ? _c : "");
+        if (taskId.length > 0 && type) {
+            return {
+                taskId,
+                type,
+                raw: trimmed,
+            };
+        }
+    }
+    const compactNumericMatch = trimmed.match(/^(\d+)(FS|SS|FF|SF)$/i);
+    if (compactNumericMatch) {
+        const taskId = (_e = (_d = compactNumericMatch[1]) === null || _d === void 0 ? void 0 : _d.trim()) !== null && _e !== void 0 ? _e : "";
+        const type = resolveDataGridGanttDependencyType((_f = compactNumericMatch[2]) !== null && _f !== void 0 ? _f : "");
+        if (taskId.length > 0 && type) {
+            return {
+                taskId,
+                type,
+                raw: trimmed,
+            };
+        }
+    }
+    return {
+        taskId: trimmed,
+        type: "FS",
+        raw: trimmed,
+    };
+}
+export function resolveDataGridGanttDependencyRefs(value) {
+    return resolveDataGridGanttDependencies(value)
+        .map(parseDataGridGanttDependencyRef)
+        .filter((dependencyRef) => dependencyRef !== null);
+}
+export function normalizeDataGridGanttOptions(input) {
+    var _a, _b;
+    if (input == null || input === false) {
+        return null;
+    }
+    if (input === true) {
+        return { ...DEFAULT_GANTT_OPTIONS };
+    }
+    const zoomLevel = input.zoomLevel === "week" || input.zoomLevel === "month"
+        ? input.zoomLevel
+        : "day";
+    return {
+        startKey: typeof input.startKey === "string" && input.startKey.length > 0
+            ? input.startKey
+            : DEFAULT_GANTT_OPTIONS.startKey,
+        endKey: typeof input.endKey === "string" && input.endKey.length > 0
+            ? input.endKey
+            : DEFAULT_GANTT_OPTIONS.endKey,
+        baselineStartKey: typeof input.baselineStartKey === "string" && input.baselineStartKey.length > 0
+            ? input.baselineStartKey
+            : DEFAULT_GANTT_OPTIONS.baselineStartKey,
+        baselineEndKey: typeof input.baselineEndKey === "string" && input.baselineEndKey.length > 0
+            ? input.baselineEndKey
+            : DEFAULT_GANTT_OPTIONS.baselineEndKey,
+        progressKey: typeof input.progressKey === "string" && input.progressKey.length > 0
+            ? input.progressKey
+            : DEFAULT_GANTT_OPTIONS.progressKey,
+        dependencyKey: typeof input.dependencyKey === "string" && input.dependencyKey.length > 0
+            ? input.dependencyKey
+            : DEFAULT_GANTT_OPTIONS.dependencyKey,
+        labelKey: typeof input.labelKey === "string" && input.labelKey.length > 0
+            ? input.labelKey
+            : DEFAULT_GANTT_OPTIONS.labelKey,
+        idKey: typeof input.idKey === "string" && input.idKey.length > 0
+            ? input.idKey
+            : DEFAULT_GANTT_OPTIONS.idKey,
+        criticalKey: typeof input.criticalKey === "string" && input.criticalKey.length > 0
+            ? input.criticalKey
+            : DEFAULT_GANTT_OPTIONS.criticalKey,
+        computedCriticalPath: input.computedCriticalPath === true,
+        paneWidth: normalizeNumericOption(input.paneWidth, DEFAULT_GANTT_OPTIONS.paneWidth, 280),
+        pixelsPerDay: normalizeNumericOption(input.pixelsPerDay, PIXELS_PER_DAY_BY_ZOOM[zoomLevel], 1),
+        zoomLevel,
+        timelineStart: (_a = input.timelineStart) !== null && _a !== void 0 ? _a : null,
+        timelineEnd: (_b = input.timelineEnd) !== null && _b !== void 0 ? _b : null,
+        rangePaddingDays: normalizeNumericOption(input.rangePaddingDays, DEFAULT_GANTT_OPTIONS.rangePaddingDays, 0),
+        workingCalendar: resolveDataGridWorkingCalendar(input.workingCalendar),
+        rowBarHeight: normalizeNumericOption(input.rowBarHeight, DEFAULT_GANTT_OPTIONS.rowBarHeight, 6),
+        minBarWidth: normalizeNumericOption(input.minBarWidth, DEFAULT_GANTT_OPTIONS.minBarWidth, 1),
+        resizeHandleWidth: normalizeNumericOption(input.resizeHandleWidth, DEFAULT_GANTT_OPTIONS.resizeHandleWidth, 2),
+    };
+}
+export function resolveDataGridGanttTimelineState(rows, options) {
+    return resolveDataGridGanttAnalysis(rows, options).timeline;
+}
+function resolveDataGridGanttCriticalTaskIdsFromTaskNodes(taskNodes, taskIdByRowId) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    const successorIdsByTaskId = new Map();
+    const predecessorIdsByTaskId = new Map();
+    const indegreeByTaskId = new Map();
+    for (const taskId of taskNodes.keys()) {
+        successorIdsByTaskId.set(taskId, []);
+        predecessorIdsByTaskId.set(taskId, []);
+        indegreeByTaskId.set(taskId, 0);
+    }
+    for (const node of taskNodes.values()) {
+        const predecessors = predecessorIdsByTaskId.get(node.taskId);
+        const uniquePredecessors = new Set();
+        for (const dependency of node.dependencyRefs) {
+            if (dependency.type !== "FS") {
+                continue;
+            }
+            const dependencyId = dependency.taskId;
+            const predecessorTaskId = taskNodes.has(dependencyId)
+                ? dependencyId
+                : ((_a = taskIdByRowId.get(dependencyId)) !== null && _a !== void 0 ? _a : null);
+            if (!predecessorTaskId || predecessorTaskId === node.taskId || uniquePredecessors.has(predecessorTaskId)) {
+                continue;
+            }
+            uniquePredecessors.add(predecessorTaskId);
+            predecessors === null || predecessors === void 0 ? void 0 : predecessors.push(predecessorTaskId);
+            (_b = successorIdsByTaskId.get(predecessorTaskId)) === null || _b === void 0 ? void 0 : _b.push(node.taskId);
+            indegreeByTaskId.set(node.taskId, ((_c = indegreeByTaskId.get(node.taskId)) !== null && _c !== void 0 ? _c : 0) + 1);
+        }
+    }
+    const queue = Array.from(taskNodes.keys()).filter(taskId => { var _a; return ((_a = indegreeByTaskId.get(taskId)) !== null && _a !== void 0 ? _a : 0) === 0; });
+    const topologicalOrder = [];
+    for (let index = 0; index < queue.length; index += 1) {
+        const taskId = queue[index];
+        if (!taskId) {
+            continue;
+        }
+        topologicalOrder.push(taskId);
+        for (const successorTaskId of (_d = successorIdsByTaskId.get(taskId)) !== null && _d !== void 0 ? _d : []) {
+            const nextIndegree = ((_e = indegreeByTaskId.get(successorTaskId)) !== null && _e !== void 0 ? _e : 0) - 1;
+            indegreeByTaskId.set(successorTaskId, nextIndegree);
+            if (nextIndegree === 0) {
+                queue.push(successorTaskId);
+            }
+        }
+    }
+    if (topologicalOrder.length !== taskNodes.size) {
+        return new Set();
+    }
+    const earliestStartByTaskId = new Map();
+    const earliestFinishByTaskId = new Map();
+    let projectEndMs = Number.NEGATIVE_INFINITY;
+    for (const taskId of topologicalOrder) {
+        const node = taskNodes.get(taskId);
+        if (!node) {
+            continue;
+        }
+        const durationMs = Math.max(0, node.endMs - node.startMs);
+        const predecessorFinishMs = ((_f = predecessorIdsByTaskId.get(taskId)) !== null && _f !== void 0 ? _f : []).reduce((maxFinish, predecessorTaskId) => {
+            var _a;
+            return Math.max(maxFinish, (_a = earliestFinishByTaskId.get(predecessorTaskId)) !== null && _a !== void 0 ? _a : Number.NEGATIVE_INFINITY);
+        }, Number.NEGATIVE_INFINITY);
+        const earliestStartMs = Math.max(node.startMs, Number.isFinite(predecessorFinishMs) ? predecessorFinishMs : node.startMs);
+        const earliestFinishMs = earliestStartMs + durationMs;
+        earliestStartByTaskId.set(taskId, earliestStartMs);
+        earliestFinishByTaskId.set(taskId, earliestFinishMs);
+        projectEndMs = Math.max(projectEndMs, earliestFinishMs, node.endMs);
+    }
+    if (!Number.isFinite(projectEndMs)) {
+        return new Set();
+    }
+    const latestStartByTaskId = new Map();
+    for (let index = topologicalOrder.length - 1; index >= 0; index -= 1) {
+        const taskId = topologicalOrder[index];
+        const node = taskNodes.get(taskId);
+        if (!node) {
+            continue;
+        }
+        const durationMs = Math.max(0, node.endMs - node.startMs);
+        const successorStartMs = ((_g = successorIdsByTaskId.get(taskId)) !== null && _g !== void 0 ? _g : []).reduce((minStart, successorTaskId) => {
+            var _a;
+            return Math.min(minStart, (_a = latestStartByTaskId.get(successorTaskId)) !== null && _a !== void 0 ? _a : Number.POSITIVE_INFINITY);
+        }, Number.POSITIVE_INFINITY);
+        const latestFinishMs = Number.isFinite(successorStartMs) ? successorStartMs : projectEndMs;
+        latestStartByTaskId.set(taskId, latestFinishMs - durationMs);
+    }
+    const criticalTaskIds = new Set();
+    const slackEpsilonMs = 60 * 1000;
+    for (const taskId of topologicalOrder) {
+        const earliestStartMs = earliestStartByTaskId.get(taskId);
+        const latestStartMs = latestStartByTaskId.get(taskId);
+        if (earliestStartMs == null || latestStartMs == null) {
+            continue;
+        }
+        if (Math.abs(latestStartMs - earliestStartMs) <= slackEpsilonMs) {
+            criticalTaskIds.add(taskId);
+        }
+    }
+    return criticalTaskIds;
+}
+function resolveDataGridGanttAnalysisInternal(rows, options, computeCriticalPath) {
+    const readResolvedRow = createResolvedGanttRowSnapshotReader(options);
+    const explicitStartMs = resolveDataGridGanttDateMs(options.timelineStart);
+    const explicitEndMs = resolveDataGridGanttDateMs(options.timelineEnd);
+    let minMs = explicitStartMs;
+    let maxMs = explicitEndMs;
+    const taskNodes = new Map();
+    const taskIdByRowId = new Map();
+    if (explicitStartMs == null || explicitEndMs == null || computeCriticalPath) {
+        const count = rows.getCount();
+        for (let index = 0; index < count; index += 1) {
+            const row = rows.get(index);
+            if (!row) {
+                continue;
+            }
+            const resolvedRow = readResolvedRow(row);
+            const startMs = resolvedRow.startMs;
+            const endMs = resolvedRow.endMs;
+            if (startMs == null && endMs == null) {
+                continue;
+            }
+            const boundedStart = startMs !== null && startMs !== void 0 ? startMs : endMs;
+            const boundedEnd = endMs !== null && endMs !== void 0 ? endMs : startMs;
+            if (boundedStart == null || boundedEnd == null) {
+                continue;
+            }
+            if (explicitStartMs == null) {
+                minMs = minMs == null ? boundedStart : Math.min(minMs, boundedStart);
+            }
+            if (explicitEndMs == null) {
+                maxMs = maxMs == null ? boundedEnd : Math.max(maxMs, boundedEnd);
+            }
+            if (computeCriticalPath) {
+                if (row.kind === "group" || boundedEnd < boundedStart) {
+                    continue;
+                }
+                const taskId = resolvedRow.taskId || (row.rowId == null ? String(index) : String(row.rowId));
+                const rowId = row.rowId == null ? String(index) : String(row.rowId);
+                taskNodes.set(taskId, {
+                    taskId,
+                    rowId,
+                    startMs: boundedStart,
+                    endMs: boundedEnd,
+                    dependencyRefs: resolvedRow.dependencyRefs,
+                });
+                taskIdByRowId.set(rowId, taskId);
+            }
+        }
+    }
+    const range = resolveDataGridTimelineRange({
+        minTaskDateMs: minMs,
+        maxTaskDateMs: maxMs,
+        pixelsPerDay: options.pixelsPerDay,
+        rangePaddingDays: options.rangePaddingDays,
+    });
+    return {
+        timeline: {
+            startMs: range.startMs,
+            endMs: range.endMs,
+            pixelsPerDay: options.pixelsPerDay,
+            totalWidth: range.totalWidth,
+            zoomLevel: options.zoomLevel,
+        },
+        criticalTaskIds: computeCriticalPath
+            ? resolveDataGridGanttCriticalTaskIdsFromTaskNodes(taskNodes, taskIdByRowId)
+            : new Set(),
+    };
+}
+export function resolveDataGridGanttAnalysis(rows, options) {
+    return resolveDataGridGanttAnalysisInternal(rows, options, options.computedCriticalPath === true);
+}
+export function resolveDataGridGanttRangeFrame(range, timeline, minBarWidth, milestoneWidth) {
+    if (range.endMs <= range.startMs) {
+        const width = Math.max(minBarWidth, milestoneWidth !== null && milestoneWidth !== void 0 ? milestoneWidth : minBarWidth);
+        return {
+            x: resolveDataGridTimelineDateToPixel(range.startMs, timeline) - (width / 2),
+            width,
+        };
+    }
+    return {
+        x: resolveDataGridTimelineDateToPixel(range.startMs, timeline),
+        width: Math.max(minBarWidth, resolveDataGridTimelineDateToPixel(range.endMs, timeline)
+            - resolveDataGridTimelineDateToPixel(range.startMs, timeline)),
+    };
+}
+export function resolveDataGridGanttDateOffset(dateMs, timeline) {
+    return resolveDataGridTimelineDateToPixel(dateMs, timeline);
+}
+export function clampDataGridGanttScrollLeft(scrollLeft, totalWidth, viewportWidth) {
+    return clampDataGridTimelineScrollLeft(scrollLeft, totalWidth, viewportWidth);
+}
+export function resolveDataGridGanttScrollLeftForDate(input) {
+    return resolveDataGridTimelineScrollLeftForDate({
+        dateMs: input.dateMs,
+        timeline: input.timeline,
+        viewportWidth: input.viewportWidth,
+        align: input.align,
+    });
+}
+export function buildDataGridGanttVisibleBars(input) {
+    var _a, _b, _c, _d, _e, _f;
+    const readResolvedRow = createResolvedGanttRowSnapshotReader(input.options);
+    const bars = [];
+    const rowContexts = [];
+    let currentY = input.topSpacerHeight;
+    const rowBarHeight = input.options.rowBarHeight;
+    input.rows.forEach((row, rowOffset) => {
+        var _a, _b, _c;
+        const rowIndex = input.viewportRowStart + rowOffset;
+        const metric = (_a = input.rowMetrics) === null || _a === void 0 ? void 0 : _a[rowOffset];
+        const rowHeight = Math.max(1, (_b = metric === null || metric === void 0 ? void 0 : metric.height) !== null && _b !== void 0 ? _b : (input.resolveRowHeight(rowIndex) || input.baseRowHeight));
+        const rowTop = (_c = metric === null || metric === void 0 ? void 0 : metric.top) !== null && _c !== void 0 ? _c : currentY;
+        rowContexts.push({
+            row,
+            rowIndex,
+            rowId: row.rowId == null ? String(rowIndex) : String(row.rowId),
+            rowUpdateId: row.rowId == null ? rowIndex : row.rowId,
+            rowHeight,
+            y: (rowTop - input.scrollTop) + Math.max(0, (rowHeight - rowBarHeight) / 2),
+            resolvedRow: readResolvedRow(row),
+        });
+        currentY = rowTop + rowHeight;
+    });
+    const summaryRangesByRowId = new Map();
+    const activeGroups = [];
+    function absorbRangeIntoActiveGroups(startMs, endMs) {
+        for (const group of activeGroups) {
+            group.startMs = group.startMs == null ? startMs : Math.min(group.startMs, startMs);
+            group.endMs = group.endMs == null ? endMs : Math.max(group.endMs, endMs);
+        }
+    }
+    function closeGroupsAtLevel(level) {
+        while (activeGroups.length > 0) {
+            const current = activeGroups[activeGroups.length - 1];
+            if (!current || current.level < level) {
+                break;
+            }
+            activeGroups.pop();
+            if (current.startMs != null && current.endMs != null && current.endMs >= current.startMs) {
+                summaryRangesByRowId.set(current.rowId, {
+                    startMs: current.startMs,
+                    endMs: current.endMs,
+                });
+            }
+        }
+    }
+    for (const context of rowContexts) {
+        if (context.row.kind === "group") {
+            const level = Math.max(0, Math.trunc((_b = (_a = context.row.groupMeta) === null || _a === void 0 ? void 0 : _a.level) !== null && _b !== void 0 ? _b : 0));
+            closeGroupsAtLevel(level);
+            activeGroups.push({
+                rowId: context.rowId,
+                level,
+                startMs: null,
+                endMs: null,
+            });
+            const ownStartMs = context.resolvedRow.startMs;
+            const ownEndMs = context.resolvedRow.endMs;
+            if (ownStartMs != null && ownEndMs != null && ownEndMs >= ownStartMs) {
+                absorbRangeIntoActiveGroups(ownStartMs, ownEndMs);
+            }
+            continue;
+        }
+        const startMs = context.resolvedRow.startMs;
+        const endMs = context.resolvedRow.endMs;
+        if (startMs != null && endMs != null && endMs >= startMs) {
+            absorbRangeIntoActiveGroups(startMs, endMs);
+        }
+    }
+    closeGroupsAtLevel(0);
+    for (const context of rowContexts) {
+        const ownStartMs = context.resolvedRow.startMs;
+        const ownEndMs = context.resolvedRow.endMs;
+        const ownBaselineStartMs = context.resolvedRow.baselineStartMs;
+        const ownBaselineEndMs = context.resolvedRow.baselineEndMs;
+        const summaryRange = context.row.kind === "group"
+            ? summaryRangesByRowId.get(context.rowId)
+            : null;
+        const startMs = (_c = summaryRange === null || summaryRange === void 0 ? void 0 : summaryRange.startMs) !== null && _c !== void 0 ? _c : ownStartMs;
+        const endMs = (_d = summaryRange === null || summaryRange === void 0 ? void 0 : summaryRange.endMs) !== null && _d !== void 0 ? _d : ownEndMs;
+        if (startMs == null || endMs == null || endMs < startMs) {
+            continue;
+        }
+        const summary = context.row.kind === "group" && summaryRange != null;
+        const computedCritical = (_f = (_e = input.criticalTaskIds) === null || _e === void 0 ? void 0 : _e.has(context.resolvedRow.taskId || context.rowId)) !== null && _f !== void 0 ? _f : false;
+        const height = rowBarHeight;
+        const y = context.y;
+        if (y + height < 0 || y > input.viewportHeight) {
+            continue;
+        }
+        const milestone = !summary && endMs === startMs;
+        const frame = resolveDataGridGanttRangeFrame({ startMs, endMs }, input.timeline, input.options.minBarWidth, milestone ? height : undefined);
+        bars.push({
+            row: context.row,
+            rowId: context.rowId,
+            rowUpdateId: context.rowUpdateId,
+            taskId: context.resolvedRow.taskId || context.rowId,
+            rowIndex: context.rowIndex,
+            label: context.resolvedRow.label,
+            dependencies: summary ? [] : context.resolvedRow.dependencies,
+            dependencyRefs: summary ? [] : context.resolvedRow.dependencyRefs,
+            critical: summary ? false : (context.resolvedRow.critical || computedCritical),
+            criticalSource: summary
+                ? null
+                : (context.resolvedRow.critical ? "manual" : (computedCritical ? "computed" : null)),
+            milestone,
+            summary,
+            progress: summary ? 0 : context.resolvedRow.progress,
+            startMs,
+            endMs,
+            baselineStartMs: summary || ownBaselineStartMs == null || ownBaselineEndMs == null || ownBaselineEndMs < ownBaselineStartMs
+                ? null
+                : ownBaselineStartMs,
+            baselineEndMs: summary || ownBaselineStartMs == null || ownBaselineEndMs == null || ownBaselineEndMs < ownBaselineStartMs
+                ? null
+                : ownBaselineEndMs,
+            x: frame.x,
+            width: frame.width,
+            y,
+            height,
+        });
+    }
+    return bars;
+}
+export function resolveDataGridGanttCriticalTaskIds(rows, options) {
+    return resolveDataGridGanttAnalysisInternal(rows, options, true).criticalTaskIds;
+}
+export function buildDataGridGanttDependencyPaths(input) {
+    var _a, _b;
+    const barsByTaskId = new Map();
+    const barsByRowId = new Map();
+    for (const bar of input.bars) {
+        const taskId = bar.taskId.trim();
+        const rowId = bar.rowId.trim();
+        if (taskId.length > 0) {
+            barsByTaskId.set(taskId, bar);
+        }
+        if (rowId.length > 0) {
+            barsByRowId.set(rowId, bar);
+        }
+    }
+    const paths = [];
+    const resolveFrame = (_a = input.resolveFrame) !== null && _a !== void 0 ? _a : (bar => bar);
+    const minBendPx = Math.max(0, (_b = input.minBendPx) !== null && _b !== void 0 ? _b : 12);
+    const portStubPx = Math.max(4, Math.min(8, Math.round(minBendPx / 2)));
+    const compactGapThresholdPx = (portStubPx * 2) + minBendPx;
+    function resolveAnchorX(frame, side) {
+        return side === "start" ? frame.x : frame.x + frame.width;
+    }
+    function resolveLeadX(anchorX, side) {
+        return side === "start" ? anchorX - portStubPx : anchorX + portStubPx;
+    }
+    for (const targetBar of input.bars) {
+        const targetFrame = resolveFrame(targetBar);
+        targetBar.dependencyRefs.forEach((dependency, dependencyIndex) => {
+            var _a;
+            const dependencyTaskId = dependency.taskId;
+            const sourceBar = (_a = barsByTaskId.get(dependencyTaskId)) !== null && _a !== void 0 ? _a : barsByRowId.get(dependencyTaskId);
+            if (!sourceBar) {
+                return;
+            }
+            const sourceFrame = resolveFrame(sourceBar);
+            const sourceSide = dependency.type === "SS" || dependency.type === "SF" ? "start" : "end";
+            const targetSide = dependency.type === "FS" || dependency.type === "SS" ? "start" : "end";
+            const sourceX = resolveAnchorX(sourceFrame, sourceSide);
+            const targetX = resolveAnchorX(targetFrame, targetSide);
+            const sourceY = sourceFrame.y + (sourceFrame.height / 2);
+            const targetY = targetFrame.y + (targetFrame.height / 2);
+            const laneOffsetPx = minBendPx + ((dependencyIndex % 4) * 8);
+            const sourceLeadX = resolveLeadX(sourceX, sourceSide);
+            const targetApproachX = resolveLeadX(targetX, targetSide);
+            const points = (() => {
+                if (sourceSide === targetSide) {
+                    const laneX = sourceSide === "start"
+                        ? Math.min(sourceLeadX, targetApproachX) - laneOffsetPx
+                        : Math.max(sourceLeadX, targetApproachX) + laneOffsetPx;
+                    return [
+                        { x: sourceX, y: sourceY },
+                        { x: sourceLeadX, y: sourceY },
+                        { x: laneX, y: sourceY },
+                        { x: laneX, y: targetY },
+                        { x: targetApproachX, y: targetY },
+                        { x: targetX, y: targetY },
+                    ];
+                }
+                if (sourceSide === "end" && targetSide === "start" && targetX >= sourceX) {
+                    const gapPx = targetX - sourceX;
+                    const laneX = gapPx <= compactGapThresholdPx
+                        ? sourceLeadX
+                        : Math.max(sourceLeadX, sourceX + Math.max(laneOffsetPx, (targetApproachX - sourceX) / 2));
+                    return [
+                        { x: sourceX, y: sourceY },
+                        { x: sourceLeadX, y: sourceY },
+                        { x: laneX, y: sourceY },
+                        { x: laneX, y: targetY },
+                        { x: targetApproachX, y: targetY },
+                        { x: targetX, y: targetY },
+                    ];
+                }
+                const detourX = sourceSide === "end"
+                    ? Math.max(sourceFrame.x + sourceFrame.width, targetFrame.x + targetFrame.width) + laneOffsetPx
+                    : Math.min(sourceFrame.x, targetFrame.x) - laneOffsetPx;
+                const laneY = sourceY + ((targetY - sourceY) / 2);
+                return [
+                    { x: sourceX, y: sourceY },
+                    { x: sourceLeadX, y: sourceY },
+                    { x: detourX, y: sourceY },
+                    { x: detourX, y: laneY },
+                    { x: targetApproachX, y: laneY },
+                    { x: targetApproachX, y: targetY },
+                    { x: targetX, y: targetY },
+                ];
+            })();
+            paths.push({
+                dependencyTaskId,
+                dependencyType: dependency.type,
+                sourceBar,
+                targetBar,
+                points,
+            });
+        });
+    }
+    return paths;
+}
+export function hitTestDataGridGanttBar(bars, point, resizeHandleWidth) {
+    for (let index = bars.length - 1; index >= 0; index -= 1) {
+        const bar = bars[index];
+        if (!bar) {
+            continue;
+        }
+        if (point.x < bar.x
+            || point.x > bar.x + bar.width
+            || point.y < bar.y
+            || point.y > bar.y + bar.height) {
+            continue;
+        }
+        if (bar.summary) {
+            continue;
+        }
+        if (bar.milestone) {
+            return { bar, mode: "move" };
+        }
+        const distanceToStart = point.x - bar.x;
+        const distanceToEnd = (bar.x + bar.width) - point.x;
+        if (distanceToStart <= resizeHandleWidth) {
+            return { bar, mode: "resize-start" };
+        }
+        if (distanceToEnd <= resizeHandleWidth) {
+            return { bar, mode: "resize-end" };
+        }
+        return { bar, mode: "move" };
+    }
+    return null;
+}
+export function applyDataGridGanttDragDelta(range, mode, dayDelta, zoomLevel = "day", workingCalendar) {
+    const snappedDayDelta = snapDataGridGanttDayDelta(dayDelta, zoomLevel);
+    if (!Number.isFinite(snappedDayDelta) || snappedDayDelta === 0) {
+        return range;
+    }
+    if (workingCalendar && resolveDataGridGanttSnapDays(zoomLevel) === 1) {
+        if (mode === "move") {
+            return {
+                startMs: addDataGridWorkingDays(range.startMs, snappedDayDelta, workingCalendar),
+                endMs: addDataGridWorkingDays(range.endMs, snappedDayDelta, workingCalendar),
+            };
+        }
+        if (mode === "resize-start") {
+            const startMs = addDataGridWorkingDays(range.startMs, snappedDayDelta, workingCalendar);
+            return {
+                startMs: Math.min(startMs, addDataGridWorkingDays(range.endMs, -1, workingCalendar)),
+                endMs: range.endMs,
+            };
+        }
+        const endMs = addDataGridWorkingDays(range.endMs, snappedDayDelta, workingCalendar);
+        return {
+            startMs: range.startMs,
+            endMs: Math.max(addDataGridWorkingDays(range.startMs, 1, workingCalendar), endMs),
+        };
+    }
+    const deltaMs = snappedDayDelta * DAY_MS;
+    if (mode === "move") {
+        const durationMs = Math.max(0, range.endMs - range.startMs);
+        const startMs = snapDataGridGanttDateMs(range.startMs + deltaMs, zoomLevel, workingCalendar);
+        return {
+            startMs,
+            endMs: startMs + durationMs,
+        };
+    }
+    if (mode === "resize-start") {
+        const startMs = snapDataGridGanttDateMs(range.startMs + deltaMs, zoomLevel, workingCalendar);
+        return {
+            startMs: Math.min(startMs, range.endMs - DAY_MS),
+            endMs: range.endMs,
+        };
+    }
+    const endMs = snapDataGridGanttDateMs(range.endMs + deltaMs, zoomLevel, workingCalendar);
+    return {
+        startMs: range.startMs,
+        endMs: Math.max(range.startMs + DAY_MS, endMs),
+    };
+}
+export function buildDataGridGanttRowEditPatch(rowId, range, options) {
+    return {
+        rowId,
+        data: {
+            [options.startKey]: new Date(range.startMs),
+            [options.endKey]: new Date(range.endMs),
+        },
+    };
+}
+export function formatDataGridGanttDayLabel(dayMs, zoomLevel) {
+    const date = new Date(dayMs);
+    if (zoomLevel === "month") {
+        return date.toLocaleDateString(undefined, {
+            month: "short",
+            year: "numeric",
+        });
+    }
+    if (zoomLevel === "week") {
+        return date.toLocaleDateString(undefined, {
+            month: "short",
+            day: "numeric",
+        });
+    }
+    return date.toLocaleDateString(undefined, {
+        weekday: "short",
+        month: "short",
+        day: "numeric",
+    });
+}