Measurement caches retain removed item keys during sliding-window pagination (3.3.11) #544

import assert from "node:assert/strict";
import { readFileSync } from "node:fs";
import { createRequire } from "node:module";
import { dirname, join } from "node:path";
import { runInNewContext } from "node:vm";
import ts from "typescript";

const require = createRequire(import.meta.url);
const packageDirectory = process.argv[2] ?? dirname(require.resolve("@legendapp/list/react-native"));

// Run the published layout functions; stub platform/measurement IO only.
function loadLayoutEngine(filename) {
    const source = readFileSync(join(packageDirectory, filename), "utf8");
    const ast = ts.createSourceFile(filename, source, ts.ScriptTarget.Latest, true);
    const functions = ["resetLayoutCachesForDataChange", "updateItemPositions"].map((name) => {
        const declaration = ast.statements.find(
            (statement) => ts.isFunctionDeclaration(statement) && statement.name?.text === name,
        );
        assert.ok(declaration, `Missing installed LegendList function: ${name}`);
        return declaration.getText(ast);
    });
    return runInNewContext(`${functions.join("\n")}\n({resetLayoutCachesForDataChange, updateItemPositions})`, {
        IS_DEV: false,
        Platform: { OS: filename.startsWith("react.") || filename.includes(".web.") ? "web" : "ios" },
        peek$: () => 1,
        getScrollVelocity: () => 0,
        getId: (state, index) => {
            const id = state.props.data[index].id;
            state.idCache[index] = id;
            return id;
        },
        getItemSize: (ctx, id, index, item) => {
            const size = ctx.state.sizesKnown.get(id) ?? item.height;
            ctx.state.sizes.set(id, size);
            return size;
        },
        updateTotalSize: () => {},
    });
}

function createContext() {
    return {
        positionListeners: new Map(),
        state: {
            columns: [],
            columnSpans: [],
            indexByKey: new Map(),
            positions: [],
            idCache: [],
            sizes: new Map(),
            sizesKnown: new Map(),
            lastScrollDelta: 0,
            scrollLength: 800,
            scrollAdjustHandler: { getAdjust: () => 0 },
            props: { data: [] },
        },
    };
}

function rows(start, count) {
    return Array.from({ length: count }, (_, offset) => ({
        id: `item-${start + offset}`,
        height: 100 + ((start + offset) % 9) * 73.5,
    }));
}

function applyData(engine, context, data) {
    context.state.props.data = data;
    engine.resetLayoutCachesForDataChange(context.state);
    engine.updateItemPositions(context, true);
}

const results = [];
for (const filename of [
    "react-native.js",
    "react-native.mjs",
    "react-native.web.js",
    "react-native.web.mjs",
    "react.js",
    "react.mjs",
]) {
    const engine = loadLayoutEngine(filename);
    const context = createContext();
    const { state } = context;
    for (let cycle = 0; cycle <= 100; cycle++) {
        const data = rows(cycle * 20, 400);
        // Model rows that have been measured. Only new IDs allocate entries.
        for (const item of data) {
            state.sizes.set(item.id, item.height);
            state.sizesKnown.set(item.id, item.height);
        }
        applyData(engine, context, data);
    }
    const liveIds = new Set(state.props.data.map((item) => item.id));
    results.push({
        bundle: filename,
        data: state.props.data.length,
        indexByKey: state.indexByKey.size,
        sizes: state.sizes.size,
        sizesKnown: state.sizesKnown.size,
        removedKeys: [...state.sizesKnown.keys()].filter((id) => !liveIds.has(id)).length,
    });
}
console.table(results);
if (results.some((row) => row.sizes > row.data || row.sizesKnown > row.data)) {
    process.exitCode = 1;
}