@q9labsai/chalk-react-native 4.1.12 → 4.1.13

package/src/components/Chalk.test.tsx

@@ -1,223 +0,0 @@
-// @vitest-environment happy-dom
-import type { SpaceClient, SpaceSnapshot } from "@q9labsai/chalk-client";
-import { createRequire } from "node:module";
-import { join } from "node:path";
-import type { ReactNode } from "react";
-import { afterEach, describe, expect, it, vi } from "vitest";
-
-const testingLibrary = createRequire(import.meta.url)(join(process.cwd(), "../react/node_modules", "@testing-library/react")) as {
-  readonly act: (callback: () => void | Promise<void>) => void | Promise<void>;
-  readonly cleanup: () => void;
-  readonly render: (element: ReactNode) => { readonly container: HTMLElement; readonly unmount: () => void; readonly rerender: (element: ReactNode) => void };
-};
-const { act, cleanup, render } = testingLibrary;
-
-const nativeClientFactory = vi.hoisted(() => vi.fn());
-const spaceViewSpy = vi.hoisted(() => vi.fn(() => <div data-testid="space" />));
-
-vi.mock("react-native", () => ({
-  StyleSheet: { create: <T,>(styles: T) => styles },
-  View: ({ children }: { readonly children?: ReactNode }) => children,
-  Text: ({ children }: { readonly children?: ReactNode }) => children,
-  Pressable: ({ children }: { readonly children?: ReactNode }) => children,
-}));
-vi.mock("../space-client/create-native-space-client", () => ({ createNativeSpaceClient: nativeClientFactory }));
-vi.mock("./SpaceView", () => ({ SpaceView: spaceViewSpy }));
-vi.mock("./Entrance", () => ({ Entrance: () => <div data-testid="entrance" /> }));
-
-import { Chalk } from "./Chalk";
-
-afterEach(() => {
-  cleanup();
-  nativeClientFactory.mockReset();
-  spaceViewSpy.mockClear();
-});
-
-describe("Chalk", () => {
-  it("fires joined and left only for the specified connection transitions", () => {
-    const client = createClient("joining");
-    const onJoined = vi.fn();
-    const onLeft = vi.fn();
-    render(<Chalk client={client.client} entrance={false} onJoined={onJoined} onLeft={onLeft} />);
-
-    act(() => client.setStatus("live"));
-    act(() => client.setStatus("reconnecting"));
-    act(() => client.setStatus("live"));
-    act(() => client.setStatus("left"));
-
-    expect(onJoined).toHaveBeenCalledTimes(1);
-    expect(onLeft).toHaveBeenCalledTimes(1);
-  });
-
-  it("does not fire joined for an already-live supplied client", () => {
-    const client = createClient("live");
-    const onJoined = vi.fn();
-    render(<Chalk client={client.client} entrance={false} onJoined={onJoined} />);
-
-    expect(onJoined).not.toHaveBeenCalled();
-  });
-
-  it("forwards the optional diagnostics action to the live Space", () => {
-    const client = createClient("live");
-    const onOpenDiagnostics = vi.fn();
-    render(<Chalk client={client.client} onOpenDiagnostics={onOpenDiagnostics} />);
-
-    expect(spaceViewSpy).toHaveBeenCalledWith(expect.objectContaining({ onOpenDiagnostics }), undefined);
-  });
-
-  it("forwards canonical client events and cleans their subscriptions up", () => {
-    const client = createClient("live");
-    const handlers = new Map<string, (event: unknown) => void>();
-    const unsubscribe = vi.fn();
-    const eventClient = client.client as { on: (event: string, handler: unknown) => () => void };
-    eventClient.on = vi.fn((event, handler) => {
-      handlers.set(event, handler as (event: unknown) => void);
-      return unsubscribe;
-    });
-    const onError = vi.fn();
-    const view = render(<Chalk client={client.client} onEpisodeEnded={vi.fn()} onError={onError} onParticipantJoined={vi.fn()} onParticipantLeft={vi.fn()} onScreenShareStarted={vi.fn()} onScreenShareStopped={vi.fn()} />);
-
-    const error = { error: { code: "client.internal_error", message: "test", recoverable: true } };
-    handlers.get("error")?.(error);
-    expect(onError).toHaveBeenCalledWith(error);
-
-    view.unmount();
-    expect(unsubscribe).toHaveBeenCalledTimes(6);
-  });
-
-  it("leaves an owned client before disposing it on unmount", async () => {
-    const client = createClient("joining");
-    let resolveLeave: (() => void) | undefined;
-    client.client.leave = vi.fn(
-      () =>
-        new Promise<void>((resolve) => {
-          resolveLeave = resolve;
-        }),
-    );
-    nativeClientFactory.mockReturnValue(client.client);
-
-    const view = render(<Chalk entrance={false} getAccess={vi.fn()} space="space-1" />);
-    view.unmount();
-
-    expect(client.client.leave).toHaveBeenCalledTimes(1);
-    expect(client.client.dispose).not.toHaveBeenCalled();
-    await act(async () => resolveLeave?.());
-    expect(client.client.dispose).toHaveBeenCalledTimes(1);
-  });
-
-  it("keeps an owned SpaceClient when getAccess changes identity and uses the latest callback", async () => {
-    const client = createClient("idle");
-    const firstAccess = vi.fn(async () => ({ token: "first" }));
-    const latestAccess = vi.fn(async () => ({ token: "latest" }));
-    nativeClientFactory.mockReturnValue(client.client);
-
-    const view = render(<Chalk entrance getAccess={firstAccess} space="space-1" />);
-    view.rerender(<Chalk entrance getAccess={latestAccess} space="space-1" />);
-
-    expect(nativeClientFactory).toHaveBeenCalledTimes(1);
-    const access = nativeClientFactory.mock.calls[0]?.[0].getAccess as (input: unknown) => Promise<unknown>;
-    await expect(access({})).resolves.toEqual({ token: "latest" });
-    expect(firstAccess).not.toHaveBeenCalled();
-    expect(latestAccess).toHaveBeenCalledTimes(1);
-  });
-
-  it("omits an absent display name when joining without Entrance", async () => {
-    const client = createClient("idle");
-    render(<Chalk client={client.client} entrance={false} />);
-
-    await act(async () => undefined);
-    expect(client.client.join).toHaveBeenCalledWith({ microphone: true, camera: true });
-  });
-
-  it("retries automatic join when an owned client is replaced for a new Space", async () => {
-    const first = createClient("idle");
-    const replacement = createClient("idle");
-    nativeClientFactory.mockReturnValueOnce(first.client).mockReturnValueOnce(replacement.client);
-
-    const view = render(<Chalk entrance={false} getAccess={vi.fn()} space="space-1" />);
-    await act(async () => undefined);
-    expect(first.client.join).toHaveBeenCalledWith({ microphone: true, camera: true });
-
-    view.rerender(<Chalk entrance={false} getAccess={vi.fn()} space="space-2" />);
-    await act(async () => undefined);
-
-    expect(nativeClientFactory).toHaveBeenCalledTimes(2);
-    expect(replacement.client.join).toHaveBeenCalledWith({ microphone: true, camera: true });
-  });
-
-  it("treats a replacement client's initial failure as an Entrance failure", () => {
-    const first = createClient("live");
-    const replacement = createClient("failed");
-    nativeClientFactory.mockReturnValueOnce(first.client).mockReturnValueOnce(replacement.client);
-
-    const view = render(<Chalk entrance getAccess={vi.fn()} space="space-1" />);
-    view.rerender(<Chalk entrance getAccess={vi.fn()} space="space-2" />);
-
-    expect(view.container.querySelector('[data-testid="entrance"]')).not.toBeNull();
-  });
-
-  it("keeps the active Space visible during reconnecting and never after left", () => {
-    const client = createClient("live");
-    const view = render(<Chalk client={client.client} />);
-
-    expect(view.container.querySelector('[data-testid="space"]')).not.toBeNull();
-    act(() => client.setStatus("reconnecting"));
-    expect(view.container.querySelector('[data-testid="space"]')).not.toBeNull();
-    act(() => client.setStatus("left"));
-    expect(view.container.querySelector('[data-testid="space"]')).toBeNull();
-    expect(view.container.textContent).toContain("You have left this Space.");
-  });
-});
-
-function createClient(status: SpaceSnapshot["connection"]["status"]): { readonly client: SpaceClient; readonly setStatus: (nextStatus: SpaceSnapshot["connection"]["status"]) => void } {
-  let snapshot = createSnapshot(status);
-  const listeners = new Set<() => void>();
-  const client = {
-    getSnapshot: () => snapshot,
-    subscribe: (listener: () => void) => {
-      listeners.add(listener);
-      return () => listeners.delete(listener);
-    },
-    on: vi.fn(() => () => undefined),
-    join: vi.fn(async () => undefined),
-    leave: vi.fn(async () => undefined),
-    dispose: vi.fn(),
-    endEpisode: vi.fn(async () => undefined),
-    media: {},
-    chat: {},
-    participants: {},
-    reactions: {},
-    whiteboard: {},
-  } as unknown as SpaceClient;
-  return {
-    client,
-    setStatus(nextStatus) {
-      snapshot = { ...snapshot, connection: { ...snapshot.connection, status: nextStatus } };
-      listeners.forEach((listener) => listener());
-    },
-  };
-}
-
-function createSnapshot(status: SpaceSnapshot["connection"]["status"]): SpaceSnapshot {
-  const capabilities = [] as const;
-  return {
-    connection: { status, episode: null, lastError: null },
-    self: { participantId: null, displayName: null, role: null, capabilities, handRaised: false, can: () => false },
-    participants: { roster: [], admissionQueue: [] },
-    media: {
-      devices: { microphones: [], cameras: [], speakers: [] },
-      selection: { microphone: null, camera: null, speaker: null },
-      local: {
-        microphone: { source: "microphone", state: "disabled", track: null },
-        camera: { source: "camera", state: "disabled", track: null },
-        screen: { source: "screen", state: "disabled", track: null },
-      },
-      remote: [],
-      screenShare: { source: "screen", state: "disabled", track: null },
-      incomingRequests: [],
-    },
-    chat: { status: "idle", messages: [], pendingSends: [], readReceipts: [], unreadCount: 0, pagination: { cursor: null, hasOlder: false, historyTruncated: false }, lastError: null },
-    reactions: { active: [] },
-    whiteboard: { open: false, engine: { status: "unsubscribed", sceneId: null, revision: null, presenting: false, error: null } },
-  };
-}

package/src/components/EmbeddedWhiteboard.test.tsx

@@ -1,92 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-
-const nativeTheme = vi.hoisted(() => ({
-  colorScheme: "light" as const,
-  colors: {
-    dangerSurfaceOverlay94: "#danger",
-    info: "#info",
-    lightMutedText: "#muted",
-    lightSubtleText: "#subtle",
-    lightSurface: "#surface",
-    lightText: "#text",
-    onDark: "#on-dark",
-  },
-}));
-const controllerOptions = vi.hoisted(() => [] as unknown[]);
-
-vi.mock("react", () => ({
-  useCallback: <T,>(callback: T) => callback,
-  useEffect: (effect: () => void) => effect(),
-  useMemo: <T,>(factory: () => T) => factory(),
-  useRef: <T,>(current: T) => ({ current }),
-  useState: <T,>(initial: T | (() => T)): readonly [T, () => void] => [typeof initial === "function" ? (initial as () => T)() : initial, () => undefined],
-}));
-vi.mock("@q9labsai/chalk-whiteboard/embedded", () => ({
-  ChalkWhiteboardController: class {
-    constructor(options: unknown) {
-      controllerOptions.push(options);
-    }
-
-    rendererReloaded(): void {}
-
-    setCapabilities(): void {}
-
-    setViewport(): void {}
-
-    start(): void {}
-
-    stop(): void {}
-  },
-}));
-vi.mock("react-native", () => ({
-  ActivityIndicator: "ActivityIndicator",
-  Pressable: "Pressable",
-  StyleSheet: { create: <Styles,>(styles: Styles) => styles },
-  Text: "Text",
-  View: "View",
-  useWindowDimensions: () => ({ width: 320, height: 640, scale: 2 }),
-}));
-vi.mock("react-native-webview", () => ({ default: "WebView" }));
-vi.mock("../ui/native-theme", () => ({ useNativeTheme: () => nativeTheme }));
-vi.mock("../whiteboard/embedded-whiteboard-assets", () => ({
-  isEmbeddedWhiteboardNavigationAllowed: () => true,
-  rendererURLWithContext: (url: string) => url,
-  resolveEmbeddedWhiteboardRendererURL: async () => "file:///android_asset/chalk-whiteboard/index.html",
-}));
-
-import type { ChalkEmbeddedWhiteboardTransport } from "@q9labsai/chalk-whiteboard/embedded";
-import { EmbeddedWhiteboard, embeddedWhiteboardWebViewSecurityPolicy } from "./EmbeddedWhiteboard";
-
-describe("EmbeddedWhiteboard WebView policy", () => {
-  it("keeps the offline renderer isolated from files, networks, storage, and cookies", () => {
-    expect(embeddedWhiteboardWebViewSecurityPolicy).toEqual({
-      allowFileAccess: true,
-      allowFileAccessFromFileURLs: false,
-      allowUniversalAccessFromFileURLs: false,
-      cacheEnabled: false,
-      domStorageEnabled: false,
-      javaScriptCanOpenWindowsAutomatically: false,
-      javaScriptEnabled: true,
-      mixedContentMode: "never",
-      setSupportMultipleWindows: false,
-      sharedCookiesEnabled: false,
-      thirdPartyCookiesEnabled: false,
-    });
-  });
-
-  it("uses the active NativeTheme colors throughout its loading surface", () => {
-    controllerOptions.length = 0;
-    const rendered = EmbeddedWhiteboard({
-      canClear: false,
-      canDraw: true,
-      journeyId: "journey-test",
-      transport: {} as ChalkEmbeddedWhiteboardTransport,
-    });
-    const children = rendered.props.children as readonly [{ readonly props: { readonly color: string } }, { readonly props: { readonly style: readonly unknown[] } }];
-
-    expect(rendered.props.style).toContainEqual({ backgroundColor: "#surface" });
-    expect(children[0]?.props.color).toBe("#info");
-    expect(children[1]?.props.style).toContainEqual({ color: "#muted" });
-    expect(controllerOptions[0]).toMatchObject({ theme: "light" });
-  });
-});

package/src/components/Entrance.test.tsx

@@ -1,26 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-
-vi.mock("./EntranceView", () => ({ EntranceView: "EntranceView" }));
-vi.mock("./logo/Logo", () => ({ Logo: "Logo" }));
-vi.mock("react-native", () => ({ Image: "Image" }));
-
-import { Entrance } from "./Entrance";
-
-describe("Entrance", () => {
-  it("exposes the preparation component", () => {
-    expect(Entrance).toBeTypeOf("function");
-  });
-
-  it("forwards the public cancel callback to the native Entrance view", () => {
-    const onCancel = vi.fn();
-    const element = Entrance({ onCancel, onJoin: vi.fn(), spaceName: "Space" });
-
-    expect(element.props.onCancel).toBe(onCancel);
-  });
-
-  it("uses the SDK wordmark when no custom logo URL is supplied", () => {
-    const element = Entrance({ onJoin: vi.fn(), spaceName: "Space" });
-
-    expect(element.props.logo).toMatchObject({ type: "Logo", props: { height: 32, variant: "wordmark" } });
-  });
-});

package/src/components/EntranceView.android.test.tsx

@@ -1,100 +0,0 @@
-import { isValidElement, type ReactElement, type ReactNode } from "react";
-import { describe, expect, it, vi } from "vitest";
-
-const controller = vi.hoisted(() => ({
-  displayName: "Ada",
-  audioEnabled: true,
-  videoEnabled: true,
-  isSubmitting: false,
-  isInputFocused: false,
-  previewError: null,
-  previewStream: null,
-  simulatorMediaDisabled: false,
-  setDisplayName: vi.fn(),
-  setInputFocused: vi.fn(),
-  toggleAudio: vi.fn(),
-  toggleVideo: vi.fn(),
-  handleJoin: vi.fn(),
-}));
-
-const theme = vi.hoisted(() => ({
-  colors: {
-    background: "#101112",
-    foreground: "#f7f8f9",
-    primary: "#12ab89",
-    primaryForeground: "#ffffff",
-    muted: "#343536",
-    mutedForeground: "#909192",
-    error: "#dc2626",
-    card: "#202122",
-    surface: "#303132",
-    raisedSurface: "#404142",
-    insetSurface: "#505152",
-    controlsBackground: "#606162",
-    border: "#707172",
-    ring: "#808182",
-    darkCanvas: "#010203",
-  },
-}));
-
-vi.mock("react-native", () => ({
-  KeyboardAvoidingView: "KeyboardAvoidingView",
-  Platform: { OS: "android" },
-  Pressable: "Pressable",
-  StyleSheet: { absoluteFillObject: {}, create: <T,>(styles: T) => styles },
-  Text: "Text",
-  TextInput: "TextInput",
-  View: "View",
-}));
-vi.mock("@hugeicons/react-native", () => ({ HugeiconsIcon: "HugeiconsIcon" }));
-vi.mock("../media/native-webrtc", () => ({ RTCView: "RTCView" }));
-vi.mock("../ui/native-theme", () => ({ useNativeTheme: () => theme }));
-vi.mock("./FaceAvatar", () => ({ FaceAvatar: "FaceAvatar" }));
-vi.mock("./native-entrance/useEntranceController", () => ({ useEntranceController: () => controller }));
-
-import { EntranceViewAndroid } from "./EntranceView.android";
-
-describe("EntranceViewAndroid", () => {
-  it("applies the active theme to its native surface and media controls", () => {
-    const entrance = EntranceViewAndroid({ onJoin: vi.fn(), spaceName: "Design review" });
-    const screen = findElements(entrance, (element) => element.type === "KeyboardAvoidingView")[0];
-    const mediaControl = findElements(entrance, (element) => element.type === "Pressable" && !element.props.accessibilityLabel)[0];
-    const mediaStyle = mediaControl?.props.style as ((state: { readonly pressed: boolean }) => unknown) | undefined;
-
-    expect(JSON.stringify(screen?.props.style)).toContain(theme.colors.background);
-    expect(JSON.stringify(mediaStyle?.({ pressed: false }))).toContain(theme.colors.controlsBackground);
-  });
-
-  it("omits the Android cancel control when no cancellation handler is supplied", () => {
-    const withoutCancel = EntranceViewAndroid({ onJoin: vi.fn(), spaceName: "Design review" });
-    const withCancel = EntranceViewAndroid({ onCancel: vi.fn(), onJoin: vi.fn(), spaceName: "Design review" });
-
-    expect(findElements(withoutCancel, (element) => element.props.accessibilityLabel === "Cancel and leave Entrance")).toHaveLength(0);
-    expect(findElements(withCancel, (element) => element.props.accessibilityLabel === "Cancel and leave Entrance")).toHaveLength(1);
-  });
-});
-
-interface NativeElementProps {
-  readonly accessibilityLabel?: string;
-  readonly children?: ReactNode;
-  readonly style?: unknown;
-}
-
-function findElements(node: ReactNode, matches: (element: ReactElement<NativeElementProps>) => boolean): ReactElement<NativeElementProps>[] {
-  const found: ReactElement<NativeElementProps>[] = [];
-  if (!isValidElement<NativeElementProps>(node)) {
-    return found;
-  }
-
-  if (matches(node)) {
-    found.push(node);
-  }
-
-  const children = node.props.children;
-  for (const child of Array.isArray(children) ? children : [children]) {
-    if (child !== undefined && child !== null) {
-      found.push(...findElements(child, matches));
-    }
-  }
-  return found;
-}

package/src/components/EntranceView.ios-pad.test.tsx

@@ -1,160 +0,0 @@
-// @vitest-environment happy-dom
-import type { ReactElement, ReactNode } from "react";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-import { renderHook } from "../test-support/test-renderer";
-
-const controller = vi.hoisted(() => ({
-  displayName: "Ada",
-  audioEnabled: true,
-  videoEnabled: true,
-  isSubmitting: false,
-  isInputFocused: false,
-  previewError: null,
-  previewStream: null,
-  simulatorMediaDisabled: false,
-  setDisplayName: vi.fn(),
-  setInputFocused: vi.fn(),
-  toggleAudio: vi.fn(),
-  toggleVideo: vi.fn(),
-  handleJoin: vi.fn(),
-}));
-
-const theme = vi.hoisted(() => ({
-  colors: {
-    background: "#101112",
-    foreground: "#f7f8f9",
-    primary: "#12ab89",
-    primaryForeground: "#ffffff",
-    mutedForeground: "#909192",
-    error: "#dc2626",
-    card: "#202122",
-    surface: "#303132",
-    border: "#707172",
-    ring: "#808182",
-    darkCanvas: "#010203",
-    controlsBackground: "#606162",
-  },
-}));
-
-vi.mock("react-native", () => {
-  class AnimatedValue {
-    interpolate(input: unknown): { readonly input: unknown } {
-      return { input };
-    }
-  }
-
-  return {
-    ActivityIndicator: "ActivityIndicator",
-    Animated: {
-      Value: AnimatedValue,
-      View: "Animated.View",
-      delay: vi.fn(),
-      loop: vi.fn(),
-      sequence: vi.fn(),
-      spring: vi.fn(),
-      stagger: vi.fn(),
-      timing: vi.fn(),
-    },
-    KeyboardAvoidingView: "KeyboardAvoidingView",
-    Platform: { OS: "ios" },
-    Pressable: "Pressable",
-    StyleSheet: { absoluteFillObject: {}, create: <T,>(styles: T) => styles },
-    Text: "Text",
-    TextInput: "TextInput",
-    View: "View",
-  };
-});
-vi.mock("@hugeicons/react-native", () => ({ HugeiconsIcon: "HugeiconsIcon" }));
-vi.mock("./FaceAvatar", () => ({ FaceAvatar: "FaceAvatar" }));
-vi.mock("./RtcVideoView", () => ({ RtcVideoView: "RtcVideoView", hasRtcVideoView: () => false }));
-vi.mock("../ui/native-theme", () => ({ useNativeTheme: () => theme }));
-vi.mock("../utils/ios-simulator", () => ({ getIosSimulatorMediaMessage: () => "Media is unavailable in the simulator." }));
-vi.mock("./native-animation-controller", () => ({ createAnimationRefController: () => () => undefined }));
-vi.mock("./native-entrance/useEntranceController", () => ({ useEntranceController: () => controller }));
-
-import { EntranceViewIosPad } from "./EntranceView.ios-pad";
-
-beforeEach(() => {
-  controller.displayName = "Ada";
-  controller.audioEnabled = true;
-  controller.videoEnabled = true;
-  controller.isSubmitting = false;
-  controller.isInputFocused = false;
-  controller.previewError = null;
-  controller.previewStream = null;
-  controller.simulatorMediaDisabled = false;
-  controller.setDisplayName.mockReset();
-  controller.setInputFocused.mockReset();
-  controller.toggleAudio.mockReset();
-  controller.toggleVideo.mockReset();
-  controller.handleJoin.mockReset();
-});
-
-describe("EntranceViewIosPad", () => {
-  it("composes the immersive surface with themed title, media controls, and cancel action", () => {
-    const onCancel = vi.fn();
-    const { result } = renderHook(() => EntranceViewIosPad({ onCancel, onJoin: vi.fn(), spaceName: "Design review" }));
-    const tree = result.current;
-
-    const screen = findElement(tree, "KeyboardAvoidingView");
-    const cancel = findElement(tree, "Pressable", (element) => element.props.accessibilityLabel === "Cancel and leave Entrance");
-    const microphone = findElement(tree, "Pressable", (element) => element.props.accessibilityLabel === "Mute microphone");
-    const camera = findElement(tree, "Pressable", (element) => element.props.accessibilityLabel === "Turn camera off");
-    const join = findElement(tree, "Pressable", (element) => element.props.accessibilityLabel === "Enter Space");
-
-    expect(screen?.props.style).toEqual(expect.arrayContaining([expect.objectContaining({ backgroundColor: theme.colors.background })]));
-    expect(findText(tree)).toContain("Design review");
-    expect(cancel).toBeDefined();
-    expect(microphone).toBeDefined();
-    expect(camera).toBeDefined();
-    expect(join?.props.accessibilityState).toEqual({ disabled: false });
-
-    cancel?.props.onPress();
-    expect(onCancel).toHaveBeenCalledOnce();
-  });
-
-  it("uses the avatar fallback and disables joining until a name is entered", () => {
-    controller.displayName = "";
-
-    const { result } = renderHook(() => EntranceViewIosPad({ onJoin: vi.fn(), spaceName: "Quiet Space" }));
-    const tree = result.current;
-    const join = findElement(tree, "Pressable", (element) => element.props.accessibilityLabel === "Enter Space");
-
-    expect(findElement(tree, "FaceAvatar")).toBeDefined();
-    expect(findElement(tree, "RtcVideoView")).toBeUndefined();
-    expect(join?.props.accessibilityState).toEqual({ disabled: true });
-    expect(findText(tree)).toContain("Quiet Space");
-  });
-});
-
-interface NativeElementProps {
-  readonly accessibilityLabel?: string;
-  readonly accessibilityState?: unknown;
-  readonly children?: ReactNode;
-  readonly onPress?: () => void;
-  readonly style?: unknown;
-}
-
-function findElement(node: ReactNode, type: string, matches: (element: ReactElement<NativeElementProps>) => boolean = () => true): ReactElement<NativeElementProps> | undefined {
-  if (!isElement(node)) return undefined;
-  if (node.type === type && matches(node)) return node;
-
-  const children = node.props.children;
-  for (const child of Array.isArray(children) ? children : [children]) {
-    const found = findElement(child, type, matches);
-    if (found) return found;
-  }
-  return undefined;
-}
-
-function findText(node: ReactNode): string[] {
-  if (typeof node === "string") return [node];
-  if (!isElement(node)) return [];
-  const children = node.props.children;
-  return (Array.isArray(children) ? children : [children]).flatMap(findText);
-}
-
-function isElement(node: ReactNode): node is ReactElement<NativeElementProps> {
-  return typeof node === "object" && node !== null && "type" in node && "props" in node;
-}