@peers-app/peers-ui 0.27.3 → 0.27.5

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

@@ -1,175 +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 use_rows_1 = require("./use-rows");
-/** A table whose reads are answered by the test, one at a time. */
-function fakeTable(answer) {
-    const listeners = new Set();
-    const reads = [];
-    const table = {
-        list: jest.fn(async (filter) => {
-            reads.push(filter);
-            return answer(filter);
-        }),
-        dataChanged: {
-            subscribe: (handler, options) => {
-                const listener = { handler: () => handler({}), options };
-                listeners.add(listener);
-                return { unsubscribe: () => listeners.delete(listener) };
-            },
-        },
-    };
-    return {
-        table,
-        reads,
-        listeners,
-        change: () => {
-            for (const listener of listeners)
-                listener.handler();
-        },
-        reconnect: () => {
-            for (const listener of listeners)
-                listener.options?.onReconnect?.();
-        },
-    };
-}
-function Rows({ table, filter }) {
-    const { rows, loading, error } = (0, use_rows_1.useRows)(table, filter);
-    return ((0, jsx_runtime_1.jsxs)("div", { children: [(0, jsx_runtime_1.jsx)("span", { "data-testid": "rows", children: rows.map((row) => row.id).join(",") }), (0, jsx_runtime_1.jsx)("span", { "data-testid": "loading", children: String(loading) }), (0, jsx_runtime_1.jsx)("span", { "data-testid": "error", children: error?.message ?? "" })] }));
-}
-const text = (id) => react_1.screen.getByTestId(id).textContent;
-describe("useRows", () => {
-    test("reads on mount and again when the table changes", async () => {
-        let rows = [{ id: "a" }];
-        const fake = fakeTable(() => rows);
-        (0, react_1.render)((0, jsx_runtime_1.jsx)(Rows, { table: fake.table }));
-        expect(text("loading")).toBe("true");
-        await (0, react_1.waitFor)(() => expect(text("rows")).toBe("a"));
-        expect(text("loading")).toBe("false");
-        rows = [{ id: "a" }, { id: "b" }];
-        (0, react_1.act)(() => fake.change());
-        await (0, react_1.waitFor)(() => expect(text("rows")).toBe("a,b"));
-    });
-    test("changes during a read cause one more read, not one per change", async () => {
-        let release;
-        let n = 0;
-        const fake = fakeTable(() => new Promise((resolve) => {
-            const id = String(++n);
-            release = () => resolve([{ id }]);
-        }));
-        (0, react_1.render)((0, jsx_runtime_1.jsx)(Rows, { table: fake.table }));
-        await (0, react_1.waitFor)(() => expect(fake.reads).toHaveLength(1));
-        (0, react_1.act)(() => {
-            fake.change();
-            fake.change();
-            fake.change();
-        });
-        await (0, react_1.act)(async () => release?.());
-        await (0, react_1.waitFor)(() => expect(fake.reads).toHaveLength(2));
-        await (0, react_1.act)(async () => release?.());
-        await (0, react_1.waitFor)(() => expect(text("rows")).toBe("2"));
-        expect(fake.reads).toHaveLength(2);
-    });
-    test("reads again after a reconnect", async () => {
-        let rows = [{ id: "a" }];
-        const fake = fakeTable(() => rows);
-        (0, react_1.render)((0, jsx_runtime_1.jsx)(Rows, { table: fake.table }));
-        await (0, react_1.waitFor)(() => expect(text("rows")).toBe("a"));
-        rows = [{ id: "missed" }];
-        (0, react_1.act)(() => fake.reconnect());
-        await (0, react_1.waitFor)(() => expect(text("rows")).toBe("missed"));
-    });
-    test("reports a failed read and keeps the last rows", async () => {
-        let fail = false;
-        const fake = fakeTable(() => {
-            if (fail)
-                throw new Error("host is down");
-            return [{ id: "a" }];
-        });
-        (0, react_1.render)((0, jsx_runtime_1.jsx)(Rows, { table: fake.table }));
-        await (0, react_1.waitFor)(() => expect(text("rows")).toBe("a"));
-        fail = true;
-        (0, react_1.act)(() => fake.change());
-        await (0, react_1.waitFor)(() => expect(text("error")).toBe("host is down"));
-        expect(text("rows")).toBe("a");
-        fail = false;
-        (0, react_1.act)(() => fake.change());
-        await (0, react_1.waitFor)(() => expect(text("error")).toBe(""));
-    });
-    test("reads again when the filter changes, and unsubscribes on unmount", async () => {
-        const fake = fakeTable((filter) => [{ id: JSON.stringify(filter) }]);
-        const { rerender, unmount } = (0, react_1.render)((0, jsx_runtime_1.jsx)(Rows, { table: fake.table, filter: { id: "x" } }));
-        await (0, react_1.waitFor)(() => expect(text("rows")).toBe('{"id":"x"}'));
-        // An equal filter in a new object doesn't read again.
-        rerender((0, jsx_runtime_1.jsx)(Rows, { table: fake.table, filter: { id: "x" } }));
-        rerender((0, jsx_runtime_1.jsx)(Rows, { table: fake.table, filter: { id: "y" } }));
-        await (0, react_1.waitFor)(() => expect(text("rows")).toBe('{"id":"y"}'));
-        expect(fake.reads).toEqual([{ id: "x" }, { id: "y" }]);
-        expect(fake.listeners.size).toBe(1);
-        unmount();
-        expect(fake.listeners.size).toBe(0);
-    });
-    test("reads again once an asynchronous subscription is live", async () => {
-        let rows = [{ id: "before" }];
-        const fake = fakeTable(() => rows);
-        let release;
-        const ready = new Promise((resolve) => {
-            release = resolve;
-        });
-        const subscribe = fake.table.dataChanged.subscribe;
-        fake.table.dataChanged.subscribe = (handler, options) => ({
-            ...subscribe(handler, options),
-            ready,
-        });
-        (0, react_1.render)((0, jsx_runtime_1.jsx)(Rows, { table: fake.table }));
-        await (0, react_1.waitFor)(() => expect(text("rows")).toBe("before"));
-        // No notification can be delivered while the remote subscription is still attaching.
-        rows = [{ id: "during setup" }];
-        await (0, react_1.act)(async () => release(true));
-        await (0, react_1.waitFor)(() => expect(text("rows")).toBe("during setup"));
-    });
-    test("a synchronous list failure can be retried", async () => {
-        const fake = fakeTable(() => [{ id: "recovered" }]);
-        const list = fake.table.list;
-        fake.table.list = jest.fn(() => {
-            throw new Error("offline");
-        });
-        (0, react_1.render)((0, jsx_runtime_1.jsx)(Rows, { table: fake.table }));
-        await (0, react_1.waitFor)(() => expect(text("error")).toBe("offline"));
-        fake.table.list = list;
-        (0, react_1.act)(() => fake.change());
-        await (0, react_1.waitFor)(() => expect(text("rows")).toBe("recovered"));
-    });
-    test("reload retries a failed subscription", async () => {
-        const fake = fakeTable(() => [{ id: "recovered" }]);
-        const subscribe = fake.table.dataChanged.subscribe;
-        fake.table.dataChanged.subscribe = () => {
-            throw new Error("subscription unavailable");
-        };
-        const { result } = (0, react_1.renderHook)(() => (0, use_rows_1.useRows)(fake.table));
-        await (0, react_1.waitFor)(() => expect(result.current.error?.message).toBe("subscription unavailable"));
-        fake.table.dataChanged.subscribe = subscribe;
-        await (0, react_1.act)(async () => result.current.reload());
-        expect(result.current.rows).toEqual([{ id: "recovered" }]);
-        expect(result.current.error).toBeUndefined();
-        expect(fake.listeners.size).toBe(1);
-    });
-    test("reload resolves once the rows are current", async () => {
-        let rows = [{ id: "a" }];
-        const fake = fakeTable(() => rows);
-        let reload;
-        function Reloading() {
-            const result = (0, use_rows_1.useRows)(fake.table);
-            reload = result.reload;
-            return (0, jsx_runtime_1.jsx)("span", { "data-testid": "rows", children: result.rows.map((row) => row.id).join(",") });
-        }
-        (0, react_1.render)((0, jsx_runtime_1.jsx)(Reloading, {}));
-        await (0, react_1.waitFor)(() => expect(text("rows")).toBe("a"));
-        rows = [{ id: "b" }];
-        await (0, react_1.act)(async () => {
-            await reload?.();
-        });
-        expect(text("rows")).toBe("b");
-    });
-});

package/dist/hooks/use-tool.test.d.ts

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

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 {};