@assistant-ui/react-native 0.1.27 → 0.1.28

package/src/primitives/branchPicker/BranchPickerNumber.test.tsx

@@ -0,0 +1,56 @@
+import { act } from "react";
+import { createRoot, type Root } from "react-dom/client";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { BranchPickerNumber } from "./BranchPickerNumber";
+
+const h = vi.hoisted(() => ({
+  state: { message: { branchNumber: 0 } },
+}));
+
+vi.mock("@assistant-ui/store", () => ({
+  useAuiState: <T,>(
+    selector: (s: { message: { branchNumber: number } }) => T,
+  ) => selector(h.state),
+}));
+
+(globalThis as Record<string, unknown>).IS_REACT_ACT_ENVIRONMENT = true;
+
+describe("BranchPickerNumber", () => {
+  let container: HTMLDivElement;
+  let root: Root;
+
+  beforeEach(() => {
+    h.state.message.branchNumber = 0;
+    container = document.createElement("div");
+    document.body.appendChild(container);
+    root = createRoot(container);
+  });
+
+  afterEach(async () => {
+    await act(async () => {
+      root.unmount();
+    });
+    container.remove();
+  });
+
+  const mount = async () => {
+    await act(async () => {
+      root.render(<BranchPickerNumber testID="number" />);
+    });
+    const el = container.querySelector('[data-testid="number"]');
+    expect(el).not.toBeNull();
+    return el as HTMLElement;
+  };
+
+  it("renders the branchNumber from store state", async () => {
+    h.state.message.branchNumber = 1;
+    const el = await mount();
+    expect(el.textContent).toBe("1");
+  });
+
+  it("renders a different branchNumber value", async () => {
+    h.state.message.branchNumber = 7;
+    const el = await mount();
+    expect(el.textContent).toBe("7");
+  });
+});

package/src/primitives/branchPicker/BranchPickerPrevious.test.tsx

@@ -0,0 +1,100 @@
+import { act } from "react";
+import { createRoot, type Root } from "react-dom/client";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { BranchPickerPrevious } from "./BranchPickerPrevious";
+
+const h = vi.hoisted(() => ({
+  previous: vi.fn<() => void>(),
+  state: { disabled: false },
+}));
+
+vi.mock("@assistant-ui/core/react", () => ({
+  useBranchPickerPrevious: () => ({
+    previous: h.previous,
+    disabled: h.state.disabled,
+  }),
+}));
+
+(globalThis as Record<string, unknown>).IS_REACT_ACT_ENVIRONMENT = true;
+
+const click = (el: Element) =>
+  el.dispatchEvent(
+    new MouseEvent("click", { bubbles: true, cancelable: true }),
+  );
+
+describe("BranchPickerPrevious", () => {
+  let container: HTMLDivElement;
+  let root: Root;
+
+  beforeEach(() => {
+    h.previous.mockReset();
+    h.state.disabled = false;
+
+    container = document.createElement("div");
+    document.body.appendChild(container);
+    root = createRoot(container);
+  });
+
+  afterEach(async () => {
+    await act(async () => {
+      root.unmount();
+    });
+    container.remove();
+  });
+
+  const mount = async (
+    props: Partial<Parameters<typeof BranchPickerPrevious>[0]> = {},
+  ) => {
+    await act(async () => {
+      root.render(
+        <BranchPickerPrevious testID="t" {...props}>
+          prev
+        </BranchPickerPrevious>,
+      );
+    });
+    return container.querySelector('[data-testid="t"]') as HTMLElement;
+  };
+
+  it("fires previous when pressed and the hook is enabled", async () => {
+    const el = await mount();
+
+    await act(async () => {
+      click(el);
+    });
+
+    expect(h.previous).toHaveBeenCalledTimes(1);
+  });
+
+  it("does not fire previous when the hook reports disabled", async () => {
+    h.state.disabled = true;
+    const el = await mount();
+
+    await act(async () => {
+      click(el);
+    });
+
+    expect(h.previous).not.toHaveBeenCalled();
+  });
+
+  it("lets an explicit disabled prop override an enabled hook", async () => {
+    h.state.disabled = false;
+    const el = await mount({ disabled: true });
+
+    await act(async () => {
+      click(el);
+    });
+
+    expect(h.previous).not.toHaveBeenCalled();
+  });
+
+  it("lets an explicit disabled={false} prop override a disabled hook", async () => {
+    h.state.disabled = true;
+    const el = await mount({ disabled: false });
+
+    await act(async () => {
+      click(el);
+    });
+
+    expect(h.previous).toHaveBeenCalledTimes(1);
+  });
+});

package/src/primitives/chainOfThought/ChainOfThoughtAccordionTrigger.test.tsx

@@ -0,0 +1,85 @@
+import { act } from "react";
+import { createRoot, type Root } from "react-dom/client";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { Text } from "react-native";
+import { ChainOfThoughtAccordionTrigger } from "./ChainOfThoughtAccordionTrigger";
+
+const h = vi.hoisted(() => ({
+  setCollapsed: vi.fn<(collapsed: boolean) => void>(),
+  state: { chainOfThought: { collapsed: true } },
+}));
+
+vi.mock("@assistant-ui/store", () => {
+  const aui = {
+    chainOfThought: () => ({ setCollapsed: h.setCollapsed }),
+  };
+  return {
+    useAui: () => aui,
+    useAuiState: <T,>(selector: (s: typeof h.state) => T) => selector(h.state),
+  };
+});
+
+(globalThis as Record<string, unknown>).IS_REACT_ACT_ENVIRONMENT = true;
+
+describe("ChainOfThoughtAccordionTrigger", () => {
+  let container: HTMLDivElement;
+  let root: Root;
+
+  beforeEach(() => {
+    h.setCollapsed.mockReset();
+    h.state.chainOfThought.collapsed = true;
+    container = document.createElement("div");
+    document.body.appendChild(container);
+    root = createRoot(container);
+  });
+
+  afterEach(async () => {
+    await act(async () => {
+      root.unmount();
+    });
+    container.remove();
+  });
+
+  const mount = async () => {
+    await act(async () => {
+      root.render(
+        <ChainOfThoughtAccordionTrigger testID="trigger">
+          <Text>toggle</Text>
+        </ChainOfThoughtAccordionTrigger>,
+      );
+    });
+    return container.querySelector(
+      '[data-testid="trigger"]',
+    ) as HTMLElement | null;
+  };
+
+  const press = async (el: HTMLElement) => {
+    await act(async () => {
+      el.dispatchEvent(
+        new MouseEvent("click", { bubbles: true, cancelable: true }),
+      );
+    });
+  };
+
+  it("renders the trigger with its children", async () => {
+    const el = await mount();
+    expect(el).not.toBeNull();
+    expect(el?.textContent).toBe("toggle");
+  });
+
+  it("expands (sets collapsed false) when currently collapsed", async () => {
+    h.state.chainOfThought.collapsed = true;
+    const el = await mount();
+    await press(el!);
+    expect(h.setCollapsed).toHaveBeenCalledTimes(1);
+    expect(h.setCollapsed).toHaveBeenCalledWith(false);
+  });
+
+  it("collapses (sets collapsed true) when currently expanded", async () => {
+    h.state.chainOfThought.collapsed = false;
+    const el = await mount();
+    await press(el!);
+    expect(h.setCollapsed).toHaveBeenCalledTimes(1);
+    expect(h.setCollapsed).toHaveBeenCalledWith(true);
+  });
+});

package/src/primitives/composer/ComposerAddAttachment.test.tsx

@@ -0,0 +1,136 @@
+import { act } from "react";
+import { createRoot, type Root } from "react-dom/client";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { ComposerAddAttachment } from "./ComposerAddAttachment";
+
+const h = vi.hoisted(() => ({
+  disabled: false,
+}));
+
+vi.mock("@assistant-ui/core/react", () => ({
+  useComposerAddAttachment: () => ({ disabled: h.disabled }),
+}));
+
+(globalThis as Record<string, unknown>).IS_REACT_ACT_ENVIRONMENT = true;
+
+const click = (el: Element) => {
+  el.dispatchEvent(
+    new MouseEvent("click", { bubbles: true, cancelable: true }),
+  );
+};
+
+describe("ComposerAddAttachment", () => {
+  let container: HTMLDivElement;
+  let root: Root;
+
+  beforeEach(() => {
+    h.disabled = false;
+
+    container = document.createElement("div");
+    document.body.appendChild(container);
+    root = createRoot(container);
+  });
+
+  afterEach(async () => {
+    await act(async () => {
+      root.unmount();
+    });
+    container.remove();
+  });
+
+  const mount = async (
+    props: Partial<Parameters<typeof ComposerAddAttachment>[0]> & {
+      onPress?: () => void;
+    } = {},
+  ) => {
+    await act(async () => {
+      root.render(
+        <ComposerAddAttachment testID="add" {...props}>
+          add
+        </ComposerAddAttachment>,
+      );
+    });
+    const el = container.querySelector('[data-testid="add"]');
+    expect(el).not.toBeNull();
+    return el as Element;
+  };
+
+  it("renders its children", async () => {
+    const el = await mount();
+    expect(el.textContent).toBe("add");
+  });
+
+  it("wires no onPress so pressing is a no-op", async () => {
+    const el = await mount();
+
+    let threw = false;
+    await act(async () => {
+      try {
+        click(el);
+      } catch {
+        threw = true;
+      }
+    });
+
+    expect(threw).toBe(false);
+  });
+
+  it("forwards an explicit onPress prop", async () => {
+    const onPress = vi.fn();
+    const el = await mount({ onPress });
+
+    await act(async () => {
+      click(el);
+    });
+
+    expect(onPress).toHaveBeenCalledTimes(1);
+  });
+
+  it("blocks a forwarded onPress when the hook reports disabled", async () => {
+    h.disabled = true;
+    const onPress = vi.fn();
+    const el = await mount({ onPress });
+
+    await act(async () => {
+      click(el);
+    });
+
+    expect(onPress).not.toHaveBeenCalled();
+  });
+
+  it("lets a false prop override the hook's disabled:true", async () => {
+    h.disabled = true;
+    const onPress = vi.fn();
+    const el = await mount({ disabled: false, onPress });
+
+    await act(async () => {
+      click(el);
+    });
+
+    expect(onPress).toHaveBeenCalledTimes(1);
+  });
+
+  it("lets a true prop override the hook's disabled:false", async () => {
+    h.disabled = false;
+    const onPress = vi.fn();
+    const el = await mount({ disabled: true, onPress });
+
+    await act(async () => {
+      click(el);
+    });
+
+    expect(onPress).not.toHaveBeenCalled();
+  });
+
+  it("defers to the hook when disabled is undefined", async () => {
+    h.disabled = false;
+    const onPress = vi.fn();
+    const el = await mount({ disabled: undefined, onPress });
+
+    await act(async () => {
+      click(el);
+    });
+
+    expect(onPress).toHaveBeenCalledTimes(1);
+  });
+});

package/src/primitives/composer/ComposerCancel.test.tsx

@@ -0,0 +1,116 @@
+import { act } from "react";
+import { createRoot, type Root } from "react-dom/client";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { ComposerCancel } from "./ComposerCancel";
+
+const h = vi.hoisted(() => ({
+  cancel: vi.fn<() => void>(),
+  disabled: false,
+}));
+
+vi.mock("@assistant-ui/core/react", () => ({
+  useComposerCancel: () => ({ cancel: h.cancel, disabled: h.disabled }),
+}));
+
+(globalThis as Record<string, unknown>).IS_REACT_ACT_ENVIRONMENT = true;
+
+const click = (el: Element) => {
+  el.dispatchEvent(
+    new MouseEvent("click", { bubbles: true, cancelable: true }),
+  );
+};
+
+describe("ComposerCancel", () => {
+  let container: HTMLDivElement;
+  let root: Root;
+
+  beforeEach(() => {
+    h.cancel.mockReset();
+    h.disabled = false;
+
+    container = document.createElement("div");
+    document.body.appendChild(container);
+    root = createRoot(container);
+  });
+
+  afterEach(async () => {
+    await act(async () => {
+      root.unmount();
+    });
+    container.remove();
+  });
+
+  const mount = async (
+    props: Partial<Parameters<typeof ComposerCancel>[0]> = {},
+  ) => {
+    await act(async () => {
+      root.render(
+        <ComposerCancel testID="cancel" {...props}>
+          cancel
+        </ComposerCancel>,
+      );
+    });
+    const el = container.querySelector('[data-testid="cancel"]');
+    expect(el).not.toBeNull();
+    return el as Element;
+  };
+
+  it("renders its children", async () => {
+    const el = await mount();
+    expect(el.textContent).toBe("cancel");
+  });
+
+  it("calls cancel on press", async () => {
+    const el = await mount();
+
+    await act(async () => {
+      click(el);
+    });
+
+    expect(h.cancel).toHaveBeenCalledTimes(1);
+  });
+
+  it("does not press when the hook reports disabled", async () => {
+    h.disabled = true;
+    const el = await mount();
+
+    await act(async () => {
+      click(el);
+    });
+
+    expect(h.cancel).not.toHaveBeenCalled();
+  });
+
+  it("lets a false prop override the hook's disabled:true", async () => {
+    h.disabled = true;
+    const el = await mount({ disabled: false });
+
+    await act(async () => {
+      click(el);
+    });
+
+    expect(h.cancel).toHaveBeenCalledTimes(1);
+  });
+
+  it("lets a true prop override the hook's disabled:false", async () => {
+    h.disabled = false;
+    const el = await mount({ disabled: true });
+
+    await act(async () => {
+      click(el);
+    });
+
+    expect(h.cancel).not.toHaveBeenCalled();
+  });
+
+  it("defers to the hook when disabled is undefined", async () => {
+    h.disabled = false;
+    const el = await mount({ disabled: undefined });
+
+    await act(async () => {
+      click(el);
+    });
+
+    expect(h.cancel).toHaveBeenCalledTimes(1);
+  });
+});