@gtkx/components 1.0.0-rc.4 → 1.1.0

package/src/internal/collection-index.ts

@@ -1,137 +1,118 @@
 import type { ListItem, ListSection } from "../types.js";
+import { decodePartAt, encodePart } from "./keys.js";
 
 type Level = {
-    key: string;
-    ids: string[];
+    path: string;
+    items: ListItem[];
     expandableFlags: boolean[];
 };
 
 type CollectionIndex = {
     isTree: boolean;
-    size: number;
     groups: Level[];
-    children: Map<string, Level>;
-    hasId: (id: string) => boolean;
-    itemFor: (id: string) => ListItem | undefined;
-    sectionFor: (id: string) => unknown;
-    positionFor: (id: string) => number;
+    childLevel: (level: Level, slot: number) => Level | undefined;
+    levelFor: (levelPath: string) => Level | undefined;
+    itemAt: (levelPath: string, slot: number) => ListItem | undefined;
+    sectionFor: (levelPath: string) => unknown;
 };
 
 type IndexState = {
     isTree: boolean;
     groups: Level[];
-    children: Map<string, Level>;
-    itemsById: Map<string, ListItem>;
-    sections: ListSection[] | undefined;
-    positions: Map<string, number> | null;
-    starts: number[] | null;
+    levels: Map<string, Level>;
+    sectionValues: Map<string, unknown>;
 };
 
-const ROOT_LEVEL_KEY = "";
+type ParentItem = ListItem & { children: ListItem[] };
 
-const hasChildren = (item: ListItem): boolean => item.children !== undefined && item.children.length > 0;
-const childLevelKey = (id: string): string => `child:${id}`;
+const emptyLevel = (): Level => ({ path: "", items: [], expandableFlags: [] });
+const hasChildren = (item: ListItem): item is ParentItem => item.children !== undefined && item.children.length > 0;
 
-function collectChildren(state: IndexState, level: Level, item: ListItem): void {
-    if (!state.isTree) {
-        return;
-    }
-
-    const canExpand = hasChildren(item);
-    level.expandableFlags.push(canExpand);
-
-    if (!canExpand) {
-        return;
-    }
-
-    const key = childLevelKey(item.id);
-    state.children.set(key, collectLevel(state, key, item.children ?? []));
-}
-
-function collectLevel(state: IndexState, key: string, items: ListItem[]): Level {
-    const level: Level = { key, ids: [], expandableFlags: [] };
-
-    for (const item of items) {
-        level.ids.push(item.id);
-        state.itemsById.set(item.id, item);
-        collectChildren(state, level, item);
-    }
+function newLevel(state: IndexState, path: string, items: ListItem[]): Level {
+    const expandableFlags = state.isTree ? items.map((item) => hasChildren(item)) : [];
+    const level: Level = { path, items, expandableFlags };
+    state.levels.set(path, level);
 
     return level;
 }
 
-function buildPositions(state: IndexState): void {
-    const positions: Map<string, number> = new Map();
-    const starts: number[] = [];
-    let offset = 0;
+function slotItems(state: IndexState, parent: Level, slot: number): ListItem[] | undefined {
+    const owner = state.levels.get(parent.path) === parent ? parent : levelFor(state, parent.path);
+    const item = owner?.items[slot];
 
-    for (const level of state.groups) {
-        starts.push(offset);
+    return item !== undefined && hasChildren(item) ? item.children : undefined;
+}
 
-        for (const id of level.ids) {
-            positions.set(id, offset);
-            offset += 1;
-        }
+function childLevel(state: IndexState, parent: Level, slot: number): Level | undefined {
+    if (!state.isTree) {
+        return undefined;
     }
 
-    state.positions = positions;
-    state.starts = starts;
-}
+    const path = parent.path + encodePart(String(slot));
+    const cached = state.levels.get(path);
 
-function positionFor(state: IndexState, id: string): number {
-    if (state.isTree) {
-        return -1;
+    if (cached !== undefined) {
+        return cached;
     }
 
-    if (state.positions === null) {
-        buildPositions(state);
-    }
+    const items = slotItems(state, parent, slot);
 
-    return state.positions?.get(id) ?? -1;
+    return items === undefined ? undefined : newLevel(state, path, items);
 }
 
-function sectionAt(starts: number[], position: number): number {
-    let low = 0;
-    let high = starts.length - 1;
+function descendPath(state: IndexState, levelPath: string, group: string): Level | undefined {
+    let level = state.levels.get(encodePart(group));
+    let offset = encodePart(group).length;
 
-    while (low < high) {
-        const middle = Math.ceil((low + high) / 2);
+    while (level !== undefined && offset < levelPath.length) {
+        const part = decodePartAt(levelPath, offset);
 
-        if ((starts[middle] ?? 0) <= position) {
-            low = middle;
-        } else {
-            high = middle - 1;
+        if (part === null) {
+            return undefined;
         }
+
+        level = childLevel(state, level, Number(part));
+        offset += encodePart(part).length;
     }
 
-    return low;
+    return level;
 }
 
-function sectionFor(state: IndexState, id: string): unknown {
-    const sections = state.sections;
-    const position = positionFor(state, id);
+function levelFor(state: IndexState, levelPath: string): Level | undefined {
+    const cached = state.levels.get(levelPath);
 
-    if (sections === undefined || position < 0 || state.starts === null) {
-        return undefined;
+    if (cached !== undefined) {
+        return cached;
     }
 
-    return sections[sectionAt(state.starts, position)]?.value;
+    const group = decodePartAt(levelPath, 0);
+
+    return group === null ? undefined : descendPath(state, levelPath, group);
 }
 
 function buildGroups(state: IndexState, source: ListItem[], sections: ListSection[] | undefined): Level[] {
     if (sections === undefined) {
-        return [collectLevel(state, ROOT_LEVEL_KEY, source)];
+        return [newLevel(state, encodePart("0"), source)];
     }
 
-    return sections.map((section) => collectLevel(state, section.id, section.data));
+    return sections.map((section, group) => {
+        const path = encodePart(String(group));
+        state.sectionValues.set(path, section.value);
+
+        return newLevel(state, path, section.data);
+    });
 }
 
 function isTreeSource(source: ListItem[], sections: ListSection[] | undefined, isFlat: boolean): boolean {
-    if (sections !== undefined || isFlat) {
+    if (isFlat) {
         return false;
     }
 
-    return source.some((item) => hasChildren(item));
+    if (sections === undefined) {
+        return source.some((item) => hasChildren(item));
+    }
+
+    return sections.some((section) => section.data.some((item) => hasChildren(item)));
 }
 
 function createCollectionIndex(
@@ -144,25 +125,20 @@ function createCollectionIndex(
     const state: IndexState = {
         isTree: isTreeSource(source, sections, isFlat),
         groups: [],
-        children: new Map(),
-        itemsById: new Map(),
-        sections,
-        positions: null,
-        starts: null,
+        levels: new Map(),
+        sectionValues: new Map(),
     };
 
     state.groups = buildGroups(state, source, sections);
 
     return {
         isTree: state.isTree,
-        size: state.itemsById.size,
         groups: state.groups,
-        children: state.children,
-        hasId: (id) => state.itemsById.has(id),
-        itemFor: (id) => state.itemsById.get(id),
-        sectionFor: (id) => sectionFor(state, id),
-        positionFor: (id) => positionFor(state, id),
+        childLevel: (level, slot) => childLevel(state, level, slot),
+        levelFor: (levelPath) => levelFor(state, levelPath),
+        itemAt: (levelPath, slot) => levelFor(state, levelPath)?.items[slot],
+        sectionFor: (levelPath) => state.sectionValues.get(levelPath),
     };
 }
 
-export { createCollectionIndex, childLevelKey, ROOT_LEVEL_KEY, type CollectionIndex, type Level };
+export { createCollectionIndex, emptyLevel, type CollectionIndex, type Level };