..

frontend/sync-client/src/utils/data-structures/min-covered.test.ts

@@ -1,76 +0,0 @@
-import { describe, it } from "node:test";
-import assert from "node:assert";
-import { CoveredValues } from "./min-covered";
-
-describe("CoveredValues", () => {
-    it("should initialize with the given min value", () => {
-        const covered = new CoveredValues(5);
-        assert.strictEqual(covered.min, 5);
-    });
-
-    it("should add values greater than min", () => {
-        const covered = new CoveredValues(0);
-        covered.add(3);
-        assert.strictEqual(covered.min, 0);
-        covered.add(1);
-        assert.strictEqual(covered.min, 1);
-        covered.add(4);
-        assert.strictEqual(covered.min, 1);
-        covered.add(2);
-        assert.strictEqual(covered.min, 4);
-    });
-
-    it("should ignore duplicate values", () => {
-        const covered = new CoveredValues(0);
-        covered.add(3);
-        covered.add(3);
-        covered.add(3);
-        assert.strictEqual(covered.min, 0);
-        covered.add(1);
-        covered.add(2);
-        assert.strictEqual(covered.min, 3);
-    });
-
-    it("should handle multiple consecutive values", () => {
-        const covered = new CoveredValues(132);
-        for (let i = 250; i > 132; i--) {
-            assert.strictEqual(covered.min, 132);
-            covered.add(i);
-        }
-        assert.strictEqual(covered.min, 250);
-    });
-
-    it("should handle adding values lower than current min", () => {
-        const covered = new CoveredValues(5);
-        covered.add(3);
-        assert.strictEqual(covered.min, 5);
-        covered.add(6);
-        assert.strictEqual(covered.min, 6);
-    });
-
-    it("should auto-advance when setting min value", () => {
-        const covered = new CoveredValues(5);
-        covered.add(7);
-        covered.add(8);
-        covered.add(9);
-        assert.strictEqual(covered.min, 5);
-        // Setting min to 6 should auto-advance through 7, 8, 9
-        covered.min = 6;
-        assert.strictEqual(covered.min, 9);
-        covered.add(10);
-        assert.strictEqual(covered.min, 10);
-    });
-
-    it("should handle setting min value with no consecutive values", () => {
-        const covered = new CoveredValues(5);
-        covered.add(10);
-        covered.add(15);
-        assert.strictEqual(covered.min, 5);
-        // Setting min to 8 should not auto-advance (no consecutive values)
-        covered.min = 8;
-        assert.strictEqual(covered.min, 8);
-        // Add 9 to trigger auto-advance to 10
-        covered.add(9);
-        assert.strictEqual(covered.min, 10);
-    });
-});

frontend/sync-client/src/utils/data-structures/min-covered.ts

@@ -1,61 +0,0 @@
-/**
- * A class that tracks the minimum covered value in a sequence of numbers.
- * It keeps track of a minimum value based on the seen values.
- *
- * It expects integers slightly out of order and makes sure that the value of `min` is
- * always the minimum of the seen values. This is done with bounded memory usage.
- *
- * @example
- * ```typescript
- * const covered = new CoveredValues(0);
- * covered.add(2); // seenValues = [2], min = 0
- * covered.add(1); // seenValues = [], min = 2
- * covered.min; // returns 2
- * ```
- */
-export class CoveredValues {
-    private seenValues: number[] = [];
-
-    public constructor(private minValue: number) {}
-
-    public get min(): number {
-        return this.minValue;
-    }
-
-    public set min(value: number) {
-        this.minValue = Math.max(value, this.minValue);
-        this.seenValues = this.seenValues.filter((v) => v > this.minValue);
-        this.advanceMinWhilePossible();
-    }
-
-    public add(value: number | undefined): void {
-        if (value === undefined || value < this.minValue) {
-            return;
-        }
-
-        let i = 0;
-        while (i < this.seenValues.length && this.seenValues[i] < value) {
-            i++;
-        }
-
-        if (i === this.seenValues.length) {
-            this.seenValues.push(value);
-        } else if (this.seenValues[i] === value) {
-            return;
-        } else {
-            this.seenValues.splice(i, 0, value);
-        }
-
-        this.advanceMinWhilePossible();
-    }
-
-    private advanceMinWhilePossible(): void {
-        while (
-            this.seenValues.length > 0 &&
-            this.seenValues[0] === this.minValue + 1
-        ) {
-            this.seenValues.shift();
-            this.minValue++;
-        }
-    }
-}