@peers-app/peers-ui 0.27.2 → 0.27.4

package/dist/hooks/use-tool.test.js

@@ -1,190 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const react_1 = require("@testing-library/react");
-const use_tool_1 = require("./use-tool");
-function deferred() {
-    let resolve;
-    let reject;
-    const promise = new Promise((yes, no) => {
-        resolve = yes;
-        reject = no;
-    });
-    return { promise, resolve, reject };
-}
-describe("useTool", () => {
-    test("tracks a run from pending to its result", async () => {
-        const answer = deferred();
-        const tool = jest.fn((_input) => answer.promise);
-        const { result } = (0, react_1.renderHook)(() => (0, use_tool_1.useTool)(tool));
-        expect(result.current.pending).toBe(false);
-        let running;
-        (0, react_1.act)(() => {
-            running = result.current.run({ feed: "bbc" });
-        });
-        expect(result.current.pending).toBe(true);
-        expect(tool).toHaveBeenCalledWith({ feed: "bbc" });
-        await (0, react_1.act)(async () => answer.resolve({ count: 3 }));
-        await expect(running).resolves.toEqual({ count: 3 });
-        expect(result.current).toMatchObject({ pending: false, result: { count: 3 } });
-        expect(result.current.error).toBeUndefined();
-        const typeChecks = () => {
-            // @ts-expect-error the input is the tool's
-            void result.current.run({ feed: 1 });
-            const count = result.current.result?.count;
-            void count;
-        };
-        void typeChecks;
-    });
-    test("a failed run sets error and resolves undefined instead of throwing", async () => {
-        const onError = jest.fn();
-        const { result } = (0, react_1.renderHook)(() => (0, use_tool_1.useTool)(async () => {
-            throw "offline";
-        }, { onError }));
-        let outcome = "unset";
-        await (0, react_1.act)(async () => {
-            outcome = await result.current.run();
-        });
-        expect(outcome).toBeUndefined();
-        expect(result.current.error?.message).toBe("offline");
-        expect(result.current.pending).toBe(false);
-        expect(onError).toHaveBeenCalledWith(expect.any(Error));
-    });
-    test("a new run clears the last error and result", async () => {
-        let fail = true;
-        const { result } = (0, react_1.renderHook)(() => (0, use_tool_1.useTool)(async () => {
-            if (fail)
-                throw new Error("nope");
-            return "ok";
-        }));
-        await (0, react_1.act)(async () => {
-            await result.current.run();
-        });
-        expect(result.current.error).toBeDefined();
-        fail = false;
-        const next = deferred();
-        (0, react_1.act)(() => {
-            void result.current.run().then(() => next.resolve());
-        });
-        expect(result.current.error).toBeUndefined();
-        expect(result.current.pending).toBe(true);
-        await (0, react_1.act)(async () => next.promise);
-        expect(result.current.result).toBe("ok");
-    });
-    test("overlapping runs: the state follows the latest, each run resolves its own result", async () => {
-        const slow = deferred();
-        const fast = deferred();
-        const answers = [slow, fast];
-        const onSuccess = jest.fn();
-        const { result } = (0, react_1.renderHook)(() => (0, use_tool_1.useTool)(() => answers.shift().promise, {
-            onSuccess,
-        }));
-        let first;
-        let second;
-        (0, react_1.act)(() => {
-            first = result.current.run();
-            second = result.current.run();
-        });
-        await (0, react_1.act)(async () => fast.resolve("fast"));
-        await expect(second).resolves.toBe("fast");
-        expect(result.current).toMatchObject({ pending: false, result: "fast" });
-        await (0, react_1.act)(async () => slow.resolve("slow"));
-        await expect(first).resolves.toBe("slow");
-        expect(result.current.result).toBe("fast");
-        expect(onSuccess.mock.calls.map(([value]) => value)).toEqual(["fast", "slow"]);
-    });
-    test("reset clears state but lets the pending call and callback finish", async () => {
-        const answer = deferred();
-        const onSuccess = jest.fn();
-        const { result } = (0, react_1.renderHook)(() => (0, use_tool_1.useTool)(() => answer.promise, { onSuccess }));
-        (0, react_1.act)(() => {
-            void result.current.run();
-        });
-        (0, react_1.act)(() => result.current.reset());
-        expect(result.current.pending).toBe(false);
-        await (0, react_1.act)(async () => answer.resolve("late"));
-        expect(result.current.result).toBeUndefined();
-        expect(onSuccess).toHaveBeenCalledWith("late");
-    });
-    test("run is stable and calls the latest function and callbacks", async () => {
-        const onSuccess = jest.fn();
-        const { result, rerender } = (0, react_1.renderHook)(({ label }) => (0, use_tool_1.useTool)(async () => label, { onSuccess: (value) => onSuccess(label, value) }), { initialProps: { label: "first" } });
-        const run = result.current.run;
-        rerender({ label: "second" });
-        expect(result.current.run).toBe(run);
-        await (0, react_1.act)(async () => {
-            await run();
-        });
-        expect(result.current.result).toBe("second");
-        expect(onSuccess).toHaveBeenCalledWith("second", "second");
-    });
-    test("nothing updates after unmount", async () => {
-        const answer = deferred();
-        const onSuccess = jest.fn();
-        const errors = jest.spyOn(console, "error").mockImplementation(() => { });
-        const { result, unmount } = (0, react_1.renderHook)(() => (0, use_tool_1.useTool)(() => answer.promise, { onSuccess }));
-        let running;
-        (0, react_1.act)(() => {
-            running = result.current.run();
-        });
-        unmount();
-        answer.resolve("done");
-        await expect(running).resolves.toBe("done");
-        expect(onSuccess).not.toHaveBeenCalled();
-        expect(errors).not.toHaveBeenCalled();
-        errors.mockRestore();
-    });
-    test("callback failures do not change the call's outcome or reject run", async () => {
-        const errors = jest.spyOn(console, "error").mockImplementation(() => { });
-        const onError = jest.fn(() => {
-            throw new Error("error callback failed");
-        });
-        const { result, rerender } = (0, react_1.renderHook)(({ fail }) => (0, use_tool_1.useTool)(async () => {
-            if (fail)
-                throw new Error("tool failed");
-            return "saved";
-        }, {
-            onSuccess: () => {
-                throw new Error("success callback failed");
-            },
-            onError,
-        }), { initialProps: { fail: false } });
-        await (0, react_1.act)(async () => {
-            await expect(result.current.run()).resolves.toBe("saved");
-        });
-        expect(result.current.result).toBe("saved");
-        expect(result.current.error).toBeUndefined();
-        expect(onError).not.toHaveBeenCalled();
-        rerender({ fail: true });
-        await (0, react_1.act)(async () => {
-            await expect(result.current.run()).resolves.toBeUndefined();
-        });
-        expect(result.current.error?.message).toBe("tool failed");
-        expect(errors).toHaveBeenCalledTimes(2);
-        errors.mockRestore();
-    });
-    test("observes rejected async callbacks and unprintable rejection values", async () => {
-        const errors = jest.spyOn(console, "error").mockImplementation(() => { });
-        const { result, rerender } = (0, react_1.renderHook)(({ fail }) => (0, use_tool_1.useTool)(async () => {
-            if (fail)
-                throw Object.create(null);
-            return "ok";
-        }, {
-            onSuccess: async () => {
-                throw new Error("async success callback");
-            },
-            onError: async () => {
-                throw new Error("async error callback");
-            },
-        }), { initialProps: { fail: false } });
-        await (0, react_1.act)(async () => {
-            await expect(result.current.run()).resolves.toBe("ok");
-        });
-        rerender({ fail: true });
-        await (0, react_1.act)(async () => {
-            await expect(result.current.run()).resolves.toBeUndefined();
-        });
-        expect(result.current.error).toBeInstanceOf(Error);
-        expect(errors).toHaveBeenCalledTimes(2);
-        errors.mockRestore();
-    });
-});

package/dist/host-shell/host-shell-consumer.test.d.ts

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

package/dist/host-shell/host-shell-consumer.test.js

@@ -1,28 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const mockTools = { open: jest.fn(), openInEditor: jest.fn() };
-jest.mock("@peers-app/peers-sdk", () => ({
-    getHostShellContractDefinition: () => ({ contractId: "host-shell" }),
-    hostContractConsumer: () => ({ get: async () => ({ tools: mockTools }), dispose: () => { } }),
-}));
-const host_shell_consumer_1 = require("./host-shell-consumer");
-const alert = jest.fn();
-beforeEach(() => {
-    Object.assign(window, { alert });
-    jest.spyOn(console, "error").mockImplementation(() => { });
-    mockTools.open.mockReset();
-    mockTools.openInEditor.mockReset();
-    alert.mockReset();
-});
-it("opens links and folders on the host", async () => {
-    await (0, host_shell_consumer_1.openOnHost)("https://peers.app");
-    expect(mockTools.open).toHaveBeenCalledWith({ target: "https://peers.app" });
-    await (0, host_shell_consumer_1.openInEditorOnHost)("~/peers/packages/desk");
-    expect(mockTools.openInEditor).toHaveBeenCalledWith({ path: "~/peers/packages/desk" });
-    expect(alert).not.toHaveBeenCalled();
-});
-it("shows why the host could not open something", async () => {
-    mockTools.open.mockRejectedValueOnce(new Error("open refuses git: links"));
-    await (0, host_shell_consumer_1.openOnHost)("git@github.com:me/pkg.git");
-    expect(alert).toHaveBeenCalledWith("Could not open git@github.com:me/pkg.git: open refuses git: links");
-});

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

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

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

@@ -1,86 +0,0 @@
-"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 identity_routes_1 = require("../screens/identity/identity-routes");
-const invite_capture_1 = require("../screens/invites/invite-capture");
-const root_layout_host_1 = require("./root-layout-host");
-const TOKEN = "eyJhbGciOiJub25lIn0-_abcdefghijklmnopqrstuvwxyz0123456789";
-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(),
-        }),
-        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("getSession")) {
-            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#invite=${TOKEN}`);
-        (0, react_1.fireEvent)(window, new HashChangeEvent("hashchange"));
-        expect(window.location.hash).toBe("");
-        expect((0, invite_capture_1.peekPendingInvite)()).toBe(TOKEN);
-        expect(globals_1.mainContentPath).toHaveBeenCalledWith(identity_routes_1.IDENTITY_ACCEPT_PATH);
-        expect(globals_1.mainContentPath).not.toHaveBeenCalledWith(expect.stringContaining(TOKEN));
-    });
-    it("ignores ordinary hash routes", () => {
-        (0, react_1.render)((0, jsx_runtime_1.jsx)(root_layout_host_1.RootLayoutHost, {}));
-        window.history.replaceState(null, "", "/?app#groups");
-        (0, react_1.fireEvent)(window, new HashChangeEvent("hashchange"));
-        expect(window.location.hash).toBe("#groups");
-        expect((0, invite_capture_1.peekPendingInvite)()).toBeUndefined();
-    });
-});

package/dist/screens/account/account-screen.test.d.ts

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

package/dist/screens/account/account-screen.test.js

@@ -1,51 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const jsx_runtime_1 = require("react/jsx-runtime");
-const react_1 = require("@testing-library/react");
-const account_screen_1 = require("./account-screen");
-jest.mock("../../components/tooltip", () => ({
-    Tooltip: () => null,
-}));
-jest.mock("../../hooks", () => ({
-    useObservable: (value) => value === "device-observable" ? ["device0000000000000000001"] : [undefined],
-    // One result for every usePromise on the screen. getKeyInfo reads previousPublicKeys
-    // and canRotate; the profile card reads the rest.
-    usePromise: () => ({
-        userId: "user00000000000000000001",
-        name: "Taylor Example",
-        publicKey: "public-signing-key",
-        publicBoxKey: "public-encryption-key",
-        previousPublicKeys: [],
-        canRotate: false,
-    }),
-}));
-jest.mock("../../peers-services-registration", () => ({
-    persistPeersServicesRegistration: jest.fn(),
-    registrationStatusPvar: "registration-observable",
-}));
-jest.mock("../device-pairing/identity-ipc", () => ({
-    identityTools: jest.fn(),
-}));
-jest.mock("@peers-app/peers-sdk", () => {
-    const actual = jest.requireActual("@peers-app/peers-sdk");
-    return {
-        ...actual,
-        copyToClipboard: jest.fn(async () => true),
-        getMe: jest.fn(),
-        thisDeviceId: "device-observable",
-    };
-});
-describe("AccountScreen", () => {
-    it("shows profile actions and copyable identity diagnostics", () => {
-        (0, react_1.render)((0, jsx_runtime_1.jsx)(account_screen_1.AccountScreen, {}));
-        expect(react_1.screen.getByText("Taylor Example")).toBeInTheDocument();
-        expect(react_1.screen.getByText("user00000000000000000001")).toBeInTheDocument();
-        expect(react_1.screen.getAllByText("public-signing-key")).toHaveLength(2);
-        expect(react_1.screen.getByText("public-encryption-key")).toBeInTheDocument();
-        expect(react_1.screen.getByText("device0000000000000000001")).toBeInTheDocument();
-        expect(react_1.screen.getByRole("link", { name: "Edit display name" })).toHaveAttribute("href", "#settings");
-        expect(react_1.screen.getByRole("link", { name: "Manage devices" })).toHaveAttribute("href", "#identity/devices");
-        expect(react_1.screen.getByRole("link", { name: "Add device" })).toHaveAttribute("href", "#identity/devices/pair");
-        expect(react_1.screen.getByRole("button", { name: "Copy User ID" })).toBeInTheDocument();
-    });
-});

package/dist/screens/assistants/assistant-config.test.d.ts

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

package/dist/screens/assistants/assistant-config.test.js

@@ -1,57 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const jsx_runtime_1 = require("react/jsx-runtime");
-const peers_sdk_1 = require("@peers-app/peers-sdk");
-const react_1 = require("@testing-library/react");
-const assistant_config_1 = require("./assistant-config");
-const mockRunners = [
-    { toolId: "selected", name: "Retired", catalogState: "quarantined" },
-    { toolId: "hidden", name: "Other unavailable", catalogState: "quarantined" },
-    { toolId: "available", name: "Available" },
-];
-const mockCatalog = jest.fn();
-jest.mock("@peers-app/peers-sdk", () => ({
-    ...jest.requireActual("@peers-app/peers-sdk"),
-    Tools: () => ({
-        get: async () => mockRunners[0],
-        list: async () => mockRunners,
-    }),
-}));
-jest.mock("../tools/tool-catalog-ipc", () => ({
-    getToolCatalogConsumer: () => mockCatalog(),
-}));
-jest.mock("../../components/io-schema-values", () => ({ IOSchemaValues: () => null }));
-test.each([
-    "catalog",
-    "browser fallback",
-])("runner selection retains a disabled current runner in %s", async (mode) => {
-    mockCatalog.mockReset();
-    if (mode === "catalog")
-        mockCatalog.mockResolvedValue({
-            tools: {
-                getTool: async ({ toolIdOrName }) => ({
-                    tool: { workflowInvocable: toolIdOrName === "available" },
-                }),
-            },
-        });
-    else
-        mockCatalog.mockRejectedValue(new Error("No host transport"));
-    const selected = (0, peers_sdk_1.observable)("selected");
-    const assistant = {
-        assistantRunnerToolId: "selected",
-        qs: { assistantRunnerToolId: selected },
-    };
-    const { container } = (0, react_1.render)((0, jsx_runtime_1.jsx)(assistant_config_1.AssistantConfig, { assistant: assistant }));
-    await react_1.screen.findByRole("button", { name: "Available" });
-    const retired = container.querySelector(".dropdown-menu button:disabled");
-    expect(retired).toHaveTextContent("Retired (unavailable)");
-    expect(container.querySelector(".dropdown-toggle")).toHaveTextContent("Retired (unavailable)");
-    expect(react_1.screen.queryByText("Other unavailable")).not.toBeInTheDocument();
-    if (!retired)
-        throw new Error("Missing unavailable runner option");
-    react_1.fireEvent.click(retired);
-    expect(selected()).toBe("selected");
-    react_1.fireEvent.click(react_1.screen.getByRole("button", { name: "Available" }));
-    await (0, react_1.waitFor)(() => expect(selected()).toBe("available"));
-    expect(react_1.screen.queryByText("Retired (unavailable)")).not.toBeInTheDocument();
-});

package/dist/screens/contacts/contact-list.test.d.ts

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

package/dist/screens/contacts/contact-list.test.js

@@ -1,48 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const jsx_runtime_1 = require("react/jsx-runtime");
-const peers_sdk_1 = require("@peers-app/peers-sdk");
-const react_1 = require("@testing-library/react");
-const contact_list_1 = require("./contact-list");
-jest.mock("../../globals", () => ({
-    mainContentPath: jest.fn(),
-}));
-jest.mock("../../hooks", () => ({
-    usePromise: jest.fn(),
-}));
-jest.mock("../../ui-router/ui-loader", () => ({
-    registerInternalPeersUI: jest.fn(),
-}));
-jest.mock("../identity/invite-contact-panel", () => ({
-    InviteContactPanel: () => null,
-}));
-jest.mock("../identity/profile-invite", () => ({
-    ProfileInviteSection: () => null,
-}));
-jest.mock("../invites/activity-view", () => ({
-    PendingWorkLink: () => null,
-}));
-const person = {
-    user: {
-        userId: "abcdefghijklmnopqrstuvwxy",
-        name: "Alex",
-        publicKey: "signing-key",
-        publicBoxKey: "box-key",
-    },
-    isContact: true,
-    trustLevel: peers_sdk_1.TrustLevel.Known,
-    sharedGroups: [{ groupId: "zyxwvutsrqponmlkjihgfedcb", name: "Neighbors" }],
-};
-describe("PersonRow", () => {
-    it("shows useful relationship context without exposing an ordinary user id", () => {
-        (0, react_1.render)((0, jsx_runtime_1.jsx)(contact_list_1.PersonRow, { row: person, duplicateName: false }));
-        expect(react_1.screen.getByText("Alex")).toBeInTheDocument();
-        expect(react_1.screen.getByText("Contact · Shared group: Neighbors")).toBeInTheDocument();
-        expect(react_1.screen.queryByText(person.user.userId)).not.toBeInTheDocument();
-        expect(react_1.screen.getByRole("link")).toHaveAttribute("href", `#identity/people/${person.user.userId}`);
-    });
-    it("adds only a short discriminator when names collide", () => {
-        (0, react_1.render)((0, jsx_runtime_1.jsx)(contact_list_1.PersonRow, { row: person, duplicateName: true }));
-        expect(react_1.screen.getByText(`…${person.user.userId.slice(-6)}`)).toBeInTheDocument();
-    });
-});

package/dist/screens/device-pairing/device-pairing.test.d.ts

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

package/dist/screens/device-pairing/device-pairing.test.js

@@ -1,119 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const jsx_runtime_1 = require("react/jsx-runtime");
-const react_1 = require("@testing-library/react");
-const device_pairing_1 = require("./device-pairing");
-const mockRpc = {
-    startSource: jest.fn(),
-    startDestination: jest.fn(),
-    approve: jest.fn(),
-    reject: jest.fn(),
-    cancel: jest.fn(),
-};
-let mockPairingState = { phase: "idle" };
-jest.mock("./identity-ipc", () => ({
-    identityTools: async () => mockRpc,
-}));
-jest.mock("./use-device-pairing-state", () => ({
-    useDevicePairingState: () => mockPairingState,
-}));
-describe("device pairing UI lifecycle", () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-        mockPairingState = { phase: "idle" };
-        mockRpc.cancel.mockResolvedValue({ phase: "idle" });
-    });
-    it("starts the destination on mount and cancels when it resolves after unmount", async () => {
-        let resolveStart;
-        mockRpc.startDestination.mockReturnValue(new Promise((resolve) => {
-            resolveStart = resolve;
-        }));
-        const view = (0, react_1.render)((0, jsx_runtime_1.jsx)(device_pairing_1.DestinationDevicePairing, { onBack: jest.fn() }));
-        await (0, react_1.waitFor)(() => expect(mockRpc.startDestination).toHaveBeenCalledWith({ deviceType: "browser" }));
-        view.unmount();
-        resolveStart({
-            sessionId: "00mh0wlipkdbeaw8tests0001",
-            role: "destination",
-            phase: "showing-code",
-            code: "7-aardvark-adroitness-absurd",
-        });
-        await (0, react_1.waitFor)(() => {
-            expect(mockRpc.cancel).toHaveBeenCalledWith({
-                sessionId: "00mh0wlipkdbeaw8tests0001",
-            });
-        });
-    });
-    it("shows the destination code and QR while waiting for a source", () => {
-        mockPairingState = {
-            sessionId: "00mh0wlipkdbeaw8tests0004",
-            role: "destination",
-            phase: "showing-code",
-            code: "7-aardvark-adroitness-absurd",
-            notice: "Pairing code did not match. Try the new code.",
-            expiresAt: Date.now() + 60_000,
-        };
-        mockRpc.startDestination.mockResolvedValue(mockPairingState);
-        const view = (0, react_1.render)((0, jsx_runtime_1.jsx)(device_pairing_1.DestinationDevicePairing, { onBack: jest.fn() }));
-        expect(view.getByLabelText("Pairing code")).toHaveTextContent("7-aardvark-adroitness-absurd");
-        expect(view.getByLabelText("Pairing code QR")).toBeInTheDocument();
-        expect(view.getByText("Pairing code did not match. Try the new code.")).toBeInTheDocument();
-    });
-    it("sends the typed code to the host and only approves from the source", async () => {
-        mockRpc.startSource.mockResolvedValue({
-            sessionId: "00mh0wlipkdbeaw8tests0002",
-            role: "source",
-            phase: "connecting",
-        });
-        const view = (0, react_1.render)((0, jsx_runtime_1.jsx)(device_pairing_1.SourceDevicePairing, { onClose: jest.fn() }));
-        react_1.fireEvent.change(view.getByLabelText("Pairing code"), {
-            target: { value: " 7 aardvark adroitness absurd " },
-        });
-        react_1.fireEvent.click(view.getByRole("button", { name: "Connect" }));
-        await (0, react_1.waitFor)(() => expect(mockRpc.startSource).toHaveBeenCalledWith({ code: "7 aardvark adroitness absurd" }));
-        mockPairingState = {
-            sessionId: "00mh0wlipkdbeaw8tests0002",
-            role: "source",
-            phase: "waiting-for-approval",
-            remoteDevice: { deviceName: "New phone", deviceType: "mobile" },
-        };
-        view.rerender((0, jsx_runtime_1.jsx)(device_pairing_1.SourceDevicePairing, { onClose: jest.fn() }));
-        expect(view.getByText("New phone (mobile)")).toBeInTheDocument();
-        react_1.fireEvent.click(view.getByRole("button", { name: "Approve" }));
-        await (0, react_1.waitFor)(() => expect(mockRpc.approve).toHaveBeenCalledWith({ sessionId: "00mh0wlipkdbeaw8tests0002" }));
-    });
-    it("keeps source cancellation available while transferring", async () => {
-        const onClose = jest.fn();
-        mockPairingState = {
-            sessionId: "00mh0wlipkdbeaw8tests0003",
-            role: "source",
-            phase: "transferring",
-        };
-        const view = (0, react_1.render)((0, jsx_runtime_1.jsx)(device_pairing_1.SourceDevicePairing, { onClose: onClose }));
-        react_1.fireEvent.click(view.getByRole("button", { name: "Cancel" }));
-        await (0, react_1.waitFor)(() => {
-            expect(mockRpc.cancel).toHaveBeenCalledWith({
-                sessionId: "00mh0wlipkdbeaw8tests0003",
-            });
-            expect(onClose).toHaveBeenCalled();
-        });
-    });
-    it("does not clear the destination success reload when Done unmounts the flow", () => {
-        jest.useFakeTimers();
-        mockPairingState = {
-            sessionId: "00mh0wlipkdbeaw8tests0005",
-            role: "destination",
-            phase: "complete",
-        };
-        mockRpc.startDestination.mockResolvedValue(mockPairingState);
-        const setTimeoutSpy = jest.spyOn(window, "setTimeout");
-        const clearTimeoutSpy = jest.spyOn(window, "clearTimeout");
-        const view = (0, react_1.render)((0, jsx_runtime_1.jsx)(device_pairing_1.DestinationDevicePairing, { onBack: jest.fn() }));
-        const reloadTimer = setTimeoutSpy.mock.calls.find(([, delay]) => delay === 750);
-        expect(reloadTimer).toBeDefined();
-        view.unmount();
-        expect(clearTimeoutSpy).not.toHaveBeenCalled();
-        setTimeoutSpy.mockRestore();
-        clearTimeoutSpy.mockRestore();
-        jest.useRealTimers();
-    });
-});

package/dist/screens/devices/devices-list.test.d.ts

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

package/dist/screens/devices/devices-list.test.js

@@ -1,53 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const jsx_runtime_1 = require("react/jsx-runtime");
-const peers_sdk_1 = require("@peers-app/peers-sdk");
-const react_1 = require("@testing-library/react");
-const devices_list_1 = require("./devices-list");
-jest.mock("../../globals", () => ({
-    mainContentPath: jest.fn(),
-}));
-jest.mock("../../hooks", () => ({
-    useObservable: jest.fn(),
-    useObservableState: jest.fn(),
-    usePromise: jest.fn(),
-}));
-jest.mock("../device-pairing", () => ({
-    SourceDevicePairing: () => null,
-}));
-jest.mock("../invites/activity-view", () => ({
-    PendingWorkLink: () => null,
-}));
-jest.mock("../network-viewer/network-viewer-ipc", () => ({
-    getNetworkControlConsumer: jest.fn(),
-    getNetworkDiagnosticsConsumer: jest.fn(),
-}));
-function device(deviceId, userId, name) {
-    return {
-        deviceId,
-        userId,
-        name,
-        firstSeen: new Date("2026-01-01T00:00:00Z"),
-        lastSeen: new Date(),
-        trustLevel: peers_sdk_1.TrustLevel.Trusted,
-    };
-}
-describe("Devices identity list", () => {
-    it("filters out devices owned by other users", () => {
-        const mine = device("abcdefghijklmnopqrstuvwxy", "mine000000000000000000001", "Laptop");
-        const theirs = device("zyxwvutsrqponmlkjihgfedcb", "theirs000000000000000001", "Other");
-        expect((0, devices_list_1.devicesForUser)([mine, theirs], mine.userId)).toEqual([mine]);
-    });
-    it("shows the current-device and connection context without a destructive row action", () => {
-        const mine = device("abcdefghijklmnopqrstuvwxy", "mine000000000000000000001", "Laptop");
-        (0, react_1.render)((0, jsx_runtime_1.jsx)(devices_list_1.DeviceRow, { device: mine, isThisDevice: true, connection: {
-                deviceId: mine.deviceId,
-                connectionState: "connected",
-                pathType: "direct",
-            } }));
-        expect(react_1.screen.getByText("Laptop")).toBeInTheDocument();
-        expect(react_1.screen.getByText("This device")).toBeInTheDocument();
-        expect(react_1.screen.getByText("Online")).toBeInTheDocument();
-        expect(react_1.screen.queryByRole("button", { name: /Forget/i })).not.toBeInTheDocument();
-    });
-});

package/dist/screens/groups/group-list.test.d.ts

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