npm - @enhanced-dom/virtualizer - Versions diffs - 0.2.0 → 0.3.0 - Mend

@enhanced-dom/virtualizer 0.2.0 → 0.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (9) hide show

package/StickyGroup.d.ts ADDED Viewed

@@ -0,0 +1,35 @@
+import { TreePartType, ITreePart } from './types.js';
+export declare class StickyGroupNode implements ITreePart {
+    id: string | number;
+    level: number;
+    parent?: StickyGroupNode | StickyGroupForest | null;
+    children: StickyGroupNode[];
+    type: TreePartType;
+    static isInstance(treePart?: ITreePart | null): treePart is StickyGroupNode;
+    constructor(id: string | number, level: number);
+    addChild(child: StickyGroupNode): StickyGroupNode;
+    getAncestor(level: number): StickyGroupNode | null | undefined;
+    findNode(id: string | number): ITreePart | null | undefined;
+    findNextSibling(): StickyGroupNode | null;
+    findPreviousSibling(): StickyGroupNode | null;
+    hasChildren(): boolean;
+    private _size?;
+    get size(): number | undefined;
+    private _depth?;
+    get depth(): number | undefined;
+}
+export declare class StickyGroupForest implements ITreePart {
+    children: StickyGroupNode[];
+    type: TreePartType;
+    addChild(child: StickyGroupNode): void;
+    hasChildren(): boolean;
+    getAncestor(): null;
+    private _size?;
+    size(id?: string | number): number | undefined;
+    get depth(): number;
+    findNode(id: string | number): StickyGroupNode | undefined;
+    findAncestors(startNode: StickyGroupNode): StickyGroupNode[];
+    findNextSibling(): null;
+    findPreviousSibling(): null;
+}
+export declare const findStickyGroupAncestor: (node: StickyGroupNode | null, level: number) => StickyGroupNode | null;

package/StickyGroup.js ADDED Viewed

@@ -0,0 +1,112 @@
+import { TreePartType } from './types.js';
+export class StickyGroupNode {
+    id;
+    level;
+    parent = null;
+    children = [];
+    type = TreePartType.NODE;
+    static isInstance(treePart) {
+        return treePart?.type === TreePartType.NODE;
+    }
+    constructor(id, level) {
+        this.id = id;
+        this.level = level;
+    }
+    addChild(child) {
+        child.parent = this;
+        this.children.push(child);
+        return child;
+    }
+    getAncestor(level) {
+        if (this.level > level) {
+            return this;
+        }
+        return this.parent?.getAncestor(level);
+    }
+    findNode(id) {
+        if (this.id == id) {
+            return this;
+        }
+        return this.children.map((c) => c.findNode(id)).find((n) => !!n);
+    }
+    findNextSibling() {
+        const currentNodeIndex = this.parent.children.indexOf(this);
+        return this.parent.children[currentNodeIndex + 1] ?? this.parent.findNextSibling();
+    }
+    findPreviousSibling() {
+        const currentNodeIndex = this.parent.children.indexOf(this);
+        return this.parent.children[currentNodeIndex - 1] ?? (StickyGroupNode.isInstance(this.parent) ? this.parent : null);
+    }
+    hasChildren() {
+        return !!this.children.length;
+    }
+    _size = undefined;
+    get size() {
+        if (this._size == null) {
+            this._size = this.hasChildren() ? Math.max(...this.children.map((c) => c.size).filter((v) => v != null)) + 1 : 0;
+        }
+        return this._size;
+    }
+    _depth = undefined;
+    get depth() {
+        if (this._depth == null) {
+            this._depth = (this.parent?.depth ?? 0) + 1;
+        }
+        return this._depth;
+    }
+}
+export class StickyGroupForest {
+    children = [];
+    type = TreePartType.FOREST;
+    addChild(child) {
+        child.parent = this;
+        this.children.push(child);
+    }
+    hasChildren() {
+        return !!this.children.length;
+    }
+    getAncestor() {
+        return null;
+    }
+    _size = undefined;
+    size(id) {
+        if (id != null) {
+            return this.findNode(id)?.size;
+        }
+        if (this._size == null) {
+            this._size = this.hasChildren() ? Math.max(...this.children.map((c) => c.size).filter((v) => v != null)) + 1 : 0;
+        }
+        return this._size;
+    }
+    get depth() {
+        return 0;
+    }
+    findNode(id) {
+        return this.children.map((c) => c.findNode(id)).find((n) => !!n);
+    }
+    findAncestors(startNode) {
+        let node = startNode;
+        const ancestors = [];
+        while (node.parent !== this) {
+            node = node.parent;
+            ancestors.unshift(node);
+        }
+        return ancestors;
+    }
+    findNextSibling() {
+        return null;
+    }
+    findPreviousSibling() {
+        return null;
+    }
+}
+export const findStickyGroupAncestor = (node, level) => {
+    if (!node) {
+        return null;
+    }
+    if (node.level > level) {
+        return node;
+    }
+    return node.getAncestor(level) ?? null;
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"StickyGroup.js","sourceRoot":"","sources":["../src/StickyGroup.ts"],"names":[],"mappings":"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","sourcesContent":["import { TreePartType, ITreePart } from './types'\n\nexport class StickyGroupNode implements ITreePart {\n  public id: string | number\n  public level: number\n  public parent?: StickyGroupNode | StickyGroupForest | null = null\n  public children: StickyGroupNode[] = []\n  public type = TreePartType.NODE\n  static isInstance(treePart?: ITreePart | null): treePart is StickyGroupNode {\n    return treePart?.type === TreePartType.NODE\n  }\n  constructor(id: string | number, level: number) {\n    this.id = id\n    this.level = level\n  }\n\n  public addChild(child: StickyGroupNode) {\n    child.parent = this\n    this.children.push(child)\n    return child\n  }\n\n  public getAncestor(level: number): StickyGroupNode | null | undefined {\n    if (this.level > level) {\n      return this\n    }\n    return this.parent?.getAncestor(level)\n  }\n\n  public findNode(id: string | number): ITreePart | null | undefined {\n    if (this.id == id) {\n      return this\n    }\n    return this.children.map((c) => c.findNode(id)).find((n) => !!n)\n  }\n\n  public findNextSibling(): StickyGroupNode | null {\n    const currentNodeIndex = this.parent!.children.indexOf(this)\n    return this.parent!.children[currentNodeIndex + 1] ?? this.parent!.findNextSibling()\n  }\n\n  public findPreviousSibling(): StickyGroupNode | null {\n    const currentNodeIndex = this.parent!.children.indexOf(this)\n    return this.parent!.children[currentNodeIndex - 1] ?? (StickyGroupNode.isInstance(this.parent) ? this.parent : null)\n  }\n\n  public hasChildren() {\n    return !!this.children.length\n  }\n\n  private _size?: number = undefined\n  public get size(): number | undefined {\n    if (this._size == null) {\n      this._size = this.hasChildren() ? Math.max(...this.children.map((c) => c.size).filter((v) => v != null)) + 1 : 0\n    }\n\n    return this._size\n  }\n\n  private _depth?: number | undefined = undefined\n  public get depth(): number | undefined {\n    if (this._depth == null) {\n      this._depth = (this.parent?.depth ?? 0) + 1\n    }\n\n    return this._depth\n  }\n}\n\nexport class StickyGroupForest implements ITreePart {\n  public children: StickyGroupNode[] = []\n  public type = TreePartType.FOREST\n  public addChild(child: StickyGroupNode) {\n    child.parent = this\n    this.children.push(child)\n  }\n\n  public hasChildren() {\n    return !!this.children.length\n  }\n\n  public getAncestor() {\n    return null\n  }\n\n  private _size?: number = undefined\n  public size(id?: string | number): number | undefined {\n    if (id != null) {\n      return this.findNode(id)?.size\n    }\n    if (this._size == null) {\n      this._size = this.hasChildren() ? Math.max(...this.children.map((c) => c.size).filter((v) => v != null)) + 1 : 0\n    }\n\n    return this._size\n  }\n\n  public get depth() {\n    return 0\n  }\n\n  public findNode(id: string | number): StickyGroupNode | undefined {\n    return this.children.map((c) => c.findNode(id)).find((n) => !!n) as StickyGroupNode | undefined\n  }\n\n  public findAncestors(startNode: StickyGroupNode) {\n    let node: StickyGroupNode = startNode\n    const ancestors = []\n    while (node.parent !== this) {\n      node = node.parent as StickyGroupNode\n      ancestors.unshift(node)\n    }\n    return ancestors\n  }\n\n  public findNextSibling() {\n    return null\n  }\n\n  public findPreviousSibling() {\n    return null\n  }\n}\n\nexport const findStickyGroupAncestor = (node: StickyGroupNode | null, level: number): StickyGroupNode | null => {\n  if (!node) {\n    return null\n  }\n  if (node.level > level) {\n    return node\n  }\n  return node.getAncestor(level) ?? null\n}\n"]}

package/index.d.ts CHANGED Viewed

@@ -1,26 +1,2 @@
-export type IVirtualizerEntry = {
-    level?: number;
-    id: string | number;
-    maxSize?: number;
-    weight?: number;
-} & ({
-    minSize: number;
-    fixedSize?: number;
-} | {
-    minSize?: number;
-    fixedSize: number;
-});
-export interface IVirtualizerConfig {
-    viewportSize: number;
-    offset?: number;
-    overscan?: number;
-}
-export interface IVirtualizerResult extends Pick<IVirtualizerEntry, 'id'> {
-    size: number;
-    offset?: number;
-    relativeOffset?: number;
-    minOffset?: number;
-    maxOffset?: number;
-    level?: number;
-}
-export declare const virtualize: (config: IVirtualizerConfig, entries: IVirtualizerEntry[]) => IVirtualizerResult[];
+export type { IVirtualizerEntry, IVirtualizerConfig, IVirtualizerResult, IVirtualizerResultFlat, IVirtualizerResultLevel } from './types.js';
+export * from './virtualizer.js';

package/index.js CHANGED Viewed

@@ -1,333 +1,2 @@
-var TreePartType;
-(function (TreePartType) {
-    TreePartType["NODE"] = "node";
-    TreePartType["FOREST"] = "forest";
-})(TreePartType || (TreePartType = {}));
-class StickyGroupNode {
-    static isInstance(treePart) {
-        return (treePart === null || treePart === void 0 ? void 0 : treePart.type) === TreePartType.NODE;
-    }
-    constructor(id, level) {
-        this.parent = null;
-        this.children = [];
-        this.type = TreePartType.NODE;
-        this._size = null;
-        this._depth = null;
-        this.id = id;
-        this.level = level;
-    }
-    addChild(child) {
-        child.parent = this;
-        this.children.push(child);
-        return child;
-    }
-    getAncestor(level) {
-        var _a;
-        if (this.level > level) {
-            return this;
-        }
-        return (_a = this.parent) === null || _a === void 0 ? void 0 : _a.getAncestor(level);
-    }
-    findNode(id) {
-        if (this.id == id) {
-            return this;
-        }
-        return this.children.map((c) => c.findNode(id)).find((n) => !!n);
-    }
-    findNextSibling() {
-        var _a;
-        const currentNodeIndex = this.parent.children.indexOf(this);
-        return (_a = this.parent.children[currentNodeIndex + 1]) !== null && _a !== void 0 ? _a : this.parent.findNextSibling();
-    }
-    findPreviousSibling() {
-        var _a;
-        const currentNodeIndex = this.parent.children.indexOf(this);
-        return (_a = this.parent.children[currentNodeIndex - 1]) !== null && _a !== void 0 ? _a : (StickyGroupNode.isInstance(this.parent) ? this.parent : null);
-    }
-    hasChildren() {
-        return !!this.children.length;
-    }
-    get size() {
-        if (this._size == null) {
-            this._size = this.hasChildren() ? Math.max(...this.children.map((c) => c.size)) + 1 : 0;
-        }
-        return this._size;
-    }
-    get depth() {
-        if (this._depth == null) {
-            this._depth = this.parent.depth + 1;
-        }
-        return this._depth;
-    }
-}
-class StickyGroupForest {
-    constructor() {
-        this.children = [];
-        this.type = TreePartType.FOREST;
-        this._size = null;
-    }
-    addChild(child) {
-        child.parent = this;
-        this.children.push(child);
-    }
-    hasChildren() {
-        return !!this.children.length;
-    }
-    getAncestor() {
-        return null;
-    }
-    size(id) {
-        var _a;
-        if (id != null) {
-            return (_a = this.findNode(id)) === null || _a === void 0 ? void 0 : _a.size;
-        }
-        if (this._size == null) {
-            this._size = this.hasChildren() ? Math.max(...this.children.map((c) => c.size)) + 1 : 0;
-        }
-        return this._size;
-    }
-    get depth() {
-        return 0;
-    }
-    findNode(id) {
-        return this.children.map((c) => c.findNode(id)).find((n) => !!n);
-    }
-    findAncestors(id) {
-        let node = this.findNode(id);
-        if (!node) {
-            return [];
-        }
-        const ancestors = [];
-        while (node.parent !== this) {
-            node = node.parent;
-            ancestors.unshift(node);
-        }
-        return ancestors;
-    }
-    findNextSibling() {
-        return null;
-    }
-    findPreviousSibling() {
-        return null;
-    }
-}
-export const virtualize = (config, entries) => {
-    var _a, _b, _c;
-    const { offset, overscan, viewportSize } = {
-        offset: 0,
-        overscan: 5,
-        ...config,
-    };
-    // first, let us figure out if the size is smaller than the viewport
-    // while we iterate over the entries, we should also find out some 'statisticts' about weights
-    let lowerBoundSize = 0;
-    const entriesWithDynamicSpace = [];
-    const unboundedEntries = [];
-    const entriesOffsets = [];
-    const stickyGroups = new StickyGroupForest();
-    const entryById = {};
-    let currentStickyGroupNode = null;
-    let minimumExplicitWeight = Infinity;
-    let minimumDerivedWeight = Infinity;
-    for (const e of entries) {
-        const entryMinSize = (_a = e.fixedSize) !== null && _a !== void 0 ? _a : e.minSize;
-        entriesOffsets.push({ id: e.id, offset: lowerBoundSize, size: entryMinSize });
-        lowerBoundSize += entryMinSize;
-        entryById[e.id] = e;
-        if (e.level != null) {
-            currentStickyGroupNode =
-                ((_b = currentStickyGroupNode === null || currentStickyGroupNode === void 0 ? void 0 : currentStickyGroupNode.level) !== null && _b !== void 0 ? _b : 0) > e.level ? currentStickyGroupNode : currentStickyGroupNode === null || currentStickyGroupNode === void 0 ? void 0 : currentStickyGroupNode.getAncestor(e.level);
-            if (!currentStickyGroupNode) {
-                currentStickyGroupNode = new StickyGroupNode(e.id, e.level);
-                stickyGroups.addChild(currentStickyGroupNode);
-            }
-            else {
-                currentStickyGroupNode = currentStickyGroupNode.addChild(new StickyGroupNode(e.id, e.level));
-            }
-        }
-        if (e.fixedSize == null && (e.weight || e.maxSize == null || e.maxSize > e.minSize)) {
-            entriesWithDynamicSpace.push(e);
-            if (e.maxSize == null) {
-                unboundedEntries.push(e.id);
-            }
-            if (e.weight && e.weight < minimumExplicitWeight) {
-                minimumExplicitWeight = e.weight;
-            }
-            // TODO: we assume that the input is 'sane', and maxSize > minSize if given
-            if (e.maxSize && e.maxSize - e.minSize < minimumDerivedWeight) {
-                minimumDerivedWeight = e.maxSize - e.minSize;
-            }
-        }
-    }
-    if (!isFinite(minimumExplicitWeight)) {
-        minimumExplicitWeight = 1;
-    }
-    if (!isFinite(minimumDerivedWeight)) {
-        minimumDerivedWeight = 1;
-    }
-    if (lowerBoundSize <= viewportSize) {
-        // we will show ALL entries
-        const totalSpaceToDistribute = viewportSize - lowerBoundSize;
-        if (entriesWithDynamicSpace.some((e) => e.weight)) {
-            // we will attempt distribute the rest of the available space among entries that have not maxSize based on their weights
-            const totalExplicitWeights = entriesWithDynamicSpace.reduce((acc, e) => {
-                var _a;
-                return acc + ((_a = e.weight) !== null && _a !== void 0 ? _a : minimumExplicitWeight);
-            }, 0);
-            const unitOfSpace = totalSpaceToDistribute / totalExplicitWeights;
-            let remainingSpaceToDistribute = totalSpaceToDistribute;
-            const transformedEntries = entries.map((e) => {
-                var _a;
-                const transformedEntry = { id: e.id, floating: false, size: e.fixedSize };
-                if (transformedEntry.size == null) {
-                    let computedSize = e.minSize;
-                    if (remainingSpaceToDistribute > 0) {
-                        const entryWeight = (_a = e.weight) !== null && _a !== void 0 ? _a : minimumExplicitWeight;
-                        let entryExtraSpace = Math.min(remainingSpaceToDistribute, Math.max(Math.round(entryWeight * unitOfSpace), 1));
-                        computedSize = e.minSize + entryExtraSpace;
-                        if (e.maxSize && computedSize > e.maxSize) {
-                            computedSize = e.maxSize;
-                            entryExtraSpace = e.maxSize - e.minSize;
-                        }
-                        remainingSpaceToDistribute -= entryExtraSpace;
-                    }
-                    transformedEntry.size = computedSize;
-                }
-                return transformedEntry;
-            });
-            if (remainingSpaceToDistribute > 0 && unboundedEntries.length) {
-                const outstandingUnitOfSpace = remainingSpaceToDistribute / unboundedEntries.length;
-                transformedEntries.forEach((e) => {
-                    if (unboundedEntries.includes(e.id) && remainingSpaceToDistribute > 0) {
-                        const extraEntrySpace = e.id === unboundedEntries[unboundedEntries.length - 1] ? remainingSpaceToDistribute : Math.round(outstandingUnitOfSpace);
-                        e.size = e.size + extraEntrySpace;
-                        remainingSpaceToDistribute -= extraEntrySpace;
-                    }
-                });
-            }
-            return transformedEntries;
-        }
-        // we attempt to distribute the remaining space based on the maxSize - minSize
-        const totalDerivedWeights = entriesWithDynamicSpace.reduce((acc, e) => {
-            return acc + (e.maxSize ? e.maxSize - e.minSize : minimumDerivedWeight);
-        }, 0);
-        if (minimumDerivedWeight) {
-            const unitOfSpace = totalSpaceToDistribute / totalDerivedWeights;
-            let remainingSpaceToDistribute = totalSpaceToDistribute;
-            const transformedEntries = entries.map((e) => {
-                const transformedEntry = { id: e.id, size: e.fixedSize };
-                if (transformedEntry.size == null) {
-                    let computedSize = e.minSize;
-                    if (remainingSpaceToDistribute > 0) {
-                        const entryWeight = e.maxSize ? e.maxSize - e.minSize : minimumDerivedWeight;
-                        let entryExtraSpace = Math.min(remainingSpaceToDistribute, Math.max(Math.round(entryWeight * unitOfSpace), 1));
-                        computedSize = e.minSize + entryExtraSpace;
-                        if (e.maxSize && computedSize > e.maxSize) {
-                            computedSize = e.maxSize;
-                            entryExtraSpace = e.maxSize - e.minSize;
-                        }
-                        remainingSpaceToDistribute -= entryExtraSpace;
-                    }
-                    transformedEntry.size = computedSize;
-                }
-                return transformedEntry;
-            });
-            if (remainingSpaceToDistribute > 0 && unboundedEntries.length) {
-                const outstandingUnitOfSpace = remainingSpaceToDistribute / unboundedEntries.length;
-                transformedEntries.forEach((e) => {
-                    if (unboundedEntries.includes(e.id) && remainingSpaceToDistribute > 0) {
-                        const extraEntrySpace = e.id === unboundedEntries[unboundedEntries.length - 1] ? remainingSpaceToDistribute : Math.round(outstandingUnitOfSpace);
-                        e.size = e.size + extraEntrySpace;
-                        remainingSpaceToDistribute -= extraEntrySpace;
-                    }
-                });
-            }
-            return transformedEntries;
-        }
-        // no luck distributing the weights - we will return the entries as they are...
-        return entries.map((e) => { var _a; return ({ id: e.id, floating: false, size: (_a = e.fixedSize) !== null && _a !== void 0 ? _a : e.minSize }); });
-    }
-    // we will show only 'some' entries. Let's figure out which ones are in the window
-    const firstOffsetInWindow = entriesOffsets.find((o) => o.offset <= offset && o.offset + o.size >= offset);
-    if (!firstOffsetInWindow) {
-        return [];
-    }
-    const firstEntryIdxInWindow = entriesOffsets.indexOf(firstOffsetInWindow);
-    const firstEntryIdx = Math.max(0, firstEntryIdxInWindow - overscan);
-    const firstOffsetOutOfWindow = entriesOffsets.find((o) => o.offset >= offset + viewportSize);
-    const lastEntryIdxInWindow = firstOffsetOutOfWindow ? entriesOffsets.indexOf(firstOffsetOutOfWindow) - 1 : entries.length - 1;
-    const lastEntryIdx = Math.min(entries.length - 1, lastEntryIdxInWindow + overscan);
-    // take the entries corresponding to the viewport and include the overscan
-    const selectedEntries = entries.slice(firstEntryIdx, lastEntryIdx + 1);
-    const entryOffsetById = entriesOffsets.reduce((acc, eo) => {
-        acc[eo.id] = { start: eo.offset, end: eo.offset + eo.size };
-        return acc;
-    }, {});
-    let transformedEntries = selectedEntries.map((e) => {
-        var _a;
-        return ({
-            id: e.id,
-            size: (_a = e.fixedSize) !== null && _a !== void 0 ? _a : e.minSize,
-            offset: entryOffsetById[e.id].start,
-            level: e.level,
-        });
-    });
-    // adjust selected entries off the window which have a stickyGroup
-    if (stickyGroups.hasChildren()) {
-        // first, we will adjust the maxOffset for the sticky entries within the view:
-        transformedEntries.forEach((e) => {
-            if (e.level) {
-                const entryGroupNode = stickyGroups.findNode(e.id);
-                const nextSiblingGroupNode = entryGroupNode.findNextSibling();
-                e.maxOffset = nextSiblingGroupNode ? entryOffsetById[nextSiblingGroupNode.id].start - e.size : null;
-                e.minOffset = e.offset;
-            }
-        });
-        const firstStickyEntryOutsideTheWindow = entries
-            .slice(0, firstEntryIdx)
-            .reverse()
-            .find((e) => !!e.level);
-        if (firstStickyEntryOutsideTheWindow) {
-            const stickyAncestors = stickyGroups.findAncestors(firstStickyEntryOutsideTheWindow.id);
-            // then, find and transform preceding sticky entries
-            const stickyTransformedEntries = stickyAncestors.map((stickyGroupNode) => {
-                var _a;
-                const entry = entryById[stickyGroupNode.id];
-                const size = (_a = entry.fixedSize) !== null && _a !== void 0 ? _a : entry.minSize;
-                return {
-                    id: entry.id,
-                    size,
-                    offset: entryOffsetById[entry.id].start,
-                    level: entry.level,
-                };
-            });
-            transformedEntries = [
-                ...stickyTransformedEntries,
-                {
-                    id: firstStickyEntryOutsideTheWindow.id,
-                    size: (_c = firstStickyEntryOutsideTheWindow.fixedSize) !== null && _c !== void 0 ? _c : firstStickyEntryOutsideTheWindow.minSize,
-                    offset: entryOffsetById[firstStickyEntryOutsideTheWindow.id].start,
-                    level: firstStickyEntryOutsideTheWindow.level,
-                },
-                ...transformedEntries,
-            ];
-        }
-        // then figure out the level of the sticky entries based on the depth of the tree of group nodes
-        const relativeOffsets = {};
-        transformedEntries
-            .filter((te) => !!te.level)
-            .sort((e1, e2) => e2.level - e1.level)
-            .forEach((te) => {
-            var _a;
-            const stickyGroupNode = stickyGroups.findNode(te.id);
-            const nextSiblingGroupNode = stickyGroupNode.findNextSibling();
-            te.maxOffset = nextSiblingGroupNode ? entryOffsetById[nextSiblingGroupNode.id].start - te.size : lowerBoundSize - te.size;
-            te.minOffset = te.offset;
-            const parentGroupNode = StickyGroupNode.isInstance(stickyGroupNode.parent) ? stickyGroupNode.parent : null;
-            const levelOffset = (_a = relativeOffsets[parentGroupNode === null || parentGroupNode === void 0 ? void 0 : parentGroupNode.id]) !== null && _a !== void 0 ? _a : 0;
-            te.relativeOffset = levelOffset;
-            relativeOffsets[te.id] = levelOffset + te.size;
-        });
-    }
-    return transformedEntries;
-};
+export * from './virtualizer.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsY0FBYyxlQUFlLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgdHlwZSB7IElWaXJ0dWFsaXplckVudHJ5LCBJVmlydHVhbGl6ZXJDb25maWcsIElWaXJ0dWFsaXplclJlc3VsdCwgSVZpcnR1YWxpemVyUmVzdWx0RmxhdCwgSVZpcnR1YWxpemVyUmVzdWx0TGV2ZWwgfSBmcm9tICcuL3R5cGVzJ1xuZXhwb3J0ICogZnJvbSAnLi92aXJ0dWFsaXplcidcbiJdfQ==

package/package.json CHANGED Viewed

@@ -1,28 +1,24 @@
 {
   "name": "@enhanced-dom/virtualizer",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Helpers for item list virtualization in 1d or 2d",
   "repository": "https://github.com/enhanced-dom/virtualizer.git",
+  "type": "module",
   "main": "index.js",
   "keywords": [],
   "author": "CD9B4A105290E17E0948E021DF4105107C88693C59C0B891CCC08366C51AEA990902A6A156AC87D88A2FC41422A5E1C3C4071F251F19441C4516000EC25F87DF",
   "license": "MIT",
   "dependencies": {},
   "devDependencies": {
-    "@enhanced-dom/build": "^0.2.0",
-    "@enhanced-dom/jest": "^0.2.0",
-    "@enhanced-dom/lint": "^0.2.1",
-    "@enhanced-dom/react": "^0.2.0",
-    "@enhanced-dom/webpack": "^0.3.0",
-    "@types/jest": "^30.0.0",
-    "@types/react": "^18.3.27",
-    "@types/react-dom": "^18.3.7",
-    "typescript": "^5.9.3",
-    "lodash.debounce": "^4.0.8",
-    "use-lodash-debounce": "^1.3.0"
+    "@enhanced-dom/babel": "^0.3.0",
+    "@enhanced-dom/claude": "^0.3.1",
+    "@enhanced-dom/jest": "^0.3.0",
+    "@enhanced-dom/lint": "^0.4.2",
+    "@enhanced-dom/react": "^0.4.0",
+    "@enhanced-dom/webpack": "^0.5.1"
   },
   "engines": {
-    "node": ">=20",
-    "npm": ">=10"
+    "node": ">=22.23.2",
+    "npm": ">=12"
   }
 }

package/types.d.ts ADDED Viewed

@@ -0,0 +1,36 @@
+export type IVirtualizerEntry = {
+    level?: number;
+    id: string | number;
+    maxSize?: number;
+    weight?: number;
+} & ({
+    minSize: number;
+    fixedSize?: number;
+} | {
+    minSize?: number;
+    fixedSize: number;
+});
+export interface IVirtualizerConfig {
+    viewportSize: number;
+    offset?: number;
+    overscan?: number;
+}
+export interface IVirtualizerResultFlat extends Pick<IVirtualizerEntry, 'id'> {
+    size: number;
+    offset: number;
+    level?: never;
+}
+export interface IVirtualizerResultLevel extends Omit<IVirtualizerResultFlat, 'level'> {
+    levelOffset: number;
+    minOffset: number;
+    maxOffset: number;
+    level: number;
+}
+export type IVirtualizerResult = IVirtualizerResultFlat | IVirtualizerResultLevel;
+export declare enum TreePartType {
+    NODE = "node",
+    FOREST = "forest"
+}
+export interface ITreePart {
+    type: TreePartType;
+}

package/types.js ADDED Viewed

@@ -0,0 +1,6 @@
+export var TreePartType;
+(function (TreePartType) {
+    TreePartType["NODE"] = "node";
+    TreePartType["FOREST"] = "forest";
+})(TreePartType || (TreePartType = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBeUJBLE1BQU0sQ0FBTixJQUFZLFlBR1g7QUFIRCxXQUFZLFlBQVk7SUFDdEIsNkJBQWEsQ0FBQTtJQUNiLGlDQUFpQixDQUFBO0FBQ25CLENBQUMsRUFIVyxZQUFZLEtBQVosWUFBWSxRQUd2QiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB0eXBlIElWaXJ0dWFsaXplckVudHJ5ID0geyBsZXZlbD86IG51bWJlcjsgaWQ6IHN0cmluZyB8IG51bWJlcjsgbWF4U2l6ZT86IG51bWJlcjsgd2VpZ2h0PzogbnVtYmVyIH0gJiAoXG4gIHsgbWluU2l6ZTogbnVtYmVyOyBmaXhlZFNpemU/OiBudW1iZXIgfSB8IHsgbWluU2l6ZT86IG51bWJlcjsgZml4ZWRTaXplOiBudW1iZXIgfVxuKVxuXG5leHBvcnQgaW50ZXJmYWNlIElWaXJ0dWFsaXplckNvbmZpZyB7XG4gIHZpZXdwb3J0U2l6ZTogbnVtYmVyXG4gIG9mZnNldD86IG51bWJlclxuICBvdmVyc2Nhbj86IG51bWJlclxufVxuXG5leHBvcnQgaW50ZXJmYWNlIElWaXJ0dWFsaXplclJlc3VsdEZsYXQgZXh0ZW5kcyBQaWNrPElWaXJ0dWFsaXplckVudHJ5LCAnaWQnPiB7XG4gIHNpemU6IG51bWJlclxuICBvZmZzZXQ6IG51bWJlclxuICBsZXZlbD86IG5ldmVyXG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgSVZpcnR1YWxpemVyUmVzdWx0TGV2ZWwgZXh0ZW5kcyBPbWl0PElWaXJ0dWFsaXplclJlc3VsdEZsYXQsICdsZXZlbCc+IHtcbiAgbGV2ZWxPZmZzZXQ6IG51bWJlclxuICBtaW5PZmZzZXQ6IG51bWJlclxuICBtYXhPZmZzZXQ6IG51bWJlclxuICBsZXZlbDogbnVtYmVyXG59XG5cbmV4cG9ydCB0eXBlIElWaXJ0dWFsaXplclJlc3VsdCA9IElWaXJ0dWFsaXplclJlc3VsdEZsYXQgfCBJVmlydHVhbGl6ZXJSZXN1bHRMZXZlbFxuXG5leHBvcnQgZW51bSBUcmVlUGFydFR5cGUge1xuICBOT0RFID0gJ25vZGUnLFxuICBGT1JFU1QgPSAnZm9yZXN0Jyxcbn1cblxuZXhwb3J0IGludGVyZmFjZSBJVHJlZVBhcnQge1xuICB0eXBlOiBUcmVlUGFydFR5cGVcbn1cbiJdfQ==

package/virtualizer.d.ts ADDED Viewed

@@ -0,0 +1,3 @@
+import { IVirtualizerEntry, IVirtualizerConfig, IVirtualizerResult } from './types.js';
+export declare const virtualize: (config: IVirtualizerConfig, entries: IVirtualizerEntry[]) => IVirtualizerResult[];
+export declare const createCachedVirtualizer: () => (config: IVirtualizerConfig, entries: IVirtualizerEntry[]) => IVirtualizerResult[];

package/virtualizer.js ADDED Viewed

@@ -0,0 +1,239 @@
+import { StickyGroupNode, StickyGroupForest, findStickyGroupAncestor } from './StickyGroup.js';
+const distributeRemainingSpace = (entries, entriesWithDynamicSpace, unboundedEntries, totalSpaceToDistribute, getEntryWeight) => {
+    const totalWeights = entriesWithDynamicSpace.reduce((acc, e) => acc + getEntryWeight(e), 0);
+    const unitOfSpace = totalSpaceToDistribute / totalWeights;
+    let remainingSpaceToDistribute = totalSpaceToDistribute;
+    let runningOffset = 0;
+    const transformedEntries = entries.map((e) => {
+        let size = e.fixedSize;
+        if (size == null) {
+            let computedSize = e.minSize;
+            if (remainingSpaceToDistribute > 0) {
+                const entryWeight = getEntryWeight(e);
+                let entryExtraSpace = Math.min(remainingSpaceToDistribute, Math.max(Math.round(entryWeight * unitOfSpace), 1));
+                computedSize = (e.minSize ?? 0) + entryExtraSpace;
+                if (e.maxSize && computedSize > e.maxSize) {
+                    computedSize = e.maxSize;
+                    entryExtraSpace = e.maxSize - (e.minSize ?? 0);
+                }
+                remainingSpaceToDistribute -= entryExtraSpace;
+            }
+            size = computedSize;
+        }
+        const entryOffset = runningOffset;
+        runningOffset += size;
+        return { id: e.id, size, offset: entryOffset };
+    });
+    // extra space could only be handed to unbounded entries after every size above was settled, so if that
+    // happens the offsets computed above are stale for everything following the first adjusted entry
+    if (remainingSpaceToDistribute > 0 && unboundedEntries.length) {
+        const outstandingUnitOfSpace = remainingSpaceToDistribute / unboundedEntries.length;
+        transformedEntries.forEach((e) => {
+            if (unboundedEntries.includes(e.id) && remainingSpaceToDistribute > 0) {
+                const extraEntrySpace = e.id === unboundedEntries[unboundedEntries.length - 1] ? remainingSpaceToDistribute : Math.round(outstandingUnitOfSpace);
+                e.size = e.size + extraEntrySpace;
+                remainingSpaceToDistribute -= extraEntrySpace;
+            }
+        });
+        runningOffset = 0;
+        transformedEntries.forEach((e) => {
+            e.offset = runningOffset;
+            runningOffset += e.size;
+        });
+    }
+    return transformedEntries;
+};
+const buildCompleteEntryMapping = (entries) => {
+    let lowerBoundSize = 0;
+    // while we iterate over the entries, we should also find out some 'statisticts' about weights
+    const entriesWithDynamicSpace = [];
+    const unboundedEntries = [];
+    const entriesOffsets = [];
+    const entryOffsetById = {};
+    const stickyGroups = new StickyGroupForest();
+    const stickyGroupNodeById = new Map();
+    const entryById = {};
+    let currentStickyGroupNode = null;
+    let minimumExplicitWeight = Infinity;
+    let minimumDerivedWeight = Infinity;
+    for (const e of entries) {
+        const entryMinSize = (e.fixedSize ?? e.minSize);
+        entriesOffsets.push({ id: e.id, offset: lowerBoundSize, size: entryMinSize });
+        entryOffsetById[e.id] = { start: lowerBoundSize, end: lowerBoundSize + entryMinSize };
+        lowerBoundSize += entryMinSize ?? 0;
+        entryById[e.id] = e;
+        if (e.level != null) {
+            const ancestor = findStickyGroupAncestor(currentStickyGroupNode, e.level);
+            if (ancestor == null) {
+                currentStickyGroupNode = new StickyGroupNode(e.id, e.level);
+                stickyGroups.addChild(currentStickyGroupNode);
+            }
+            else {
+                currentStickyGroupNode = ancestor.addChild(new StickyGroupNode(e.id, e.level));
+            }
+            stickyGroupNodeById.set(e.id, currentStickyGroupNode);
+        }
+        if (e.fixedSize == null && (e.weight || e.maxSize == null || e.maxSize > e.minSize)) {
+            entriesWithDynamicSpace.push(e);
+            if (e.maxSize == null) {
+                unboundedEntries.push(e.id);
+            }
+            if (e.weight && e.weight < minimumExplicitWeight) {
+                minimumExplicitWeight = e.weight;
+            }
+            // TODO: we assume that the input is 'sane', and maxSize > minSize if given
+            if (e.maxSize && e.maxSize - (e.minSize ?? 0) < minimumDerivedWeight) {
+                minimumDerivedWeight = e.maxSize - (e.minSize ?? 0);
+            }
+        }
+    }
+    if (!isFinite(minimumExplicitWeight)) {
+        minimumExplicitWeight = 1;
+    }
+    if (!isFinite(minimumDerivedWeight)) {
+        minimumDerivedWeight = 1;
+    }
+    return {
+        lowerBoundSize,
+        entriesOffsets,
+        entryOffsetById,
+        entryById,
+        stickyGroups,
+        stickyGroupNodeById,
+        entriesWithDynamicSpace,
+        unboundedEntries,
+        minimumExplicitWeight,
+        minimumDerivedWeight,
+    };
+};
+const buildResultWithLevel = (entry, size, offset) => entry.level == null
+    ? { id: entry.id, size, offset }
+    : { id: entry.id, size, offset, level: entry.level, minOffset: offset, maxOffset: offset, levelOffset: 0 };
+// derives levelOffset/minOffset/maxOffset for whichever already-placed entries carry a level, based on
+// their position in the sticky group tree. Shared by both the 'everything fits' and windowed paths.
+const attachStickyLevelOffsets = (transformedEntries, completeEntryMapping) => {
+    const { entryOffsetById, stickyGroupNodeById, lowerBoundSize } = completeEntryMapping;
+    const relativeOffsets = {};
+    transformedEntries
+        .filter((te) => te.level != null)
+        .sort((e1, e2) => e2.level - e1.level)
+        .forEach((te) => {
+        const stickyGroupNode = stickyGroupNodeById.get(te.id);
+        const nextSiblingGroupNode = stickyGroupNode.findNextSibling();
+        te.maxOffset = nextSiblingGroupNode ? entryOffsetById[nextSiblingGroupNode.id].start - te.size : lowerBoundSize - te.size;
+        te.minOffset = te.offset;
+        const parentGroupNode = StickyGroupNode.isInstance(stickyGroupNode.parent) ? stickyGroupNode.parent : null;
+        const levelOffset = relativeOffsets[String(parentGroupNode?.id)] ?? 0;
+        te.levelOffset = levelOffset;
+        relativeOffsets[te.id] = levelOffset + te.size;
+    });
+};
+const virtualizeFromMapping = (config, entries, completeEntryMapping) => {
+    const { offset, overscan, viewportSize } = {
+        offset: 0,
+        overscan: 5,
+        ...config,
+    };
+    const { lowerBoundSize, entriesOffsets, entryOffsetById, entryById, stickyGroups, stickyGroupNodeById, entriesWithDynamicSpace, unboundedEntries, minimumExplicitWeight, minimumDerivedWeight, } = completeEntryMapping;
+    // first, let us figure out if the size is smaller than the viewport
+    if (lowerBoundSize <= viewportSize) {
+        // we will show ALL entries
+        const totalSpaceToDistribute = viewportSize - lowerBoundSize;
+        let flatResults;
+        if (entriesWithDynamicSpace.some((e) => e.weight)) {
+            // we will attempt distribute the rest of the available space among entries that have not maxSize based on their weights
+            flatResults = distributeRemainingSpace(entries, entriesWithDynamicSpace, unboundedEntries, totalSpaceToDistribute, (e) => e.weight ?? minimumExplicitWeight);
+        }
+        else if (entriesWithDynamicSpace.length) {
+            // we attempt to distribute the remaining space based on the maxSize - minSize
+            flatResults = distributeRemainingSpace(entries, entriesWithDynamicSpace, unboundedEntries, totalSpaceToDistribute, (e) => e.maxSize ? e.maxSize - (e.minSize ?? 0) : minimumDerivedWeight);
+        }
+        else {
+            // nothing to distribute to (every entry has a fixedSize) - entriesOffsets already has everything we need, no need to re-map entries
+            flatResults = entriesOffsets;
+        }
+        // even though every entry fits without virtualizing the window, sticky entries still need their level/offsets attached
+        const resultsWithLevel = flatResults.map((r) => buildResultWithLevel(entryById[r.id], r.size, r.offset));
+        if (stickyGroups.hasChildren()) {
+            attachStickyLevelOffsets(resultsWithLevel, completeEntryMapping);
+        }
+        return resultsWithLevel;
+    }
+    // we will show only 'some' entries. Let's figure out which ones are in the window
+    const firstOffsetInWindow = entriesOffsets.find((o) => o.offset <= offset && o.offset + o.size >= offset);
+    if (!firstOffsetInWindow) {
+        return [];
+    }
+    const firstEntryIdxInWindow = entriesOffsets.indexOf(firstOffsetInWindow);
+    const firstEntryIdx = Math.max(0, firstEntryIdxInWindow - overscan);
+    const firstOffsetOutOfWindow = entriesOffsets.find((o) => o.offset >= offset + viewportSize);
+    const lastEntryIdxInWindow = firstOffsetOutOfWindow ? entriesOffsets.indexOf(firstOffsetOutOfWindow) - 1 : entries.length - 1;
+    const lastEntryIdx = Math.min(entries.length - 1, lastEntryIdxInWindow + overscan);
+    // take the entries corresponding to the viewport and include the overscan
+    const selectedEntries = entries.slice(firstEntryIdx, lastEntryIdx + 1);
+    let transformedEntries = selectedEntries.map((e) => {
+        const size = (e.fixedSize ?? e.minSize);
+        const resultOffset = entryOffsetById[e.id].start;
+        if (e.level == null) {
+            return { id: e.id, size, offset: resultOffset };
+        }
+        // minOffset/maxOffset/levelOffset are placeholders here, overwritten below once every sticky group is known
+        return { id: e.id, size, offset: resultOffset, level: e.level, minOffset: resultOffset, maxOffset: resultOffset, levelOffset: 0 };
+    });
+    // adjust selected entries off the window which have a stickyGroup
+    if (stickyGroups.hasChildren()) {
+        const firstStickyEntryOutsideTheWindow = entries
+            .slice(0, firstEntryIdx)
+            .reverse()
+            .find((e) => e.level != null);
+        if (firstStickyEntryOutsideTheWindow) {
+            const stickyAncestors = stickyGroups.findAncestors(stickyGroupNodeById.get(firstStickyEntryOutsideTheWindow.id));
+            // then, find and transform preceding sticky entries
+            const stickyTransformedEntries = stickyAncestors.map((stickyGroupNode) => {
+                const entry = entryById[stickyGroupNode.id];
+                const size = (entry.fixedSize ?? entry.minSize);
+                const resultOffset = entryOffsetById[entry.id].start;
+                return {
+                    id: entry.id,
+                    size,
+                    offset: resultOffset,
+                    level: entry.level,
+                    minOffset: resultOffset,
+                    maxOffset: resultOffset,
+                    levelOffset: 0,
+                };
+            });
+            const size = (firstStickyEntryOutsideTheWindow.fixedSize ?? firstStickyEntryOutsideTheWindow.minSize);
+            const resultOffset = entryOffsetById[firstStickyEntryOutsideTheWindow.id].start;
+            transformedEntries = [
+                ...stickyTransformedEntries,
+                {
+                    id: firstStickyEntryOutsideTheWindow.id,
+                    size,
+                    offset: resultOffset,
+                    level: firstStickyEntryOutsideTheWindow.level,
+                    minOffset: resultOffset,
+                    maxOffset: resultOffset,
+                    levelOffset: 0,
+                },
+                ...transformedEntries,
+            ];
+        }
+        // then figure out the level of the sticky entries based on the depth of the tree of group nodes
+        attachStickyLevelOffsets(transformedEntries, completeEntryMapping);
+    }
+    return transformedEntries;
+};
+export const virtualize = (config, entries) => virtualizeFromMapping(config, entries, buildCompleteEntryMapping(entries));
+export const createCachedVirtualizer = () => {
+    let completeEntryMapping = null;
+    let previousEntries = null;
+    return (config, entries) => {
+        if (entries !== previousEntries) {
+            completeEntryMapping = buildCompleteEntryMapping(entries);
+            previousEntries = entries;
+        }
+        return virtualizeFromMapping(config, entries, completeEntryMapping);
+    };
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"virtualizer.js","sourceRoot":"","sources":["../src/virtualizer.ts"],"names":[],"mappings":"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","sourcesContent":["import { IVirtualizerEntry, IVirtualizerConfig, IVirtualizerResult, IVirtualizerResultFlat, IVirtualizerResultLevel } from './types'\nimport { StickyGroupNode, StickyGroupForest, findStickyGroupAncestor } from './StickyGroup'\n\nconst distributeRemainingSpace = (\n  entries: IVirtualizerEntry[],\n  entriesWithDynamicSpace: IVirtualizerEntry[],\n  unboundedEntries: IVirtualizerEntry['id'][],\n  totalSpaceToDistribute: number,\n  getEntryWeight: (e: IVirtualizerEntry) => number,\n): IVirtualizerResultFlat[] => {\n  const totalWeights = entriesWithDynamicSpace.reduce((acc, e) => acc + getEntryWeight(e), 0)\n  const unitOfSpace = totalSpaceToDistribute / totalWeights\n  let remainingSpaceToDistribute = totalSpaceToDistribute\n  let runningOffset = 0\n  const transformedEntries = entries.map((e) => {\n    let size = e.fixedSize\n    if (size == null) {\n      let computedSize = e.minSize!\n      if (remainingSpaceToDistribute > 0) {\n        const entryWeight = getEntryWeight(e)\n        let entryExtraSpace = Math.min(remainingSpaceToDistribute, Math.max(Math.round(entryWeight * unitOfSpace), 1))\n        computedSize = (e.minSize ?? 0) + entryExtraSpace\n        if (e.maxSize && computedSize > e.maxSize) {\n          computedSize = e.maxSize\n          entryExtraSpace = e.maxSize - (e.minSize ?? 0)\n        }\n        remainingSpaceToDistribute -= entryExtraSpace\n      }\n      size = computedSize\n    }\n    const entryOffset = runningOffset\n    runningOffset += size\n    return { id: e.id, size, offset: entryOffset }\n  })\n  // extra space could only be handed to unbounded entries after every size above was settled, so if that\n  // happens the offsets computed above are stale for everything following the first adjusted entry\n  if (remainingSpaceToDistribute > 0 && unboundedEntries.length) {\n    const outstandingUnitOfSpace = remainingSpaceToDistribute / unboundedEntries.length\n    transformedEntries.forEach((e) => {\n      if (unboundedEntries.includes(e.id) && remainingSpaceToDistribute > 0) {\n        const extraEntrySpace =\n          e.id === unboundedEntries[unboundedEntries.length - 1] ? remainingSpaceToDistribute : Math.round(outstandingUnitOfSpace)\n        e.size = e.size + extraEntrySpace\n        remainingSpaceToDistribute -= extraEntrySpace\n      }\n    })\n    runningOffset = 0\n    transformedEntries.forEach((e) => {\n      e.offset = runningOffset\n      runningOffset += e.size\n    })\n  }\n  return transformedEntries\n}\n\ninterface ICompleteEntryMapping {\n  lowerBoundSize: number\n  entriesOffsets: { id: string | number; offset: number; size: number }[]\n  entryOffsetById: Record<string | number, { start: number; end: number }>\n  entryById: Record<string, IVirtualizerEntry>\n  stickyGroups: StickyGroupForest\n  stickyGroupNodeById: Map<IVirtualizerEntry['id'], StickyGroupNode>\n  entriesWithDynamicSpace: IVirtualizerEntry[]\n  unboundedEntries: IVirtualizerEntry['id'][]\n  minimumExplicitWeight: number\n  minimumDerivedWeight: number\n}\n\nconst buildCompleteEntryMapping = (entries: IVirtualizerEntry[]): ICompleteEntryMapping => {\n  let lowerBoundSize = 0\n  // while we iterate over the entries, we should also find out some 'statisticts' about weights\n  const entriesWithDynamicSpace: IVirtualizerEntry[] = []\n  const unboundedEntries: IVirtualizerEntry['id'][] = []\n  const entriesOffsets: { id: string | number; offset: number; size: number }[] = []\n  const entryOffsetById: Record<string | number, { start: number; end: number }> = {}\n  const stickyGroups = new StickyGroupForest()\n  const stickyGroupNodeById = new Map<IVirtualizerEntry['id'], StickyGroupNode>()\n  const entryById: Record<string, IVirtualizerEntry> = {}\n  let currentStickyGroupNode: StickyGroupNode | null = null\n  let minimumExplicitWeight = Infinity\n  let minimumDerivedWeight = Infinity\n  for (const e of entries) {\n    const entryMinSize = (e.fixedSize ?? e.minSize)!\n    entriesOffsets.push({ id: e.id, offset: lowerBoundSize, size: entryMinSize })\n    entryOffsetById[e.id] = { start: lowerBoundSize, end: lowerBoundSize + entryMinSize }\n    lowerBoundSize += entryMinSize ?? 0\n    entryById[e.id] = e\n    if (e.level != null) {\n      const ancestor = findStickyGroupAncestor(currentStickyGroupNode, e.level)\n      if (ancestor == null) {\n        currentStickyGroupNode = new StickyGroupNode(e.id, e.level)\n        stickyGroups.addChild(currentStickyGroupNode)\n      } else {\n        currentStickyGroupNode = ancestor.addChild(new StickyGroupNode(e.id, e.level))\n      }\n      stickyGroupNodeById.set(e.id, currentStickyGroupNode)\n    }\n    if (e.fixedSize == null && (e.weight || e.maxSize == null || e.maxSize > e.minSize!)) {\n      entriesWithDynamicSpace.push(e)\n      if (e.maxSize == null) {\n        unboundedEntries.push(e.id)\n      }\n      if (e.weight && e.weight < minimumExplicitWeight) {\n        minimumExplicitWeight = e.weight\n      }\n      // TODO: we assume that the input is 'sane', and maxSize > minSize if given\n      if (e.maxSize && e.maxSize - (e.minSize ?? 0) < minimumDerivedWeight) {\n        minimumDerivedWeight = e.maxSize - (e.minSize ?? 0)\n      }\n    }\n  }\n  if (!isFinite(minimumExplicitWeight)) {\n    minimumExplicitWeight = 1\n  }\n  if (!isFinite(minimumDerivedWeight)) {\n    minimumDerivedWeight = 1\n  }\n  return {\n    lowerBoundSize,\n    entriesOffsets,\n    entryOffsetById,\n    entryById,\n    stickyGroups,\n    stickyGroupNodeById,\n    entriesWithDynamicSpace,\n    unboundedEntries,\n    minimumExplicitWeight,\n    minimumDerivedWeight,\n  }\n}\n\nconst buildResultWithLevel = (entry: IVirtualizerEntry, size: number, offset: number): IVirtualizerResult =>\n  entry.level == null\n    ? { id: entry.id, size, offset }\n    : { id: entry.id, size, offset, level: entry.level, minOffset: offset, maxOffset: offset, levelOffset: 0 }\n\n// derives levelOffset/minOffset/maxOffset for whichever already-placed entries carry a level, based on\n// their position in the sticky group tree. Shared by both the 'everything fits' and windowed paths.\nconst attachStickyLevelOffsets = (transformedEntries: IVirtualizerResult[], completeEntryMapping: ICompleteEntryMapping): void => {\n  const { entryOffsetById, stickyGroupNodeById, lowerBoundSize } = completeEntryMapping\n  const relativeOffsets: Record<string, number> = {}\n  transformedEntries\n    .filter((te): te is IVirtualizerResultLevel => te.level != null)\n    .sort((e1, e2) => e2.level - e1.level)\n    .forEach((te) => {\n      const stickyGroupNode = stickyGroupNodeById.get(te.id)!\n      const nextSiblingGroupNode = stickyGroupNode.findNextSibling()\n      te.maxOffset = nextSiblingGroupNode ? entryOffsetById[nextSiblingGroupNode.id]!.start - te.size : lowerBoundSize - te.size\n      te.minOffset = te.offset\n      const parentGroupNode = StickyGroupNode.isInstance(stickyGroupNode.parent) ? stickyGroupNode.parent : null\n      const levelOffset = relativeOffsets[String(parentGroupNode?.id)] ?? 0\n      te.levelOffset = levelOffset\n      relativeOffsets[te.id] = levelOffset + te.size\n    })\n}\n\nconst virtualizeFromMapping = (\n  config: IVirtualizerConfig,\n  entries: IVirtualizerEntry[],\n  completeEntryMapping: ICompleteEntryMapping,\n): IVirtualizerResult[] => {\n  const { offset, overscan, viewportSize } = {\n    offset: 0,\n    overscan: 5,\n    ...config,\n  }\n  const {\n    lowerBoundSize,\n    entriesOffsets,\n    entryOffsetById,\n    entryById,\n    stickyGroups,\n    stickyGroupNodeById,\n    entriesWithDynamicSpace,\n    unboundedEntries,\n    minimumExplicitWeight,\n    minimumDerivedWeight,\n  } = completeEntryMapping\n\n  // first, let us figure out if the size is smaller than the viewport\n  if (lowerBoundSize <= viewportSize) {\n    // we will show ALL entries\n    const totalSpaceToDistribute = viewportSize - lowerBoundSize\n    let flatResults: IVirtualizerResultFlat[]\n    if (entriesWithDynamicSpace.some((e) => e.weight)) {\n      // we will attempt distribute the rest of the available space among entries that have not maxSize based on their weights\n      flatResults = distributeRemainingSpace(\n        entries,\n        entriesWithDynamicSpace,\n        unboundedEntries,\n        totalSpaceToDistribute,\n        (e) => e.weight ?? minimumExplicitWeight,\n      )\n    } else if (entriesWithDynamicSpace.length) {\n      // we attempt to distribute the remaining space based on the maxSize - minSize\n      flatResults = distributeRemainingSpace(entries, entriesWithDynamicSpace, unboundedEntries, totalSpaceToDistribute, (e) =>\n        e.maxSize ? e.maxSize - (e.minSize ?? 0) : minimumDerivedWeight,\n      )\n    } else {\n      // nothing to distribute to (every entry has a fixedSize) - entriesOffsets already has everything we need, no need to re-map entries\n      flatResults = entriesOffsets\n    }\n    // even though every entry fits without virtualizing the window, sticky entries still need their level/offsets attached\n    const resultsWithLevel: IVirtualizerResult[] = flatResults.map((r) => buildResultWithLevel(entryById[r.id]!, r.size, r.offset))\n    if (stickyGroups.hasChildren()) {\n      attachStickyLevelOffsets(resultsWithLevel, completeEntryMapping)\n    }\n    return resultsWithLevel\n  }\n\n  // we will show only 'some' entries. Let's figure out which ones are in the window\n  const firstOffsetInWindow = entriesOffsets.find((o) => o.offset <= offset && o.offset + o.size >= offset)\n  if (!firstOffsetInWindow) {\n    return []\n  }\n  const firstEntryIdxInWindow = entriesOffsets.indexOf(firstOffsetInWindow)\n  const firstEntryIdx = Math.max(0, firstEntryIdxInWindow - overscan)\n  const firstOffsetOutOfWindow = entriesOffsets.find((o) => o.offset >= offset + viewportSize)\n  const lastEntryIdxInWindow = firstOffsetOutOfWindow ? entriesOffsets.indexOf(firstOffsetOutOfWindow) - 1 : entries.length - 1\n  const lastEntryIdx = Math.min(entries.length - 1, lastEntryIdxInWindow + overscan)\n  // take the entries corresponding to the viewport and include the overscan\n  const selectedEntries = entries.slice(firstEntryIdx, lastEntryIdx + 1)\n  let transformedEntries: IVirtualizerResult[] = selectedEntries.map((e) => {\n    const size = (e.fixedSize ?? e.minSize)!\n    const resultOffset = entryOffsetById[e.id]!.start\n    if (e.level == null) {\n      return { id: e.id, size, offset: resultOffset }\n    }\n    // minOffset/maxOffset/levelOffset are placeholders here, overwritten below once every sticky group is known\n    return { id: e.id, size, offset: resultOffset, level: e.level, minOffset: resultOffset, maxOffset: resultOffset, levelOffset: 0 }\n  })\n\n  // adjust selected entries off the window which have a stickyGroup\n  if (stickyGroups.hasChildren()) {\n    const firstStickyEntryOutsideTheWindow = entries\n      .slice(0, firstEntryIdx)\n      .reverse()\n      .find((e): e is IVirtualizerEntry & { level: number } => e.level != null)\n    if (firstStickyEntryOutsideTheWindow) {\n      const stickyAncestors = stickyGroups.findAncestors(stickyGroupNodeById.get(firstStickyEntryOutsideTheWindow.id)!)\n      // then, find and transform preceding sticky entries\n      const stickyTransformedEntries: IVirtualizerResultLevel[] = stickyAncestors.map((stickyGroupNode) => {\n        const entry = entryById[stickyGroupNode.id]!\n        const size = (entry.fixedSize ?? entry.minSize)!\n        const resultOffset = entryOffsetById[entry.id]!.start\n        return {\n          id: entry.id,\n          size,\n          offset: resultOffset,\n          level: entry.level!,\n          minOffset: resultOffset,\n          maxOffset: resultOffset,\n          levelOffset: 0,\n        }\n      })\n      const size = (firstStickyEntryOutsideTheWindow.fixedSize ?? firstStickyEntryOutsideTheWindow.minSize)!\n      const resultOffset = entryOffsetById[firstStickyEntryOutsideTheWindow.id]!.start\n      transformedEntries = [\n        ...stickyTransformedEntries,\n        {\n          id: firstStickyEntryOutsideTheWindow.id,\n          size,\n          offset: resultOffset,\n          level: firstStickyEntryOutsideTheWindow.level,\n          minOffset: resultOffset,\n          maxOffset: resultOffset,\n          levelOffset: 0,\n        },\n        ...transformedEntries,\n      ]\n    }\n\n    // then figure out the level of the sticky entries based on the depth of the tree of group nodes\n    attachStickyLevelOffsets(transformedEntries, completeEntryMapping)\n  }\n  return transformedEntries\n}\n\nexport const virtualize = (config: IVirtualizerConfig, entries: IVirtualizerEntry[]): IVirtualizerResult[] =>\n  virtualizeFromMapping(config, entries, buildCompleteEntryMapping(entries))\n\nexport const createCachedVirtualizer = () => {\n  let completeEntryMapping: ICompleteEntryMapping | null = null\n  let previousEntries: IVirtualizerEntry[] | null = null\n  return (config: IVirtualizerConfig, entries: IVirtualizerEntry[]): IVirtualizerResult[] => {\n    if (entries !== previousEntries) {\n      completeEntryMapping = buildCompleteEntryMapping(entries)\n      previousEntries = entries\n    }\n    return virtualizeFromMapping(config, entries, completeEntryMapping!)\n  }\n}\n"]}