@hexclave/shared 1.0.0

package/dist/esm/utils/paginated-lists.test.js

@@ -0,0 +1,1304 @@
+import { describe, expect, it } from "vitest";
+import { stringCompare } from "./strings.js";
+import { ArrayPaginatedList, PaginatedList } from "./paginated-lists.js";
+
+//#region src/utils/paginated-lists.test.ts
+const items = (result) => result.items.map((i) => i.item);
+describe("ArrayPaginatedList", () => {
+	describe("basic forward pagination (next)", () => {
+		it("should return all items when limit is greater than array length", async () => {
+			const list = new ArrayPaginatedList([
+				1,
+				2,
+				3
+			]);
+			const result = await list.next({
+				after: list.getFirstCursor(),
+				limit: 10,
+				filter: () => true,
+				orderBy: (a, b) => a - b,
+				limitPrecision: "exact"
+			});
+			expect(items(result)).toEqual([
+				1,
+				2,
+				3
+			]);
+			expect(result.isFirst).toBe(true);
+			expect(result.isLast).toBe(true);
+		});
+		it("should return exact limit when more items exist", async () => {
+			const list = new ArrayPaginatedList([
+				1,
+				2,
+				3,
+				4,
+				5
+			]);
+			const result = await list.next({
+				after: list.getFirstCursor(),
+				limit: 3,
+				filter: () => true,
+				orderBy: (a, b) => a - b,
+				limitPrecision: "exact"
+			});
+			expect(items(result)).toEqual([
+				1,
+				2,
+				3
+			]);
+			expect(result.isFirst).toBe(true);
+			expect(result.isLast).toBe(false);
+		});
+		it("should continue from cursor correctly", async () => {
+			const list = new ArrayPaginatedList([
+				1,
+				2,
+				3,
+				4,
+				5
+			]);
+			const first = await list.next({
+				after: list.getFirstCursor(),
+				limit: 2,
+				filter: () => true,
+				orderBy: (a, b) => a - b,
+				limitPrecision: "exact"
+			});
+			expect(items(first)).toEqual([1, 2]);
+			expect(first.cursor).toBe("before-2");
+			const second = await list.next({
+				after: first.cursor,
+				limit: 2,
+				filter: () => true,
+				orderBy: (a, b) => a - b,
+				limitPrecision: "exact"
+			});
+			expect(items(second)).toEqual([3, 4]);
+			expect(second.isFirst).toBe(false);
+			expect(second.isLast).toBe(false);
+		});
+		it("should handle empty array", async () => {
+			const list = new ArrayPaginatedList([]);
+			const result = await list.next({
+				after: list.getFirstCursor(),
+				limit: 10,
+				filter: () => true,
+				orderBy: (a, b) => a - b,
+				limitPrecision: "exact"
+			});
+			expect(items(result)).toEqual([]);
+			expect(result.isFirst).toBe(true);
+			expect(result.isLast).toBe(true);
+		});
+		it("should handle limit of 0", async () => {
+			const list = new ArrayPaginatedList([
+				1,
+				2,
+				3
+			]);
+			expect(items(await list.next({
+				after: list.getFirstCursor(),
+				limit: 0,
+				filter: () => true,
+				orderBy: (a, b) => a - b,
+				limitPrecision: "exact"
+			}))).toEqual([]);
+		});
+	});
+	describe("backward pagination (prev)", () => {
+		it("should return items before cursor", async () => {
+			const list = new ArrayPaginatedList([
+				1,
+				2,
+				3,
+				4,
+				5
+			]);
+			const result = await list.prev({
+				before: list.getLastCursor(),
+				limit: 2,
+				filter: () => true,
+				orderBy: (a, b) => a - b,
+				limitPrecision: "exact"
+			});
+			expect(items(result)).toEqual([4, 5]);
+			expect(result.isFirst).toBe(false);
+			expect(result.isLast).toBe(true);
+		});
+		it("should paginate backwards correctly", async () => {
+			const list = new ArrayPaginatedList([
+				1,
+				2,
+				3,
+				4,
+				5
+			]);
+			const last = await list.prev({
+				before: list.getLastCursor(),
+				limit: 2,
+				filter: () => true,
+				orderBy: (a, b) => a - b,
+				limitPrecision: "exact"
+			});
+			expect(items(last)).toEqual([4, 5]);
+			const middle = await list.prev({
+				before: last.cursor,
+				limit: 2,
+				filter: () => true,
+				orderBy: (a, b) => a - b,
+				limitPrecision: "exact"
+			});
+			expect(items(middle)).toEqual([2, 3]);
+			const first = await list.prev({
+				before: middle.cursor,
+				limit: 2,
+				filter: () => true,
+				orderBy: (a, b) => a - b,
+				limitPrecision: "exact"
+			});
+			expect(items(first)).toEqual([1]);
+			expect(first.isFirst).toBe(true);
+		});
+	});
+	describe("cursor semantics (prevCursor and nextCursor)", () => {
+		it("should have prevCursor before the item and nextCursor after", async () => {
+			const list = new ArrayPaginatedList([
+				10,
+				20,
+				30
+			]);
+			const result = await list.next({
+				after: list.getFirstCursor(),
+				limit: 3,
+				filter: () => true,
+				orderBy: (a, b) => a - b,
+				limitPrecision: "exact"
+			});
+			expect(result.items[0].prevCursor).toBe("before-0");
+			expect(result.items[0].nextCursor).toBe("before-1");
+			expect(result.items[1].prevCursor).toBe("before-1");
+			expect(result.items[1].nextCursor).toBe("before-2");
+			expect(result.items[2].prevCursor).toBe("before-2");
+			expect(result.items[2].nextCursor).toBe("before-3");
+		});
+		it("should allow using nextCursor to continue forward pagination", async () => {
+			const list = new ArrayPaginatedList([
+				1,
+				2,
+				3,
+				4,
+				5
+			]);
+			const first = await list.next({
+				after: list.getFirstCursor(),
+				limit: 2,
+				filter: () => true,
+				orderBy: (a, b) => a - b,
+				limitPrecision: "exact"
+			});
+			const continueFrom = first.items[first.items.length - 1].nextCursor;
+			expect(items(await list.next({
+				after: continueFrom,
+				limit: 2,
+				filter: () => true,
+				orderBy: (a, b) => a - b,
+				limitPrecision: "exact"
+			}))).toEqual([3, 4]);
+		});
+		it("should allow using prevCursor to go back", async () => {
+			const list = new ArrayPaginatedList([
+				1,
+				2,
+				3,
+				4,
+				5
+			]);
+			const middle = await list.next({
+				after: "before-2",
+				limit: 3,
+				filter: () => true,
+				orderBy: (a, b) => a - b,
+				limitPrecision: "exact"
+			});
+			expect(items(middle)).toEqual([
+				3,
+				4,
+				5
+			]);
+			expect(middle.items[0].prevCursor).toBe("before-2");
+			expect(items(await list.prev({
+				before: middle.items[0].prevCursor,
+				limit: 2,
+				filter: () => true,
+				orderBy: (a, b) => a - b,
+				limitPrecision: "exact"
+			}))).toEqual([1, 2]);
+		});
+	});
+	describe("filtering", () => {
+		it("should filter items correctly", async () => {
+			const list = new ArrayPaginatedList([
+				1,
+				2,
+				3,
+				4,
+				5,
+				6
+			]);
+			expect(items(await list.next({
+				after: list.getFirstCursor(),
+				limit: 10,
+				filter: (n) => n % 2 === 0,
+				orderBy: (a, b) => a - b,
+				limitPrecision: "exact"
+			}))).toEqual([
+				2,
+				4,
+				6
+			]);
+		});
+		it("should respect limit with filtering", async () => {
+			const list = new ArrayPaginatedList([
+				1,
+				2,
+				3,
+				4,
+				5,
+				6,
+				7,
+				8,
+				9,
+				10
+			]);
+			expect(items(await list.next({
+				after: list.getFirstCursor(),
+				limit: 2,
+				filter: (n) => n % 2 === 0,
+				orderBy: (a, b) => a - b,
+				limitPrecision: "exact"
+			}))).toEqual([2, 4]);
+		});
+		it("should handle filter that matches nothing", async () => {
+			const list = new ArrayPaginatedList([
+				1,
+				2,
+				3
+			]);
+			expect(items(await list.next({
+				after: list.getFirstCursor(),
+				limit: 10,
+				filter: () => false,
+				orderBy: (a, b) => a - b,
+				limitPrecision: "exact"
+			}))).toEqual([]);
+		});
+	});
+	describe("ordering", () => {
+		it("should sort items in ascending order", async () => {
+			const list = new ArrayPaginatedList([
+				5,
+				2,
+				8,
+				1,
+				9
+			]);
+			expect(items(await list.next({
+				after: list.getFirstCursor(),
+				limit: 10,
+				filter: () => true,
+				orderBy: (a, b) => a - b,
+				limitPrecision: "exact"
+			}))).toEqual([
+				1,
+				2,
+				5,
+				8,
+				9
+			]);
+		});
+		it("should sort items in descending order", async () => {
+			const list = new ArrayPaginatedList([
+				5,
+				2,
+				8,
+				1,
+				9
+			]);
+			expect(items(await list.next({
+				after: list.getFirstCursor(),
+				limit: 10,
+				filter: () => true,
+				orderBy: (a, b) => b - a,
+				limitPrecision: "exact"
+			}))).toEqual([
+				9,
+				8,
+				5,
+				2,
+				1
+			]);
+		});
+		it("should sort objects by property", async () => {
+			const list = new ArrayPaginatedList([
+				{
+					name: "Charlie",
+					age: 30
+				},
+				{
+					name: "Alice",
+					age: 25
+				},
+				{
+					name: "Bob",
+					age: 35
+				}
+			]);
+			expect(items(await list.next({
+				after: list.getFirstCursor(),
+				limit: 10,
+				filter: () => true,
+				orderBy: (a, b) => stringCompare(a.name, b.name),
+				limitPrecision: "exact"
+			})).map((p) => p.name)).toEqual([
+				"Alice",
+				"Bob",
+				"Charlie"
+			]);
+			expect(items(await list.next({
+				after: list.getFirstCursor(),
+				limit: 10,
+				filter: () => true,
+				orderBy: (a, b) => a.age - b.age,
+				limitPrecision: "exact"
+			})).map((p) => p.name)).toEqual([
+				"Alice",
+				"Charlie",
+				"Bob"
+			]);
+		});
+	});
+	describe("limitPrecision", () => {
+		it("exact should return exactly the limit", async () => {
+			const list = new ArrayPaginatedList([
+				1,
+				2,
+				3,
+				4,
+				5
+			]);
+			expect((await list.next({
+				after: list.getFirstCursor(),
+				limit: 3,
+				filter: () => true,
+				orderBy: (a, b) => a - b,
+				limitPrecision: "exact"
+			})).items.length).toBe(3);
+		});
+		it("at-least should return at least the limit (or all if less available)", async () => {
+			const list = new ArrayPaginatedList([
+				1,
+				2,
+				3,
+				4,
+				5
+			]);
+			expect((await list.next({
+				after: list.getFirstCursor(),
+				limit: 3,
+				filter: () => true,
+				orderBy: (a, b) => a - b,
+				limitPrecision: "at-least"
+			})).items.length).toBeGreaterThanOrEqual(3);
+		});
+		it("at-most should return at most the limit", async () => {
+			const list = new ArrayPaginatedList([
+				1,
+				2,
+				3,
+				4,
+				5
+			]);
+			expect((await list.next({
+				after: list.getFirstCursor(),
+				limit: 3,
+				filter: () => true,
+				orderBy: (a, b) => a - b,
+				limitPrecision: "at-most"
+			})).items.length).toBeLessThanOrEqual(3);
+		});
+		it("approximate should allow flexibility in either direction", async () => {
+			const list = new ArrayPaginatedList([
+				1,
+				2,
+				3,
+				4,
+				5
+			]);
+			const result = await list.next({
+				after: list.getFirstCursor(),
+				limit: 3,
+				filter: () => true,
+				orderBy: (a, b) => a - b,
+				limitPrecision: "approximate"
+			});
+			expect(result.items.length).toBeGreaterThan(0);
+			expect(items(result).every((n) => typeof n === "number")).toBe(true);
+		});
+		it("approximate should still make progress when limit > 0", async () => {
+			const list = new ArrayPaginatedList([
+				1,
+				2,
+				3,
+				4,
+				5,
+				6,
+				7,
+				8,
+				9,
+				10
+			]);
+			const allItems = [];
+			let cursor = list.getFirstCursor();
+			let iterations = 0;
+			const maxIterations = 20;
+			while (iterations < maxIterations) {
+				const result = await list.next({
+					after: cursor,
+					limit: 2,
+					filter: () => true,
+					orderBy: (a, b) => a - b,
+					limitPrecision: "approximate"
+				});
+				if (result.items.length === 0) break;
+				allItems.push(...items(result));
+				expect(result.cursor).not.toBe(cursor);
+				cursor = result.cursor;
+				iterations++;
+				if (result.isLast) break;
+			}
+			expect(allItems.length).toBeGreaterThan(0);
+		});
+	});
+	describe("getFirstCursor and getLastCursor", () => {
+		it("should return correct cursor format", () => {
+			const list = new ArrayPaginatedList([
+				1,
+				2,
+				3
+			]);
+			expect(list.getFirstCursor()).toBe("before-0");
+			expect(list.getLastCursor()).toBe("before-3");
+		});
+		it("should work for empty array", () => {
+			const list = new ArrayPaginatedList([]);
+			expect(list.getFirstCursor()).toBe("before-0");
+			expect(list.getLastCursor()).toBe("before-0");
+		});
+	});
+	describe("compare", () => {
+		it("should compare items using the orderBy function", () => {
+			const list = new ArrayPaginatedList([
+				1,
+				2,
+				3
+			]);
+			const orderBy = (a, b) => a - b;
+			expect(list.compare(orderBy, 1, 2)).toBeLessThan(0);
+			expect(list.compare(orderBy, 2, 1)).toBeGreaterThan(0);
+			expect(list.compare(orderBy, 1, 1)).toBe(0);
+		});
+	});
+});
+describe("PaginatedList.empty", () => {
+	it("should return empty results", async () => {
+		const list = PaginatedList.empty();
+		const result = await list.next({
+			after: list.getFirstCursor(),
+			limit: 10,
+			filter: {},
+			orderBy: {},
+			limitPrecision: "exact"
+		});
+		expect(result.items).toEqual([]);
+		expect(result.isFirst).toBe(true);
+		expect(result.isLast).toBe(true);
+	});
+	it("should have first cursor", () => {
+		const list = PaginatedList.empty();
+		expect(list.getFirstCursor()).toBe("first");
+		expect(list.getLastCursor()).toBe("last");
+	});
+});
+describe("PaginatedList.map", () => {
+	it("should transform items", async () => {
+		const doubled = new ArrayPaginatedList([
+			1,
+			2,
+			3
+		]).map({
+			itemMapper: (n) => n * 2,
+			oldItemFromNewItem: (n) => n / 2,
+			oldFilterFromNewFilter: (f) => f,
+			oldOrderByFromNewOrderBy: (o) => o
+		});
+		expect(items(await doubled.next({
+			after: doubled.getFirstCursor(),
+			limit: 10,
+			filter: () => true,
+			orderBy: (a, b) => a - b,
+			limitPrecision: "exact"
+		}))).toEqual([
+			2,
+			4,
+			6
+		]);
+	});
+	it("should preserve cursor semantics", async () => {
+		const doubled = new ArrayPaginatedList([
+			1,
+			2,
+			3
+		]).map({
+			itemMapper: (n) => n * 2,
+			oldItemFromNewItem: (n) => n / 2,
+			oldFilterFromNewFilter: (f) => f,
+			oldOrderByFromNewOrderBy: (o) => o
+		});
+		const first = await doubled.next({
+			after: doubled.getFirstCursor(),
+			limit: 1,
+			filter: () => true,
+			orderBy: (a, b) => a - b,
+			limitPrecision: "exact"
+		});
+		expect(items(first)).toEqual([2]);
+		expect(items(await doubled.next({
+			after: first.cursor,
+			limit: 1,
+			filter: () => true,
+			orderBy: (a, b) => a - b,
+			limitPrecision: "exact"
+		}))).toEqual([4]);
+	});
+});
+describe("PaginatedList.filter", () => {
+	it("should filter items", async () => {
+		const evens = new ArrayPaginatedList([
+			1,
+			2,
+			3,
+			4,
+			5,
+			6
+		]).filter({
+			filter: (n) => n % 2 === 0,
+			oldFilterFromNewFilter: () => () => true,
+			estimateItemsToFetch: ({ limit }) => limit * 2
+		});
+		expect(items(await evens.next({
+			after: evens.getFirstCursor(),
+			limit: 10,
+			filter: void 0,
+			orderBy: (a, b) => a - b,
+			limitPrecision: "exact"
+		}))).toEqual([
+			2,
+			4,
+			6
+		]);
+	});
+});
+describe("PaginatedList.addFilter", () => {
+	it("should add additional filter constraint", async () => {
+		const evenAndGreaterThan5 = new ArrayPaginatedList([
+			1,
+			2,
+			3,
+			4,
+			5,
+			6,
+			7,
+			8,
+			9,
+			10
+		]).filter({
+			filter: (n) => n % 2 === 0,
+			oldFilterFromNewFilter: () => () => true,
+			estimateItemsToFetch: ({ limit }) => limit * 2
+		}).addFilter({
+			filter: (n) => n > 5,
+			estimateItemsToFetch: ({ limit }) => limit * 2
+		});
+		expect(items(await evenAndGreaterThan5.next({
+			after: evenAndGreaterThan5.getFirstCursor(),
+			limit: 10,
+			filter: void 0,
+			orderBy: (a, b) => a - b,
+			limitPrecision: "exact"
+		}))).toEqual([
+			6,
+			8,
+			10
+		]);
+	});
+});
+describe("PaginatedList.flatMap", () => {
+	it("should expand items", async () => {
+		const expanded = new ArrayPaginatedList([
+			1,
+			2,
+			3
+		]).flatMap({
+			itemMapper: (entry) => [{
+				item: entry.item,
+				prevCursor: entry.prevCursor,
+				nextCursor: entry.nextCursor
+			}, {
+				item: entry.item + .5,
+				prevCursor: entry.prevCursor,
+				nextCursor: entry.nextCursor
+			}],
+			compare: (_, a, b) => a - b,
+			newCursorFromOldCursor: (c) => c,
+			oldCursorFromNewCursor: (c) => c,
+			oldFilterFromNewFilter: (f) => f,
+			oldOrderByFromNewOrderBy: (o) => o,
+			estimateItemsToFetch: ({ limit }) => limit
+		});
+		expect(items(await expanded.next({
+			after: expanded.getFirstCursor(),
+			limit: 10,
+			filter: () => true,
+			orderBy: (a, b) => a - b,
+			limitPrecision: "exact"
+		}))).toEqual([
+			1,
+			1.5,
+			2,
+			2.5,
+			3,
+			3.5
+		]);
+	});
+	it("should filter out items (return empty array)", async () => {
+		const evensOnly = new ArrayPaginatedList([
+			1,
+			2,
+			3,
+			4,
+			5
+		]).flatMap({
+			itemMapper: (entry) => entry.item % 2 === 0 ? [{
+				item: entry.item,
+				prevCursor: entry.prevCursor,
+				nextCursor: entry.nextCursor
+			}] : [],
+			compare: (_, a, b) => a - b,
+			newCursorFromOldCursor: (c) => c,
+			oldCursorFromNewCursor: (c) => c,
+			oldFilterFromNewFilter: (f) => f,
+			oldOrderByFromNewOrderBy: (o) => o,
+			estimateItemsToFetch: ({ limit }) => limit * 2
+		});
+		expect(items(await evensOnly.next({
+			after: evensOnly.getFirstCursor(),
+			limit: 10,
+			filter: () => true,
+			orderBy: (a, b) => a - b,
+			limitPrecision: "exact"
+		}))).toEqual([2, 4]);
+	});
+});
+describe("PaginatedList.merge", () => {
+	it("should merge two lists", async () => {
+		const list1 = new ArrayPaginatedList([
+			1,
+			3,
+			5
+		]);
+		const list2 = new ArrayPaginatedList([
+			2,
+			4,
+			6
+		]);
+		const merged = PaginatedList.merge(list1, list2);
+		expect(items(await merged.next({
+			after: merged.getFirstCursor(),
+			limit: 10,
+			filter: () => true,
+			orderBy: (a, b) => a - b,
+			limitPrecision: "exact"
+		}))).toEqual([
+			1,
+			2,
+			3,
+			4,
+			5,
+			6
+		]);
+	});
+	it("should merge three lists", async () => {
+		const list1 = new ArrayPaginatedList([
+			1,
+			4,
+			7
+		]);
+		const list2 = new ArrayPaginatedList([
+			2,
+			5,
+			8
+		]);
+		const list3 = new ArrayPaginatedList([
+			3,
+			6,
+			9
+		]);
+		const merged = PaginatedList.merge(list1, list2, list3);
+		expect(items(await merged.next({
+			after: merged.getFirstCursor(),
+			limit: 10,
+			filter: () => true,
+			orderBy: (a, b) => a - b,
+			limitPrecision: "exact"
+		}))).toEqual([
+			1,
+			2,
+			3,
+			4,
+			5,
+			6,
+			7,
+			8,
+			9
+		]);
+	});
+	it("should handle empty lists in merge", async () => {
+		const list1 = new ArrayPaginatedList([
+			1,
+			2,
+			3
+		]);
+		const list2 = new ArrayPaginatedList([]);
+		const merged = PaginatedList.merge(list1, list2);
+		expect(items(await merged.next({
+			after: merged.getFirstCursor(),
+			limit: 10,
+			filter: () => true,
+			orderBy: (a, b) => a - b,
+			limitPrecision: "exact"
+		}))).toEqual([
+			1,
+			2,
+			3
+		]);
+	});
+	it("should paginate through merged list", async () => {
+		const list1 = new ArrayPaginatedList([
+			1,
+			3,
+			5,
+			7,
+			9
+		]);
+		const list2 = new ArrayPaginatedList([
+			2,
+			4,
+			6,
+			8,
+			10
+		]);
+		const merged = PaginatedList.merge(list1, list2);
+		const first = await merged.next({
+			after: merged.getFirstCursor(),
+			limit: 4,
+			filter: () => true,
+			orderBy: (a, b) => a - b,
+			limitPrecision: "exact"
+		});
+		expect(items(first)).toEqual([
+			1,
+			2,
+			3,
+			4
+		]);
+		expect(items(await merged.next({
+			after: first.cursor,
+			limit: 4,
+			filter: () => true,
+			orderBy: (a, b) => a - b,
+			limitPrecision: "exact"
+		}))).toEqual([
+			5,
+			6,
+			7,
+			8
+		]);
+	});
+	it("should have JSON-encoded cursor", () => {
+		const list1 = new ArrayPaginatedList([1, 2]);
+		const list2 = new ArrayPaginatedList([3, 4]);
+		const cursor = PaginatedList.merge(list1, list2).getFirstCursor();
+		expect(() => JSON.parse(cursor)).not.toThrow();
+		expect(JSON.parse(cursor)).toEqual(["before-0", "before-0"]);
+	});
+	it("should paginate backward through merged list correctly", async () => {
+		const list1 = new ArrayPaginatedList([
+			1,
+			3,
+			5
+		]);
+		const list2 = new ArrayPaginatedList([
+			2,
+			4,
+			6
+		]);
+		const merged = PaginatedList.merge(list1, list2);
+		const last = await merged.prev({
+			before: merged.getLastCursor(),
+			limit: 3,
+			filter: () => true,
+			orderBy: (a, b) => a - b,
+			limitPrecision: "exact"
+		});
+		expect(items(last)).toEqual([
+			4,
+			5,
+			6
+		]);
+		expect(last.isLast).toBe(true);
+		expect(last.isFirst).toBe(false);
+		const middle = await merged.prev({
+			before: last.cursor,
+			limit: 3,
+			filter: () => true,
+			orderBy: (a, b) => a - b,
+			limitPrecision: "exact"
+		});
+		expect(items(middle)).toEqual([
+			1,
+			2,
+			3
+		]);
+		expect(middle.isFirst).toBe(true);
+	});
+	it("should paginate backward through entire merged list", async () => {
+		const list1 = new ArrayPaginatedList([
+			1,
+			3,
+			5,
+			7,
+			9
+		]);
+		const list2 = new ArrayPaginatedList([
+			2,
+			4,
+			6,
+			8,
+			10
+		]);
+		const merged = PaginatedList.merge(list1, list2);
+		const allItems = [];
+		let cursor = merged.getLastCursor();
+		let isFirst = false;
+		while (!isFirst) {
+			const result = await merged.prev({
+				before: cursor,
+				limit: 3,
+				filter: () => true,
+				orderBy: (a, b) => a - b,
+				limitPrecision: "exact"
+			});
+			allItems.unshift(...items(result));
+			cursor = result.cursor;
+			isFirst = result.isFirst;
+		}
+		expect(allItems).toEqual([
+			1,
+			2,
+			3,
+			4,
+			5,
+			6,
+			7,
+			8,
+			9,
+			10
+		]);
+	});
+	it("should have consistent forward and backward pagination results", async () => {
+		const list1 = new ArrayPaginatedList([
+			1,
+			4,
+			7
+		]);
+		const list2 = new ArrayPaginatedList([
+			2,
+			5,
+			8
+		]);
+		const list3 = new ArrayPaginatedList([
+			3,
+			6,
+			9
+		]);
+		const merged = PaginatedList.merge(list1, list2, list3);
+		const forwardItems = [];
+		let forwardCursor = merged.getFirstCursor();
+		let isLast = false;
+		while (!isLast) {
+			const result = await merged.next({
+				after: forwardCursor,
+				limit: 2,
+				filter: () => true,
+				orderBy: (a, b) => a - b,
+				limitPrecision: "exact"
+			});
+			forwardItems.push(...items(result));
+			forwardCursor = result.cursor;
+			isLast = result.isLast;
+		}
+		const backwardItems = [];
+		let backwardCursor = merged.getLastCursor();
+		let isFirst = false;
+		while (!isFirst) {
+			const result = await merged.prev({
+				before: backwardCursor,
+				limit: 2,
+				filter: () => true,
+				orderBy: (a, b) => a - b,
+				limitPrecision: "exact"
+			});
+			backwardItems.unshift(...items(result));
+			backwardCursor = result.cursor;
+			isFirst = result.isFirst;
+		}
+		expect(forwardItems).toEqual([
+			1,
+			2,
+			3,
+			4,
+			5,
+			6,
+			7,
+			8,
+			9
+		]);
+		expect(backwardItems).toEqual([
+			1,
+			2,
+			3,
+			4,
+			5,
+			6,
+			7,
+			8,
+			9
+		]);
+	});
+});
+describe("edge cases", () => {
+	it("should handle single item", async () => {
+		const list = new ArrayPaginatedList([42]);
+		const result = await list.next({
+			after: list.getFirstCursor(),
+			limit: 10,
+			filter: () => true,
+			orderBy: (a, b) => a - b,
+			limitPrecision: "exact"
+		});
+		expect(items(result)).toEqual([42]);
+		expect(result.isFirst).toBe(true);
+		expect(result.isLast).toBe(true);
+	});
+	it("should handle duplicate values", async () => {
+		const list = new ArrayPaginatedList([
+			1,
+			1,
+			2,
+			2,
+			3,
+			3
+		]);
+		expect(items(await list.next({
+			after: list.getFirstCursor(),
+			limit: 10,
+			filter: () => true,
+			orderBy: (a, b) => a - b,
+			limitPrecision: "exact"
+		}))).toEqual([
+			1,
+			1,
+			2,
+			2,
+			3,
+			3
+		]);
+	});
+	it("should handle negative numbers", async () => {
+		const list = new ArrayPaginatedList([
+			-3,
+			-1,
+			0,
+			1,
+			3
+		]);
+		expect(items(await list.next({
+			after: list.getFirstCursor(),
+			limit: 10,
+			filter: () => true,
+			orderBy: (a, b) => a - b,
+			limitPrecision: "exact"
+		}))).toEqual([
+			-3,
+			-1,
+			0,
+			1,
+			3
+		]);
+	});
+	it("should handle string items", async () => {
+		const list = new ArrayPaginatedList([
+			"banana",
+			"apple",
+			"cherry"
+		]);
+		expect(items(await list.next({
+			after: list.getFirstCursor(),
+			limit: 10,
+			filter: () => true,
+			orderBy: (a, b) => stringCompare(a, b),
+			limitPrecision: "exact"
+		}))).toEqual([
+			"apple",
+			"banana",
+			"cherry"
+		]);
+	});
+	it("should handle object items", async () => {
+		const list = new ArrayPaginatedList([{
+			id: 1,
+			value: "a"
+		}, {
+			id: 2,
+			value: "b"
+		}]);
+		expect(items(await list.next({
+			after: list.getFirstCursor(),
+			limit: 10,
+			filter: () => true,
+			orderBy: (a, b) => a.id - b.id,
+			limitPrecision: "exact"
+		}))).toEqual([{
+			id: 1,
+			value: "a"
+		}, {
+			id: 2,
+			value: "b"
+		}]);
+	});
+});
+describe("complete pagination walkthrough", () => {
+	it("should paginate forward through entire list", async () => {
+		const list = new ArrayPaginatedList([
+			1,
+			2,
+			3,
+			4,
+			5,
+			6,
+			7,
+			8,
+			9,
+			10
+		]);
+		const allItems = [];
+		let cursor = list.getFirstCursor();
+		let isLast = false;
+		while (!isLast) {
+			const result = await list.next({
+				after: cursor,
+				limit: 3,
+				filter: () => true,
+				orderBy: (a, b) => a - b,
+				limitPrecision: "exact"
+			});
+			allItems.push(...items(result));
+			cursor = result.cursor;
+			isLast = result.isLast;
+		}
+		expect(allItems).toEqual([
+			1,
+			2,
+			3,
+			4,
+			5,
+			6,
+			7,
+			8,
+			9,
+			10
+		]);
+	});
+	it("should paginate backward through entire list", async () => {
+		const list = new ArrayPaginatedList([
+			1,
+			2,
+			3,
+			4,
+			5,
+			6,
+			7,
+			8,
+			9,
+			10
+		]);
+		const allItems = [];
+		let cursor = list.getLastCursor();
+		let isFirst = false;
+		while (!isFirst) {
+			const result = await list.prev({
+				before: cursor,
+				limit: 3,
+				filter: () => true,
+				orderBy: (a, b) => a - b,
+				limitPrecision: "exact"
+			});
+			allItems.unshift(...items(result));
+			cursor = result.cursor;
+			isFirst = result.isFirst;
+		}
+		expect(allItems).toEqual([
+			1,
+			2,
+			3,
+			4,
+			5,
+			6,
+			7,
+			8,
+			9,
+			10
+		]);
+	});
+});
+describe("unsorted array pagination", () => {
+	it("should correctly paginate through an unsorted array with sorting", async () => {
+		const list = new ArrayPaginatedList([
+			3,
+			1,
+			2
+		]);
+		const first = await list.next({
+			after: list.getFirstCursor(),
+			limit: 2,
+			filter: () => true,
+			orderBy: (a, b) => a - b,
+			limitPrecision: "exact"
+		});
+		expect(items(first)).toEqual([1, 2]);
+		expect(items(await list.next({
+			after: first.cursor,
+			limit: 2,
+			filter: () => true,
+			orderBy: (a, b) => a - b,
+			limitPrecision: "exact"
+		}))).toEqual([3]);
+	});
+	it("should maintain sorted order across pagination boundaries", async () => {
+		const list = new ArrayPaginatedList([
+			5,
+			4,
+			3,
+			2,
+			1
+		]);
+		const allItems = [];
+		let cursor = list.getFirstCursor();
+		let isLast = false;
+		while (!isLast) {
+			const result = await list.next({
+				after: cursor,
+				limit: 2,
+				filter: () => true,
+				orderBy: (a, b) => a - b,
+				limitPrecision: "exact"
+			});
+			allItems.push(...items(result));
+			cursor = result.cursor;
+			isLast = result.isLast;
+		}
+		expect(allItems).toEqual([
+			1,
+			2,
+			3,
+			4,
+			5
+		]);
+	});
+	it("should handle random order array correctly", async () => {
+		const list = new ArrayPaginatedList([
+			7,
+			2,
+			9,
+			1,
+			5,
+			8,
+			3,
+			6,
+			4
+		]);
+		const allItems = [];
+		let cursor = list.getFirstCursor();
+		let isLast = false;
+		while (!isLast) {
+			const result = await list.next({
+				after: cursor,
+				limit: 3,
+				filter: () => true,
+				orderBy: (a, b) => a - b,
+				limitPrecision: "exact"
+			});
+			allItems.push(...items(result));
+			cursor = result.cursor;
+			isLast = result.isLast;
+		}
+		expect(allItems).toEqual([
+			1,
+			2,
+			3,
+			4,
+			5,
+			6,
+			7,
+			8,
+			9
+		]);
+	});
+	it("should have consistent cursor semantics with sorted data", async () => {
+		const list = new ArrayPaginatedList([
+			3,
+			1,
+			2
+		]);
+		const first = await list.next({
+			after: list.getFirstCursor(),
+			limit: 1,
+			filter: () => true,
+			orderBy: (a, b) => a - b,
+			limitPrecision: "exact"
+		});
+		expect(items(first)).toEqual([1]);
+		expect(items(await list.next({
+			after: first.cursor,
+			limit: 1,
+			filter: () => true,
+			orderBy: (a, b) => a - b,
+			limitPrecision: "exact"
+		}))).toEqual([2]);
+	});
+});
+
+//#endregion
+export {  };
+//# sourceMappingURL=paginated-lists.test.js.map