@gtkx/components 1.0.0-rc.3 → 1.0.0

package/src/internal/collection-index.ts

@@ -1,132 +1,87 @@
-import type { Item, Section } from "../types.js";
+import type { ListItem, ListSection } from "../types.js";
+import { encodePart } from "./keys.js";
 
 type Level = {
-    key: string;
-    ids: string[];
-    isExpandable: boolean[];
+    path: string;
+    items: ListItem[];
+    expandableFlags: boolean[];
 };
 
 type CollectionIndex = {
     isTree: boolean;
-    size: number;
     groups: Level[];
     children: Map<string, Level>;
-    has: (id: string) => boolean;
-    itemFor: (id: string) => Item | undefined;
-    sectionFor: (id: string) => unknown;
-    positionFor: (id: string) => number;
+    itemAt: (levelPath: string, slot: number) => ListItem | undefined;
+    sectionFor: (levelPath: string) => unknown;
+    expandablePathsFor: (id: string) => string[];
 };
 
 type IndexState = {
     isTree: boolean;
     groups: Level[];
     children: Map<string, Level>;
-    itemsById: Map<string, Item>;
-    sections: Section[] | undefined;
-    positions: Map<string, number> | null;
-    starts: number[] | null;
+    levels: Map<string, Level>;
+    expandablePaths: Map<string, string[]>;
+    sectionValues: Map<string, unknown>;
 };
 
-const ROOT_LEVEL_KEY = "";
+const NO_PATHS: string[] = [];
 
-const hasChildren = (item: Item): boolean => item.children !== undefined && item.children.length > 0;
-const childLevelKey = (id: string): string => `child:${id}`;
+const hasChildren = (item: ListItem): boolean => item.children !== undefined && item.children.length > 0;
 
-function collectChildren(state: IndexState, level: Level, item: Item): void {
-    if (!state.isTree) {
-        return;
-    }
+function pushPath(table: Map<string, string[]>, id: string, path: string): void {
+    const existing = table.get(id);
 
-    const canExpand = hasChildren(item);
-    level.isExpandable.push(canExpand);
+    if (existing === undefined) {
+        table.set(id, [path]);
 
-    if (!canExpand) {
         return;
     }
 
-    const key = childLevelKey(item.id);
-    state.children.set(key, collectLevel(state, key, item.children ?? []));
-}
-
-function collectLevel(state: IndexState, key: string, items: Item[]): Level {
-    const level: Level = { key, ids: [], isExpandable: [] };
-
-    for (const item of items) {
-        level.ids.push(item.id);
-        state.itemsById.set(item.id, item);
-        collectChildren(state, level, item);
-    }
-
-    return level;
-}
-
-function buildPositions(state: IndexState): void {
-    const positions: Map<string, number> = new Map();
-    const starts: number[] = [];
-    let offset = 0;
-
-    for (const level of state.groups) {
-        starts.push(offset);
-
-        for (const id of level.ids) {
-            positions.set(id, offset);
-            offset += 1;
-        }
-    }
-
-    state.positions = positions;
-    state.starts = starts;
+    existing.push(path);
 }
 
-function positionFor(state: IndexState, id: string): number {
-    if (state.isTree) {
-        return -1;
-    }
+function collectChildren(state: IndexState, level: Level, slotPath: string, item: ListItem): void {
+    const canExpand = hasChildren(item);
+    level.expandableFlags.push(canExpand);
 
-    if (state.positions === null) {
-        buildPositions(state);
+    if (!canExpand) {
+        return;
     }
 
-    return state.positions?.get(id) ?? -1;
+    pushPath(state.expandablePaths, item.id, slotPath);
+    state.children.set(slotPath, collectLevel(state, slotPath, item.children ?? []));
 }
 
-function sectionAt(starts: number[], position: number): number {
-    let low = 0;
-    let high = starts.length - 1;
+function collectLevel(state: IndexState, path: string, items: ListItem[]): Level {
+    const level: Level = { path, items, expandableFlags: [] };
+    state.levels.set(path, level);
 
-    while (low < high) {
-        const middle = Math.ceil((low + high) / 2);
-
-        if ((starts[middle] ?? 0) <= position) {
-            low = middle;
-        } else {
-            high = middle - 1;
-        }
+    if (!state.isTree) {
+        return level;
     }
 
-    return low;
-}
-
-function sectionFor(state: IndexState, id: string): unknown {
-    const sections = state.sections;
-    const position = positionFor(state, id);
-
-    if (sections === undefined || position < 0 || state.starts === null) {
-        return undefined;
+    for (const [slot, item] of items.entries()) {
+        collectChildren(state, level, path + encodePart(String(slot)), item);
     }
 
-    return sections[sectionAt(state.starts, position)]?.value;
+    return level;
 }
 
-function buildGroups(state: IndexState, source: Item[], sections: Section[] | undefined): Level[] {
+function buildGroups(state: IndexState, source: ListItem[], sections: ListSection[] | undefined): Level[] {
     if (sections === undefined) {
-        return [collectLevel(state, ROOT_LEVEL_KEY, source)];
+        return [collectLevel(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 collectLevel(state, path, section.data);
+    });
 }
 
-function isTreeSource(source: Item[], sections: Section[] | undefined, isFlat: boolean): boolean {
+function isTreeSource(source: ListItem[], sections: ListSection[] | undefined, isFlat: boolean): boolean {
     if (sections !== undefined || isFlat) {
         return false;
     }
@@ -135,8 +90,8 @@ function isTreeSource(source: Item[], sections: Section[] | undefined, isFlat: b
 }
 
 function createCollectionIndex(
-    items: Item[] | undefined,
-    sections: Section[] | undefined,
+    items: ListItem[] | undefined,
+    sections: ListSection[] | undefined,
     isFlat: boolean,
 ): CollectionIndex {
     const source = items ?? [];
@@ -145,24 +100,21 @@ function createCollectionIndex(
         isTree: isTreeSource(source, sections, isFlat),
         groups: [],
         children: new Map(),
-        itemsById: new Map(),
-        sections,
-        positions: null,
-        starts: null,
+        levels: new Map(),
+        expandablePaths: 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,
-        has: (id) => state.itemsById.has(id),
-        itemFor: (id) => state.itemsById.get(id),
-        sectionFor: (id) => sectionFor(state, id),
-        positionFor: (id) => positionFor(state, id),
+        itemAt: (levelPath, slot) => state.levels.get(levelPath)?.items[slot],
+        sectionFor: (levelPath) => state.sectionValues.get(levelPath),
+        expandablePathsFor: (id) => state.expandablePaths.get(id) ?? NO_PATHS,
     };
 }
 
-export { createCollectionIndex, childLevelKey, ROOT_LEVEL_KEY, type CollectionIndex, type Level };
+export { createCollectionIndex, type CollectionIndex, type Level };