@full-ui/headless-grid 7.0.0-beta.6 → 7.0.0-beta.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@full-ui/headless-grid",
-  "version": "7.0.0-beta.6",
+  "version": "7.0.0-beta.7",
   "keywords": [
     "headless",
     "grid",
@@ -23,17 +23,13 @@
     "url": "http://arshaw.com/"
   },
   "copyright": "2025 Adam Shaw",
-  "types": "./esm/index.d.ts",
-  "module": "./esm/index.js",
-  "main": "./cjs/index.cjs",
+  "types": "./index.d.ts",
+  "main": "./index.js",
   "exports": {
     "./package.json": "./package.json",
     ".": {
-      "import": {
-        "types": "./esm/index.d.ts",
-        "default": "./esm/index.js"
-      },
-      "require": "./cjs/index.cjs"
+      "types": "./index.d.ts",
+      "default": "./index.js"
     }
   },
   "sideEffects": false

package/cjs/index.cjs

@@ -1,371 +0,0 @@
-'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;