@peers-app/peers-ui 0.20.3 → 0.20.5

package/dist/screens/contacts/user-connect-invite.test.js

@@ -0,0 +1,215 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const peers_sdk_1 = require("@peers-app/peers-sdk");
+const user_connect_invite_1 = require("./user-connect-invite");
+function createMemoryStorage() {
+    const map = new Map();
+    return {
+        get length() {
+            return map.size;
+        },
+        clear() {
+            map.clear();
+        },
+        getItem(key) {
+            return map.get(key) ?? null;
+        },
+        key(index) {
+            return [...map.keys()][index] ?? null;
+        },
+        removeItem(key) {
+            map.delete(key);
+        },
+        setItem(key, value) {
+            map.set(key, value);
+        },
+    };
+}
+describe("user-connect-invite", () => {
+    const validCode = "ABCD1234EFGH";
+    const formattedCode = "ABCD-1234-EFGH";
+    describe("normalizeUserConnectCode", () => {
+        it("accepts formatted and unformatted valid codes", () => {
+            expect((0, user_connect_invite_1.normalizeUserConnectCode)(validCode)).toBe(validCode);
+            expect((0, user_connect_invite_1.normalizeUserConnectCode)(formattedCode)).toBe(validCode);
+            expect((0, user_connect_invite_1.normalizeUserConnectCode)("abcd-1234-efgh")).toBe(validCode);
+        });
+        it("rejects invalid alphabet and length", () => {
+            expect((0, user_connect_invite_1.normalizeUserConnectCode)("ABCD1234EFG")).toBeNull();
+            expect((0, user_connect_invite_1.normalizeUserConnectCode)("ABCD1234EFGHI")).toBeNull();
+            expect((0, user_connect_invite_1.normalizeUserConnectCode)("ABCD1234EFGI")).toBeNull(); // I invalid in Crockford
+            expect((0, user_connect_invite_1.normalizeUserConnectCode)("A-B-C-D-1-2-3-4-E-F-G-H")).toBeNull();
+            expect((0, user_connect_invite_1.normalizeUserConnectCode)("ABCD 1234 EFGH")).toBeNull();
+            expect((0, user_connect_invite_1.normalizeUserConnectCode)("")).toBeNull();
+        });
+    });
+    describe("extractUserConnectCodeFromFragment", () => {
+        it("extracts codes from contacts/connect fragments", () => {
+            expect((0, user_connect_invite_1.extractUserConnectCodeFromFragment)(`#contacts/connect?code=${formattedCode}`)).toBe(formattedCode);
+            expect((0, user_connect_invite_1.extractUserConnectCodeFromFragment)(`contacts/connect?code=${validCode}`)).toBe(validCode);
+        });
+        it("returns null for unrelated routes", () => {
+            expect((0, user_connect_invite_1.extractUserConnectCodeFromFragment)("#contacts/list")).toBeNull();
+            expect((0, user_connect_invite_1.extractUserConnectCodeFromFragment)("#home")).toBeNull();
+            expect((0, user_connect_invite_1.extractUserConnectCodeFromFragment)("#contacts/connect")).toBeNull();
+            expect((0, user_connect_invite_1.extractUserConnectCodeFromFragment)("")).toBeNull();
+        });
+    });
+    describe("buildUserConnectInviteUrl", () => {
+        it("builds the canonical peers.app URL with ?app and fragment code", () => {
+            const url = (0, user_connect_invite_1.buildUserConnectInviteUrl)(validCode);
+            expect(url).toBe(`https://peers.app/?app#contacts/connect?code=${encodeURIComponent(formattedCode)}`);
+            expect(url.includes("?app#")).toBe(true);
+            expect(url.split("?")[1]?.startsWith("app#")).toBe(true);
+            const beforeHash = url.split("#")[0];
+            expect(beforeHash.includes(validCode)).toBe(false);
+            expect(beforeHash.includes(formattedCode)).toBe(false);
+        });
+        it("accepts an explicit base URL without putting the code in the HTTP query", () => {
+            const url = (0, user_connect_invite_1.buildUserConnectInviteUrl)(formattedCode, "https://example.test/");
+            expect(url.startsWith("https://example.test/?app#")).toBe(true);
+            expect(url).toContain(`code=${encodeURIComponent(formattedCode)}`);
+            const query = new URL(url.split("#")[0]).searchParams;
+            expect(query.has("code")).toBe(false);
+            expect(query.has("app")).toBe(true);
+        });
+    });
+    describe("sessionStorage intent lifecycle", () => {
+        it("writes, reads, and one-time consumes a pending intent", () => {
+            const storage = createMemoryStorage();
+            const now = 1_000_000;
+            (0, user_connect_invite_1.writeUserConnectPendingIntent)({ code: validCode, capturedAt: now }, storage);
+            const read = (0, user_connect_invite_1.readUserConnectPendingIntent)(storage, now + 1000);
+            expect(read).toEqual({
+                ok: true,
+                intent: { code: validCode, capturedAt: now },
+            });
+            expect((0, user_connect_invite_1.hasPendingUserConnectInvite)(storage, now + 1000)).toBe(true);
+            const consumed = (0, user_connect_invite_1.consumeUserConnectPendingIntent)(storage, now + 1000);
+            expect(consumed).toEqual({
+                ok: true,
+                intent: { code: validCode, capturedAt: now },
+            });
+            expect(storage.getItem(user_connect_invite_1.USER_CONNECT_INVITE_STORAGE_KEY)).toBeNull();
+            expect((0, user_connect_invite_1.consumeUserConnectPendingIntent)(storage, now + 1000)).toEqual({
+                ok: false,
+                reason: "none",
+            });
+        });
+        it("expires stale intents using the shared TTL", () => {
+            const storage = createMemoryStorage();
+            const now = 1_000_000;
+            (0, user_connect_invite_1.writeUserConnectPendingIntent)({ code: validCode, capturedAt: now }, storage);
+            expect((0, user_connect_invite_1.readUserConnectPendingIntent)(storage, now + peers_sdk_1.USER_CONNECT_TTL_MS)).toEqual({
+                ok: false,
+                reason: "expired",
+            });
+            expect((0, user_connect_invite_1.consumeUserConnectPendingIntent)(storage, now + peers_sdk_1.USER_CONNECT_TTL_MS)).toEqual({
+                ok: false,
+                reason: "expired",
+            });
+            expect(storage.getItem(user_connect_invite_1.USER_CONNECT_INVITE_STORAGE_KEY)).toBeNull();
+        });
+        it("rejects implausible future capture timestamps", () => {
+            const storage = createMemoryStorage();
+            (0, user_connect_invite_1.writeUserConnectPendingIntent)({ code: validCode, capturedAt: 20_000 }, storage);
+            expect((0, user_connect_invite_1.readUserConnectPendingIntent)(storage, 10_000)).toEqual({
+                ok: false,
+                reason: "expired",
+            });
+        });
+        it("treats malformed stored data as invalid", () => {
+            const storage = createMemoryStorage();
+            storage.setItem(user_connect_invite_1.USER_CONNECT_INVITE_STORAGE_KEY, "{not-json");
+            expect((0, user_connect_invite_1.readUserConnectPendingIntent)(storage)).toEqual({ ok: false, reason: "invalid" });
+            expect((0, user_connect_invite_1.consumeUserConnectPendingIntent)(storage)).toEqual({
+                ok: false,
+                reason: "invalid",
+            });
+            expect(storage.getItem(user_connect_invite_1.USER_CONNECT_INVITE_STORAGE_KEY)).toBeNull();
+        });
+        it("clears pending intent explicitly", () => {
+            const storage = createMemoryStorage();
+            (0, user_connect_invite_1.writeUserConnectPendingIntent)({ code: validCode, capturedAt: Date.now() }, storage);
+            (0, user_connect_invite_1.clearUserConnectPendingIntent)(storage);
+            expect((0, user_connect_invite_1.readUserConnectPendingIntent)(storage)).toEqual({ ok: false, reason: "none" });
+        });
+    });
+    describe("capture and URL cleanup", () => {
+        it("captures a valid invite, stores it, and strips the code from the URL", () => {
+            const storage = createMemoryStorage();
+            let replacedUrl = "";
+            const locationLike = {
+                pathname: "/",
+                search: "?app",
+                hash: `#contacts/connect?code=${formattedCode}`,
+            };
+            const historyLike = {
+                state: null,
+                replaceState: (_state, _title, url) => {
+                    replacedUrl = String(url ?? "");
+                    locationLike.hash = replacedUrl.includes("#") ? `#${replacedUrl.split("#")[1]}` : "";
+                },
+            };
+            const result = (0, user_connect_invite_1.captureUserConnectInviteFromLocation)({
+                locationLike,
+                historyLike,
+                storage,
+                nowMs: 5_000,
+            });
+            expect(result).toEqual({
+                ok: true,
+                intent: { code: validCode, capturedAt: 5_000 },
+            });
+            expect(replacedUrl).toBe("/?app#contacts/connect");
+            expect(locationLike.hash).toBe("#contacts/connect");
+            expect((0, user_connect_invite_1.hasPendingUserConnectInvite)(storage, 5_000)).toBe(true);
+        });
+        it("stores an invalid marker for malformed codes and still cleans the URL", () => {
+            const storage = createMemoryStorage();
+            const locationLike = {
+                pathname: "/",
+                search: "?app",
+                hash: "#contacts/connect?code=BAD",
+            };
+            const historyLike = {
+                state: null,
+                replaceState: (_state, _title, url) => {
+                    locationLike.hash = String(url ?? "").includes("#")
+                        ? `#${String(url).split("#")[1]}`
+                        : "";
+                },
+            };
+            expect((0, user_connect_invite_1.captureUserConnectInviteFromLocation)({
+                locationLike,
+                historyLike,
+                storage,
+                nowMs: 9_000,
+            })).toEqual({ ok: false, reason: "invalid" });
+            expect(locationLike.hash).toBe("#contacts/connect");
+            expect((0, user_connect_invite_1.readUserConnectPendingIntent)(storage, 9_000)).toEqual({
+                ok: false,
+                reason: "invalid",
+            });
+        });
+        it("stripUserConnectCodeFromUrl is a no-op without a code", () => {
+            const locationLike = { pathname: "/", search: "", hash: "#home" };
+            let calls = 0;
+            (0, user_connect_invite_1.stripUserConnectCodeFromUrl)(locationLike, {
+                state: null,
+                replaceState: () => {
+                    calls += 1;
+                },
+            });
+            expect(calls).toBe(0);
+        });
+    });
+    describe("buildUserConnectShareText", () => {
+        it("mentions expiry and that both people need Peers open", () => {
+            const text = (0, user_connect_invite_1.buildUserConnectShareText)("https://peers.app/?app#contacts/connect?code=X");
+            expect(text).toContain("https://peers.app/?app#contacts/connect?code=X");
+            expect(text.toLowerCase()).toContain("expire");
+            expect(text.toLowerCase()).toContain("peers open");
+        });
+    });
+});

package/dist/screens/contacts/user-connect.d.ts

@@ -1 +1,8 @@
+/**
+ * Connect-to-user screen: QR invite, link share, manual code entry, and trust confirmation.
+ */
+/**
+ * Polished Connect to user screen. Creating an invite is the default path;
+ * inbound links open a review state before connecting.
+ */
 export declare function UserConnect(): import("react/jsx-runtime").JSX.Element;