@legendapp/list 2.0.0-next.1 → 2.0.0-next.2

package/src/ListComponent.tsx

@@ -0,0 +1,191 @@
+import { useMemo } from "react";
+import * as React from "react";
+import {
+    Animated,
+    type LayoutChangeEvent,
+    type LayoutRectangle,
+    type NativeScrollEvent,
+    type NativeSyntheticEvent,
+    ScrollView,
+    type ScrollViewProps,
+    View,
+    type ViewStyle,
+} from "react-native";
+import { Containers } from "./Containers";
+import { ScrollAdjust } from "./ScrollAdjust";
+import type { ScrollAdjustHandler } from "./ScrollAdjustHandler";
+import { ENABLE_DEVMODE } from "./constants";
+import { set$, useStateContext } from "./state";
+import { type GetRenderedItem, type LegendListProps, typedMemo } from "./types";
+import { useSyncLayout } from "./useSyncLayout";
+import { useValue$ } from "./useValue$";
+
+interface ListComponentProps<ItemT>
+    extends Omit<
+        LegendListProps<ItemT> & { scrollEventThrottle: number | undefined },
+        | "data"
+        | "estimatedItemSize"
+        | "drawDistance"
+        | "maintainScrollAtEnd"
+        | "maintainScrollAtEndThreshold"
+        | "maintainVisibleContentPosition"
+        | "style"
+    > {
+    horizontal: boolean;
+    initialContentOffset: number | undefined;
+    refScrollView: React.Ref<ScrollView>;
+    getRenderedItem: GetRenderedItem;
+    updateItemSize: (itemKey: string, size: { width: number; height: number }) => void;
+    onScroll: (event: NativeSyntheticEvent<NativeScrollEvent>) => void;
+    onLayout: (event: LayoutChangeEvent) => void;
+    onLayoutHeader: (rect: LayoutRectangle, fromLayoutEffect: boolean) => void;
+    maintainVisibleContentPosition: boolean;
+    renderScrollComponent?: (props: ScrollViewProps) => React.ReactElement<ScrollViewProps>;
+    style: ViewStyle;
+    canRender: boolean;
+    scrollAdjustHandler: ScrollAdjustHandler;
+}
+
+const getComponent = (Component: React.ComponentType<any> | React.ReactElement) => {
+    if (React.isValidElement<any>(Component)) {
+        return Component;
+    }
+    if (Component) {
+        return <Component />;
+    }
+    return null;
+};
+
+const Padding = () => {
+    const animPaddingTop = useValue$("alignItemsPaddingTop", { delay: 0 });
+
+    return <Animated.View style={{ paddingTop: animPaddingTop }} />;
+};
+
+const PaddingDevMode = () => {
+    const animPaddingTop = useValue$("alignItemsPaddingTop", { delay: 0 });
+
+    return (
+        <>
+            <Animated.View style={{ paddingTop: animPaddingTop }} />
+            <Animated.View
+                style={{
+                    position: "absolute",
+                    top: 0,
+                    height: animPaddingTop,
+                    left: 0,
+                    right: 0,
+                    backgroundColor: "green",
+                }}
+            />
+        </>
+    );
+};
+
+export const ListComponent = typedMemo(function ListComponent<ItemT>({
+    canRender,
+    style,
+    contentContainerStyle,
+    horizontal,
+    initialContentOffset,
+    recycleItems,
+    ItemSeparatorComponent,
+    alignItemsAtEnd,
+    waitForInitialLayout,
+    onScroll,
+    onLayout,
+    ListHeaderComponent,
+    ListHeaderComponentStyle,
+    ListFooterComponent,
+    ListFooterComponentStyle,
+    ListEmptyComponent,
+    getRenderedItem,
+    updateItemSize,
+    refScrollView,
+    maintainVisibleContentPosition,
+    renderScrollComponent,
+    scrollAdjustHandler,
+    onLayoutHeader,
+    ...rest
+}: ListComponentProps<ItemT>) {
+    const ctx = useStateContext();
+    const { onLayout: onLayoutHeaderSync, ref: refHeader } = useSyncLayout({
+        onChange: onLayoutHeader,
+    });
+
+    // Use renderScrollComponent if provided, otherwise a regular ScrollView
+    const ScrollComponent = renderScrollComponent
+        ? useMemo(
+              () => React.forwardRef((props, ref) => renderScrollComponent({ ...props, ref } as any)),
+              [renderScrollComponent],
+          )
+        : ScrollView;
+
+    React.useEffect(() => {
+        if (canRender) {
+            setTimeout(() => {
+                scrollAdjustHandler.setMounted();
+            }, 0);
+        }
+    }, [canRender]);
+
+    return (
+        <ScrollComponent
+            {...rest}
+            style={style}
+            maintainVisibleContentPosition={
+                maintainVisibleContentPosition && !ListEmptyComponent ? { minIndexForVisible: 0 } : undefined
+            }
+            contentContainerStyle={[
+                contentContainerStyle,
+                horizontal
+                    ? {
+                          height: "100%",
+                      }
+                    : {},
+            ]}
+            onScroll={onScroll}
+            onLayout={onLayout}
+            horizontal={horizontal}
+            contentOffset={
+                initialContentOffset
+                    ? horizontal
+                        ? { x: initialContentOffset, y: 0 }
+                        : { x: 0, y: initialContentOffset }
+                    : undefined
+            }
+            ref={refScrollView as any}
+        >
+            {maintainVisibleContentPosition && <ScrollAdjust />}
+            {ENABLE_DEVMODE ? <PaddingDevMode /> : <Padding />}
+            {ListHeaderComponent && (
+                <View style={ListHeaderComponentStyle} onLayout={onLayoutHeaderSync} ref={refHeader}>
+                    {getComponent(ListHeaderComponent)}
+                </View>
+            )}
+            {ListEmptyComponent && getComponent(ListEmptyComponent)}
+
+            {canRender && (
+                <Containers
+                    horizontal={horizontal!}
+                    recycleItems={recycleItems!}
+                    waitForInitialLayout={waitForInitialLayout}
+                    getRenderedItem={getRenderedItem}
+                    ItemSeparatorComponent={ItemSeparatorComponent}
+                    updateItemSize={updateItemSize}
+                />
+            )}
+            {ListFooterComponent && (
+                <View
+                    style={ListFooterComponentStyle}
+                    onLayout={(event) => {
+                        const size = event.nativeEvent.layout[horizontal ? "width" : "height"];
+                        set$(ctx, "footerSize", size);
+                    }}
+                >
+                    {getComponent(ListFooterComponent)}
+                </View>
+            )}
+        </ScrollComponent>
+    );
+});

package/src/ScrollAdjust.tsx

@@ -0,0 +1,24 @@
+// biome-ignore lint/correctness/noUnusedImports: Leaving this out makes it crash in some environments
+import * as React from "react";
+import { View } from "react-native";
+import { useArr$ } from "./state";
+
+export function ScrollAdjust() {
+    // Use a large bias to ensure this value never goes negative
+    const bias = 10_000_000;
+    const [scrollAdjust, scrollAdjustUserOffset] = useArr$(["scrollAdjust", "scrollAdjustUserOffset"]);
+    const scrollOffset = (scrollAdjust || 0) + (scrollAdjustUserOffset || 0) + bias;
+    const horizontal = false;
+
+    return (
+        <View
+            style={{
+                position: "absolute",
+                height: 0,
+                width: 0,
+                top: horizontal ? 0 : scrollOffset,
+                left: horizontal ? scrollOffset : 0,
+            }}
+        />
+    );
+}

package/src/ScrollAdjustHandler.ts

@@ -0,0 +1,26 @@
+import { type StateContext, peek$, set$ } from "./state";
+
+export class ScrollAdjustHandler {
+    private appliedAdjust = 0;
+    private context: StateContext;
+    private mounted = false;
+
+    constructor(ctx: StateContext) {
+        this.context = ctx;
+    }
+    requestAdjust(add: number) {
+        const oldAdjustTop = peek$(this.context, "scrollAdjust") || 0;
+
+        this.appliedAdjust = add + oldAdjustTop;
+
+        const set = () => set$(this.context, "scrollAdjust", this.appliedAdjust);
+        if (this.mounted) {
+            set();
+        } else {
+            requestAnimationFrame(set);
+        }
+    }
+    setMounted() {
+        this.mounted = true;
+    }
+}

package/src/Separator.tsx

@@ -0,0 +1,14 @@
+import { useArr$ } from "./state";
+
+export interface SeparatorProps<ItemT> {
+    ItemSeparatorComponent: React.ComponentType<{ leadingItem: ItemT }>;
+    itemKey: string;
+    leadingItem: ItemT;
+}
+
+export function Separator<ItemT>({ ItemSeparatorComponent, itemKey, leadingItem }: SeparatorProps<ItemT>) {
+    const [lastItemKeys] = useArr$(["lastItemKeys"]);
+    const isALastItem = lastItemKeys.includes(itemKey);
+
+    return isALastItem ? null : <ItemSeparatorComponent leadingItem={leadingItem} />;
+}

package/src/animated.tsx

@@ -0,0 +1,6 @@
+import { LegendList } from "@legendapp/list";
+import { Animated } from "react-native";
+
+const AnimatedLegendList = Animated.createAnimatedComponent(LegendList);
+
+export { AnimatedLegendList };

package/src/calculateItemsInView.ts

@@ -0,0 +1,363 @@
+import { calculateOffsetForIndex } from "./calculateOffsetForIndex";
+import { calculateOffsetWithOffsetPosition } from "./calculateOffsetWithOffsetPosition";
+import { checkAllSizesKnown } from "./checkAllSizesKnown";
+import { ENABLE_DEBUG_VIEW, POSITION_OUT_OF_VIEW } from "./constants";
+import { findAvailableContainers } from "./findAvailableContainers";
+import { getId } from "./getId";
+import { getItemSize } from "./getItemSize";
+import { getScrollVelocity } from "./getScrollVelocity";
+import { prepareMVCP } from "./prepareMVCP";
+import { setDidLayout } from "./setDidLayout";
+import { type StateContext, peek$, set$ } from "./state";
+import type { InternalState } from "./types";
+import { updateAllPositions } from "./updateAllPositions";
+import { updateViewableItems } from "./viewability";
+
+export function calculateItemsInView(
+    ctx: StateContext,
+    state: InternalState,
+    params: { doMVCP?: boolean; dataChanged?: boolean } = {},
+) {
+    const {
+        scrollLength,
+        startBufferedId: startBufferedIdOrig,
+        positions,
+        columns,
+        containerItemKeys,
+        idCache,
+        sizes,
+        indexByKey,
+        scrollForNextCalculateItemsInView,
+        enableScrollForNextCalculateItemsInView,
+        minIndexSizeChanged,
+    } = state;
+    const data = state.props.data;
+    if (!data || scrollLength === 0) {
+        return;
+    }
+
+    const totalSize = peek$(ctx, "totalSize");
+    const topPad = peek$(ctx, "stylePaddingTop") + peek$(ctx, "headerSize");
+    const numColumns = peek$(ctx, "numColumns");
+    const previousScrollAdjust = 0;
+    const { dataChanged, doMVCP } = params;
+    const speed = getScrollVelocity(state);
+
+    if (doMVCP || dataChanged) {
+        // TODO: This should only run if a size changed or items changed
+        // Handle maintainVisibleContentPosition adjustment early
+        const checkMVCP = doMVCP ? prepareMVCP(ctx, state) : undefined;
+
+        // Update all positions upfront so we can assume they're correct
+        updateAllPositions(ctx, state, dataChanged);
+
+        checkMVCP?.();
+    }
+
+    const scrollExtra = 0;
+    // Disabled this optimization for now because it was causing blanks to appear sometimes
+    // We may need to control speed calculation better, or not have a 5 item history to avoid this issue
+    // const scrollExtra = Math.max(-16, Math.min(16, speed)) * 24;
+
+    const { queuedInitialLayout } = state;
+    let { scroll: scrollState } = state;
+
+    // If this is before the initial layout, and we have an initialScrollIndex,
+    // then ignore the actual scroll which might be shifting due to scrollAdjustHandler
+    // and use the calculated offset of the initialScrollIndex instead.
+    const initialScroll = state.props.initialScroll;
+    if (!queuedInitialLayout && initialScroll) {
+        const updatedOffset = calculateOffsetWithOffsetPosition(
+            state,
+            calculateOffsetForIndex(ctx, state, initialScroll.index),
+            initialScroll,
+        );
+        scrollState = updatedOffset;
+    }
+
+    const scrollAdjustPad = -previousScrollAdjust - topPad;
+    let scroll = scrollState + scrollExtra + scrollAdjustPad;
+
+    // Sometimes we may have scrolled past the visible area which can make items at the top of the
+    // screen not render. So make sure we clamp scroll to the end.
+    if (scroll + scrollLength > totalSize) {
+        scroll = totalSize - scrollLength;
+    }
+
+    if (ENABLE_DEBUG_VIEW) {
+        set$(ctx, "debugRawScroll", scrollState);
+        set$(ctx, "debugComputedScroll", scroll);
+    }
+
+    const scrollBuffer = state.props.scrollBuffer;
+    let scrollBufferTop = scrollBuffer;
+    let scrollBufferBottom = scrollBuffer;
+
+    if (speed > 0) {
+        scrollBufferTop = scrollBuffer * 0.5;
+        scrollBufferBottom = scrollBuffer * 1.5;
+    } else {
+        scrollBufferTop = scrollBuffer * 1.5;
+        scrollBufferBottom = scrollBuffer * 0.5;
+    }
+
+    const scrollTopBuffered = scroll - scrollBufferTop;
+    const scrollBottom = scroll + scrollLength;
+    const scrollBottomBuffered = scrollBottom + scrollBufferBottom;
+
+    // Check precomputed scroll range to see if we can skip this check
+    if (scrollForNextCalculateItemsInView) {
+        const { top, bottom } = scrollForNextCalculateItemsInView;
+        if (scrollTopBuffered > top && scrollBottomBuffered < bottom) {
+            return;
+        }
+    }
+
+    let startNoBuffer: number | null = null;
+    let startBuffered: number | null = null;
+    let startBufferedId: string | null = null;
+    let endNoBuffer: number | null = null;
+    let endBuffered: number | null = null;
+
+    let loopStart: number = startBufferedIdOrig ? indexByKey.get(startBufferedIdOrig) || 0 : 0;
+
+    if (minIndexSizeChanged !== undefined) {
+        loopStart = Math.min(minIndexSizeChanged, loopStart);
+        state.minIndexSizeChanged = undefined;
+    }
+
+    // Go backwards from the last start position to find the first item that is in view
+    // This is an optimization to avoid looping through all items, which could slow down
+    // when scrolling at the end of a long list.
+    for (let i = loopStart; i >= 0; i--) {
+        const id = idCache.get(i) ?? getId(state, i)!;
+        const top = positions.get(id)!;
+        const size = sizes.get(id) ?? getItemSize(state, id, i, data[i]);
+        const bottom = top + size;
+
+        if (bottom > scroll - scrollBuffer) {
+            loopStart = i;
+        } else {
+            break;
+        }
+    }
+
+    const loopStartMod = loopStart % numColumns;
+    if (loopStartMod > 0) {
+        loopStart -= loopStartMod;
+    }
+
+    let foundEnd = false;
+    let nextTop: number | undefined;
+    let nextBottom: number | undefined;
+
+    // TODO PERF: Could cache this while looping through numContainers at the end of this function
+    // This takes 0.03 ms in an example in the ios simulator
+    const prevNumContainers = ctx.values.get("numContainers") as number;
+    let maxIndexRendered = 0;
+    for (let i = 0; i < prevNumContainers; i++) {
+        const key = peek$(ctx, `containerItemKey${i}`);
+        if (key !== undefined) {
+            const index = indexByKey.get(key)!;
+            maxIndexRendered = Math.max(maxIndexRendered, index);
+        }
+    }
+
+    let firstFullyOnScreenIndex: number | undefined;
+
+    // scan data forwards
+    // Continue until we've found the end and we've updated positions of all items that were previously in view
+    const dataLength = data!.length;
+    for (let i = Math.max(0, loopStart); i < dataLength && (!foundEnd || i <= maxIndexRendered); i++) {
+        const id = idCache.get(i) ?? getId(state, i)!;
+        const size = sizes.get(id) ?? getItemSize(state, id, i, data[i]);
+        const top = positions.get(id)!;
+
+        if (!foundEnd) {
+            if (startNoBuffer === null && top + size > scroll) {
+                startNoBuffer = i;
+            }
+            // Subtract 10px for a little buffer so it can be slightly off screen
+            if (firstFullyOnScreenIndex === undefined && top >= scroll - 10) {
+                firstFullyOnScreenIndex = i;
+            }
+
+            if (startBuffered === null && top + size > scrollTopBuffered) {
+                startBuffered = i;
+                startBufferedId = id;
+                nextTop = top;
+            }
+            if (startNoBuffer !== null) {
+                if (top <= scrollBottom) {
+                    endNoBuffer = i;
+                }
+                if (top <= scrollBottomBuffered) {
+                    endBuffered = i;
+                    nextBottom = top + size;
+                } else {
+                    foundEnd = true;
+                }
+            }
+        }
+    }
+
+    const idsInView: string[] = [];
+    for (let i = firstFullyOnScreenIndex!; i <= endNoBuffer!; i++) {
+        const id = idCache.get(i) ?? getId(state, i)!;
+        idsInView.push(id);
+    }
+
+    Object.assign(state, {
+        startBuffered,
+        startBufferedId,
+        startNoBuffer,
+        endBuffered,
+        endNoBuffer,
+        idsInView,
+        firstFullyOnScreenIndex,
+    });
+
+    // Precompute the scroll that will be needed for the range to change
+    // so it can be skipped if not needed
+    if (enableScrollForNextCalculateItemsInView && nextTop !== undefined && nextBottom !== undefined) {
+        state.scrollForNextCalculateItemsInView =
+            nextTop !== undefined && nextBottom !== undefined
+                ? {
+                      top: nextTop,
+                      bottom: nextBottom,
+                  }
+                : undefined;
+    }
+
+    const numContainers = peek$(ctx, "numContainers");
+    // Reset containers that aren't used anymore because the data has changed
+    const pendingRemoval: number[] = [];
+    if (dataChanged) {
+        for (let i = 0; i < numContainers; i++) {
+            const itemKey = peek$(ctx, `containerItemKey${i}`);
+            if (!state.props.keyExtractor || (itemKey && indexByKey.get(itemKey) === undefined)) {
+                pendingRemoval.push(i);
+            }
+        }
+    }
+
+    // Place newly added items into containers
+    if (startBuffered !== null && endBuffered !== null) {
+        let numContainers = prevNumContainers;
+        const needNewContainers: number[] = [];
+
+        for (let i = startBuffered!; i <= endBuffered; i++) {
+            const id = idCache.get(i) ?? getId(state, i)!;
+            if (!containerItemKeys.has(id)) {
+                needNewContainers.push(i);
+            }
+        }
+
+        if (needNewContainers.length > 0) {
+            const availableContainers = findAvailableContainers(
+                ctx,
+                state,
+                needNewContainers.length,
+                startBuffered,
+                endBuffered,
+                pendingRemoval,
+            );
+            for (let idx = 0; idx < needNewContainers.length; idx++) {
+                const i = needNewContainers[idx];
+                const containerIndex = availableContainers[idx];
+                const id = idCache.get(i) ?? getId(state, i)!;
+
+                // Remove old key from cache
+                const oldKey = peek$(ctx, `containerItemKey${containerIndex}`);
+                if (oldKey && oldKey !== id) {
+                    containerItemKeys!.delete(oldKey);
+                }
+
+                set$(ctx, `containerItemKey${containerIndex}`, id);
+                set$(ctx, `containerItemData${containerIndex}`, data[i]);
+
+                // Update cache when adding new item
+                containerItemKeys!.add(id);
+
+                if (containerIndex >= numContainers) {
+                    numContainers = containerIndex + 1;
+                }
+            }
+
+            if (numContainers !== prevNumContainers) {
+                set$(ctx, "numContainers", numContainers);
+                if (numContainers > peek$(ctx, "numContainersPooled")) {
+                    set$(ctx, "numContainersPooled", Math.ceil(numContainers * 1.5));
+                }
+            }
+        }
+    }
+
+    // Update top positions of all containers
+    for (let i = 0; i < numContainers; i++) {
+        const itemKey = peek$(ctx, `containerItemKey${i}`);
+
+        // If it was
+        if (pendingRemoval.includes(i)) {
+            // Update cache when removing item
+            if (itemKey) {
+                containerItemKeys!.delete(itemKey);
+            }
+
+            set$(ctx, `containerItemKey${i}`, undefined);
+            set$(ctx, `containerItemData${i}`, undefined);
+            set$(ctx, `containerPosition${i}`, POSITION_OUT_OF_VIEW);
+            set$(ctx, `containerColumn${i}`, -1);
+        } else {
+            const itemIndex = indexByKey.get(itemKey)!;
+            const item = data[itemIndex];
+            if (item !== undefined) {
+                const id = idCache.get(itemIndex) ?? getId(state, itemIndex);
+                const position = positions.get(id);
+
+                if (position === undefined) {
+                    // This item may have been in view before data changed and positions were reset
+                    // so we need to set it to out of view
+                    set$(ctx, `containerPosition${i}`, POSITION_OUT_OF_VIEW);
+                } else {
+                    const pos = positions.get(id)!;
+                    const column = columns.get(id) || 1;
+
+                    const prevPos = peek$(ctx, `containerPosition${i}`);
+                    const prevColumn = peek$(ctx, `containerColumn${i}`);
+                    const prevData = peek$(ctx, `containerItemData${i}`);
+
+                    if (!prevPos || (pos > POSITION_OUT_OF_VIEW && pos !== prevPos)) {
+                        set$(ctx, `containerPosition${i}`, pos);
+                    }
+                    if (column >= 0 && column !== prevColumn) {
+                        set$(ctx, `containerColumn${i}`, column);
+                    }
+
+                    if (prevData !== item) {
+                        set$(ctx, `containerItemData${i}`, data[itemIndex]);
+                    }
+                }
+            }
+        }
+    }
+
+    if (!queuedInitialLayout && endBuffered !== null) {
+        // If waiting for initial layout and all items in view have a known size then
+        // initial layout is complete
+        if (checkAllSizesKnown(state)) {
+            setDidLayout(ctx, state);
+        }
+    }
+
+    if (state.props.viewabilityConfigCallbackPairs) {
+        updateViewableItems(
+            state,
+            ctx,
+            state.props.viewabilityConfigCallbackPairs,
+            scrollLength,
+            startNoBuffer!,
+            endNoBuffer!,
+        );
+    }
+}

package/src/calculateOffsetForIndex.ts

@@ -0,0 +1,23 @@
+import { getId } from "./getId";
+import { type StateContext, peek$ } from "./state";
+import type { InternalState } from "./types";
+
+export function calculateOffsetForIndex(ctx: StateContext, state: InternalState, index: number | undefined) {
+    let position = 0;
+
+    if (index !== undefined) {
+        position = state?.positions.get(getId(state, index)) || 0;
+    }
+
+    const paddingTop = peek$(ctx, "stylePaddingTop");
+    if (paddingTop) {
+        position += paddingTop;
+    }
+
+    const headerSize = peek$(ctx, "headerSize");
+    if (headerSize) {
+        position += headerSize;
+    }
+
+    return position;
+}

package/src/calculateOffsetWithOffsetPosition.ts

@@ -0,0 +1,26 @@
+import { getId } from "./getId";
+import { getItemSize } from "./getItemSize";
+import type { InternalState, ScrollIndexWithOffsetPosition } from "./types";
+
+export function calculateOffsetWithOffsetPosition(
+    state: InternalState,
+    offsetParam: number,
+    params: Partial<ScrollIndexWithOffsetPosition>,
+) {
+    const { index, viewOffset, viewPosition } = params;
+    let offset = offsetParam;
+
+    if (viewOffset) {
+        offset -= viewOffset;
+    }
+
+    if (viewPosition !== undefined && index !== undefined) {
+        // TODO: This can be inaccurate if the item size is very different from the estimatedItemSize
+        // In the future we can improve this by listening for the item size change and then updating the scroll position
+        offset -=
+            viewPosition *
+            (state.scrollLength - getItemSize(state, getId(state, index), index, state.props.data[index]!));
+    }
+
+    return offset;
+}

package/src/checkAllSizesKnown.ts

@@ -0,0 +1,17 @@
+import { getId } from "./getId";
+import type { InternalState } from "./types";
+
+export function checkAllSizesKnown(state: InternalState) {
+    const { startBuffered, endBuffered, sizesKnown } = state;
+    if (endBuffered !== null) {
+        // If waiting for initial layout and all items in view have a known size then
+        // initial layout is complete
+        let areAllKnown = true;
+        for (let i = startBuffered!; areAllKnown && i <= endBuffered!; i++) {
+            const key = getId(state, i)!;
+            areAllKnown &&= sizesKnown.has(key);
+        }
+        return areAllKnown;
+    }
+    return false;
+}