@peers-app/peers-sdk 0.27.2 → 0.27.4

package/dist/utils.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/utils.test.js

@@ -1,232 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const lodash_1 = require("lodash");
-const utils_1 = require("./utils");
-describe("retryOnErrorOrTimeout", () => {
-    it("reports a terminal error after one call and clears its timeout", async () => {
-        jest.useFakeTimers();
-        const error = new Error("No handler registered for event: listChanges_group");
-        const fn = jest.fn().mockRejectedValue(error);
-        try {
-            await expect((0, utils_1.retryOnErrorOrTimeout)({
-                fn,
-                connection: { deviceId: (0, utils_1.newid)(), latencyMs: 1, errorRate: 0, timestampLastApplied: 0 },
-                opts: { shouldRetry: () => false },
-            })).rejects.toBe(error);
-            expect(fn).toHaveBeenCalledTimes(1);
-            expect(jest.getTimerCount()).toBe(0);
-        }
-        finally {
-            jest.useRealTimers();
-        }
-    });
-});
-describe("readResponseTextCapped", () => {
-    it("returns a body within the cap and refuses one over it", async () => {
-        await expect((0, utils_1.readResponseTextCapped)(new Response("hello"), 5)).resolves.toBe("hello");
-        await expect((0, utils_1.readResponseTextCapped)(new Response("hello!"), 5)).resolves.toBeUndefined();
-    });
-    it("stops reading a streamed body as soon as the cap is passed", async () => {
-        let pulled = 0;
-        let cancelled = false;
-        const stream = new ReadableStream({
-            pull(controller) {
-                pulled++;
-                controller.enqueue(new Uint8Array(1024));
-            },
-            cancel() {
-                cancelled = true;
-            },
-        });
-        await expect((0, utils_1.readResponseTextCapped)(new Response(stream), 4096)).resolves.toBeUndefined();
-        expect(cancelled).toBe(true);
-        // Five chunks pass the cap; an unbounded reader would never stop.
-        expect(pulled).toBeLessThanOrEqual(8);
-    });
-});
-describe("getTimestamp", () => {
-    afterEach(() => {
-        jest.restoreAllMocks();
-    });
-    it("tracks the wall clock while the high-resolution clock is frozen (suspended tab)", () => {
-        // performance.now() stops advancing on iOS while the page is suspended; Date.now() does not.
-        const wallStart = 1_790_000_000_000;
-        let wall = wallStart;
-        const frozenHighRes = 12_345.678;
-        jest.spyOn(Date, "now").mockImplementation(() => wall);
-        jest.spyOn(performance, "now").mockImplementation(() => frozenHighRes);
-        const before = (0, utils_1.getTimestamp)();
-        expect(Math.abs(before - wallStart)).toBeLessThanOrEqual(utils_1.TIMESTAMP_REANCHOR_THRESHOLD_MS);
-        wall += 15 * 60 * 1000; // device slept for 15 minutes
-        const after = (0, utils_1.getTimestamp)();
-        expect(Math.abs(after - wall)).toBeLessThanOrEqual(utils_1.TIMESTAMP_REANCHOR_THRESHOLD_MS);
-        expect(after - before).toBeGreaterThan(14 * 60 * 1000);
-    });
-    it("keeps sub-millisecond resolution between re-anchors", () => {
-        const wall = 1_790_000_000_000;
-        let highRes = 1_000;
-        jest.spyOn(Date, "now").mockImplementation(() => wall + Math.floor(highRes - 1_000));
-        jest.spyOn(performance, "now").mockImplementation(() => highRes);
-        const first = (0, utils_1.getTimestamp)();
-        highRes += 0.25;
-        const second = (0, utils_1.getTimestamp)();
-        expect(second - first).toBeCloseTo(0.25, 5);
-    });
-});
-describe("newid", () => {
-    it("should return a valid id", async () => {
-        const id = (0, utils_1.newid)();
-        expect((0, utils_1.isid)(id)).toBe(true);
-        const time = (0, utils_1.idTime)(id);
-        expect(time).toBeGreaterThan(Date.now() - 1000);
-        expect(time).toBeLessThan(Date.now() + 1000);
-    });
-    // NOTE: Make sure to run this if you change the random number generation
-    describe.skip("it should return ids with the random portion evenly distributed", () => {
-        it("random portion should have evenly distributed character values", async () => {
-            const buckets = {};
-            for (let i = 0; i < 1000000; i++) {
-                const randomPart = (0, utils_1.newid)().substring(10);
-                expect(randomPart.length).toBe(15);
-                for (const c of randomPart) {
-                    buckets[c] = (buckets[c] || 0) + 1;
-                }
-            }
-            console.log(buckets);
-            const counts = Object.values(buckets);
-            let average = 0;
-            let max = 0;
-            let min = Number.MAX_SAFE_INTEGER;
-            for (const c of counts) {
-                average += c;
-                max = Math.max(max, c);
-                min = Math.min(min, c);
-            }
-            average /= counts.length;
-            const maxDeviation = Math.max(max - average, average - min);
-            const maxDeviationPercent = (maxDeviation / average) * 100;
-            console.log({ average, max, min, maxDeviation, maxDeviationPercent });
-            // expect all values to be within 0.5% of the average
-            expect(maxDeviationPercent).toBeLessThan(0.5);
-        });
-        it("random portion should have evenly distributed character value positions", async () => {
-            const buckets = {};
-            for (let i = 0; i < 2000000; i++) {
-                const randomPart = (0, utils_1.newid)().substring(10);
-                expect(randomPart.length).toBe(15);
-                for (let j = 0; j < randomPart.length; j++) {
-                    const c = randomPart[j];
-                    const k = `${c},${String(j).padStart(2, "0")}`;
-                    buckets[k] = (buckets[k] || 0) + 1;
-                }
-            }
-            const orderedKeys = {};
-            let keys = (0, lodash_1.sortBy)(Object.keys(buckets), (key) => Number(key.split(",")[1]));
-            keys = (0, lodash_1.sortBy)(keys, (key) => key.split(",")[0]);
-            keys.forEach((key) => {
-                orderedKeys[key] = buckets[key];
-            });
-            console.log(orderedKeys);
-            const orderedValues = {};
-            const values = (0, lodash_1.sortBy)(Object.entries(buckets), ([, value]) => value);
-            values.forEach(([key, value]) => {
-                orderedValues[key] = value;
-            });
-            console.log(orderedValues);
-            const counts = Object.values(buckets);
-            let average = 0;
-            let max = 0;
-            let min = Number.MAX_SAFE_INTEGER;
-            for (const c of counts) {
-                average += c;
-                max = Math.max(max, c);
-                min = Math.min(min, c);
-            }
-            average /= counts.length;
-            const maxDeviation = Math.max(max - average, average - min);
-            const maxDeviationPercent = (maxDeviation / average) * 100;
-            console.log({ average, max, min, maxDeviation, maxDeviationPercent });
-            // expect all values to be within 2% of the average
-            expect(maxDeviationPercent).toBeLessThan(2);
-        });
-    });
-});
-describe("deterministicGroupMemberId", () => {
-    it("preserves the membership identity protocol across SDK versions", () => {
-        expect((0, utils_1.deterministicGroupMemberId)("00000000000000000000000001", "00000000000000000000000002")).toBe("000gmbr0jzkpw7vuc2ew84u8c");
-    });
-    it("is a stable peer id per group and user", () => {
-        const groupId = (0, utils_1.newid)();
-        const userId = (0, utils_1.newid)();
-        const id = (0, utils_1.deterministicGroupMemberId)(groupId, userId);
-        expect(id).toMatch(/^[a-z0-9]{25}$/);
-        expect((0, utils_1.isid)(id)).toBe(true);
-        expect((0, utils_1.isDeterministicGroupMemberId)(id)).toBe(true);
-        expect((0, utils_1.deterministicGroupMemberId)(groupId, userId)).toBe(id);
-        expect((0, utils_1.deterministicGroupMemberId)(groupId, (0, utils_1.newid)())).not.toBe(id);
-        expect((0, utils_1.deterministicGroupMemberId)(userId, groupId)).not.toBe(id);
-        expect((0, utils_1.isDeterministicGroupMemberId)((0, utils_1.newid)())).toBe(false);
-    });
-});
-describe("debounceByArgs", () => {
-    beforeEach(() => {
-        jest.useFakeTimers();
-    });
-    afterEach(() => {
-        jest.useRealTimers();
-    });
-    it("should debounce function calls with different arguments independently", () => {
-        const mockFn = jest.fn();
-        const debouncedFn = (0, utils_1.debounceByArgs)(mockFn, 100);
-        debouncedFn(1);
-        debouncedFn(2);
-        debouncedFn(1);
-        expect(mockFn).not.toHaveBeenCalled();
-        jest.advanceTimersByTime(100);
-        expect(mockFn).toHaveBeenCalledTimes(2);
-        expect(mockFn).toHaveBeenCalledWith(1);
-        expect(mockFn).toHaveBeenCalledWith(2);
-    });
-    it("should debounce multiple calls with same arguments", () => {
-        const mockFn = jest.fn();
-        const debouncedFn = (0, utils_1.debounceByArgs)(mockFn, 100);
-        debouncedFn(1);
-        debouncedFn(1);
-        debouncedFn(1);
-        expect(mockFn).not.toHaveBeenCalled();
-        jest.advanceTimersByTime(100);
-        expect(mockFn).toHaveBeenCalledTimes(1);
-        expect(mockFn).toHaveBeenCalledWith(1);
-    });
-    it("should handle complex arguments", () => {
-        const mockFn = jest.fn();
-        const debouncedFn = (0, utils_1.debounceByArgs)(mockFn, 50);
-        const obj1 = { id: 1, name: "test" };
-        const obj2 = { id: 2, name: "test" };
-        debouncedFn(obj1, "extra");
-        debouncedFn(obj2, "extra");
-        debouncedFn(obj1, "extra");
-        jest.advanceTimersByTime(50);
-        expect(mockFn).toHaveBeenCalledTimes(2);
-        expect(mockFn).toHaveBeenCalledWith(obj1, "extra");
-        expect(mockFn).toHaveBeenCalledWith(obj2, "extra");
-    });
-    it("should call the function with correct arguments after debounce", () => {
-        const mockFn = jest.fn().mockReturnValue("result");
-        const debouncedFn = (0, utils_1.debounceByArgs)(mockFn, 100);
-        debouncedFn(1, "test");
-        expect(mockFn).not.toHaveBeenCalled();
-        jest.advanceTimersByTime(100);
-        expect(mockFn).toHaveBeenCalledTimes(1);
-        expect(mockFn).toHaveBeenCalledWith(1, "test");
-    });
-    it("should use default wait time of 300ms", () => {
-        const mockFn = jest.fn();
-        const debouncedFn = (0, utils_1.debounceByArgs)(mockFn);
-        debouncedFn(1);
-        jest.advanceTimersByTime(299);
-        expect(mockFn).not.toHaveBeenCalled();
-        jest.advanceTimersByTime(1);
-        expect(mockFn).toHaveBeenCalledTimes(1);
-    });
-});