@full-ui/headless-grid 7.0.0-beta.5

package/LICENSE.md

@@ -0,0 +1,18 @@
+
+For complete licensing information, visit:
+https://fullcalendar.io/license
+
+FullCalendar Premium is tri-licensed, meaning you must choose
+one of three licenses to use. Here is a summary of those licenses:
+
+- Commercial License
+  (a paid license, intended for commercial use)
+  https://fullcalendar.io/commercial-license
+
+- Creative Commons Non-Commercial No-Derivatives
+  (intended for trial and non-commercial use)
+  https://creativecommons.org/licenses/by-nc-nd/4.0/
+
+- AGPLv3 License
+  (intended for open-source projects)
+  https://www.gnu.org/licenses/agpl-3.0.en.html

package/README.md

@@ -0,0 +1,23 @@
+
+# Full UI :: Headless Grid
+
+Headless datagrid library by the makers of FullCalendar
+
+## Description
+
+This "headless" library provides a very minimal set of primitives to render a JavaScript data grid using DOM-related optimizations like absolute positioning and scroll-simulation, which are traditionally the thorniest aspects of making a performant grid. It intends to be utility-first, like Tanstack Table, though in some aspects it must perform framework-dependent optimizations to achieve 60 FPS.
+
+> [!IMPORTANT]
+> If you are a FullCalendar Premium subscriber, and wish to use this library, please reach out to the tech support email you received upon purchase.
+
+In its current form, it's being used internally by the `@fullcalendar/resource-timeline` package, which renders a timeline view alongside a FullCalendar-built datagrid. Our goal is to make the *FullCalendar* datagrid the best in the world, though in the meantime, many users will want to use a datagrid of their choosing and integrate it with Resource-Timeline. This is the dual-purpose of this package: to allow shimming of third-party data grid libraries into FullCalendar's UI.
+
+## High-level API
+
+- Column absolute positioning
+- Row absolute positioning
+- Scroll-view syncing across unrelated parents
+- Virtual rendering (soon)
+- A little bit of cross-framework magic
+
+And more to come!... 👀

package/cjs/index.cjs

@@ -0,0 +1,371 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function fracToCssDim(frac) {
+    return frac * 100 + '%';
+}
+
+function parseDimConfig(input, minDim = 0) {
+    if (input != null) {
+        if (typeof input === 'string') {
+            let m = input.match(/^(.*)(%|px)$/);
+            if (m) {
+                const num = parseFloat(m[1]);
+                if (!isNaN(num)) {
+                    if (m[2] === '%') {
+                        return { pixels: 0, frac: num / 100, min: minDim };
+                    }
+                    else {
+                        return { pixels: num, frac: 0, min: minDim };
+                    }
+                }
+            }
+        }
+        else if (typeof input === 'number' && !isNaN(input)) {
+            return { pixels: input, frac: 0, min: minDim };
+        }
+    }
+}
+function parseSiblingDimConfig(input, grow, // TODO: use (and sanitize)
+minDim) {
+    const partialDimConfig = parseDimConfig(input, minDim);
+    return partialDimConfig
+        ? Object.assign(Object.assign({}, partialDimConfig), { grow: grow || 0 }) : { pixels: 0, frac: 0, grow: grow || 1, min: minDim };
+}
+/*
+Ensure at least one column can grow
+Mutates in-place
+*/
+function ensureDimConfigsGrow(dimConfigs) {
+    for (const dimConfig of dimConfigs) {
+        if (dimConfig.grow) {
+            return;
+        }
+    }
+    // make all expand equally
+    for (const dimConfig of dimConfigs) {
+        dimConfig.grow = 1;
+    }
+}
+function pixelizeDimConfigs(dimConfigs, clientDim) {
+    const pixelDims = [];
+    let preGrowTotal = 0;
+    let growDenom = 0;
+    for (const dimConfig of dimConfigs) {
+        const constrainedPixels = Math.max(dimConfig.pixels + (dimConfig.frac * clientDim), dimConfig.min);
+        pixelDims.push(constrainedPixels);
+        preGrowTotal += constrainedPixels;
+        growDenom += dimConfig.grow;
+    }
+    if (preGrowTotal < clientDim) {
+        const remainder = clientDim - preGrowTotal;
+        for (let i = 0; i < dimConfigs.length; i++) {
+            pixelDims[i] += remainder * (dimConfigs[i].grow / growDenom);
+        }
+    }
+    return [pixelDims, preGrowTotal];
+}
+function flexifyDimConfigs(dimConfigs, pixelDims) {
+    const flexDims = [];
+    const flexGrows = [];
+    let pixelTotal = 0;
+    let fracTotal = 0;
+    for (let i = 0; i < dimConfigs.length; i++) {
+        const dimConfig = dimConfigs[i];
+        const constrainedPixels = Math.max(dimConfig.pixels, dimConfig.min);
+        flexDims.push(constrainedPixels);
+        flexGrows.push(pixelDims[i] - constrainedPixels); // a pixel value, but used as a proportion
+        pixelTotal += dimConfig.pixels + (dimConfig.grow ? dimConfig.min : 0);
+        fracTotal += dimConfig.frac; // not possible to enforce min for percentage here
+    }
+    const minCanvasDim = serializeDimConfig({
+        pixels: pixelTotal,
+        frac: fracTotal,
+    });
+    return [flexDims, flexGrows, minCanvasDim];
+}
+function serializeDimConfig({ pixels, frac }) {
+    if (!frac) {
+        return pixels;
+    }
+    if (!pixels) {
+        return fracToCssDim(frac);
+    }
+    return `calc(${fracToCssDim(frac)} + ${pixels}px)`;
+}
+function resizeSiblingDimConfig(dimConfigs, pixelDims, clientDim, resizeIndex, resizeDim) {
+    const newDimConfigs = [];
+    for (let i = 0; i < resizeIndex; i++) {
+        newDimConfigs.push(resizeDimConfig(dimConfigs[i], pixelDims[i], clientDim));
+    }
+    newDimConfigs.push(resizeDimConfig(dimConfigs[resizeIndex], resizeDim, clientDim));
+    const len = dimConfigs.length;
+    let anyGrow = false;
+    for (let i = resizeIndex + 1; i < len; i++) {
+        const dimConfig = dimConfigs[i];
+        newDimConfigs.push(dimConfig);
+        if (dimConfig.grow) {
+            anyGrow = true;
+        }
+    }
+    if (!anyGrow) {
+        for (let i = resizeIndex + 1; i < len; i++) {
+            newDimConfigs[i] = Object.assign({}, newDimConfigs[i], { grow: 1 });
+        }
+    }
+    return newDimConfigs;
+}
+function resizeDimConfig(dimConfig, newPixels, clientDim) {
+    const { min } = dimConfig;
+    newPixels = Math.max(min, newPixels);
+    if (dimConfig.pixels) {
+        return { pixels: newPixels, frac: 0, grow: 0, min };
+    }
+    return { pixels: 0, frac: newPixels / clientDim, grow: 0, min };
+}
+
+const ROW_BORDER_WIDTH = 1;
+// Resource/Group Verticals
+// -------------------------------------------------------------------------------------------------
+function computeHeights(siblingNodes, getEntityKey, getEntityHeight, minHeight) {
+    const heightMap = new Map();
+    let [totalHeight, expandableCount] = computeTightHeights(siblingNodes, getEntityKey, getEntityHeight, heightMap);
+    if (minHeight != null && minHeight > totalHeight) {
+        expandHeights(siblingNodes, getEntityKey, heightMap, (minHeight - totalHeight) / expandableCount);
+        totalHeight = minHeight;
+    }
+    return [heightMap, totalHeight];
+}
+function computeTightHeights(siblingNodes, getEntityKey, getEntityHeight, heightMap) {
+    let totalHeight = 0;
+    let expandableCount = 0;
+    for (const siblingNode of siblingNodes) {
+        const entityKey = getEntityKey(siblingNode.entity);
+        let ownHeight = getEntityHeight(entityKey) || 0;
+        const [childrenHeight, childrenExpandableCount] = computeTightHeights(siblingNode.children, getEntityKey, getEntityHeight, heightMap);
+        if (siblingNode.pooledHeight) { // 'own' is side-by-side with children
+            if (ownHeight > childrenHeight) {
+                // children are smaller. grow them
+                expandHeights(siblingNode.children, getEntityKey, heightMap, (ownHeight - childrenHeight) / childrenExpandableCount);
+            }
+            else {
+                // own-element is smaller. grow to height of children
+                ownHeight = childrenHeight;
+            }
+            totalHeight += ownHeight;
+        }
+        else { // 'own' is above children
+            totalHeight += ownHeight + ROW_BORDER_WIDTH + childrenHeight;
+        }
+        heightMap.set(entityKey, ownHeight);
+        // expandable?
+        // vertically stacked, and not a group
+        if (siblingNode.pooledHeight === undefined) {
+            expandableCount++;
+        }
+        expandableCount += childrenExpandableCount;
+    }
+    return [
+        totalHeight + ROW_BORDER_WIDTH * (siblingNodes.length - 1),
+        expandableCount,
+    ];
+}
+function expandHeights(siblingNodes, getEntityKey, heightMap, expansion) {
+    for (const siblingNode of siblingNodes) {
+        // expandable?
+        // vertically stacked, and not a group
+        if (siblingNode.pooledHeight === undefined) {
+            const entityKey = getEntityKey(siblingNode.entity);
+            heightMap.set(entityKey, heightMap.get(entityKey) + expansion);
+        }
+        expandHeights(siblingNode.children, getEntityKey, heightMap, expansion);
+    }
+}
+function computeTopsFromHeights(siblingNodes, getEntityKey, heightMap) {
+    const topMap = new Map();
+    computeTopsStartingAt(siblingNodes, getEntityKey, heightMap, topMap, 0);
+    return topMap;
+}
+function computeTopsStartingAt(siblingNodes, getEntityKey, heightMap, topMap, top) {
+    for (let i = 0; i < siblingNodes.length; i++) {
+        const siblingNode = siblingNodes[i];
+        const entityKey = getEntityKey(siblingNode.entity);
+        topMap.set(entityKey, top);
+        if (!siblingNode.pooledHeight) {
+            top += heightMap.get(entityKey) + ROW_BORDER_WIDTH;
+        }
+        top = computeTopsStartingAt(siblingNode.children, getEntityKey, heightMap, topMap, top);
+    }
+    return top;
+}
+function findEntityByCoord(siblingNodes, entityTops, // keyed by createEntityId
+entityHeights, // keyed by createEntityId
+coord, // assumed >= 0
+createEntityId) {
+    for (const siblingNode of siblingNodes) {
+        const entityKey = createEntityId(siblingNode.entity);
+        const siblingOwnTop = entityTops.get(entityKey);
+        const siblingOwnHeight = entityHeights.get(entityKey);
+        // intersection of the sibling's own element?
+        if (siblingOwnTop + siblingOwnHeight > coord) {
+            if (siblingNode.pooledHeight) {
+                // need more specific result
+                return findEntityByCoord(siblingNode.children, entityTops, entityHeights, coord, createEntityId);
+            }
+            else {
+                return [siblingNode.entity, siblingOwnTop, siblingOwnHeight];
+            }
+        }
+        else if (!siblingNode.pooledHeight) {
+            // search siblings below
+            const childrenRes = findEntityByCoord(siblingNode.children, entityTops, entityHeights, coord, createEntityId);
+            if (childrenRes) {
+                return childrenRes;
+            }
+        }
+    }
+}
+
+class ScrollerSyncer {
+    constructor(isHorizontal = false) {
+        this.isHorizontal = isHorizontal;
+        this.scrollers = [];
+        this.destroyFuncs = [];
+        this.isPaused = false;
+    }
+    handleChildren(scrollers) {
+        if (!isArraysEqual(this.scrollers, scrollers)) {
+            this.destroy();
+            for (const scroller of scrollers) {
+                if (scroller) { // could be null
+                    this.destroyFuncs.push(this.bindScroller(scroller));
+                    this.scrollers.push(scroller);
+                }
+            }
+        }
+    }
+    destroy() {
+        for (let destroyFunc of this.destroyFuncs) {
+            destroyFunc();
+        }
+        this.destroyFuncs = [];
+        this.scrollers = [];
+    }
+    get x() {
+        const { scrollers, masterScroller } = this;
+        return (masterScroller || scrollers[0]).x;
+    }
+    get y() {
+        const { scrollers, masterScroller } = this;
+        return (masterScroller || scrollers[0]).y;
+    }
+    scrollTo(scrollArg) {
+        this.isPaused = true;
+        const { scrollers } = this;
+        for (let scroller of scrollers) {
+            scroller.scrollTo(scrollArg);
+        }
+        this.isPaused = false;
+    }
+    addScrollEndListener(handler) {
+        var _a;
+        (_a = this.emitter) === null || _a === void 0 ? void 0 : _a.on('scrollEnd', handler);
+    }
+    removeScrollEndListener(handler) {
+        var _a;
+        (_a = this.emitter) === null || _a === void 0 ? void 0 : _a.off('scrollEnd', handler);
+    }
+    bindScroller(scroller) {
+        var _a, _b;
+        let { isHorizontal } = this;
+        const onScroll = (isUser) => {
+            if (!this.isPaused) {
+                if (!this.masterScroller || (this.masterScroller !== scroller && isUser)) {
+                    this.assignMaster(scroller);
+                }
+                if (this.masterScroller === scroller) { // dealing with current
+                    for (let otherScroller of this.scrollers) {
+                        if (otherScroller !== scroller) {
+                            if (isHorizontal) {
+                                // TODO: user raw scrollLeft for better performance. No normalization necessary
+                                otherScroller.scrollTo({ x: scroller.x });
+                            }
+                            else {
+                                otherScroller.scrollTo({ y: scroller.y });
+                            }
+                        }
+                    }
+                }
+            }
+        };
+        const onScrollEnd = (isUser) => {
+            var _a;
+            if (this.masterScroller === scroller) {
+                this.masterScroller = null;
+                const { x, y } = this; // new values
+                let isMoved = false;
+                if (this.isHorizontal) {
+                    if (x !== this.prevX) {
+                        this.prevX = x;
+                        isMoved = true;
+                    }
+                }
+                else {
+                    if (y !== this.prevY) {
+                        this.prevY = y;
+                        isMoved = true;
+                    }
+                }
+                if (isMoved) {
+                    (_a = this.emitter) === null || _a === void 0 ? void 0 : _a.trigger('scrollEnd', isUser);
+                }
+            }
+        };
+        (_a = scroller.listener.emitter) === null || _a === void 0 ? void 0 : _a.on('scroll', onScroll);
+        (_b = scroller.listener.emitter) === null || _b === void 0 ? void 0 : _b.on('scrollEnd', onScrollEnd);
+        return () => {
+            var _a, _b;
+            (_a = scroller.listener.emitter) === null || _a === void 0 ? void 0 : _a.off('scroll', onScroll);
+            (_b = scroller.listener.emitter) === null || _b === void 0 ? void 0 : _b.off('scrollEnd', onScrollEnd);
+        };
+    }
+    assignMaster(masterScroller) {
+        this.masterScroller = masterScroller;
+        for (let scroller of this.scrollers) {
+            if (scroller !== masterScroller) {
+                scroller.endScroll(); // to prevent residual scrolls from reclaiming master
+            }
+        }
+    }
+}
+function isArraysEqual(array0, array1) {
+    if (array0 === array1) {
+        return true;
+    }
+    let len = array0.length;
+    let i;
+    if (len !== array1.length) { // not array? or not same length?
+        return false;
+    }
+    for (i = 0; i < len; i += 1) {
+        if (array0[i] === array1[i]) {
+            return false;
+        }
+    }
+    return true;
+}
+
+exports.ROW_BORDER_WIDTH = ROW_BORDER_WIDTH;
+exports.ScrollerSyncer = ScrollerSyncer;
+exports.computeHeights = computeHeights;
+exports.computeTopsFromHeights = computeTopsFromHeights;
+exports.ensureDimConfigsGrow = ensureDimConfigsGrow;
+exports.findEntityByCoord = findEntityByCoord;
+exports.flexifyDimConfigs = flexifyDimConfigs;
+exports.parseDimConfig = parseDimConfig;
+exports.parseSiblingDimConfig = parseSiblingDimConfig;
+exports.pixelizeDimConfigs = pixelizeDimConfigs;
+exports.resizeDimConfig = resizeDimConfig;
+exports.resizeSiblingDimConfig = resizeSiblingDimConfig;
+exports.serializeDimConfig = serializeDimConfig;

package/esm/index.d.ts

@@ -0,0 +1,87 @@
+type CssDimValue = string | number;
+
+interface DimConfig {
+    pixels: number;
+    frac: number;
+    min: number;
+}
+interface SiblingDimConfig extends DimConfig {
+    grow: number;
+}
+declare function parseDimConfig(input: CssDimValue | undefined, minDim?: number): DimConfig | undefined;
+declare function parseSiblingDimConfig(input: CssDimValue | undefined, grow: number | undefined, // TODO: use (and sanitize)
+minDim: number | undefined): SiblingDimConfig;
+declare function ensureDimConfigsGrow(dimConfigs: SiblingDimConfig[]): void;
+declare function pixelizeDimConfigs(dimConfigs: SiblingDimConfig[], clientDim: number): [
+    pixelDims: number[],
+    minCanvasDim: number
+];
+declare function flexifyDimConfigs(dimConfigs: SiblingDimConfig[], pixelDims: number[]): [
+    flexDims: number[],
+    flexGrows: number[],
+    minCanvasDim: CssDimValue
+];
+declare function serializeDimConfig({ pixels, frac }: {
+    pixels: number;
+    frac: number;
+}): CssDimValue;
+declare function resizeSiblingDimConfig(dimConfigs: SiblingDimConfig[], pixelDims: number[], clientDim: number, resizeIndex: number, resizeDim: number): SiblingDimConfig[];
+declare function resizeDimConfig(dimConfig: DimConfig, newPixels: number, clientDim: number): SiblingDimConfig;
+
+interface GenericLayout<Entity> {
+    rowIndex: number;
+    visibleIndex: number;
+    entity: Entity;
+    pooledHeight?: boolean;
+    children: GenericLayout<Entity>[];
+}
+declare const ROW_BORDER_WIDTH = 1;
+declare function computeHeights<Entity, Key>(siblingNodes: GenericLayout<Entity>[], getEntityKey: (entity: Entity) => Key, getEntityHeight: (entityKey: Key) => number, minHeight?: number): [
+    heightMap: Map<Key, number>,
+    totalHeight: number
+];
+declare function computeTopsFromHeights<Entity, Key>(siblingNodes: GenericLayout<Entity>[], getEntityKey: (entity: Entity) => Key, heightMap: Map<Key, number>): Map<Key, number>;
+declare function findEntityByCoord<Entity>(siblingNodes: GenericLayout<Entity>[], entityTops: Map<string, number>, // keyed by createEntityId
+entityHeights: Map<string, number>, // keyed by createEntityId
+coord: number, // assumed >= 0
+createEntityId: (entity: Entity) => string): [
+    entity: Entity,
+    top: number,
+    height: number
+] | undefined;
+
+interface Scroller {
+    scrollTo({ x, y }: {
+        x?: number;
+        y?: number;
+    }): void;
+    x: number;
+    y: number;
+    listener: any;
+    endScroll(): void;
+}
+declare class ScrollerSyncer {
+    private isHorizontal;
+    private emitter;
+    private scrollers;
+    private destroyFuncs;
+    private masterScroller;
+    private isPaused;
+    private prevX;
+    private prevY;
+    constructor(isHorizontal?: boolean);
+    handleChildren(scrollers: Scroller[]): void;
+    destroy(): void;
+    get x(): number;
+    get y(): number;
+    scrollTo(scrollArg: {
+        x?: number;
+        y?: number;
+    }): void;
+    addScrollEndListener(handler: (isUser: boolean) => void): void;
+    removeScrollEndListener(handler: (isUser: boolean) => void): void;
+    bindScroller(scroller: Scroller): () => void;
+    assignMaster(masterScroller: Scroller): void;
+}
+
+export { DimConfig, GenericLayout, ROW_BORDER_WIDTH, Scroller, ScrollerSyncer, SiblingDimConfig, computeHeights, computeTopsFromHeights, ensureDimConfigsGrow, findEntityByCoord, flexifyDimConfigs, parseDimConfig, parseSiblingDimConfig, pixelizeDimConfigs, resizeDimConfig, resizeSiblingDimConfig, serializeDimConfig };

package/esm/index.js

@@ -0,0 +1,355 @@
+function fracToCssDim(frac) {
+    return frac * 100 + '%';
+}
+
+function parseDimConfig(input, minDim = 0) {
+    if (input != null) {
+        if (typeof input === 'string') {
+            let m = input.match(/^(.*)(%|px)$/);
+            if (m) {
+                const num = parseFloat(m[1]);
+                if (!isNaN(num)) {
+                    if (m[2] === '%') {
+                        return { pixels: 0, frac: num / 100, min: minDim };
+                    }
+                    else {
+                        return { pixels: num, frac: 0, min: minDim };
+                    }
+                }
+            }
+        }
+        else if (typeof input === 'number' && !isNaN(input)) {
+            return { pixels: input, frac: 0, min: minDim };
+        }
+    }
+}
+function parseSiblingDimConfig(input, grow, // TODO: use (and sanitize)
+minDim) {
+    const partialDimConfig = parseDimConfig(input, minDim);
+    return partialDimConfig
+        ? Object.assign(Object.assign({}, partialDimConfig), { grow: grow || 0 }) : { pixels: 0, frac: 0, grow: grow || 1, min: minDim };
+}
+/*
+Ensure at least one column can grow
+Mutates in-place
+*/
+function ensureDimConfigsGrow(dimConfigs) {
+    for (const dimConfig of dimConfigs) {
+        if (dimConfig.grow) {
+            return;
+        }
+    }
+    // make all expand equally
+    for (const dimConfig of dimConfigs) {
+        dimConfig.grow = 1;
+    }
+}
+function pixelizeDimConfigs(dimConfigs, clientDim) {
+    const pixelDims = [];
+    let preGrowTotal = 0;
+    let growDenom = 0;
+    for (const dimConfig of dimConfigs) {
+        const constrainedPixels = Math.max(dimConfig.pixels + (dimConfig.frac * clientDim), dimConfig.min);
+        pixelDims.push(constrainedPixels);
+        preGrowTotal += constrainedPixels;
+        growDenom += dimConfig.grow;
+    }
+    if (preGrowTotal < clientDim) {
+        const remainder = clientDim - preGrowTotal;
+        for (let i = 0; i < dimConfigs.length; i++) {
+            pixelDims[i] += remainder * (dimConfigs[i].grow / growDenom);
+        }
+    }
+    return [pixelDims, preGrowTotal];
+}
+function flexifyDimConfigs(dimConfigs, pixelDims) {
+    const flexDims = [];
+    const flexGrows = [];
+    let pixelTotal = 0;
+    let fracTotal = 0;
+    for (let i = 0; i < dimConfigs.length; i++) {
+        const dimConfig = dimConfigs[i];
+        const constrainedPixels = Math.max(dimConfig.pixels, dimConfig.min);
+        flexDims.push(constrainedPixels);
+        flexGrows.push(pixelDims[i] - constrainedPixels); // a pixel value, but used as a proportion
+        pixelTotal += dimConfig.pixels + (dimConfig.grow ? dimConfig.min : 0);
+        fracTotal += dimConfig.frac; // not possible to enforce min for percentage here
+    }
+    const minCanvasDim = serializeDimConfig({
+        pixels: pixelTotal,
+        frac: fracTotal,
+    });
+    return [flexDims, flexGrows, minCanvasDim];
+}
+function serializeDimConfig({ pixels, frac }) {
+    if (!frac) {
+        return pixels;
+    }
+    if (!pixels) {
+        return fracToCssDim(frac);
+    }
+    return `calc(${fracToCssDim(frac)} + ${pixels}px)`;
+}
+function resizeSiblingDimConfig(dimConfigs, pixelDims, clientDim, resizeIndex, resizeDim) {
+    const newDimConfigs = [];
+    for (let i = 0; i < resizeIndex; i++) {
+        newDimConfigs.push(resizeDimConfig(dimConfigs[i], pixelDims[i], clientDim));
+    }
+    newDimConfigs.push(resizeDimConfig(dimConfigs[resizeIndex], resizeDim, clientDim));
+    const len = dimConfigs.length;
+    let anyGrow = false;
+    for (let i = resizeIndex + 1; i < len; i++) {
+        const dimConfig = dimConfigs[i];
+        newDimConfigs.push(dimConfig);
+        if (dimConfig.grow) {
+            anyGrow = true;
+        }
+    }
+    if (!anyGrow) {
+        for (let i = resizeIndex + 1; i < len; i++) {
+            newDimConfigs[i] = Object.assign({}, newDimConfigs[i], { grow: 1 });
+        }
+    }
+    return newDimConfigs;
+}
+function resizeDimConfig(dimConfig, newPixels, clientDim) {
+    const { min } = dimConfig;
+    newPixels = Math.max(min, newPixels);
+    if (dimConfig.pixels) {
+        return { pixels: newPixels, frac: 0, grow: 0, min };
+    }
+    return { pixels: 0, frac: newPixels / clientDim, grow: 0, min };
+}
+
+const ROW_BORDER_WIDTH = 1;
+// Resource/Group Verticals
+// -------------------------------------------------------------------------------------------------
+function computeHeights(siblingNodes, getEntityKey, getEntityHeight, minHeight) {
+    const heightMap = new Map();
+    let [totalHeight, expandableCount] = computeTightHeights(siblingNodes, getEntityKey, getEntityHeight, heightMap);
+    if (minHeight != null && minHeight > totalHeight) {
+        expandHeights(siblingNodes, getEntityKey, heightMap, (minHeight - totalHeight) / expandableCount);
+        totalHeight = minHeight;
+    }
+    return [heightMap, totalHeight];
+}
+function computeTightHeights(siblingNodes, getEntityKey, getEntityHeight, heightMap) {
+    let totalHeight = 0;
+    let expandableCount = 0;
+    for (const siblingNode of siblingNodes) {
+        const entityKey = getEntityKey(siblingNode.entity);
+        let ownHeight = getEntityHeight(entityKey) || 0;
+        const [childrenHeight, childrenExpandableCount] = computeTightHeights(siblingNode.children, getEntityKey, getEntityHeight, heightMap);
+        if (siblingNode.pooledHeight) { // 'own' is side-by-side with children
+            if (ownHeight > childrenHeight) {
+                // children are smaller. grow them
+                expandHeights(siblingNode.children, getEntityKey, heightMap, (ownHeight - childrenHeight) / childrenExpandableCount);
+            }
+            else {
+                // own-element is smaller. grow to height of children
+                ownHeight = childrenHeight;
+            }
+            totalHeight += ownHeight;
+        }
+        else { // 'own' is above children
+            totalHeight += ownHeight + ROW_BORDER_WIDTH + childrenHeight;
+        }
+        heightMap.set(entityKey, ownHeight);
+        // expandable?
+        // vertically stacked, and not a group
+        if (siblingNode.pooledHeight === undefined) {
+            expandableCount++;
+        }
+        expandableCount += childrenExpandableCount;
+    }
+    return [
+        totalHeight + ROW_BORDER_WIDTH * (siblingNodes.length - 1),
+        expandableCount,
+    ];
+}
+function expandHeights(siblingNodes, getEntityKey, heightMap, expansion) {
+    for (const siblingNode of siblingNodes) {
+        // expandable?
+        // vertically stacked, and not a group
+        if (siblingNode.pooledHeight === undefined) {
+            const entityKey = getEntityKey(siblingNode.entity);
+            heightMap.set(entityKey, heightMap.get(entityKey) + expansion);
+        }
+        expandHeights(siblingNode.children, getEntityKey, heightMap, expansion);
+    }
+}
+function computeTopsFromHeights(siblingNodes, getEntityKey, heightMap) {
+    const topMap = new Map();
+    computeTopsStartingAt(siblingNodes, getEntityKey, heightMap, topMap, 0);
+    return topMap;
+}
+function computeTopsStartingAt(siblingNodes, getEntityKey, heightMap, topMap, top) {
+    for (let i = 0; i < siblingNodes.length; i++) {
+        const siblingNode = siblingNodes[i];
+        const entityKey = getEntityKey(siblingNode.entity);
+        topMap.set(entityKey, top);
+        if (!siblingNode.pooledHeight) {
+            top += heightMap.get(entityKey) + ROW_BORDER_WIDTH;
+        }
+        top = computeTopsStartingAt(siblingNode.children, getEntityKey, heightMap, topMap, top);
+    }
+    return top;
+}
+function findEntityByCoord(siblingNodes, entityTops, // keyed by createEntityId
+entityHeights, // keyed by createEntityId
+coord, // assumed >= 0
+createEntityId) {
+    for (const siblingNode of siblingNodes) {
+        const entityKey = createEntityId(siblingNode.entity);
+        const siblingOwnTop = entityTops.get(entityKey);
+        const siblingOwnHeight = entityHeights.get(entityKey);
+        // intersection of the sibling's own element?
+        if (siblingOwnTop + siblingOwnHeight > coord) {
+            if (siblingNode.pooledHeight) {
+                // need more specific result
+                return findEntityByCoord(siblingNode.children, entityTops, entityHeights, coord, createEntityId);
+            }
+            else {
+                return [siblingNode.entity, siblingOwnTop, siblingOwnHeight];
+            }
+        }
+        else if (!siblingNode.pooledHeight) {
+            // search siblings below
+            const childrenRes = findEntityByCoord(siblingNode.children, entityTops, entityHeights, coord, createEntityId);
+            if (childrenRes) {
+                return childrenRes;
+            }
+        }
+    }
+}
+
+class ScrollerSyncer {
+    constructor(isHorizontal = false) {
+        this.isHorizontal = isHorizontal;
+        this.scrollers = [];
+        this.destroyFuncs = [];
+        this.isPaused = false;
+    }
+    handleChildren(scrollers) {
+        if (!isArraysEqual(this.scrollers, scrollers)) {
+            this.destroy();
+            for (const scroller of scrollers) {
+                if (scroller) { // could be null
+                    this.destroyFuncs.push(this.bindScroller(scroller));
+                    this.scrollers.push(scroller);
+                }
+            }
+        }
+    }
+    destroy() {
+        for (let destroyFunc of this.destroyFuncs) {
+            destroyFunc();
+        }
+        this.destroyFuncs = [];
+        this.scrollers = [];
+    }
+    get x() {
+        const { scrollers, masterScroller } = this;
+        return (masterScroller || scrollers[0]).x;
+    }
+    get y() {
+        const { scrollers, masterScroller } = this;
+        return (masterScroller || scrollers[0]).y;
+    }
+    scrollTo(scrollArg) {
+        this.isPaused = true;
+        const { scrollers } = this;
+        for (let scroller of scrollers) {
+            scroller.scrollTo(scrollArg);
+        }
+        this.isPaused = false;
+    }
+    addScrollEndListener(handler) {
+        var _a;
+        (_a = this.emitter) === null || _a === void 0 ? void 0 : _a.on('scrollEnd', handler);
+    }
+    removeScrollEndListener(handler) {
+        var _a;
+        (_a = this.emitter) === null || _a === void 0 ? void 0 : _a.off('scrollEnd', handler);
+    }
+    bindScroller(scroller) {
+        var _a, _b;
+        let { isHorizontal } = this;
+        const onScroll = (isUser) => {
+            if (!this.isPaused) {
+                if (!this.masterScroller || (this.masterScroller !== scroller && isUser)) {
+                    this.assignMaster(scroller);
+                }
+                if (this.masterScroller === scroller) { // dealing with current
+                    for (let otherScroller of this.scrollers) {
+                        if (otherScroller !== scroller) {
+                            if (isHorizontal) {
+                                // TODO: user raw scrollLeft for better performance. No normalization necessary
+                                otherScroller.scrollTo({ x: scroller.x });
+                            }
+                            else {
+                                otherScroller.scrollTo({ y: scroller.y });
+                            }
+                        }
+                    }
+                }
+            }
+        };
+        const onScrollEnd = (isUser) => {
+            var _a;
+            if (this.masterScroller === scroller) {
+                this.masterScroller = null;
+                const { x, y } = this; // new values
+                let isMoved = false;
+                if (this.isHorizontal) {
+                    if (x !== this.prevX) {
+                        this.prevX = x;
+                        isMoved = true;
+                    }
+                }
+                else {
+                    if (y !== this.prevY) {
+                        this.prevY = y;
+                        isMoved = true;
+                    }
+                }
+                if (isMoved) {
+                    (_a = this.emitter) === null || _a === void 0 ? void 0 : _a.trigger('scrollEnd', isUser);
+                }
+            }
+        };
+        (_a = scroller.listener.emitter) === null || _a === void 0 ? void 0 : _a.on('scroll', onScroll);
+        (_b = scroller.listener.emitter) === null || _b === void 0 ? void 0 : _b.on('scrollEnd', onScrollEnd);
+        return () => {
+            var _a, _b;
+            (_a = scroller.listener.emitter) === null || _a === void 0 ? void 0 : _a.off('scroll', onScroll);
+            (_b = scroller.listener.emitter) === null || _b === void 0 ? void 0 : _b.off('scrollEnd', onScrollEnd);
+        };
+    }
+    assignMaster(masterScroller) {
+        this.masterScroller = masterScroller;
+        for (let scroller of this.scrollers) {
+            if (scroller !== masterScroller) {
+                scroller.endScroll(); // to prevent residual scrolls from reclaiming master
+            }
+        }
+    }
+}
+function isArraysEqual(array0, array1) {
+    if (array0 === array1) {
+        return true;
+    }
+    let len = array0.length;
+    let i;
+    if (len !== array1.length) { // not array? or not same length?
+        return false;
+    }
+    for (i = 0; i < len; i += 1) {
+        if (array0[i] === array1[i]) {
+            return false;
+        }
+    }
+    return true;
+}
+
+export { ROW_BORDER_WIDTH, ScrollerSyncer, computeHeights, computeTopsFromHeights, ensureDimConfigsGrow, findEntityByCoord, flexifyDimConfigs, parseDimConfig, parseSiblingDimConfig, pixelizeDimConfigs, resizeDimConfig, resizeSiblingDimConfig, serializeDimConfig };

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@full-ui/headless-grid",
+  "version": "7.0.0-beta.5",
+  "keywords": [
+    "headless",
+    "grid",
+    "datagrid"
+  ],
+  "title": "Headless DataGrid Library",
+  "description": "Headless datagrid library by the makers of FullCalendar",
+  "type": "module",
+  "homepage": "https://fullcalendar.io/docs/premium",
+  "bugs": "https://fullcalendar.io/reporting-bugs",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/fullcalendar/fullcalendar-workspace.git",
+    "directory": "premium/packages/headless-grid"
+  },
+  "license": "SEE LICENSE IN LICENSE.md",
+  "author": {
+    "name": "Adam Shaw",
+    "email": "arshaw@arshaw.com",
+    "url": "http://arshaw.com/"
+  },
+  "copyright": "2025 Adam Shaw",
+  "types": "./esm/index.d.ts",
+  "module": "./esm/index.js",
+  "main": "./cjs/index.cjs",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "import": {
+        "types": "./esm/index.d.ts",
+        "default": "./esm/index.js"
+      },
+      "require": "./cjs/index.cjs"
+    }
+  },
+  "sideEffects": false
+}