@fusion.dev/helix-headless 0.165.0 → 0.167.0

package/dist/virtual-list/sections.d.ts

@@ -0,0 +1,27 @@
+/** Where each section starts in the items, and what it is called. */
+export interface Sections {
+    /** The section names, in order. */
+    names: string[];
+    /** The index of each section's first item, in order. */
+    starts: number[];
+}
+/** The sections `field` divides the items into. */
+export declare const sectionsOf: (items: readonly unknown[], field: string) => Sections;
+/** The section item `item` is in. */
+export declare const sectionAt: ({ starts }: Sections, item: number) => number;
+/** The entry item `item` is. */
+export declare const entryOf: (sections: Sections, item: number) => number;
+/** The entry of section `section`'s header. */
+export declare const headOf: ({ starts }: Sections, section: number) => number;
+/**
+ * The items a span of entries holds: what a window of entries draws, or what
+ * a reader sees. A header at either end holds no item, so the span starts at
+ * its section's first item.
+ */
+export declare const itemsIn: (sections: Sections, entries: {
+    first: number;
+    last: number;
+}, count: number) => {
+    first: number;
+    last: number;
+};

package/dist/virtual-list/sections.js

@@ -0,0 +1,43 @@
+import { valueAt } from '@fusion.dev/helix-core';
+import { textOf } from './fill.js';
+export const sectionsOf = (items, field) => {
+    const names = [];
+    const starts = [];
+    let last;
+    for (const [at, item] of items.entries()) {
+        const name = textOf(valueAt(item, field));
+        if (at === 0 || name !== last) {
+            names.push(name);
+            starts.push(at);
+            last = name;
+        }
+    }
+    return { names, starts };
+};
+const lastUpTo = (length, at, target) => {
+    let low = 0;
+    let high = length - 1;
+    while (low < high) {
+        const middle = Math.ceil((low + high) / 2);
+        if (at(middle) <= target) {
+            low = middle;
+        }
+        else {
+            high = middle - 1;
+        }
+    }
+    return low;
+};
+export const sectionAt = ({ starts }, item) => lastUpTo(starts.length, (index) => starts[index] ?? 0, item);
+export const entryOf = (sections, item) => item + sectionAt(sections, item) + 1;
+export const headOf = ({ starts }, section) => (starts[section] ?? 0) + section;
+export const itemsIn = (sections, entries, count) => {
+    const item = (entry) => {
+        if (entry >= count + sections.starts.length) {
+            return count;
+        }
+        const section = lastUpTo(sections.starts.length, (index) => headOf(sections, index), entry);
+        return Math.max(sections.starts[section] ?? 0, entry - section - 1);
+    };
+    return { first: item(entries.first), last: Math.max(item(entries.first), item(entries.last)) };
+};