Skip to content

An open-source, privacy-first, self-hosted knowledge workspace where humans and AI agents work together 开源、隐私优先、自托管的知识工作空间,让人与智能体在此协作

7.3 KB
Raw Blame
import {describe, it} from "node:test";
import * as assert from "node:assert/strict";
import {
    clampGroupTableVirtualData,
    getGroupTableRenderPlan,
    getGroupTableViewportWindow,
    getUninitializedGroupRowCounts,
} from "./groupTableVirtual";

const createGroup = (id: string, rowCount: number, options: {
    folded?: boolean;
    hidden?: number;
} = {}) => ({
    id,
    rows: Array.from({length: rowCount}, (_, index) => ({id: `${id}-row-${index}`})),
    groupFolded: options.folded || false,
    groupHidden: options.hidden || 0,
}) as IAVTable;

describe("grouped table initial render planning", () => {
    it("renders every visible expanded row when the total is within budget", () => {
        const plan = getGroupTableRenderPlan([
            createGroup("visible", 4),
            createGroup("folded", 5, {folded: true}),
            createGroup("hidden", 6, {hidden: 1}),
        ], {}, 10);

        assert.equal(plan.virtualized, false);
        assert.deepEqual(plan.virtualData, {});
        assert.deepEqual(plan.renderedRowCounts, {visible: 4});
    });

    it("shares the budget across many groups without starving a group", () => {
        const groups = Array.from({length: 44}, (_, index) => createGroup(`group-${index}`, index === 43 ? 34 : 20));
        const plan = getGroupTableRenderPlan(groups, {}, 100);

        assert.equal(plan.virtualized, true);
        assert.equal(Object.values(plan.renderedRowCounts).reduce((sum, count) => sum + count, 0), 100);
        assert.equal(Object.values(plan.renderedRowCounts).every(count => count >= 1), true);
        assert.equal(plan.renderedRowCounts["group-0"], 20);
        assert.equal(plan.renderedRowCounts["group-1"], 20);
        assert.equal(plan.renderedRowCounts["group-2"], 19);
        assert.equal(plan.renderedRowCounts["group-3"], 1);
        assert.equal(plan.renderedRowCounts["group-43"], 1);
    });

    it("prioritizes one row per group when group count exceeds the nominal budget", () => {
        const groups = Array.from({length: 120}, (_, index) => createGroup(`group-${index}`, 2));
        const plan = getGroupTableRenderPlan(groups, {}, 100);

        assert.equal(Object.values(plan.renderedRowCounts).reduce((sum, count) => sum + count, 0), 120);
        assert.equal(Object.values(plan.renderedRowCounts).every(count => count === 1), true);
    });

    it("preserves restored windows and includes only a folded locate target", () => {
        const restored = {
            expanded: {renderedStart: 5, renderedEnd: 9, topSpacerHeight: 180},
            target: {renderedStart: 10, renderedEnd: 14, topSpacerHeight: 360, locate: true},
        } as Record<string, IAVVirtualData>;
        const plan = getGroupTableRenderPlan([
            createGroup("expanded", 20),
            createGroup("target", 20, {folded: true}),
            createGroup("folded", 20, {folded: true}),
        ], restored, 10);

        assert.deepEqual(plan.virtualData.expanded, restored.expanded);
        assert.deepEqual(plan.virtualData.target, restored.target);
        assert.equal(plan.renderedRowCounts.expanded, 5);
        assert.equal(plan.renderedRowCounts.target, 5);
        assert.equal(plan.renderedRowCounts.folded, undefined);
    });
});

describe("grouped table virtual window clamping", () => {
    it("resets a stale deep window after search shrinks the rows", () => {
        assert.deepEqual(clampGroupTableVirtualData({
            renderedStart: 90,
            renderedEnd: 99,
            topSpacerHeight: 3240,
        }, 3), {
            renderedStart: 0,
            renderedEnd: 2,
            topSpacerHeight: 0,
        });
    });

    it("clamps both bounds and clears an invalid top spacer", () => {
        assert.deepEqual(clampGroupTableVirtualData({
            renderedStart: -2,
            renderedEnd: 20,
            topSpacerHeight: 72,
        }, 5), {
            renderedStart: 0,
            renderedEnd: 4,
            topSpacerHeight: 0,
        });
        assert.equal(clampGroupTableVirtualData(undefined, 5), undefined);
        assert.equal(clampGroupTableVirtualData({
            renderedStart: 0,
            renderedEnd: 1,
            topSpacerHeight: 0,
        }, 0), undefined);
    });
});

describe("grouped table viewport window rebuilding", () => {
    it("rebuilds a three-viewport window around a middle spacer position", () => {
        assert.deepEqual(getGroupTableViewportWindow({
            dataStart: 0,
            dataEnd: 99,
            bodyTop: 100,
            headerHeight: 40,
            viewportTop: 1760,
            viewportBottom: 2120,
            rowHeight: 36,
        }), {
            renderedStart: 40,
            renderedEnd: 69,
            topSpacerHeight: 1440,
            targetIndex: 50,
        });
    });

    it("clamps the rebuilt window at both ends", () => {
        assert.deepEqual(getGroupTableViewportWindow({
            dataStart: 400,
            dataEnd: 499,
            bodyTop: 100,
            headerHeight: 40,
            viewportTop: 100,
            viewportBottom: 460,
            rowHeight: 36,
        }), {
            renderedStart: 400,
            renderedEnd: 429,
            topSpacerHeight: 0,
            targetIndex: 403,
        });
        assert.deepEqual(getGroupTableViewportWindow({
            dataStart: 400,
            dataEnd: 499,
            bodyTop: 100,
            headerHeight: 40,
            viewportTop: 3700,
            viewportBottom: 4060,
            rowHeight: 36,
        }), {
            renderedStart: 470,
            renderedEnd: 499,
            topSpacerHeight: 2520,
            targetIndex: 499,
        });
    });

    it("handles empty data and invalid row height", () => {
        assert.equal(getGroupTableViewportWindow({
            dataStart: 0,
            dataEnd: -1,
            bodyTop: 0,
            headerHeight: 0,
            viewportTop: 0,
            viewportBottom: 100,
            rowHeight: 0,
        }), undefined);
        const window = getGroupTableViewportWindow({
            dataStart: 0,
            dataEnd: 9,
            bodyTop: 0,
            headerHeight: 0,
            viewportTop: 0,
            viewportBottom: 0,
            rowHeight: 0,
        });
        assert.deepEqual(window, {
            renderedStart: 0,
            renderedEnd: 2,
            topSpacerHeight: 0,
            targetIndex: 0,
        });
    });
});

describe("grouped table deferred body initialization", () => {
    it("uses the remaining budget after initialized bodies", () => {
        assert.deepEqual(getUninitializedGroupRowCounts([
            createGroup("first", 20),
            createGroup("second", 20),
        ], 90, 100), {
            first: 9,
            second: 1,
        });
    });

    it("renders complete bodies when all loaded rows fit", () => {
        assert.deepEqual(getUninitializedGroupRowCounts([
            createGroup("first", 3),
            createGroup("second", 4),
        ], 2, 10), {
            first: 3,
            second: 4,
        });
    });

    it("still makes every newly expanded group addressable after the budget is exhausted", () => {
        assert.deepEqual(getUninitializedGroupRowCounts([
            createGroup("first", 20),
            createGroup("second", 20),
        ], 100, 100), {
            first: 1,
            second: 1,
        });
    });
});