@affino/datagrid-gantt 0.1.1

package/dist/timeline.d.ts

@@ -0,0 +1,16 @@
+import type { BuildDataGridTimelineModelInput, BuildDataGridTimelineRenderModelsInput, DataGridGanttTimelineState, DataGridTimelineHorizontalAlign, DataGridTimelineModel, DataGridTimelineRange, DataGridTimelineRenderModels, DataGridTimelineViewport, ResolveDataGridTimelineRangeInput } from "./contracts.js";
+export declare const DAY_MS: number;
+export declare function resolveDataGridTimelineDateToPixel(dateMs: number, timeline: DataGridGanttTimelineState): number;
+export declare function resolveDataGridTimelineRange(input: ResolveDataGridTimelineRangeInput): DataGridTimelineRange;
+export declare function resolveDataGridTimelinePixelToDate(pixel: number, timeline: DataGridGanttTimelineState): number;
+export declare function clampDataGridTimelineScrollLeft(scrollLeft: number, totalWidth: number, viewportWidth: number): number;
+export declare function resolveDataGridTimelineScrollLeftForDate(input: {
+    dateMs: number;
+    timeline: DataGridGanttTimelineState;
+    viewportWidth: number;
+    align?: DataGridTimelineHorizontalAlign;
+}): number;
+export declare function resolveDataGridTimelineViewport(input: BuildDataGridTimelineModelInput): DataGridTimelineViewport;
+export declare function buildDataGridTimelineModel(input: BuildDataGridTimelineModelInput): DataGridTimelineModel;
+export declare function buildDataGridTimelineRenderModels(input: BuildDataGridTimelineRenderModelsInput): DataGridTimelineRenderModels;
+//# sourceMappingURL=timeline.d.ts.map

package/dist/timeline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timeline.d.ts","sourceRoot":"","sources":["../src/timeline.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,+BAA+B,EAC/B,sCAAsC,EACtC,0BAA0B,EAE1B,+BAA+B,EAE/B,qBAAqB,EACrB,qBAAqB,EACrB,4BAA4B,EAG5B,wBAAwB,EACxB,iCAAiC,EAClC,MAAM,gBAAgB,CAAA;AAQvB,eAAO,MAAM,MAAM,QAAsB,CAAA;AA0NzC,wBAAgB,kCAAkC,CAChD,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,0BAA0B,GACnC,MAAM,CAER;AAED,wBAAgB,4BAA4B,CAC1C,KAAK,EAAE,iCAAiC,GACvC,qBAAqB,CAwBvB;AAED,wBAAgB,kCAAkC,CAChD,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,0BAA0B,GACnC,MAAM,CAIR;AAED,wBAAgB,+BAA+B,CAC7C,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,EAClB,aAAa,EAAE,MAAM,GACpB,MAAM,CAMR;AAED,wBAAgB,wCAAwC,CACtD,KAAK,EAAE;IACL,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,0BAA0B,CAAA;IACpC,aAAa,EAAE,MAAM,CAAA;IACrB,KAAK,CAAC,EAAE,+BAA+B,CAAA;CACxC,GACA,MAAM,CAcR;AAED,wBAAgB,+BAA+B,CAC7C,KAAK,EAAE,+BAA+B,GACrC,wBAAwB,CAsB1B;AAED,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,+BAA+B,GACrC,qBAAqB,CAmCvB;AAED,wBAAgB,iCAAiC,CAC/C,KAAK,EAAE,sCAAsC,GAC5C,4BAA4B,CAiB9B"}

package/dist/timeline.js

@@ -0,0 +1,287 @@
+import { buildDataGridNonWorkingDaySpans, resolveDataGridWorkingCalendar, startOfUtcDay, startOfUtcWeek, } from "./calendar.js";
+export const DAY_MS = 24 * 60 * 60 * 1000;
+const DEFAULT_TIMELINE_BUFFER_PX = 160;
+const MAX_TIMELINE_SEGMENTS = 10000;
+function ceilToUtcDay(ms) {
+    const dayStartMs = startOfUtcDay(ms);
+    if (dayStartMs === ms) {
+        return ms;
+    }
+    return dayStartMs + DAY_MS;
+}
+function startOfUtcMonth(ms) {
+    const date = new Date(ms);
+    return Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), 1);
+}
+function startOfUtcYear(ms) {
+    const date = new Date(ms);
+    return Date.UTC(date.getUTCFullYear(), 0, 1);
+}
+function addUtcDays(ms, days) {
+    return ms + (days * DAY_MS);
+}
+function addUtcWeeks(ms, weeks) {
+    return addUtcDays(ms, weeks * 7);
+}
+function addUtcMonths(ms, months) {
+    const date = new Date(ms);
+    return Date.UTC(date.getUTCFullYear(), date.getUTCMonth() + months, 1);
+}
+function addUtcYears(ms, years) {
+    const date = new Date(ms);
+    return Date.UTC(date.getUTCFullYear() + years, 0, 1);
+}
+function formatUtcDate(ms, options) {
+    return new Date(ms).toLocaleDateString(undefined, {
+        ...options,
+        timeZone: "UTC",
+    });
+}
+function resolveWeekOfMonth(ms) {
+    const labelAnchorMs = addUtcDays(startOfUtcWeek(ms), 4);
+    const monthStartMs = startOfUtcMonth(labelAnchorMs);
+    const monthFirstWeekStartMs = startOfUtcWeek(monthStartMs);
+    return Math.floor((startOfUtcWeek(labelAnchorMs) - monthFirstWeekStartMs) / (7 * DAY_MS)) + 1;
+}
+function resolveTimelinePrimaryLabel(ms, zoomLevel) {
+    if (zoomLevel === "month") {
+        return formatUtcDate(ms, { year: "numeric" });
+    }
+    return formatUtcDate(ms, {
+        month: "long",
+        year: "numeric",
+    });
+}
+function resolveTimelineSecondaryLabel(ms, zoomLevel) {
+    if (zoomLevel === "week") {
+        return `W${resolveWeekOfMonth(ms)}`;
+    }
+    if (zoomLevel === "month") {
+        return formatUtcDate(ms, { month: "short" });
+    }
+    return formatUtcDate(ms, { day: "numeric" });
+}
+function resolveTimelineUnitStart(ms, unit) {
+    if (unit === "week") {
+        return startOfUtcWeek(ms);
+    }
+    if (unit === "month") {
+        return startOfUtcMonth(ms);
+    }
+    if (unit === "year") {
+        return startOfUtcYear(ms);
+    }
+    return startOfUtcDay(ms);
+}
+function addTimelineUnits(ms, count, unit) {
+    if (unit === "week") {
+        return addUtcWeeks(ms, count);
+    }
+    if (unit === "month") {
+        return addUtcMonths(ms, count);
+    }
+    if (unit === "year") {
+        return addUtcYears(ms, count);
+    }
+    return addUtcDays(ms, count);
+}
+const ZOOM_CONFIG = {
+    day: {
+        primary: {
+            unit: "month",
+            resolveLabel: ms => resolveTimelinePrimaryLabel(ms, "day"),
+        },
+        secondary: {
+            unit: "day",
+            resolveLabel: ms => resolveTimelineSecondaryLabel(ms, "day"),
+        },
+    },
+    week: {
+        primary: {
+            unit: "month",
+            resolveLabel: ms => resolveTimelinePrimaryLabel(ms, "week"),
+        },
+        secondary: {
+            unit: "week",
+            resolveLabel: ms => resolveTimelineSecondaryLabel(ms, "week"),
+        },
+    },
+    month: {
+        primary: {
+            unit: "year",
+            resolveLabel: ms => resolveTimelinePrimaryLabel(ms, "month"),
+        },
+        secondary: {
+            unit: "month",
+            resolveLabel: ms => resolveTimelineSecondaryLabel(ms, "month"),
+        },
+    },
+};
+function buildTimelineSegments(input) {
+    const segments = [];
+    let cursorMs = input.rangeStartMs;
+    let segmentCount = 0;
+    while (cursorMs < input.viewportEndMs && segmentCount < MAX_TIMELINE_SEGMENTS) {
+        const segmentStartX = resolveDataGridTimelineDateToPixel(cursorMs, input.timeline);
+        const segmentEndMs = addTimelineUnits(cursorMs, 1, input.unit);
+        const segmentEndX = resolveDataGridTimelineDateToPixel(segmentEndMs, input.timeline);
+        const x = segmentStartX - input.scrollLeft;
+        const width = segmentEndX - segmentStartX;
+        segments.push({
+            key: `${cursorMs}:${segmentEndMs}`,
+            startMs: cursorMs,
+            endMs: segmentEndMs,
+            x,
+            width,
+            label: input.resolveLabel(cursorMs),
+        });
+        if (segmentEndMs <= cursorMs) {
+            break;
+        }
+        cursorMs = segmentEndMs;
+        segmentCount += 1;
+    }
+    return segments;
+}
+function buildTimelineLines(segments, suffix) {
+    return segments.map(segment => ({
+        key: `${suffix}:${segment.startMs}`,
+        dateMs: segment.startMs,
+        x: segment.x,
+    }));
+}
+function buildTimelineNonWorkingSpans(input) {
+    return buildDataGridNonWorkingDaySpans({
+        startMs: input.viewportStartMs,
+        endMs: input.viewportEndMs,
+        calendar: input.workingCalendar,
+    }).map(span => ({
+        key: `non-working:${span.startMs}`,
+        startMs: span.startMs,
+        endMs: span.endMs,
+        x: resolveDataGridTimelineDateToPixel(span.startMs, input.timeline) - input.scrollLeft,
+        width: resolveDataGridTimelineDateToPixel(span.endMs, input.timeline)
+            - resolveDataGridTimelineDateToPixel(span.startMs, input.timeline),
+    }));
+}
+export function resolveDataGridTimelineDateToPixel(dateMs, timeline) {
+    return ((dateMs - timeline.startMs) / DAY_MS) * timeline.pixelsPerDay;
+}
+export function resolveDataGridTimelineRange(input) {
+    var _a, _b;
+    const minTaskDateMs = Number.isFinite(input.minTaskDateMs) ? Number(input.minTaskDateMs) : null;
+    const maxTaskDateMs = Number.isFinite(input.maxTaskDateMs) ? Number(input.maxTaskDateMs) : null;
+    const pixelsPerDay = Number.isFinite(input.pixelsPerDay) ? Math.max(1, Number(input.pixelsPerDay)) : 1;
+    const rangePaddingDays = Number.isFinite(input.rangePaddingDays)
+        ? Math.max(0, Math.trunc((_a = input.rangePaddingDays) !== null && _a !== void 0 ? _a : 0))
+        : 0;
+    const fallbackDurationDays = Number.isFinite(input.fallbackDurationDays)
+        ? Math.max(1, Math.trunc((_b = input.fallbackDurationDays) !== null && _b !== void 0 ? _b : 14))
+        : 14;
+    const fallbackDateMs = Number.isFinite(input.fallbackDateMs)
+        ? Number(input.fallbackDateMs)
+        : Date.now();
+    const baseStartMs = startOfUtcDay(minTaskDateMs !== null && minTaskDateMs !== void 0 ? minTaskDateMs : fallbackDateMs);
+    const startMs = startOfUtcDay(baseStartMs - (rangePaddingDays * DAY_MS));
+    const baseEndMs = maxTaskDateMs !== null && maxTaskDateMs !== void 0 ? maxTaskDateMs : (baseStartMs + (fallbackDurationDays * DAY_MS));
+    const rawEndMs = baseEndMs + (rangePaddingDays * DAY_MS);
+    const endMs = Math.max(startMs + DAY_MS, ceilToUtcDay(rawEndMs));
+    return {
+        startMs,
+        endMs,
+        totalWidth: Math.max(1, ((endMs - startMs) / DAY_MS) * pixelsPerDay),
+    };
+}
+export function resolveDataGridTimelinePixelToDate(pixel, timeline) {
+    return Math.floor(timeline.startMs + ((pixel / timeline.pixelsPerDay) * DAY_MS));
+}
+export function clampDataGridTimelineScrollLeft(scrollLeft, totalWidth, viewportWidth) {
+    if (!Number.isFinite(scrollLeft)) {
+        return 0;
+    }
+    const maxScrollLeft = Math.max(0, totalWidth - Math.max(0, viewportWidth));
+    return Math.min(Math.max(0, scrollLeft), maxScrollLeft);
+}
+export function resolveDataGridTimelineScrollLeftForDate(input) {
+    const anchorX = resolveDataGridTimelineDateToPixel(input.dateMs, input.timeline);
+    const viewportWidth = Math.max(0, input.viewportWidth);
+    let nextScrollLeft = anchorX;
+    if (input.align === "center" || input.align == null) {
+        nextScrollLeft = anchorX - (viewportWidth / 2);
+    }
+    else if (input.align === "end") {
+        nextScrollLeft = anchorX - viewportWidth;
+    }
+    return clampDataGridTimelineScrollLeft(nextScrollLeft, input.timeline.totalWidth, viewportWidth);
+}
+export function resolveDataGridTimelineViewport(input) {
+    var _a;
+    const viewportWidth = Math.max(0, input.viewportWidth);
+    const scrollLeft = clampDataGridTimelineScrollLeft(input.scrollLeft, input.timeline.totalWidth, viewportWidth);
+    const bufferPx = Math.max(0, (_a = input.bufferPx) !== null && _a !== void 0 ? _a : DEFAULT_TIMELINE_BUFFER_PX);
+    const startX = Math.max(0, scrollLeft - bufferPx);
+    const endX = Math.min(input.timeline.totalWidth, scrollLeft + viewportWidth + bufferPx);
+    return {
+        scrollLeft,
+        viewportWidth,
+        startX,
+        endX,
+        startMs: startOfUtcDay(resolveDataGridTimelinePixelToDate(startX, input.timeline)),
+        endMs: Math.max(startOfUtcDay(resolveDataGridTimelinePixelToDate(startX, input.timeline)) + DAY_MS, ceilToUtcDay(resolveDataGridTimelinePixelToDate(endX, input.timeline))),
+    };
+}
+export function buildDataGridTimelineModel(input) {
+    var _a;
+    const workingCalendar = (_a = input.workingCalendar) !== null && _a !== void 0 ? _a : resolveDataGridWorkingCalendar(null);
+    const viewport = resolveDataGridTimelineViewport(input);
+    const zoomConfig = ZOOM_CONFIG[input.timeline.zoomLevel];
+    const secondarySegments = buildTimelineSegments({
+        timeline: input.timeline,
+        scrollLeft: viewport.scrollLeft,
+        viewportEndMs: viewport.endMs,
+        rangeStartMs: resolveTimelineUnitStart(viewport.startMs, zoomConfig.secondary.unit),
+        unit: zoomConfig.secondary.unit,
+        resolveLabel: zoomConfig.secondary.resolveLabel,
+    });
+    const primarySegments = buildTimelineSegments({
+        timeline: input.timeline,
+        scrollLeft: viewport.scrollLeft,
+        viewportEndMs: viewport.endMs,
+        rangeStartMs: resolveTimelineUnitStart(viewport.startMs, zoomConfig.primary.unit),
+        unit: zoomConfig.primary.unit,
+        resolveLabel: zoomConfig.primary.resolveLabel,
+    });
+    return {
+        viewport,
+        primarySegments,
+        secondarySegments,
+        primaryLines: buildTimelineLines(primarySegments, "primary"),
+        secondaryLines: buildTimelineLines(secondarySegments, "secondary"),
+        nonWorkingSpans: buildTimelineNonWorkingSpans({
+            timeline: input.timeline,
+            scrollLeft: viewport.scrollLeft,
+            viewportStartMs: viewport.startMs,
+            viewportEndMs: viewport.endMs,
+            workingCalendar,
+        }),
+    };
+}
+export function buildDataGridTimelineRenderModels(input) {
+    var _a, _b, _c;
+    return {
+        header: buildDataGridTimelineModel({
+            timeline: input.timeline,
+            scrollLeft: input.scrollLeft,
+            viewportWidth: input.viewportWidth,
+            workingCalendar: (_a = input.workingCalendar) !== null && _a !== void 0 ? _a : resolveDataGridWorkingCalendar(null),
+            bufferPx: Math.max(0, (_b = input.headerBufferPx) !== null && _b !== void 0 ? _b : 0),
+        }),
+        body: buildDataGridTimelineModel({
+            timeline: input.timeline,
+            scrollLeft: input.scrollLeft,
+            viewportWidth: input.viewportWidth,
+            workingCalendar: (_c = input.workingCalendar) !== null && _c !== void 0 ? _c : resolveDataGridWorkingCalendar(null),
+            bufferPx: input.bodyBufferPx,
+        }),
+    };
+}

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@affino/datagrid-gantt",
+  "version": "0.1.1",
+  "author": "Anton Pavlov <a.pavlov@affino.dev>",
+  "type": "module",
+  "description": "Headless Gantt projection engine for Affino DataGrid",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/affinio/affinio.git",
+    "directory": "packages/datagrid-gantt"
+  },
+  "homepage": "https://github.com/affinio/affinio/tree/main/packages/datagrid-gantt#readme",
+  "license": "MIT",
+  "keywords": [
+    "datagrid",
+    "gantt",
+    "timeline",
+    "engine",
+    "headless"
+  ],
+  "dependencies": {
+    "@affino/datagrid-core": "0.3.3"
+  },
+  "devDependencies": {
+    "vitest": "^4.0.18"
+  },
+  "bugs": {
+    "url": "https://github.com/affinio/affinio/issues"
+  },
+  "module": "dist/index.js",
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "type-check": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run"
+  }
+}