@peers-app/peers-ui 0.20.4 → 0.20.5

package/dist/root-layout/root-layout-host.js

@@ -20,6 +20,7 @@ const react_1 = require("react");
 const command_palette_ui_1 = require("../command-palette/command-palette-ui");
 const globals_1 = require("../globals");
 const hooks_1 = require("../hooks");
+const user_connect_invite_1 = require("../screens/contacts/user-connect-invite");
 const color_mode_dropdown_1 = require("../screens/settings/color-mode-dropdown");
 const setup_user_1 = require("../screens/setup-user");
 const welcome_modal_1 = require("../screens/welcome-modal");
@@ -34,10 +35,31 @@ const root_layout_state_1 = require("./root-layout-state");
  * order downstream is stable across the user/no-user branches.
  */
 function RootLayoutHost() {
+    (0, react_1.useState)(() => {
+        (0, user_connect_invite_1.captureUserConnectInviteFromLocation)();
+        return true;
+    });
+    const userIdRef = (0, react_1.useRef)(undefined);
     const userId = (0, hooks_1.usePromise)(async () => {
         const _userId = await peers_sdk_1.rpcServerCalls.getUserId();
         return _userId || null;
     });
+    userIdRef.current = userId;
+    (0, react_1.useEffect)(() => {
+        const captureInviteFromHashChange = () => {
+            const previousHash = window.location.hash;
+            (0, user_connect_invite_1.captureUserConnectInviteFromLocation)();
+            if (window.location.hash === previousHash) {
+                return;
+            }
+            // Signed-out captures stay in sessionStorage until setup finishes.
+            if (userIdRef.current) {
+                (0, globals_1.mainContentPath)("contacts/connect");
+            }
+        };
+        window.addEventListener("hashchange", captureInviteFromHashChange);
+        return () => window.removeEventListener("hashchange", captureInviteFromHashChange);
+    }, []);
     if (userId === undefined) {
         return;
     }
@@ -67,6 +89,10 @@ function RootLayoutBootstrap(props) {
             tabs_state_1.recentlyUsedApps.loadingPromise,
             peers_sdk_1.hasShownWelcomeModal.loadingPromise,
         ]);
+        const pendingInvite = (0, user_connect_invite_1.readUserConnectPendingIntent)();
+        if (pendingInvite.ok || pendingInvite.reason !== "none") {
+            (0, globals_1.mainContentPath)("contacts/connect");
+        }
         return true;
     });
     const [showWelcomeModal, setShowWelcomeModal] = (0, react_1.useState)(false);

package/dist/root-layout/root-layout-host.test.d.ts

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

package/dist/root-layout/root-layout-host.test.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("@testing-library/react");
+const globals_1 = require("../globals");
+const user_connect_invite_1 = require("../screens/contacts/user-connect-invite");
+const root_layout_host_1 = require("./root-layout-host");
+jest.mock("@peers-app/peers-sdk", () => {
+    const actual = jest.requireActual("@peers-app/peers-sdk");
+    return {
+        ...actual,
+        hasShownWelcomeModal: Object.assign(jest.fn(() => true), {
+            loadingPromise: Promise.resolve(),
+        }),
+        rpcServerCalls: {
+            ...actual.rpcServerCalls,
+            getUserId: jest.fn(async () => "local-user"),
+        },
+        setDefaultClientUserContext: jest.fn(),
+    };
+});
+jest.mock("../command-palette/command-palette-ui", () => ({
+    CommandPaletteOverlay: () => null,
+}));
+jest.mock("../globals", () => ({
+    loadGlobals: jest.fn(async () => true),
+    mainContentPath: jest.fn(),
+}));
+jest.mock("../hooks", () => ({
+    useObservable: (observable) => [observable(), observable],
+    usePromise: (promiseOrFactory) => {
+        if (typeof promiseOrFactory === "function" &&
+            Function.prototype.toString.call(promiseOrFactory).includes("getUserId")) {
+            return "local-user";
+        }
+        return true;
+    },
+}));
+jest.mock("../screens/settings/color-mode-dropdown", () => ({
+    colorMode: jest.fn(() => "light"),
+}));
+jest.mock("../screens/setup-user", () => ({
+    SetupUser: () => null,
+}));
+jest.mock("../screens/welcome-modal", () => ({
+    WelcomeModal: () => null,
+}));
+jest.mock("../tabs-layout/tabs-state", () => ({
+    activeTabId: { loadingPromise: Promise.resolve() },
+    activeTabs: { loadingPromise: Promise.resolve() },
+    recentlyUsedApps: { loadingPromise: Promise.resolve() },
+}));
+jest.mock("../ui-router/routes-loader", () => ({
+    loadAllRoutes: jest.fn(async () => undefined),
+}));
+jest.mock("./global-overlays", () => ({
+    globalOverlays: jest.fn(() => []),
+}));
+jest.mock("./root-layout-registry", () => ({
+    DEFAULT_ROOT_LAYOUT_ID: "default",
+    getRootLayout: jest.fn(() => ({ Component: () => null })),
+}));
+jest.mock("./root-layout-state", () => ({
+    selectedRootLayoutId: jest.fn(() => undefined),
+}));
+describe("RootLayoutHost", () => {
+    beforeEach(() => {
+        sessionStorage.clear();
+        window.history.replaceState(null, "", "/");
+        jest.clearAllMocks();
+    });
+    it("captures and sanitizes invite links opened after startup", () => {
+        (0, react_1.render)((0, jsx_runtime_1.jsx)(root_layout_host_1.RootLayoutHost, {}));
+        window.history.replaceState(null, "", `/?app#contacts/connect?code=${encodeURIComponent("ABCD-1234-EFGH")}`);
+        (0, react_1.fireEvent)(window, new HashChangeEvent("hashchange"));
+        expect(window.location.hash).toBe("#contacts/connect");
+        expect((0, user_connect_invite_1.readUserConnectPendingIntent)()).toEqual({
+            ok: true,
+            intent: expect.objectContaining({ code: "ABCD1234EFGH" }),
+        });
+        expect(globals_1.mainContentPath).toHaveBeenCalledWith("contacts/connect");
+        expect(globals_1.mainContentPath).not.toHaveBeenCalledWith(expect.stringContaining("code="));
+    });
+});

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

@@ -0,0 +1,118 @@
+/**
+ * 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`.
+ */
+/** sessionStorage key for a captured inbound invite. */
+export declare const USER_CONNECT_INVITE_STORAGE_KEY = "peers.userConnectInvite";
+/** Default production launch origin used when building shareable invite links. */
+export declare 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";
+};
+/**
+ * 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 declare function buildUserConnectInviteUrl(code: string, baseUrl?: string): string;
+/**
+ * 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 declare function extractUserConnectCodeFromFragment(hashOrPath: string): string | 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 declare function normalizeUserConnectCode(code: string): string | 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 declare function isUserConnectIntentFresh(intent: Pick<UserConnectPendingIntent, "capturedAt">, nowMs?: number): boolean;
+/**
+ * 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 declare function stripUserConnectCodeFromUrl(locationLike?: Pick<Location, "pathname" | "search" | "hash">, historyLike?: Pick<History, "replaceState" | "state">): void;
+/**
+ * Persist a pending invite in tab-scoped sessionStorage.
+ * @param intent Valid intent to store
+ * @param storage Storage backend (defaults to sessionStorage)
+ */
+export declare function writeUserConnectPendingIntent(intent: UserConnectPendingIntent, storage?: Storage): void;
+/**
+ * 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 declare function readUserConnectPendingIntent(storage?: Storage, nowMs?: number): UserConnectInviteCaptureResult;
+/**
+ * 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 declare function consumeUserConnectPendingIntent(storage?: Storage, nowMs?: number): UserConnectInviteCaptureResult;
+/**
+ * Remove any pending invite from sessionStorage.
+ * @param storage Storage backend
+ */
+export declare function clearUserConnectPendingIntent(storage?: Storage): void;
+/**
+ * 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 declare function captureUserConnectInviteFromLocation(options?: {
+    locationLike?: Pick<Location, "pathname" | "search" | "hash">;
+    historyLike?: Pick<History, "replaceState" | "state">;
+    storage?: Storage;
+    nowMs?: number;
+}): UserConnectInviteCaptureResult;
+/**
+ * Whether sessionStorage currently holds a fresh, valid pending invite.
+ * @param storage Storage backend
+ * @param nowMs Current epoch ms
+ */
+export declare function hasPendingUserConnectInvite(storage?: Storage, nowMs?: number): boolean;
+/**
+ * Share text for the Web Share API / clipboard companion copy.
+ * @param inviteUrl Canonical invite URL
+ * @returns Human-readable share body
+ */
+export declare function buildUserConnectShareText(inviteUrl: string): string;

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

@@ -0,0 +1,264 @@
+"use strict";
+/**
+ * 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`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_USER_CONNECT_BASE_URL = exports.USER_CONNECT_INVITE_STORAGE_KEY = void 0;
+exports.buildUserConnectInviteUrl = buildUserConnectInviteUrl;
+exports.extractUserConnectCodeFromFragment = extractUserConnectCodeFromFragment;
+exports.normalizeUserConnectCode = normalizeUserConnectCode;
+exports.isUserConnectIntentFresh = isUserConnectIntentFresh;
+exports.stripUserConnectCodeFromUrl = stripUserConnectCodeFromUrl;
+exports.writeUserConnectPendingIntent = writeUserConnectPendingIntent;
+exports.readUserConnectPendingIntent = readUserConnectPendingIntent;
+exports.consumeUserConnectPendingIntent = consumeUserConnectPendingIntent;
+exports.clearUserConnectPendingIntent = clearUserConnectPendingIntent;
+exports.captureUserConnectInviteFromLocation = captureUserConnectInviteFromLocation;
+exports.hasPendingUserConnectInvite = hasPendingUserConnectInvite;
+exports.buildUserConnectShareText = buildUserConnectShareText;
+const peers_sdk_1 = require("@peers-app/peers-sdk");
+/** sessionStorage key for a captured inbound invite. */
+exports.USER_CONNECT_INVITE_STORAGE_KEY = "peers.userConnectInvite";
+/** Default production launch origin used when building shareable invite links. */
+exports.DEFAULT_USER_CONNECT_BASE_URL = "https://peers.app";
+/**
+ * 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
+ */
+function buildUserConnectInviteUrl(code, baseUrl = exports.DEFAULT_USER_CONNECT_BASE_URL) {
+    const normalized = normalizeUserConnectCode(code);
+    if (!normalized) {
+        throw new Error("Invalid connection code");
+    }
+    const formatted = (0, peers_sdk_1.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
+ */
+function extractUserConnectCodeFromFragment(hashOrPath) {
+    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
+ */
+function normalizeUserConnectCode(code) {
+    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 (!(0, peers_sdk_1.isValidConnectionCode)(compact)) {
+        return null;
+    }
+    try {
+        return (0, peers_sdk_1.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
+ */
+function isUserConnectIntentFresh(intent, nowMs = Date.now()) {
+    return intent.capturedAt <= nowMs && nowMs - intent.capturedAt < peers_sdk_1.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`)
+ */
+function stripUserConnectCodeFromUrl(locationLike = window.location, historyLike = window.history) {
+    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)
+ */
+function writeUserConnectPendingIntent(intent, storage = sessionStorage) {
+    const payload = intent;
+    storage.setItem(exports.USER_CONNECT_INVITE_STORAGE_KEY, JSON.stringify(payload));
+}
+function writeErrorMarker(error, capturedAt, storage) {
+    const payload = { error, capturedAt };
+    storage.setItem(exports.USER_CONNECT_INVITE_STORAGE_KEY, JSON.stringify(payload));
+}
+function parseStoredPayload(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        const marker = parsed;
+        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.code === "string" &&
+            typeof parsed.capturedAt === "number" &&
+            Number.isFinite(parsed.capturedAt)) {
+            return {
+                code: parsed.code,
+                capturedAt: parsed.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
+ */
+function readUserConnectPendingIntent(storage = sessionStorage, nowMs = Date.now()) {
+    const raw = storage.getItem(exports.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 = {
+        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
+ */
+function consumeUserConnectPendingIntent(storage = sessionStorage, nowMs = Date.now()) {
+    const result = readUserConnectPendingIntent(storage, nowMs);
+    storage.removeItem(exports.USER_CONNECT_INVITE_STORAGE_KEY);
+    return result;
+}
+/**
+ * Remove any pending invite from sessionStorage.
+ * @param storage Storage backend
+ */
+function clearUserConnectPendingIntent(storage = sessionStorage) {
+    storage.removeItem(exports.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
+ */
+function captureUserConnectInviteFromLocation(options) {
+    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 = { 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
+ */
+function hasPendingUserConnectInvite(storage = sessionStorage, nowMs = Date.now()) {
+    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
+ */
+function buildUserConnectShareText(inviteUrl) {
+    return [
+        "Connect with me on Peers:",
+        inviteUrl,
+        "",
+        "Both of us need Peers open. This invite expires in 10 minutes.",
+    ].join("\n");
+}

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

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