@svgrid/enterprise 2.5.2 → 2.6.0

package/dist/pivot.js

@@ -0,0 +1,353 @@
+// -------------------------------------------------------- aggregators
+const numeric = (vs) => vs
+    .map((v) => (typeof v === 'number' ? v : Number(v)))
+    .filter((n) => !Number.isNaN(n));
+const BUILT_IN_AGGS = {
+    sum: (vs) => numeric(vs).reduce((a, b) => a + b, 0),
+    avg: (vs) => {
+        const ns = numeric(vs);
+        return ns.length === 0 ? null : ns.reduce((a, b) => a + b, 0) / ns.length;
+    },
+    min: (vs) => (numeric(vs).length === 0 ? null : Math.min(...numeric(vs))),
+    max: (vs) => (numeric(vs).length === 0 ? null : Math.max(...numeric(vs))),
+    count: (vs) => vs.length,
+    countDistinct: (vs) => new Set(vs).size,
+    first: (vs) => vs[0] ?? null,
+    last: (vs) => vs[vs.length - 1] ?? null,
+};
+function resolveAgg(agg) {
+    if (typeof agg === 'function')
+        return agg;
+    const fn = BUILT_IN_AGGS[agg];
+    if (!fn)
+        throw new Error(`pivot: unknown aggregator '${String(agg)}'`);
+    return fn;
+}
+function defaultCompare(a, b) {
+    if (a === b)
+        return 0;
+    if (a == null)
+        return -1;
+    if (b == null)
+        return 1;
+    if (typeof a === 'number' && typeof b === 'number')
+        return a - b;
+    return String(a).localeCompare(String(b), undefined, { numeric: true });
+}
+function buildAxisTree(rows, fields, sortBy) {
+    const root = {
+        level: 0, value: null, path: [], pathKey: '__root',
+        children: new Map(), rows: rows,
+    };
+    for (const row of rows) {
+        let node = root;
+        for (let i = 0; i < fields.length; i += 1) {
+            const field = fields[i];
+            const value = row[field];
+            const key = `${i}:${value === null ? '__null' : String(value)}`;
+            let child = node.children.get(key);
+            if (!child) {
+                child = {
+                    level: i + 1,
+                    value,
+                    path: [...node.path, value],
+                    pathKey: node.pathKey === '__root' ? key : `${node.pathKey}|${key}`,
+                    children: new Map(),
+                    rows: [],
+                };
+                node.children.set(key, child);
+            }
+            child.rows.push(row);
+            node = child;
+        }
+    }
+    // Stable, predictable child order at every level.
+    sortNode(root, sortBy);
+    return root;
+}
+function sortNode(node, sortBy) {
+    const entries = Array.from(node.children.entries());
+    entries.sort(([, a], [, b]) => (sortBy ?? defaultCompare)(a.value, b.value, a.level - 1));
+    node.children = new Map(entries);
+    for (const child of node.children.values())
+        sortNode(child, sortBy);
+}
+// --------------------------------------------------- column id helpers
+/**
+ * Generate stable leaf column ids by joining the column-axis path and the
+ * measure index. The id is what appears as `data-col-id` and as the key
+ * inside each pivot row. Kept short and deterministic.
+ */
+function leafColumnId(colPath, measureIndex) {
+    const path = colPath.length === 0 ? 'all' : colPath.map((v) => safe(v)).join('__');
+    return `pv__${path}__m${measureIndex}`;
+}
+function safe(v) {
+    if (v === null || v === undefined)
+        return 'null';
+    return String(v).replace(/[^a-zA-Z0-9_-]/g, '_');
+}
+// --------------------------------------------------- column-tree build
+function buildColumnTree(colRoot, values, config, rowHeaderLabel) {
+    // First column: the row-axis tree as a single column. The label per row
+    // comes from `__pivotLabel`, with `__pivotDepth` driving the indent.
+    const headerCol = {
+        id: '__pivotRowHeader',
+        header: rowHeaderLabel,
+        fieldFn: (row) => row.__pivotLabel,
+        width: 240,
+    };
+    function recurse(node) {
+        // If this is a column-axis leaf (no children), emit one value column
+        // per measure.
+        if (node.children.size === 0) {
+            return values.map((value, i) => {
+                const id = leafColumnId(node.path, i);
+                const label = value.label ?? `${value.field} (${typeof value.agg === 'function' ? 'custom' : value.agg})`;
+                return {
+                    id,
+                    header: label,
+                    fieldFn: (row) => row[id],
+                    format: value.format,
+                    width: 130,
+                };
+            });
+        }
+        // Otherwise emit a header group with this node's value as the label
+        // and recurse for its children.
+        return Array.from(node.children.values()).map((child) => ({
+            id: `pv_group_${child.pathKey}`,
+            header: String(child.value ?? '(blank)'),
+            columns: recurse(child),
+        }));
+    }
+    const valueCols = colRoot.children.size === 0
+        // No col dims at all: emit measures as flat columns under no group.
+        ? recurse(colRoot)
+        : recurse(colRoot);
+    const grandTotalCol = config.grandTotalCol !== false;
+    if (!grandTotalCol)
+        return [headerCol, ...valueCols];
+    // Grand total column: one measure column per value config, with no
+    // col-path filter.
+    const totalCols = values.map((value, i) => {
+        const id = leafColumnId(['__total'], i);
+        const label = value.label ?? `${value.field} (${typeof value.agg === 'function' ? 'custom' : value.agg})`;
+        return {
+            id,
+            header: label,
+            fieldFn: (row) => row[id],
+            format: value.format,
+            width: 140,
+        };
+    });
+    const grandTotal = {
+        id: 'pv_group__grand_total',
+        header: 'Total',
+        columns: totalCols,
+    };
+    return [headerCol, ...valueCols, grandTotal];
+}
+// --------------------------------------------------- row-axis materialise
+function collectColLeafPaths(node, into) {
+    if (node.children.size === 0) {
+        into.push(node.path);
+        return;
+    }
+    for (const child of node.children.values())
+        collectColLeafPaths(child, into);
+}
+/**
+ * For one source-row set (a row-axis node) compute the value at each
+ * column-axis leaf for each measure. Returns a map keyed by column id.
+ */
+function computeRowValues(sourceRows, colLeafPaths, colFields, values, includeGrandTotalCol) {
+    const result = {};
+    // For each col-axis leaf path, filter the source rows to those matching
+    // every dim value, then run each measure aggregator.
+    for (const colPath of colLeafPaths) {
+        const matched = colPath.length === 0
+            ? sourceRows
+            : sourceRows.filter((r) => colPath.every((value, i) => r[colFields[i]] === value));
+        for (let i = 0; i < values.length; i += 1) {
+            const value = values[i];
+            const fn = resolveAgg(value.agg);
+            const id = leafColumnId(colPath, i);
+            result[id] = fn(matched.map((r) => r[value.field]));
+        }
+    }
+    // Grand-total column: run each measure across the entire source set.
+    if (includeGrandTotalCol) {
+        for (let i = 0; i < values.length; i += 1) {
+            const value = values[i];
+            const fn = resolveAgg(value.agg);
+            const id = leafColumnId(['__total'], i);
+            result[id] = fn(sourceRows.map((r) => r[value.field]));
+        }
+    }
+    return result;
+}
+/**
+ * Build the same value-column keys as `computeRowValues`, but with every cell
+ * `null`. Used for group HEADER rows when `rowSubtotals` is off: the row keeps
+ * its place in the hierarchy (label + expand/collapse) yet shows no aggregate
+ * numbers. Cells are `null` rather than absent so consumers can distinguish a
+ * deliberately-blank subtotal from a missing column.
+ */
+function blankRowValues(colLeafPaths, values, includeGrandTotalCol) {
+    const result = {};
+    for (const colPath of colLeafPaths) {
+        for (let i = 0; i < values.length; i += 1)
+            result[leafColumnId(colPath, i)] = null;
+    }
+    if (includeGrandTotalCol) {
+        for (let i = 0; i < values.length; i += 1)
+            result[leafColumnId(['__total'], i)] = null;
+    }
+    return result;
+}
+function walkRowTree(node, out, colLeafPaths, colFields, values, config, rowFields, 
+/**
+ * The id of the row-axis ancestor that should be reported as
+ * `__pivotParentId` on every row emitted under this subtree. `null`
+ * at the top level.
+ */
+parentId) {
+    const includeGrandTotalCol = config.grandTotalCol !== false;
+    const wantSubtotals = config.rowSubtotals !== false;
+    // The "leaf" case: this is a row-axis leaf - no further row dimensions.
+    if (node.children.size === 0) {
+        out.push({
+            __pivotId: `row__${node.pathKey}`,
+            __pivotKind: 'leaf',
+            __pivotDepth: node.level,
+            __pivotLabel: node.value === null ? '(All)' : String(node.value),
+            __pivotParentId: parentId,
+            __pivotExpandable: false,
+            ...computeRowValues(node.rows, colLeafPaths, colFields, values, includeGrandTotalCol),
+        });
+        return;
+    }
+    // Group node. Emit the group HEADER row whenever this node is a real group
+    // (not the synthetic root, not the deepest level). The header is emitted
+    // regardless of `rowSubtotals` so the grouping hierarchy and the
+    // expand/collapse parent chain stay intact; the flag only controls whether
+    // the header carries its aggregate (subtotal) values or renders as a
+    // label-only row. This matches Excel / AG Grid, where hiding subtotals never
+    // removes a grouping level from the row axis.
+    const isRealGroup = node.level > 0 && node.level < rowFields.length;
+    let nextParentId = parentId;
+    if (isRealGroup) {
+        const id = `group__${node.pathKey}`;
+        out.push({
+            __pivotId: id,
+            __pivotKind: 'group',
+            __pivotDepth: node.level,
+            __pivotLabel: String(node.value ?? '(All)'),
+            __pivotParentId: parentId,
+            __pivotExpandable: true,
+            ...(wantSubtotals
+                ? computeRowValues(node.rows, colLeafPaths, colFields, values, includeGrandTotalCol)
+                : blankRowValues(colLeafPaths, values, includeGrandTotalCol)),
+        });
+        // Children of this group point at this row as their parent so a
+        // collapse hides the whole subtree, not just the immediate leaves.
+        nextParentId = id;
+    }
+    for (const child of node.children.values()) {
+        walkRowTree(child, out, colLeafPaths, colFields, values, config, rowFields, nextParentId);
+    }
+}
+// ------------------------------------------------------------ public API
+export function createPivotModel(data, config) {
+    if (config.values.length === 0) {
+        throw new Error('pivot: at least one value config is required');
+    }
+    const rowFields = config.rows;
+    const colFields = config.cols;
+    const values = config.values;
+    // 1. axis trees
+    const rowRoot = buildAxisTree(data, rowFields, config.rowSort);
+    const colRoot = buildAxisTree(data, colFields, config.colSort);
+    // 2. collect col-axis leaf paths (one per value column header chain)
+    const colLeafPaths = [];
+    collectColLeafPaths(colRoot, colLeafPaths);
+    // 3. flatten row-axis to pivot rows
+    const rows = [];
+    if (rowFields.length === 0) {
+        // No row dims: one synthetic "All" row.
+        rows.push({
+            __pivotId: 'row__all',
+            __pivotKind: 'leaf',
+            __pivotDepth: 0,
+            __pivotLabel: '(All)',
+            __pivotParentId: null,
+            __pivotExpandable: false,
+            ...computeRowValues(data, colLeafPaths, colFields, values, config.grandTotalCol !== false),
+        });
+    }
+    else {
+        walkRowTree(rowRoot, rows, colLeafPaths, colFields, values, config, rowFields, null);
+    }
+    // 4. grand-total row at bottom
+    if (config.grandTotalRow !== false) {
+        rows.push({
+            __pivotId: 'row__grand_total',
+            __pivotKind: 'grandTotal',
+            __pivotDepth: 0,
+            __pivotLabel: 'Grand total',
+            __pivotParentId: null,
+            __pivotExpandable: false,
+            ...computeRowValues(data, colLeafPaths, colFields, values, config.grandTotalCol !== false),
+        });
+    }
+    // 5. column tree
+    const columns = buildColumnTree(colRoot, values, config, rowFields.length > 0 ? rowFields.join(' / ') : '');
+    return { rows, columns };
+}
+/**
+ * Public registry of built-in aggregators. Useful for surfacing the
+ * available options in a pivot designer UI.
+ */
+export const pivotAggregators = { ...BUILT_IN_AGGS };
+/**
+ * Filter a `result.rows` array down to only the rows the user should
+ * see given the current expansion state. A row stays in the output if
+ * its entire ancestor chain (via `__pivotParentId`) is in `expandedIds`.
+ *
+ * Pass `true` to bypass filtering (everything visible - the default
+ * shape `createPivotModel` already returns). Pass an empty array /
+ * empty Set to collapse every group to its subtotal row.
+ *
+ * The result is a new array; the input is not mutated.
+ */
+export function filterCollapsedPivotRows(rows, expandedIds) {
+    if (expandedIds === true)
+        return rows.slice();
+    const expanded = expandedIds instanceof Set ? expandedIds : new Set(expandedIds);
+    // Parent-of index so the ancestor walk is O(depth) instead of O(rows × depth).
+    const parentOf = new Map();
+    for (const r of rows)
+        parentOf.set(r.__pivotId, r.__pivotParentId);
+    const out = [];
+    for (const row of rows) {
+        // The grand-total row, top-level groups, and the (All) row are
+        // always visible (their parent is null).
+        if (row.__pivotParentId === null) {
+            out.push(row);
+            continue;
+        }
+        let parentId = row.__pivotParentId;
+        let visible = true;
+        while (parentId !== null) {
+            if (!expanded.has(parentId)) {
+                visible = false;
+                break;
+            }
+            parentId = parentOf.get(parentId) ?? null;
+        }
+        if (visible)
+            out.push(row);
+    }
+    return out;
+}

package/dist/print.d.ts

@@ -0,0 +1,33 @@
+import type { RowData, TableFeatures, SvGridApi } from '@svgrid/grid';
+import { type ExportColumn, type ExportRowSource } from './export';
+import type { ConditionalFormat } from '@svgrid/grid/format';
+export type PrintOptions<TData> = {
+    /** Title placed above the printed grid. Defaults to "Grid". */
+    title?: string;
+    /** Smaller line under the title. */
+    subtitle?: string;
+    /** Logo data URL, shown above the title. */
+    logo?: string;
+    /** Columns to print. Defaults to the grid's own visible columns (with their
+     *  header labels + `format`, so values print formatted). */
+    columns?: ReadonlyArray<ExportColumn<TData>>;
+    /** Rows to print. Defaults to the current view; accepts the same
+     *  `'displayed' | 'selected' | 'all'` shorthand as `exportData`. */
+    rows?: ExportRowSource<TData>;
+    /** Write raw underlying values instead of the formatted display values. */
+    rawValues?: boolean;
+    /** Print orientation. Browsers honor it via `@page { size }`. Default "portrait". */
+    orientation?: 'portrait' | 'landscape';
+    /** `@page` size keyword, e.g. 'A4' | 'Letter'. Combined with orientation. */
+    pageSize?: string;
+    /** Page margin, e.g. '14mm'. Default '14mm'. */
+    margin?: string;
+    /** Zebra-stripe rows. Default true. */
+    zebra?: boolean;
+    /** Header row background color. */
+    headerColor?: string;
+    /** Conditional formatting rules (same array as `<SvGrid conditionalFormats>`);
+     *  carried into the print view as cell background / color / bold + icons. */
+    conditionalFormats?: ReadonlyArray<ConditionalFormat<TData>>;
+};
+export declare function printGrid<TFeatures extends TableFeatures, TData extends RowData>(api: SvGridApi<TFeatures, TData>, opts?: PrintOptions<TData>): Promise<void>;

package/dist/print.js

@@ -0,0 +1,61 @@
+import { assertEnterpriseLicensed } from './license';
+import { buildLinkResolver, projectRows, resolveColumns, resolveRowSource, } from './export';
+import { buildPrintDocument } from './export-print';
+import { buildConditionalResolver } from './export-conditional';
+export async function printGrid(api, opts) {
+    assertEnterpriseLicensed('Print');
+    if (typeof window === 'undefined') {
+        throw new Error('@svgrid/enterprise: print requires a browser environment');
+    }
+    const sourceRows = resolveRowSource(api, opts?.rows);
+    if (sourceRows.length === 0) {
+        throw new Error('@svgrid/enterprise: nothing to print - the grid has no rows');
+    }
+    const cols = resolveColumns(api, { columns: opts?.columns }, sourceRows);
+    const fields = cols.map((c) => c.field);
+    // Formatted display values (or raw when asked) so the print matches the grid.
+    const projected = await projectRows(sourceRows, cols, { rawValues: opts?.rawValues });
+    const dataRows = projected.slice(1).map((r) => fields.map((f) => String(r[f] ?? '')));
+    const columns = cols.map((c) => ({ header: c.header ?? c.field, align: c.align }));
+    const docOpts = {
+        title: opts?.title ?? 'Grid',
+        subtitle: opts?.subtitle,
+        logo: opts?.logo,
+        orientation: opts?.orientation ?? 'portrait',
+        pageSize: opts?.pageSize,
+        margin: opts?.margin,
+        zebra: opts?.zebra,
+        headerColor: opts?.headerColor,
+    };
+    const visual = buildConditionalResolver(cols, sourceRows, opts?.conditionalFormats);
+    const link = buildLinkResolver(cols, sourceRows);
+    const html = buildPrintDocument({
+        columns,
+        rows: dataRows,
+        cellStyle: (r, c) => visual(r, c),
+        cellLink: link,
+        opts: docOpts,
+    });
+    const w = window.open('', '_blank', 'width=900,height=700');
+    if (!w) {
+        throw new Error('@svgrid/enterprise: print() could not open a window - the browser blocked the popup');
+    }
+    w.document.open();
+    w.document.write(html);
+    w.document.close();
+    // Give the new window one tick to paint before invoking print.
+    w.focus();
+    w.addEventListener('load', () => {
+        setTimeout(() => w.print(), 50);
+    });
+    // Some browsers fire 'load' before the listener attaches if the document was
+    // already complete. Fall back: try a print after a short delay regardless.
+    setTimeout(() => {
+        try {
+            w.print();
+        }
+        catch {
+            // ignore - the listener path will have fired
+        }
+    }, 300);
+}

package/dist/revoked.d.ts

@@ -0,0 +1 @@
+export declare const REVOKED_KEYS: ReadonlySet<string>;

package/{src/revoked.ts → dist/revoked.js}

@@ -1,4 +1,4 @@
-// Revoked license keys. A key in this set throws on use even if it has the
+// Revoked license keys. A key in this set throws on use even if it has the
 // valid SVENTERPRISE- prefix. Use this to invalidate keys that have been leaked,
 // shared outside their seat count, or issued for trials that have expired.
 //
@@ -42,8 +42,7 @@
 // For npm publication the right long-term answer is a build step that
 // inlines the list from an env var or private file. Not wired up yet.
 // =============================================================================
-
-export const REVOKED_KEYS: ReadonlySet<string> = new Set<string>([
-  // 'SVENTERPRISE-EVAL-acme-202506-3F7K9P',  // example - expired ACME trial
-  // 'SVENTERPRISE-LEAKED-globex-202612-X8N4P', // example - key leaked on GitHub
-])
+export const REVOKED_KEYS = new Set([
+// 'SVENTERPRISE-EVAL-acme-202506-3F7K9P',  // example - expired ACME trial
+// 'SVENTERPRISE-LEAKED-globex-202612-X8N4P', // example - key leaked on GitHub
+]);

package/dist/scheduler-assignments.d.ts

@@ -0,0 +1,64 @@
+/**
+ * scheduler-assignments - the pure core behind Scheduler Pro *multi-assignment*
+ * (one event assigned to several resources) and the *resource utilization
+ * histogram*. No Svelte, no DOM. Generic over the event shape via accessor
+ * callbacks so it needs no dependency on the grid's ResolvedEvent.
+ */
+/** A many-to-many event <-> resource link, with an optional allocation (0..1). */
+export type SchedulerAssignment = {
+    id: string;
+    eventId: string;
+    resourceId: string;
+    /** Allocation fraction, default 1 (full). Summed for histogram / overallocation. */
+    units?: number;
+};
+/** One event placed on one resource (the flattened render unit). */
+export type Allocation<E = unknown> = {
+    event: E;
+    key: string;
+    resourceId: string;
+    units: number;
+    start: Date;
+    end: Date;
+};
+export type ExpandOptions<E> = {
+    keyOf: (e: E) => string;
+    startOf: (e: E) => Date;
+    endOf: (e: E) => Date;
+    /** Single-resource fallback when an event has no assignment. */
+    resourceOf?: (e: E) => string | undefined;
+};
+/**
+ * Flatten events into per-resource allocations. An event with assignments renders
+ * once per assigned resource (deduped by eventId+resourceId, keeping the max
+ * units); an event with none falls back to its single `resourceOf` (units 1), or
+ * is dropped when it has neither. The result drives the resource-column bucketing.
+ */
+export declare function expandAssignments<E>(events: ReadonlyArray<E>, assignments: ReadonlyArray<SchedulerAssignment>, opts: ExpandOptions<E>): Allocation<E>[];
+/**
+ * Summed allocation units on `resourceId` overlapping the bucket
+ * `[bucketStart, bucketEnd)` - the height of one histogram bar.
+ */
+export declare function resourceLoad<E>(allocs: ReadonlyArray<Allocation<E>>, resourceId: string, bucketStart: Date, bucketEnd: Date): number;
+/** One over-capacity bucket (summed load exceeds the resource capacity). */
+export type Overallocation = {
+    resourceId: string;
+    start: Date;
+    end: Date;
+    load: number;
+    capacity: number;
+};
+/**
+ * Buckets where a resource's summed load exceeds its capacity. `buckets` are the
+ * axis intervals to test; `capacity` is a flat number or a per-resource function
+ * (default 1). Used to tint histogram bars / flag conflicts.
+ */
+export declare function overallocations<E>(allocs: ReadonlyArray<Allocation<E>>, resourceIds: ReadonlyArray<string>, buckets: ReadonlyArray<{
+    start: Date;
+    end: Date;
+}>, capacity?: number | ((resourceId: string) => number)): Overallocation[];
+/**
+ * Total assigned minutes per resource across `allocs` (a simple utilization
+ * roll-up for a legend / header, independent of buckets).
+ */
+export declare function assignedMinutes<E>(allocs: ReadonlyArray<Allocation<E>>, resourceId: string): number;

package/dist/scheduler-assignments.js

@@ -0,0 +1,92 @@
+/**
+ * scheduler-assignments - the pure core behind Scheduler Pro *multi-assignment*
+ * (one event assigned to several resources) and the *resource utilization
+ * histogram*. No Svelte, no DOM. Generic over the event shape via accessor
+ * callbacks so it needs no dependency on the grid's ResolvedEvent.
+ */
+const MS_MIN = 60000;
+/**
+ * Flatten events into per-resource allocations. An event with assignments renders
+ * once per assigned resource (deduped by eventId+resourceId, keeping the max
+ * units); an event with none falls back to its single `resourceOf` (units 1), or
+ * is dropped when it has neither. The result drives the resource-column bucketing.
+ */
+export function expandAssignments(events, assignments, opts) {
+    // Group assignments by eventId, collapsing duplicate resources to the max units.
+    const byEvent = new Map();
+    for (const a of assignments) {
+        if (!a || !a.eventId || !a.resourceId)
+            continue;
+        let m = byEvent.get(a.eventId);
+        if (!m)
+            byEvent.set(a.eventId, (m = new Map()));
+        const units = a.units == null ? 1 : a.units;
+        m.set(a.resourceId, Math.max(m.get(a.resourceId) ?? 0, units));
+    }
+    const out = [];
+    for (const e of events) {
+        const key = opts.keyOf(e);
+        const start = opts.startOf(e);
+        const end = opts.endOf(e);
+        const m = byEvent.get(key);
+        if (m && m.size) {
+            for (const [resourceId, units] of m)
+                out.push({ event: e, key, resourceId, units, start, end });
+        }
+        else {
+            const resourceId = opts.resourceOf?.(e);
+            if (resourceId != null)
+                out.push({ event: e, key, resourceId, units: 1, start, end });
+        }
+    }
+    return out;
+}
+/** True when `[aStart,aEnd)` overlaps `[bStart,bEnd)`. */
+function overlaps(aStart, aEnd, bStart, bEnd) {
+    return aStart.getTime() < bEnd.getTime() && aEnd.getTime() > bStart.getTime();
+}
+/**
+ * Summed allocation units on `resourceId` overlapping the bucket
+ * `[bucketStart, bucketEnd)` - the height of one histogram bar.
+ */
+export function resourceLoad(allocs, resourceId, bucketStart, bucketEnd) {
+    let load = 0;
+    for (const a of allocs) {
+        if (a.resourceId !== resourceId)
+            continue;
+        if (overlaps(a.start, a.end, bucketStart, bucketEnd))
+            load += a.units;
+    }
+    return load;
+}
+/**
+ * Buckets where a resource's summed load exceeds its capacity. `buckets` are the
+ * axis intervals to test; `capacity` is a flat number or a per-resource function
+ * (default 1). Used to tint histogram bars / flag conflicts.
+ */
+export function overallocations(allocs, resourceIds, buckets, capacity = 1) {
+    const capOf = typeof capacity === 'function' ? capacity : () => capacity;
+    const out = [];
+    for (const resourceId of resourceIds) {
+        const cap = capOf(resourceId);
+        for (const b of buckets) {
+            const load = resourceLoad(allocs, resourceId, b.start, b.end);
+            if (load > cap + 1e-9)
+                out.push({ resourceId, start: b.start, end: b.end, load, capacity: cap });
+        }
+    }
+    return out;
+}
+/**
+ * Total assigned minutes per resource across `allocs` (a simple utilization
+ * roll-up for a legend / header, independent of buckets).
+ */
+export function assignedMinutes(allocs, resourceId) {
+    let mins = 0;
+    for (const a of allocs) {
+        if (a.resourceId !== resourceId)
+            continue;
+        mins += ((a.end.getTime() - a.start.getTime()) / MS_MIN) * a.units;
+    }
+    return mins;
+}