mtrl-addons 0.1.0 → 0.1.2

package/test/core/list-manager/utils/calculations.test.ts

@@ -0,0 +1,433 @@
+// test/core/list-manager/utils/calculations.test.ts
+
+import { describe, it, expect } from "bun:test";
+import {
+  calculateTotalVirtualSize,
+  calculateContainerPosition,
+  calculateScrollPositionForIndex,
+  calculateScrollPositionForPage,
+  calculateScrollbarMetrics,
+  calculateInitialRangeSize,
+  calculateMissingRanges,
+  calculateBufferRanges,
+  clamp,
+  applyBoundaryResistance,
+} from "../../../../src/core/list-manager/utils/calculations";
+import type { ItemRange } from "../../../../src/core/list-manager/types";
+
+describe("Calculations Utility", () => {
+  describe("clamp", () => {
+    it("should clamp value within range", () => {
+      expect(clamp(5, 0, 10)).toBe(5);
+      expect(clamp(-5, 0, 10)).toBe(0);
+      expect(clamp(15, 0, 10)).toBe(10);
+    });
+
+    it("should handle edge cases", () => {
+      expect(clamp(0, 0, 0)).toBe(0);
+      expect(clamp(5, 5, 5)).toBe(5);
+      expect(clamp(3, 5, 2)).toBe(3); // Invalid range
+    });
+  });
+
+  // Removed calculateVisibleRange tests - using unified index-based approach
+
+  describe("calculateTotalVirtualSize", () => {
+    it("should calculate total size for uniform items", () => {
+      const size = calculateTotalVirtualSize({
+        totalItems: 100,
+        estimatedItemSize: 50,
+        orientation: "vertical",
+        measuredSizes: new Map(),
+      });
+
+      expect(size).toBe(5000); // 100 * 50
+    });
+
+    it("should calculate size with some measured items", () => {
+      const measuredSizes = new Map<number, number>();
+      measuredSizes.set(0, 60);
+      measuredSizes.set(1, 70);
+      measuredSizes.set(2, 40);
+
+      const size = calculateTotalVirtualSize({
+        totalItems: 10,
+        estimatedItemSize: 50,
+        orientation: "vertical",
+        measuredSizes,
+      });
+
+      // First 3 items: 60 + 70 + 40 = 170
+      // Remaining 7 items: 7 * 50 = 350
+      // Total: 520
+      expect(size).toBe(520);
+    });
+
+    it("should handle empty list", () => {
+      const size = calculateTotalVirtualSize({
+        totalItems: 0,
+        estimatedItemSize: 50,
+        orientation: "vertical",
+        measuredSizes: new Map(),
+      });
+
+      expect(size).toBe(0);
+    });
+  });
+
+  describe("calculateContainerPosition", () => {
+    it("should calculate position for vertical orientation", () => {
+      const position = calculateContainerPosition({
+        index: 10,
+        estimatedItemSize: 50,
+        orientation: "vertical",
+        measuredSizes: new Map(),
+        totalItems: 100,
+      });
+
+      expect(position).toBe(500); // 10 * 50
+    });
+
+    it("should calculate position with measured sizes", () => {
+      const measuredSizes = new Map<number, number>();
+      measuredSizes.set(0, 60);
+      measuredSizes.set(1, 70);
+      measuredSizes.set(2, 40);
+
+      const position = calculateContainerPosition({
+        index: 3,
+        estimatedItemSize: 50,
+        orientation: "horizontal",
+        measuredSizes,
+        totalItems: 100,
+      });
+
+      expect(position).toBe(170); // 60 + 70 + 40
+    });
+
+    it("should handle index 0", () => {
+      const position = calculateContainerPosition({
+        index: 0,
+        estimatedItemSize: 50,
+        orientation: "vertical",
+        measuredSizes: new Map(),
+        totalItems: 100,
+      });
+
+      expect(position).toBe(0);
+    });
+  });
+
+  describe("calculateScrollPositionForIndex", () => {
+    it("should calculate scroll position for 'start' alignment", () => {
+      const position = calculateScrollPositionForIndex({
+        index: 10,
+        alignment: "start",
+        containerSize: 300,
+        estimatedItemSize: 50,
+        orientation: "vertical",
+        measuredSizes: new Map(),
+        totalItems: 100,
+      });
+
+      expect(position).toBe(500); // 10 * 50
+    });
+
+    it("should calculate scroll position for 'center' alignment", () => {
+      const position = calculateScrollPositionForIndex({
+        index: 10,
+        alignment: "center",
+        containerSize: 300,
+        estimatedItemSize: 50,
+        orientation: "vertical",
+        measuredSizes: new Map(),
+        totalItems: 100,
+      });
+
+      // Item at 500, center in 300px container = 500 - 150 + 25 = 375
+      expect(position).toBe(375);
+    });
+
+    it("should calculate scroll position for 'end' alignment", () => {
+      const position = calculateScrollPositionForIndex({
+        index: 10,
+        alignment: "end",
+        containerSize: 300,
+        estimatedItemSize: 50,
+        orientation: "vertical",
+        measuredSizes: new Map(),
+        totalItems: 100,
+      });
+
+      // Item at 500, end in 300px container = 500 - 300 + 50 = 250
+      expect(position).toBe(250);
+    });
+
+    it("should not scroll past beginning", () => {
+      const position = calculateScrollPositionForIndex({
+        index: 0,
+        alignment: "center",
+        containerSize: 300,
+        estimatedItemSize: 50,
+        orientation: "vertical",
+        measuredSizes: new Map(),
+        totalItems: 100,
+      });
+
+      expect(position).toBeGreaterThanOrEqual(0);
+    });
+  });
+
+  describe("calculateScrollPositionForPage", () => {
+    it("should calculate position for page", () => {
+      const position = calculateScrollPositionForPage({
+        page: 3,
+        pageSize: 10,
+        alignment: "start",
+        containerSize: 300,
+        estimatedItemSize: 50,
+        orientation: "vertical",
+        measuredSizes: new Map(),
+        totalItems: 100,
+      });
+
+      // Page 3, item 20 (0-indexed), position 1000
+      expect(position).toBe(1000);
+    });
+
+    it("should handle page 1 (first page)", () => {
+      const position = calculateScrollPositionForPage({
+        page: 1,
+        pageSize: 10,
+        alignment: "start",
+        containerSize: 300,
+        estimatedItemSize: 50,
+        orientation: "vertical",
+        measuredSizes: new Map(),
+        totalItems: 100,
+      });
+
+      expect(position).toBe(0);
+    });
+  });
+
+  describe("calculateScrollbarMetrics", () => {
+    it("should calculate scrollbar metrics", () => {
+      const metrics = calculateScrollbarMetrics({
+        containerSize: 300,
+        totalVirtualSize: 1500,
+        scrollPosition: 300,
+        orientation: "vertical",
+      });
+
+      expect(metrics.trackSize).toBe(300);
+      expect(metrics.thumbSize).toBeGreaterThan(0);
+      expect(metrics.thumbPosition).toBeGreaterThan(0);
+      expect(metrics.scrollRatio).toBe(0.2); // 300/1500
+    });
+
+    it("should handle case where content fits in container", () => {
+      const metrics = calculateScrollbarMetrics({
+        containerSize: 500,
+        totalVirtualSize: 300,
+        scrollPosition: 0,
+        orientation: "vertical",
+      });
+
+      expect(metrics.thumbSize).toBe(500); // Full size
+      expect(metrics.thumbPosition).toBe(0);
+      expect(metrics.scrollRatio).toBe(0);
+    });
+
+    it("should handle horizontal scrollbar", () => {
+      const metrics = calculateScrollbarMetrics({
+        containerSize: 400,
+        totalVirtualSize: 1200,
+        scrollPosition: 200,
+        orientation: "horizontal",
+      });
+
+      expect(metrics.trackSize).toBe(400);
+      expect(metrics.scrollRatio).toBeCloseTo(0.167, 2); // 200/1200
+    });
+  });
+
+  // Removed calculateViewportInfo tests - viewport.ts now uses virtualManager directly
+
+  describe("calculateInitialRangeSize", () => {
+    it("should calculate initial range size", () => {
+      const size = calculateInitialRangeSize({
+        containerSize: 300,
+        estimatedItemSize: 50,
+        viewportMultiplier: 2,
+        minItems: 5,
+        maxItems: 50,
+      });
+
+      // Container fits 6 items (300/50), * 2 = 12 items
+      expect(size).toBe(12);
+    });
+
+    it("should respect min items constraint", () => {
+      const size = calculateInitialRangeSize({
+        containerSize: 100,
+        estimatedItemSize: 50,
+        viewportMultiplier: 1,
+        minItems: 10,
+        maxItems: 50,
+      });
+
+      expect(size).toBe(10); // Min constraint
+    });
+
+    it("should respect max items constraint", () => {
+      const size = calculateInitialRangeSize({
+        containerSize: 1000,
+        estimatedItemSize: 10,
+        viewportMultiplier: 2,
+        minItems: 5,
+        maxItems: 50,
+      });
+
+      expect(size).toBe(50); // Max constraint
+    });
+  });
+
+  describe("calculateMissingRanges", () => {
+    it("should find missing ranges", () => {
+      const loadedRanges = new Set([0, 1, 2, 5, 6, 7]);
+      const requiredRange: ItemRange = { start: 0, end: 10 };
+
+      const missing = calculateMissingRanges(requiredRange, loadedRanges);
+
+      expect(missing).toEqual([
+        { start: 3, end: 4 },
+        { start: 8, end: 10 },
+      ]);
+    });
+
+    it("should handle no missing ranges", () => {
+      const loadedRanges = new Set([0, 1, 2, 3, 4, 5]);
+      const requiredRange: ItemRange = { start: 0, end: 5 };
+
+      const missing = calculateMissingRanges(requiredRange, loadedRanges);
+
+      expect(missing).toEqual([]);
+    });
+
+    it("should handle completely missing range", () => {
+      const loadedRanges = new Set<number>();
+      const requiredRange: ItemRange = { start: 10, end: 15 };
+
+      const missing = calculateMissingRanges(requiredRange, loadedRanges);
+
+      expect(missing).toEqual([{ start: 10, end: 15 }]);
+    });
+  });
+
+  describe("calculateBufferRanges", () => {
+    it("should calculate buffer ranges", () => {
+      const visibleRange: ItemRange = { start: 10, end: 20 };
+      const bufferSize = 5;
+      const totalItems = 100;
+
+      const bufferRanges = calculateBufferRanges(
+        visibleRange,
+        bufferSize,
+        totalItems
+      );
+
+      expect(bufferRanges.before).toEqual({ start: 5, end: 9 });
+      expect(bufferRanges.after).toEqual({ start: 21, end: 25 });
+    });
+
+    it("should handle buffer at beginning", () => {
+      const visibleRange: ItemRange = { start: 0, end: 10 };
+      const bufferSize = 5;
+      const totalItems = 100;
+
+      const bufferRanges = calculateBufferRanges(
+        visibleRange,
+        bufferSize,
+        totalItems
+      );
+
+      expect(bufferRanges.before).toEqual({ start: 0, end: -1 }); // Empty range
+      expect(bufferRanges.after).toEqual({ start: 11, end: 15 });
+    });
+
+    it("should handle buffer at end", () => {
+      const visibleRange: ItemRange = { start: 90, end: 99 };
+      const bufferSize = 5;
+      const totalItems = 100;
+
+      const bufferRanges = calculateBufferRanges(
+        visibleRange,
+        bufferSize,
+        totalItems
+      );
+
+      expect(bufferRanges.before).toEqual({ start: 85, end: 89 });
+      expect(bufferRanges.after).toEqual({ start: 100, end: 99 }); // Empty range
+    });
+  });
+
+  describe("applyBoundaryResistance", () => {
+    it("should apply resistance at beginning", () => {
+      const result = applyBoundaryResistance({
+        requestedPosition: -100,
+        currentPosition: 0,
+        maxPosition: 1000,
+        resistance: 0.5,
+      });
+
+      expect(result).toBeGreaterThan(-100);
+      expect(result).toBeLessThan(0);
+    });
+
+    it("should apply resistance at end", () => {
+      const result = applyBoundaryResistance({
+        requestedPosition: 1100,
+        currentPosition: 1000,
+        maxPosition: 1000,
+        resistance: 0.5,
+      });
+
+      expect(result).toBeLessThan(1100);
+      expect(result).toBeGreaterThan(1000);
+    });
+
+    it("should not apply resistance within bounds", () => {
+      const result = applyBoundaryResistance({
+        requestedPosition: 500,
+        currentPosition: 400,
+        maxPosition: 1000,
+        resistance: 0.5,
+      });
+
+      expect(result).toBe(500);
+    });
+
+    it("should handle zero resistance", () => {
+      const result = applyBoundaryResistance({
+        requestedPosition: -100,
+        currentPosition: 0,
+        maxPosition: 1000,
+        resistance: 0,
+      });
+
+      expect(result).toBe(0); // Clamped to boundary
+    });
+
+    it("should handle full resistance", () => {
+      const result = applyBoundaryResistance({
+        requestedPosition: -100,
+        currentPosition: 0,
+        maxPosition: 1000,
+        resistance: 1,
+      });
+
+      expect(result).toBe(0); // No movement beyond boundary
+    });
+  });
+});