@peers-app/peers-ui 0.23.13 → 0.24.0

package/src/screens/contacts/user-connect-invite.test.ts

@@ -1,256 +0,0 @@
-import { USER_CONNECT_TTL_MS } from "@peers-app/peers-sdk";
-import {
-  buildUserConnectInviteUrl,
-  buildUserConnectShareText,
-  captureUserConnectInviteFromLocation,
-  clearUserConnectPendingIntent,
-  consumeUserConnectPendingIntent,
-  extractUserConnectCodeFromFragment,
-  hasPendingUserConnectInvite,
-  normalizeUserConnectCode,
-  readUserConnectPendingIntent,
-  stripUserConnectCodeFromUrl,
-  USER_CONNECT_INVITE_STORAGE_KEY,
-  writeUserConnectPendingIntent,
-} from "./user-connect-invite";
-
-function createMemoryStorage(): Storage {
-  const map = new Map<string, string>();
-  return {
-    get length() {
-      return map.size;
-    },
-    clear() {
-      map.clear();
-    },
-    getItem(key: string) {
-      return map.get(key) ?? null;
-    },
-    key(index: number) {
-      return [...map.keys()][index] ?? null;
-    },
-    removeItem(key: string) {
-      map.delete(key);
-    },
-    setItem(key: string, value: string) {
-      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(normalizeUserConnectCode(validCode)).toBe(validCode);
-      expect(normalizeUserConnectCode(formattedCode)).toBe(validCode);
-      expect(normalizeUserConnectCode("abcd-1234-efgh")).toBe(validCode);
-    });
-
-    it("rejects invalid alphabet and length", () => {
-      expect(normalizeUserConnectCode("ABCD1234EFG")).toBeNull();
-      expect(normalizeUserConnectCode("ABCD1234EFGHI")).toBeNull();
-      expect(normalizeUserConnectCode("ABCD1234EFGI")).toBeNull(); // I invalid in Crockford
-      expect(normalizeUserConnectCode("A-B-C-D-1-2-3-4-E-F-G-H")).toBeNull();
-      expect(normalizeUserConnectCode("ABCD 1234 EFGH")).toBeNull();
-      expect(normalizeUserConnectCode("")).toBeNull();
-    });
-  });
-
-  describe("extractUserConnectCodeFromFragment", () => {
-    it("extracts codes from contacts/connect fragments", () => {
-      expect(extractUserConnectCodeFromFragment(`#contacts/connect?code=${formattedCode}`)).toBe(
-        formattedCode,
-      );
-      expect(extractUserConnectCodeFromFragment(`contacts/connect?code=${validCode}`)).toBe(
-        validCode,
-      );
-    });
-
-    it("returns null for unrelated routes", () => {
-      expect(extractUserConnectCodeFromFragment("#contacts/list")).toBeNull();
-      expect(extractUserConnectCodeFromFragment("#home")).toBeNull();
-      expect(extractUserConnectCodeFromFragment("#contacts/connect")).toBeNull();
-      expect(extractUserConnectCodeFromFragment("")).toBeNull();
-    });
-  });
-
-  describe("buildUserConnectInviteUrl", () => {
-    it("builds the canonical peers.app URL with ?app and fragment code", () => {
-      const url = 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 = 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;
-      writeUserConnectPendingIntent({ code: validCode, capturedAt: now }, storage);
-
-      const read = readUserConnectPendingIntent(storage, now + 1000);
-      expect(read).toEqual({
-        ok: true,
-        intent: { code: validCode, capturedAt: now },
-      });
-      expect(hasPendingUserConnectInvite(storage, now + 1000)).toBe(true);
-
-      const consumed = consumeUserConnectPendingIntent(storage, now + 1000);
-      expect(consumed).toEqual({
-        ok: true,
-        intent: { code: validCode, capturedAt: now },
-      });
-      expect(storage.getItem(USER_CONNECT_INVITE_STORAGE_KEY)).toBeNull();
-      expect(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;
-      writeUserConnectPendingIntent({ code: validCode, capturedAt: now }, storage);
-      expect(readUserConnectPendingIntent(storage, now + USER_CONNECT_TTL_MS)).toEqual({
-        ok: false,
-        reason: "expired",
-      });
-      expect(consumeUserConnectPendingIntent(storage, now + USER_CONNECT_TTL_MS)).toEqual({
-        ok: false,
-        reason: "expired",
-      });
-      expect(storage.getItem(USER_CONNECT_INVITE_STORAGE_KEY)).toBeNull();
-    });
-
-    it("rejects implausible future capture timestamps", () => {
-      const storage = createMemoryStorage();
-      writeUserConnectPendingIntent({ code: validCode, capturedAt: 20_000 }, storage);
-      expect(readUserConnectPendingIntent(storage, 10_000)).toEqual({
-        ok: false,
-        reason: "expired",
-      });
-    });
-
-    it("treats malformed stored data as invalid", () => {
-      const storage = createMemoryStorage();
-      storage.setItem(USER_CONNECT_INVITE_STORAGE_KEY, "{not-json");
-      expect(readUserConnectPendingIntent(storage)).toEqual({ ok: false, reason: "invalid" });
-      expect(consumeUserConnectPendingIntent(storage)).toEqual({
-        ok: false,
-        reason: "invalid",
-      });
-      expect(storage.getItem(USER_CONNECT_INVITE_STORAGE_KEY)).toBeNull();
-    });
-
-    it("clears pending intent explicitly", () => {
-      const storage = createMemoryStorage();
-      writeUserConnectPendingIntent({ code: validCode, capturedAt: Date.now() }, storage);
-      clearUserConnectPendingIntent(storage);
-      expect(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: unknown, _title: string, url?: string | null) => {
-          replacedUrl = String(url ?? "");
-          locationLike.hash = replacedUrl.includes("#") ? `#${replacedUrl.split("#")[1]}` : "";
-        },
-      };
-
-      const result = 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(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: unknown, _title: string, url?: string | null) => {
-          locationLike.hash = String(url ?? "").includes("#")
-            ? `#${String(url).split("#")[1]}`
-            : "";
-        },
-      };
-
-      expect(
-        captureUserConnectInviteFromLocation({
-          locationLike,
-          historyLike,
-          storage,
-          nowMs: 9_000,
-        }),
-      ).toEqual({ ok: false, reason: "invalid" });
-      expect(locationLike.hash).toBe("#contacts/connect");
-      expect(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;
-      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 = 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/src/screens/contacts/user-connect-invite.ts

@@ -1,332 +0,0 @@
-/**
- * Invite URL and pending-intent helpers for the user-connect QR/link flow.
- *
- * Invite codes stay in the URL fragment (never the HTTP query) and are moved
- * into tab-scoped sessionStorage before startup route restoration can persist
- * them into `mainContentPath`.
- */
-
-import {
-  formatConnectionCode,
-  isValidConnectionCode,
-  parseConnectionCode,
-  USER_CONNECT_TTL_MS,
-} from "@peers-app/peers-sdk";
-
-/** sessionStorage key for a captured inbound invite. */
-export const USER_CONNECT_INVITE_STORAGE_KEY = "peers.userConnectInvite";
-
-/** Default production launch origin used when building shareable invite links. */
-export const DEFAULT_USER_CONNECT_BASE_URL = "https://peers.app";
-
-/**
- * Serializable pending invite captured from a deep link or stored for post-setup resume.
- */
-export interface UserConnectPendingIntent {
-  /** Normalized 12-character Crockford code (no dashes). */
-  code: string;
-  /** Epoch ms when the intent was captured. */
-  capturedAt: number;
-}
-
-/**
- * Result of attempting to capture or read a pending invite.
- */
-export type UserConnectInviteCaptureResult =
-  | { ok: true; intent: UserConnectPendingIntent }
-  | { ok: false; reason: "none" | "invalid" | "expired" };
-
-interface StoredErrorMarker {
-  error: "invalid" | "expired";
-  capturedAt: number;
-}
-
-type StoredInvitePayload = UserConnectPendingIntent | StoredErrorMarker;
-
-/**
- * Build the canonical shareable invite URL.
- * Keeps the bearer code in the fragment and uses `?app` so signed-out PWA
- * recipients receive the app shell instead of the marketing landing page.
- * @param code Connection code (formatted or raw)
- * @param baseUrl Launch origin (no trailing slash); defaults to peers.app
- * @returns Absolute invite URL
- */
-export function buildUserConnectInviteUrl(
-  code: string,
-  baseUrl: string = DEFAULT_USER_CONNECT_BASE_URL,
-): string {
-  const normalized = normalizeUserConnectCode(code);
-  if (!normalized) {
-    throw new Error("Invalid connection code");
-  }
-  const formatted = formatConnectionCode(normalized);
-  const origin = baseUrl.replace(/\/$/, "");
-  return `${origin}/?app#contacts/connect?code=${encodeURIComponent(formatted)}`;
-}
-
-/**
- * Extract a connection code from a `contacts/connect` hash fragment.
- * Accepts `#contacts/connect?code=…` or `contacts/connect?code=…`.
- * @param hashOrPath Hash or path fragment from `location.hash` / a full URL
- * @returns Raw code string from the query, or null when the route is not an invite
- */
-export function extractUserConnectCodeFromFragment(hashOrPath: string): string | null {
-  const raw = hashOrPath.startsWith("#") ? hashOrPath.slice(1) : hashOrPath;
-  const [pathPart, queryPart] = raw.split("?");
-  if (pathPart !== "contacts/connect") {
-    return null;
-  }
-  if (!queryPart) {
-    return null;
-  }
-  const params = new URLSearchParams(queryPart);
-  const code = params.get("code");
-  if (code === null) {
-    return null;
-  }
-  const decoded = code.trim();
-  return decoded.length > 0 ? decoded : null;
-}
-
-/**
- * Validate and normalize a connection code to 12 Crockford characters.
- * @param code Candidate code (formatted or raw)
- * @returns Normalized code, or null when invalid
- */
-export function normalizeUserConnectCode(code: string): string | null {
-  const trimmed = code.trim().toUpperCase();
-  const isRaw = /^[0-9ABCDEFGHJKMNPQRSTVWXYZ]{12}$/.test(trimmed);
-  const isFormatted =
-    /^[0-9ABCDEFGHJKMNPQRSTVWXYZ]{4}-[0-9ABCDEFGHJKMNPQRSTVWXYZ]{4}-[0-9ABCDEFGHJKMNPQRSTVWXYZ]{4}$/.test(
-      trimmed,
-    );
-  if (!isRaw && !isFormatted) {
-    return null;
-  }
-  const compact = trimmed.replaceAll("-", "");
-  if (!isValidConnectionCode(compact)) {
-    return null;
-  }
-  try {
-    return parseConnectionCode(compact).code;
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Whether a pending intent is still within the local invite TTL.
- * @param intent Captured intent
- * @param nowMs Current epoch ms (injectable for tests)
- * @returns True when the intent has not expired
- */
-export function isUserConnectIntentFresh(
-  intent: Pick<UserConnectPendingIntent, "capturedAt">,
-  nowMs: number = Date.now(),
-): boolean {
-  return intent.capturedAt <= nowMs && nowMs - intent.capturedAt < USER_CONNECT_TTL_MS;
-}
-
-/**
- * Replace the visible URL so the bearer code is no longer in the address bar.
- * Leaves `?app` and a non-sensitive `#contacts/connect` route shell when present.
- * @param locationLike Browser location (defaults to `window.location`)
- * @param historyLike History API (defaults to `window.history`)
- */
-export function stripUserConnectCodeFromUrl(
-  locationLike: Pick<Location, "pathname" | "search" | "hash"> = window.location,
-  historyLike: Pick<History, "replaceState" | "state"> = window.history,
-): void {
-  if (!locationLike.hash.includes("code=")) {
-    return;
-  }
-  const path = locationLike.hash.startsWith("#")
-    ? locationLike.hash.slice(1).split("?")[0]
-    : locationLike.hash.split("?")[0];
-  const nextHash = path === "contacts/connect" ? "#contacts/connect" : "";
-  const nextUrl = `${locationLike.pathname}${locationLike.search}${nextHash}`;
-  historyLike.replaceState(historyLike.state ?? null, "", nextUrl);
-}
-
-/**
- * Persist a pending invite in tab-scoped sessionStorage.
- * @param intent Valid intent to store
- * @param storage Storage backend (defaults to sessionStorage)
- */
-export function writeUserConnectPendingIntent(
-  intent: UserConnectPendingIntent,
-  storage: Storage = sessionStorage,
-): void {
-  const payload: StoredInvitePayload = intent;
-  storage.setItem(USER_CONNECT_INVITE_STORAGE_KEY, JSON.stringify(payload));
-}
-
-function writeErrorMarker(
-  error: StoredErrorMarker["error"],
-  capturedAt: number,
-  storage: Storage,
-): void {
-  const payload: StoredErrorMarker = { error, capturedAt };
-  storage.setItem(USER_CONNECT_INVITE_STORAGE_KEY, JSON.stringify(payload));
-}
-
-function parseStoredPayload(raw: string): StoredInvitePayload | null {
-  try {
-    const parsed = JSON.parse(raw) as Partial<StoredInvitePayload>;
-    const marker = parsed as Partial<StoredErrorMarker>;
-    if (marker.error === "invalid" || marker.error === "expired") {
-      const capturedAt = marker.capturedAt;
-      if (typeof capturedAt !== "number" || !Number.isFinite(capturedAt)) {
-        return null;
-      }
-      return { error: marker.error, capturedAt };
-    }
-    if (
-      typeof (parsed as UserConnectPendingIntent).code === "string" &&
-      typeof (parsed as UserConnectPendingIntent).capturedAt === "number" &&
-      Number.isFinite((parsed as UserConnectPendingIntent).capturedAt)
-    ) {
-      return {
-        code: (parsed as UserConnectPendingIntent).code,
-        capturedAt: (parsed as UserConnectPendingIntent).capturedAt,
-      };
-    }
-    return null;
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Read a pending invite without consuming it.
- * Expired entries are cleared. Invalid markers remain until consumed/cleared
- * so the connection screen can show recovery UI.
- * @param storage Storage backend
- * @param nowMs Current epoch ms
- * @returns Capture result
- */
-export function readUserConnectPendingIntent(
-  storage: Storage = sessionStorage,
-  nowMs: number = Date.now(),
-): UserConnectInviteCaptureResult {
-  const raw = storage.getItem(USER_CONNECT_INVITE_STORAGE_KEY);
-  if (!raw) {
-    return { ok: false, reason: "none" };
-  }
-  const parsed = parseStoredPayload(raw);
-  if (!parsed) {
-    writeErrorMarker("invalid", nowMs, storage);
-    return { ok: false, reason: "invalid" };
-  }
-  if ("error" in parsed) {
-    return { ok: false, reason: parsed.error };
-  }
-  const normalized = normalizeUserConnectCode(parsed.code);
-  if (!normalized) {
-    writeErrorMarker("invalid", parsed.capturedAt, storage);
-    return { ok: false, reason: "invalid" };
-  }
-  const intent: UserConnectPendingIntent = {
-    code: normalized,
-    capturedAt: parsed.capturedAt,
-  };
-  if (!isUserConnectIntentFresh(intent, nowMs)) {
-    writeErrorMarker("expired", parsed.capturedAt, storage);
-    return { ok: false, reason: "expired" };
-  }
-  return { ok: true, intent };
-}
-
-/**
- * Read and remove a pending invite in one step (one-time consumption).
- * @param storage Storage backend
- * @param nowMs Current epoch ms
- * @returns Capture result for the consumed intent
- */
-export function consumeUserConnectPendingIntent(
-  storage: Storage = sessionStorage,
-  nowMs: number = Date.now(),
-): UserConnectInviteCaptureResult {
-  const result = readUserConnectPendingIntent(storage, nowMs);
-  storage.removeItem(USER_CONNECT_INVITE_STORAGE_KEY);
-  return result;
-}
-
-/**
- * Remove any pending invite from sessionStorage.
- * @param storage Storage backend
- */
-export function clearUserConnectPendingIntent(storage: Storage = sessionStorage): void {
-  storage.removeItem(USER_CONNECT_INVITE_STORAGE_KEY);
-}
-
-/**
- * Capture an inbound invite from the current location into sessionStorage and
- * strip the code from the address bar. Safe to call multiple times; a second
- * call with no code in the URL leaves existing storage alone.
- * @param options Optional location/history/storage/clock overrides for tests
- * @returns Capture result
- */
-export function captureUserConnectInviteFromLocation(options?: {
-  locationLike?: Pick<Location, "pathname" | "search" | "hash">;
-  historyLike?: Pick<History, "replaceState" | "state">;
-  storage?: Storage;
-  nowMs?: number;
-}): UserConnectInviteCaptureResult {
-  const locationLike = options?.locationLike ?? window.location;
-  const historyLike = options?.historyLike ?? window.history;
-  const storage = options?.storage ?? sessionStorage;
-  const nowMs = options?.nowMs ?? Date.now();
-
-  const extracted = extractUserConnectCodeFromFragment(locationLike.hash);
-  if (extracted === null) {
-    const rawFragment = locationLike.hash.startsWith("#")
-      ? locationLike.hash.slice(1)
-      : locationLike.hash;
-    const [path, query = ""] = rawFragment.split("?");
-    if (path === "contacts/connect" && new URLSearchParams(query).has("code")) {
-      stripUserConnectCodeFromUrl(locationLike, historyLike);
-      writeErrorMarker("invalid", nowMs, storage);
-      return { ok: false, reason: "invalid" };
-    }
-    return readUserConnectPendingIntent(storage, nowMs);
-  }
-
-  stripUserConnectCodeFromUrl(locationLike, historyLike);
-
-  const normalized = normalizeUserConnectCode(extracted);
-  if (!normalized) {
-    writeErrorMarker("invalid", nowMs, storage);
-    return { ok: false, reason: "invalid" };
-  }
-
-  const intent: UserConnectPendingIntent = { code: normalized, capturedAt: nowMs };
-  writeUserConnectPendingIntent(intent, storage);
-  return { ok: true, intent };
-}
-
-/**
- * Whether sessionStorage currently holds a fresh, valid pending invite.
- * @param storage Storage backend
- * @param nowMs Current epoch ms
- */
-export function hasPendingUserConnectInvite(
-  storage: Storage = sessionStorage,
-  nowMs: number = Date.now(),
-): boolean {
-  return readUserConnectPendingIntent(storage, nowMs).ok;
-}
-
-/**
- * Share text for the Web Share API / clipboard companion copy.
- * @param inviteUrl Canonical invite URL
- * @returns Human-readable share body
- */
-export function buildUserConnectShareText(inviteUrl: string): string {
-  return [
-    "Connect with me on Peers:",
-    inviteUrl,
-    "",
-    "Both of us need Peers open. This invite expires in 10 minutes.",
-  ].join("\n");
-}