@q9labsai/chalk-react-native 4.1.12 → 4.1.14

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

@@ -1,137 +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 as { toURL: () => string } | 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: "ios" },
-  Pressable: "Pressable",
-  StyleSheet: { absoluteFillObject: {}, create: <T,>(styles: T) => styles },
-  Text: "Text",
-  TextInput: "TextInput",
-  View: "View",
-}));
-vi.mock("@cloudflare/react-native-webrtc", () => ({ RTCView: "RTCView" }));
-vi.mock("@hugeicons/react-native", () => ({ HugeiconsIcon: "HugeiconsIcon" }));
-vi.mock("./FaceAvatar", () => ({ FaceAvatar: "FaceAvatar" }));
-vi.mock("../ui/native-theme", () => ({ useNativeTheme: () => theme }));
-vi.mock("../utils/ios-simulator", () => ({ getIosSimulatorMediaMessage: () => "Media is unavailable in the simulator." }));
-vi.mock("./native-entrance/useEntranceController", () => ({ useEntranceController: () => controller }));
-
-import { EntranceViewIosPhone } from "./EntranceView.ios-phone";
-
-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("EntranceViewIosPhone", () => {
-  it("renders the phone preview sheet with the canonical Space title and join controls", () => {
-    const onCancel = vi.fn();
-    const { result } = renderHook(() => EntranceViewIosPhone({ 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 textInput = findElement(tree, "TextInput");
-    const join = findText(tree).find((text) => text === "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(textInput?.props.placeholder).toBe("Enter your name");
-    expect(join).toBe("Enter Space");
-
-    cancel?.props.onPress();
-    expect(onCancel).toHaveBeenCalledOnce();
-  });
-
-  it("mounts the RTC preview only when the controller supplies an enabled stream", () => {
-    controller.previewStream = { toURL: () => "stream://preview" };
-
-    const { result } = renderHook(() => EntranceViewIosPhone({ onJoin: vi.fn(), spaceName: "Live Space" }));
-    const preview = findElement(result.current, "RTCView");
-
-    expect(preview?.props).toMatchObject({ mirror: true, objectFit: "cover", streamURL: "stream://preview" });
-  });
-});
-
-interface NativeElementProps {
-  readonly accessibilityLabel?: string;
-  readonly children?: ReactNode;
-  readonly onPress?: () => void;
-  readonly placeholder?: string;
-  readonly props?: unknown;
-  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;
-}

package/src/components/EntranceView.test.tsx

@@ -1,15 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-
-vi.mock("../platform/platform", () => ({ resolvePlatformVariant: () => "android" }));
-vi.mock("./EntranceView.android", () => ({ EntranceViewAndroid: () => null }));
-vi.mock("./EntranceView.ios-pad", () => ({ EntranceViewIosPad: () => null }));
-vi.mock("./EntranceView.ios-phone", () => ({ EntranceViewIosPhone: () => null }));
-vi.mock("./EntranceView.macos", () => ({ EntranceViewMacos: () => null }));
-
-describe("EntranceView", () => {
-  it("selects the platform-specific entrance", async () => {
-    const { EntranceView } = await import("./EntranceView");
-
-    expect(EntranceView({ spaceName: "Space", onJoin: vi.fn() })).toBeTruthy();
-  });
-});

package/src/components/ReactionPicker.test.tsx

@@ -1,19 +0,0 @@
-import { readFileSync } from "node:fs";
-import { describe, expect, it } from "vitest";
-
-const source = readFileSync(new URL("./ReactionPicker.tsx", import.meta.url), "utf8");
-
-describe("ReactionPicker", () => {
-  it("covers the persistent dock while keeping the reaction card inset", () => {
-    expect(source).toContain("StyleSheet.absoluteFillObject");
-    expect(source).not.toContain("paddingBottom: 110");
-    expect(source).not.toContain("bottom: 94");
-  });
-
-  it("keeps close-button press feedback defined", () => {
-    expect(source).toContain("pressed && styles.pressed");
-    expect(source).toContain("pressed: {");
-    expect(source).toContain("opacity: 0.72");
-    expect(source).toContain("transform: [{ scale: 0.96 }]");
-  });
-});

package/src/components/RtcVideoView.test.tsx

@@ -1,12 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-
-vi.mock("../media/native-webrtc", () => ({ RTCView: () => null }));
-
-describe("RtcVideoView", () => {
-  it("reports the availability of the RTC view", async () => {
-    const { hasRtcVideoView, RtcVideoView } = await import("./RtcVideoView");
-
-    expect(hasRtcVideoView()).toBe(true);
-    expect(RtcVideoView({ streamURL: "stream" })).toBeTruthy();
-  });
-});

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

@@ -1,11 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-
-vi.mock("./SpaceView.shared", () => ({ SpaceViewShared: () => null }));
-
-describe("SpaceView.android", () => {
-  it("exposes the canonical platform component name", async () => {
-    const { SpaceViewAndroid } = await import("./SpaceView.android");
-
-    expect(SpaceViewAndroid).toBeTypeOf("function");
-  });
-});

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

@@ -1,11 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-
-vi.mock("./SpaceView.shared", () => ({ SpaceViewShared: () => null }));
-
-describe("SpaceView.ios-pad", () => {
-  it("exposes the canonical platform component name", async () => {
-    const { SpaceViewIosPad } = await import("./SpaceView.ios-pad");
-
-    expect(SpaceViewIosPad).toBeTypeOf("function");
-  });
-});

package/src/components/SpaceView.ios-phone.test.tsx

@@ -1,11 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-
-vi.mock("./SpaceView.shared", () => ({ SpaceViewShared: () => null }));
-
-describe("SpaceView.ios-phone", () => {
-  it("exposes the canonical platform component name", async () => {
-    const { SpaceViewIosPhone } = await import("./SpaceView.ios-phone");
-
-    expect(SpaceViewIosPhone).toBeTypeOf("function");
-  });
-});

package/src/components/SpaceView.macos.test.tsx

@@ -1,11 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-
-vi.mock("./SpaceView.shared", () => ({ SpaceViewShared: () => null }));
-
-describe("SpaceView.macos", () => {
-  it("exposes the canonical platform component name", async () => {
-    const { SpaceViewMacos } = await import("./SpaceView.macos");
-
-    expect(SpaceViewMacos).toBeTypeOf("function");
-  });
-});

package/src/components/SpaceView.shared.test.tsx

@@ -1,116 +0,0 @@
-import { readFileSync } from "node:fs";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-const state = vi.hoisted(() => ({
-  controller: {
-    actionsOpen: false,
-    activeReactions: [],
-    canChat: true,
-    canParticipants: true,
-    derived: { allParticipants: [], gridPages: [], isCompactViewport: false, isStageMode: false, primaryContent: "grid", screenShareTrack: null, screenSharer: null },
-    handRaised: false,
-    handleLeave: vi.fn(),
-    isCameraOff: false,
-    isMuted: false,
-    layout: { layout: "grid" },
-    openPanel: vi.fn(),
-    panel: null,
-    raisedHandCount: 0,
-    reactionPickerOpen: false,
-    selfName: "Taylor",
-    setActionsOpen: vi.fn(),
-    setReactionPickerOpen: vi.fn(),
-    simulatorMediaDisabled: false,
-    spaceName: "Design space",
-    chat: { unreadCount: 0 },
-    whiteboard: { canDraw: true, elements: [], isOpen: false, openParticipants: [] },
-  },
-  useSpaceViewController: vi.fn(),
-}));
-
-vi.mock("react-native", () => ({
-  Alert: { alert: vi.fn() },
-  StyleSheet: { create: <T,>(styles: T) => styles },
-  Text: "Text",
-  View: "View",
-}));
-vi.mock("../ui/theme", () => ({ Theme: { colors: { darkCanvas: "#0a0a0b", primary: "#1bb6a6", primaryForeground: "#ffffff" } } }));
-vi.mock("../ui/native-theme", () => ({
-  useNativeTheme: () => ({ colors: { darkCanvas: "#0a0a0b", primary: "#1bb6a6", primaryForeground: "#ffffff" } }),
-}));
-vi.mock("../utils/ios-simulator", () => ({ getIosSimulatorMediaMessage: () => "Media is unavailable in the simulator." }));
-vi.mock("./ReactionPicker", () => ({ ReactionPicker: "ReactionPicker" }));
-vi.mock("./native-space-view/SpaceActionMenu", () => ({ SpaceActionMenu: "SpaceActionMenu", selectSpaceReaction: vi.fn() }));
-vi.mock("./native-space-view/SettingsSheet", () => ({ SettingsSheet: "SettingsSheet" }));
-vi.mock("./native-space-view/SpacePanelSheet", () => ({ SpacePanelSheet: "SpacePanelSheet" }));
-vi.mock("./native-space-view/SpaceBottomDock.android", () => ({ SpaceBottomDockAndroid: "SpaceBottomDockAndroid" }));
-vi.mock("./native-space-view/SpaceGrid.android", () => ({ SpaceGridAndroid: "SpaceGridAndroid" }));
-vi.mock("./native-space-view/SpaceStage.android", () => ({ SpaceStageAndroid: "SpaceStageAndroid" }));
-vi.mock("./native-space-view/SpaceTopBar.android", () => ({ SpaceTopBarAndroid: "SpaceTopBarAndroid" }));
-vi.mock("./native-space-view/SpaceWhiteboardSurface", () => ({ SpaceWhiteboardSurface: "SpaceWhiteboardSurface" }));
-vi.mock("./native-space-view/useSpaceViewController", () => ({ useSpaceViewController: state.useSpaceViewController }));
-
-import { SpaceViewShared } from "./SpaceView.shared";
-
-describe("SpaceViewShared", () => {
-  const source = readFileSync(new URL("./SpaceView.shared.tsx", import.meta.url), "utf8");
-
-  beforeEach(() => {
-    state.controller.whiteboard.isOpen = false;
-    state.useSpaceViewController.mockClear();
-    state.useSpaceViewController.mockReturnValue(state.controller);
-  });
-
-  afterEach(() => {
-    state.controller.whiteboard.isOpen = false;
-    state.useSpaceViewController.mockClear();
-  });
-
-  it("passes reconnecting state and capability-gated controls to the native surface", () => {
-    const props = { onLeave: vi.fn(), onOpenDiagnostics: vi.fn(), reconnecting: true, logoUrl: "https://cdn.example.test/logo.png", spaceName: "Design space" };
-    const tree = SpaceViewShared(props);
-
-    expect(state.useSpaceViewController).toHaveBeenCalledWith(props);
-    expect(findText(tree)).toContain("Reconnecting… controls will resume shortly.");
-    expect(findElement(tree, "SpaceTopBarAndroid")).toMatchObject({ props: { logoUrl: props.logoUrl, spaceName: props.spaceName } });
-    expect(findElement(tree, "SpaceBottomDockAndroid")).toMatchObject({ props: { onOpenChat: expect.any(Function), unreadChatCount: 0 } });
-    expect(findElement(tree, "SpaceActionMenu")).toMatchObject({ props: { onOpenDiagnostics: props.onOpenDiagnostics } });
-  });
-
-  it("renders the whiteboard surface instead of a stage or grid when it is open", () => {
-    state.controller.whiteboard.isOpen = true;
-
-    const tree = SpaceViewShared({ onLeave: vi.fn() });
-
-    expect(findElement(tree, "SpaceWhiteboardSurface")).toBeTruthy();
-    expect(findElement(tree, "SpaceStageAndroid")).toBeUndefined();
-    expect(findElement(tree, "SpaceGridAndroid")).toBeUndefined();
-  });
-
-  it("mounts the canonical panel sheet that owns the attachment composer", () => {
-    const panelSource = readFileSync(new URL("./native-space-view/SpacePanelSheet.tsx", import.meta.url), "utf8");
-    const chatSource = readFileSync(new URL("./native-space-view/SpaceChatSheet.tsx", import.meta.url), "utf8");
-
-    expect(source).toContain("<SpacePanelSheet controller={controller} />");
-    expect(source).not.toContain("<SpacePanel controller={controller} />");
-    expect(source).toContain("<SettingsSheet controller={controller}");
-    expect(panelSource).toContain("<SpaceChatSheet");
-    expect(chatSource).toContain('accessibilityLabel="Attach file"');
-    expect(chatSource).toContain("controller.removeChatAttachment(index)");
-  });
-});
-
-function findElement(value: unknown, type: string): { readonly props?: Record<string, unknown> } | undefined {
-  if (Array.isArray(value)) return value.map((child) => findElement(child, type)).find(Boolean);
-  if (!value || typeof value !== "object") return undefined;
-  const element = value as { readonly type?: unknown; readonly props?: Record<string, unknown> };
-  if (element.type === type) return element;
-  return findElement(element.props?.children, type);
-}
-
-function findText(value: unknown): string[] {
-  if (typeof value === "string") return [value];
-  if (Array.isArray(value)) return value.flatMap(findText);
-  if (!value || typeof value !== "object") return [];
-  return findText((value as { readonly props?: { readonly children?: unknown } }).props?.children);
-}

package/src/components/SpaceView.test.tsx

@@ -1,15 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-
-vi.mock("../platform/platform", () => ({ resolvePlatformVariant: () => "android" }));
-vi.mock("./SpaceView.android", () => ({ SpaceViewAndroid: () => null }));
-vi.mock("./SpaceView.ios-pad", () => ({ SpaceViewIosPad: () => null }));
-vi.mock("./SpaceView.ios-phone", () => ({ SpaceViewIosPhone: () => null }));
-vi.mock("./SpaceView.macos", () => ({ SpaceViewMacos: () => null }));
-
-describe("SpaceView", () => {
-  it("selects the platform-specific Space", async () => {
-    const { SpaceView } = await import("./SpaceView");
-
-    expect(SpaceView({ onLeave: vi.fn() })).toBeTruthy();
-  });
-});

package/src/components/android-connection-service-controller.test.ts

@@ -1,80 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import type { AndroidConnectionServiceControllerDependencies, AndroidConnectionServiceControllerInput } from "./android-connection-service-controller";
-import { AndroidConnectionServiceController } from "./android-connection-service-controller";
-
-async function flushMicrotasks(): Promise<void> {
-  await Promise.resolve();
-  await Promise.resolve();
-}
-
-function createInput(overrides: Partial<AndroidConnectionServiceControllerInput> = {}): AndroidConnectionServiceControllerInput {
-  return {
-    displayName: "Guest",
-    enabled: true,
-    hasVideo: true,
-    joinNonce: 1,
-    onDisconnectRequest: vi.fn(),
-    phase: "joining",
-    spaceId: "space-1",
-    spaceName: "Daily Standup",
-    ...overrides,
-  };
-}
-
-function createDependencies() {
-  let listener: Parameters<AndroidConnectionServiceControllerDependencies["addListener"]>[0] | undefined;
-  const dependencies: AndroidConnectionServiceControllerDependencies = {
-    addListener: vi.fn((nextListener) => {
-      listener = nextListener;
-      return vi.fn();
-    }),
-    endCall: vi.fn(async () => true),
-    ensureRegistered: vi.fn(async () => true),
-    setActive: vi.fn(async () => true),
-    startCall: vi.fn(async () => true),
-  };
-  return { dependencies, getListener: () => listener };
-}
-
-describe("AndroidConnectionServiceController", () => {
-  it("starts, activates, and filters disconnect events for the current call", async () => {
-    const onDisconnectRequest = vi.fn();
-    const { dependencies, getListener } = createDependencies();
-    const controller = new AndroidConnectionServiceController(createInput({ onDisconnectRequest }), dependencies);
-    const unsubscribe = controller.subscribe(() => {});
-
-    expect(dependencies.ensureRegistered).toHaveBeenCalledTimes(1);
-    expect(dependencies.startCall).toHaveBeenCalledWith({
-      callId: "space-1:1",
-      displayName: "Guest",
-      hasVideo: true,
-      spaceId: "space-1",
-      spaceName: "Daily Standup",
-    });
-
-    controller.update(createInput({ onDisconnectRequest, phase: "live" }));
-    await flushMicrotasks();
-    expect(dependencies.setActive).toHaveBeenCalledWith("space-1:1");
-
-    getListener()?.({ callId: "other:1", reason: "remote", type: "disconnect" });
-    getListener()?.({ callId: "space-1:1", reason: "remote", type: "disconnect" });
-    expect(onDisconnectRequest).toHaveBeenCalledTimes(1);
-
-    controller.update(createInput({ onDisconnectRequest, phase: "entrance" }));
-    await flushMicrotasks();
-    expect(dependencies.endCall).toHaveBeenCalledWith("space-1:1", { reason: "canceled" });
-
-    unsubscribe();
-  });
-
-  it("ends an active call locally and removes the native listener on unsubscribe", () => {
-    const { dependencies } = createDependencies();
-    const controller = new AndroidConnectionServiceController(createInput(), dependencies);
-    const unsubscribe = controller.subscribe(() => {});
-
-    unsubscribe();
-
-    expect(dependencies.endCall).toHaveBeenCalledWith("space-1:1", { reason: "local" });
-    expect(dependencies.addListener).toHaveBeenCalledTimes(1);
-  });
-});

package/src/components/episode-diagnostic-render-observer.test.ts

@@ -1,24 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { observeNativeFrameNotObservable } from "./episode-diagnostic-render-observer";
-
-const REGISTRY = Symbol.for("@chalk/private/episode-diagnostic-render-registry/v1");
-
-describe("observeNativeFrameNotObservable", () => {
-  it("emits an explicit gap because the native RTC view exposes no first-frame callback", () => {
-    const track = {};
-    const report = vi.fn();
-    (globalThis as unknown as Record<symbol, unknown>)[REGISTRY] = new WeakMap([[track, report]]);
-
-    observeNativeFrameNotObservable(track);
-
-    expect(report).toHaveBeenCalledWith("not_observable");
-  });
-
-  it("is inert when diagnostics did not register the track", () => {
-    const report = vi.fn();
-    (globalThis as unknown as Record<symbol, unknown>)[REGISTRY] = new WeakMap();
-
-    expect(() => observeNativeFrameNotObservable({})).not.toThrow();
-    expect(report).not.toHaveBeenCalled();
-  });
-});

package/src/components/logo/Logo.test.tsx

@@ -1,144 +0,0 @@
-// @vitest-environment happy-dom
-import type { ReactElement, ReactNode } from "react";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-import { act, renderHook } from "../../test-support/test-renderer";
-
-const mocks = vi.hoisted(() => {
-  const animationStops: ReturnType<typeof vi.fn>[] = [];
-  const createAnimation = (config?: unknown) => {
-    const stop = vi.fn();
-    animationStops.push(stop);
-    return { config, start: vi.fn(), stop };
-  };
-  class AnimatedValue {
-    readonly initial: number;
-    readonly setValue = vi.fn();
-    readonly stopAnimation = vi.fn();
-    constructor(initial: number) {
-      this.initial = initial;
-    }
-    interpolate(input: unknown): { readonly input: unknown } {
-      return { input };
-    }
-  }
-
-  return {
-    accessibilityInfo: {
-      addEventListener: vi.fn(() => ({ remove: vi.fn() })),
-      isReduceMotionEnabled: vi.fn(() => Promise.resolve(false)),
-    },
-    animationStops,
-    animation: {
-      delay: vi.fn((duration: number) => createAnimation({ duration })),
-      loop: vi.fn((animation: unknown) => createAnimation({ animation })),
-      parallel: vi.fn((animations: readonly unknown[]) => createAnimation({ animations })),
-      sequence: vi.fn((animations: readonly unknown[]) => createAnimation({ animations })),
-      timing: vi.fn((_value: unknown, config: unknown) => createAnimation(config)),
-      Value: AnimatedValue,
-    },
-  };
-});
-
-vi.mock("react-native", () => ({ AccessibilityInfo: mocks.accessibilityInfo, Animated: { ...mocks.animation, createAnimatedComponent: (component: unknown) => component }, Pressable: "Pressable" }));
-vi.mock("react-native-svg", () => ({ Defs: "Defs", Ellipse: "Ellipse", G: "G", LinearGradient: "LinearGradient", Path: "Path", Stop: "Stop", Text: "SvgText", default: "Svg" }));
-
-import { Logo } from "./Logo";
-
-describe("Logo", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    mocks.animationStops.length = 0;
-    mocks.accessibilityInfo.isReduceMotionEnabled.mockResolvedValue(false);
-  });
-
-  it("uses the canonical mark geometry and keeps the wordmark static", () => {
-    const { result } = renderHook(() => Logo({ accessibilityLabel: "Brand", color: "#123456", height: 96 }));
-    const pressable = result.current;
-    const svg = findElement(pressable, "Svg");
-
-    expect(svg).toMatchObject({ props: { accessibilityLabel: "Brand", accessible: true, color: "#123456", height: 96, viewBox: "0 0 200 80", width: 240 } });
-    expect(findElements(svg, "Path")).toHaveLength(4);
-    expect(findElements(svg, "Ellipse")).toHaveLength(4);
-    expect(findElements(svg, "SvgText")).toMatchObject([{ props: { fill: "currentColor", children: "chalk" } }]);
-    expect(findElements(svg, "G")).toHaveLength(5);
-    expect(findElements(svg, "SvgText")[0].props).not.toHaveProperty("rotation");
-  });
-
-  it("renders the mark fallback without adding an announced button", () => {
-    const { result } = renderHook(() => Logo({ accessibilityLabel: null, height: 24, motion: "none", variant: "mark" }));
-    const pressable = result.current;
-    const svg = findElement(pressable, "Svg");
-
-    expect(pressable.props).toMatchObject({ accessible: false });
-    expect(svg).toMatchObject({ props: { accessible: false, height: 24, viewBox: "0 0 68 80", width: 20.4 } });
-    expect(findElements(svg, "SvgText")).toHaveLength(0);
-  });
-
-  it("uses orbit by default and switches only the sticks to burst while active", async () => {
-    const { result } = renderHook(() => Logo({}));
-    await act(async () => await Promise.resolve());
-
-    const initialTimingCount = mocks.animation.timing.mock.calls.length;
-    act(() => {
-      result.current.props.onHoverIn();
-    });
-
-    expect(mocks.animation.timing.mock.calls.length).toBeGreaterThan(initialTimingCount);
-    expect(mocks.animation.timing.mock.calls.slice(initialTimingCount).map(([, config]) => (config as { readonly toValue: number }).toValue)).toEqual(expect.arrayContaining([-14, -9, -4, -14, 14, -6, 11, 12, 1.14, 1.16, 1.13]));
-    expect(findElements(result.current, "SvgText")[0].props).not.toHaveProperty("rotation");
-
-    act(() => {
-      result.current.props.onHoverOut();
-    });
-    expect(mocks.animation.timing.mock.calls.length).toBeGreaterThan(initialTimingCount + 12);
-  });
-
-  it("does not start animations when reduced motion is enabled and removes the listener", async () => {
-    mocks.accessibilityInfo.isReduceMotionEnabled.mockResolvedValue(true);
-    const { result, unmount } = renderHook(() => Logo({}));
-    await act(async () => await Promise.resolve());
-
-    expect(mocks.animation.timing).not.toHaveBeenCalled();
-    unmount();
-    expect(mocks.accessibilityInfo.addEventListener.mock.results[0]?.value.remove).toHaveBeenCalledTimes(1);
-    expect(findElements(result.current, "Svg")).toHaveLength(1);
-  });
-
-  it("stops the active orbit when the logo unmounts", async () => {
-    const { unmount } = renderHook(() => Logo({}));
-    await act(async () => await Promise.resolve());
-
-    unmount();
-
-    expect(mocks.animationStops.some((stop) => stop.mock.calls.length > 0)).toBe(true);
-  });
-});
-
-function findElement(node: ReactNode, type: string): ReactElement<{ readonly children?: ReactNode; readonly [key: string]: unknown }> {
-  if (isElement(node) && node.type === type) return node;
-  if (!isElement(node)) throw new Error(`Expected ${type}`);
-  const children = Array.isArray(node.props.children) ? node.props.children : [node.props.children];
-  for (const child of children) {
-    if (isElement(child) && child.type === type) return child;
-    if (isElement(child)) {
-      try {
-        return findElement(child, type);
-      } catch {
-        continue;
-      }
-    }
-  }
-  throw new Error(`Expected ${type}`);
-}
-
-function findElements(node: ReactNode, type: string): ReactElement<{ readonly children?: ReactNode; readonly [key: string]: unknown }>[] {
-  if (!isElement(node)) return [];
-  const matches = node.type === type ? [node] : [];
-  const children = Array.isArray(node.props.children) ? node.props.children : [node.props.children];
-  return matches.concat(children.flatMap((child) => findElements(child, type)));
-}
-
-function isElement(node: ReactNode): node is ReactElement<{ readonly children?: ReactNode; readonly [key: string]: unknown }> {
-  return typeof node === "object" && node !== null && "type" in node && "props" in node;
-}

package/src/components/native-animation-controller.test.ts

@@ -1,47 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { createAnimationRefController, type StoppableAnimation } from "./native-animation-controller";
-
-function createAnimation(): StoppableAnimation {
-  return {
-    start: vi.fn(),
-    stop: vi.fn(),
-  };
-}
-
-describe("createAnimationRefController", () => {
-  it("starts animations once per attachment and stops them on detachment", () => {
-    const firstAnimation = createAnimation();
-    const secondAnimation = createAnimation();
-    const ref = createAnimationRefController(() => [firstAnimation, secondAnimation]);
-
-    ref({});
-    ref({});
-
-    expect(firstAnimation.start).toHaveBeenCalledOnce();
-    expect(secondAnimation.start).toHaveBeenCalledOnce();
-    expect(firstAnimation.stop).not.toHaveBeenCalled();
-
-    ref(null);
-    ref(null);
-
-    expect(firstAnimation.stop).toHaveBeenCalledOnce();
-    expect(secondAnimation.stop).toHaveBeenCalledOnce();
-  });
-
-  it("creates a fresh animation set when a node is attached again", () => {
-    const firstAnimation = createAnimation();
-    const secondAnimation = createAnimation();
-    const createAnimations = vi.fn().mockReturnValueOnce([firstAnimation]).mockReturnValueOnce([secondAnimation]);
-    const ref = createAnimationRefController(createAnimations);
-
-    ref({});
-    ref(null);
-    ref({});
-
-    expect(createAnimations).toHaveBeenCalledTimes(2);
-    expect(firstAnimation.start).toHaveBeenCalledOnce();
-    expect(firstAnimation.stop).toHaveBeenCalledOnce();
-    expect(secondAnimation.start).toHaveBeenCalledOnce();
-    expect(secondAnimation.stop).not.toHaveBeenCalled();
-  });
-});