@assistant-ui/core 0.1.15 → 0.1.17

package/src/tests/base-composer-runtime-core-addAttachment.test.ts

@@ -0,0 +1,217 @@
+import { describe, expect, it, vi } from "vitest";
+import { DefaultThreadComposerRuntimeCore } from "../runtime/base/default-thread-composer-runtime-core";
+import type { AttachmentAdapter } from "../adapters/attachment";
+import type { ThreadRuntimeCore } from "../runtime/interfaces/thread-runtime-core";
+import type { PendingAttachment } from "../types/attachment";
+
+const makeAdapter = (
+  overrides: Partial<AttachmentAdapter> = {},
+): AttachmentAdapter => ({
+  accept: "image/*",
+  add: async ({ file }: { file: File }): Promise<PendingAttachment> => ({
+    id: "att-1",
+    type: "image",
+    name: file.name,
+    contentType: file.type,
+    file,
+    status: { type: "running", reason: "uploading", progress: 0 },
+  }),
+  remove: async () => {},
+  send: async (a) => ({ ...a, status: { type: "complete" }, content: [] }),
+  ...overrides,
+});
+
+const makeComposer = (adapter?: AttachmentAdapter) => {
+  const runtime = {
+    append: vi.fn(),
+    cancelRun: vi.fn(),
+    subscribe: vi.fn(() => () => {}),
+    capabilities: { cancel: false },
+    messages: [],
+    adapters: adapter ? { attachments: adapter } : undefined,
+  } as unknown as Omit<ThreadRuntimeCore, "composer"> & {
+    adapters?: { attachments?: AttachmentAdapter };
+  };
+  return new DefaultThreadComposerRuntimeCore(runtime);
+};
+
+describe("BaseComposerRuntimeCore.addAttachment error events", () => {
+  it("emits attachmentAddError when no adapter is configured", async () => {
+    const composer = makeComposer();
+    const onError = vi.fn();
+    const onAdd = vi.fn();
+    composer.unstable_on("attachmentAddError", onError);
+    composer.unstable_on("attachmentAdd", onAdd);
+
+    await expect(
+      composer.addAttachment(new File(["x"], "f.txt", { type: "text/plain" })),
+    ).rejects.toThrow("Attachments are not supported");
+
+    expect(onError).toHaveBeenCalledTimes(1);
+    expect(onError).toHaveBeenCalledWith(
+      expect.objectContaining({
+        reason: "no-adapter",
+        message: "Attachments are not supported",
+        error: expect.any(Error),
+      }),
+    );
+    expect(onAdd).not.toHaveBeenCalled();
+  });
+
+  it("emits attachmentAddError when file type is rejected by adapter.accept", async () => {
+    const composer = makeComposer(makeAdapter());
+    const onError = vi.fn();
+    const onAdd = vi.fn();
+    composer.unstable_on("attachmentAddError", onError);
+    composer.unstable_on("attachmentAdd", onAdd);
+
+    await expect(
+      composer.addAttachment(new File(["x"], "f.txt", { type: "text/plain" })),
+    ).rejects.toThrow(/File type text\/plain is not accepted/);
+
+    expect(onError).toHaveBeenCalledTimes(1);
+    expect(onError).toHaveBeenCalledWith(
+      expect.objectContaining({
+        reason: "not-accepted",
+        message: expect.stringContaining(
+          "File type text/plain is not accepted",
+        ),
+        error: expect.any(Error),
+      }),
+    );
+    expect(onAdd).not.toHaveBeenCalled();
+  });
+
+  it("emits attachmentAddError when adapter.add throws", async () => {
+    const composer = makeComposer(
+      makeAdapter({
+        add: async () => {
+          throw new Error("upload failed");
+        },
+      }),
+    );
+    const onError = vi.fn();
+    const onAdd = vi.fn();
+    composer.unstable_on("attachmentAddError", onError);
+    composer.unstable_on("attachmentAdd", onAdd);
+
+    await expect(
+      composer.addAttachment(new File(["x"], "f.png", { type: "image/png" })),
+    ).rejects.toThrow("upload failed");
+
+    expect(onError).toHaveBeenCalledTimes(1);
+    expect(onError).toHaveBeenCalledWith(
+      expect.objectContaining({
+        reason: "adapter-error",
+        message: "upload failed",
+        error: expect.any(Error),
+      }),
+    );
+    expect(onAdd).not.toHaveBeenCalled();
+  });
+
+  it("emits attachmentAdd on successful add", async () => {
+    const composer = makeComposer(makeAdapter());
+    const onError = vi.fn();
+    const onAdd = vi.fn();
+    composer.unstable_on("attachmentAddError", onError);
+    composer.unstable_on("attachmentAdd", onAdd);
+
+    await composer.addAttachment(
+      new File(["x"], "f.png", { type: "image/png" }),
+    );
+
+    expect(onAdd).toHaveBeenCalledTimes(1);
+    expect(onError).not.toHaveBeenCalled();
+  });
+
+  it("does not let subscriber errors mask the original throw", async () => {
+    const composer = makeComposer(makeAdapter());
+    composer.unstable_on("attachmentAddError", () => {
+      throw new Error("subscriber boom");
+    });
+
+    await expect(
+      composer.addAttachment(new File(["x"], "f.txt", { type: "text/plain" })),
+    ).rejects.toThrow(/File type text\/plain is not accepted/);
+  });
+
+  it("emits attachmentAddError when async generator adapter throws mid-iteration", async () => {
+    const composer = makeComposer(
+      makeAdapter({
+        async *add({ file }: { file: File }) {
+          yield {
+            id: "att-1",
+            type: "image" as const,
+            name: file.name,
+            contentType: file.type,
+            file,
+            status: {
+              type: "running" as const,
+              reason: "uploading" as const,
+              progress: 0,
+            },
+          };
+          throw new Error("network error");
+        },
+      }),
+    );
+    const onError = vi.fn();
+    const onAdd = vi.fn();
+    composer.unstable_on("attachmentAddError", onError);
+    composer.unstable_on("attachmentAdd", onAdd);
+
+    await expect(
+      composer.addAttachment(new File(["x"], "f.png", { type: "image/png" })),
+    ).rejects.toThrow("network error");
+
+    expect(onError).toHaveBeenCalledTimes(1);
+    expect(onError).toHaveBeenCalledWith(
+      expect.objectContaining({
+        reason: "adapter-error",
+        message: "network error",
+        attachmentId: "att-1",
+        error: expect.any(Error),
+      }),
+    );
+    expect(onAdd).not.toHaveBeenCalled();
+    expect(composer.attachments).toHaveLength(1);
+    const att = composer.attachments[0]!;
+    expect(att.status.type).toBe("incomplete");
+    if (att.status.type === "incomplete") {
+      expect(att.status.reason).toBe("error");
+    }
+  });
+
+  it("emits attachmentAddError with attachment id when adapter yields an errored attachment", async () => {
+    const composer = makeComposer(
+      makeAdapter({
+        add: async ({ file }) => ({
+          id: "att-2",
+          type: "image",
+          name: file.name,
+          contentType: file.type,
+          file,
+          status: { type: "incomplete", reason: "error" },
+        }),
+      }),
+    );
+    const onError = vi.fn();
+    const onAdd = vi.fn();
+    composer.unstable_on("attachmentAddError", onError);
+    composer.unstable_on("attachmentAdd", onAdd);
+
+    await composer.addAttachment(
+      new File(["x"], "f.png", { type: "image/png" }),
+    );
+
+    expect(onError).toHaveBeenCalledTimes(1);
+    expect(onError).toHaveBeenCalledWith(
+      expect.objectContaining({
+        reason: "adapter-error",
+        attachmentId: "att-2",
+      }),
+    );
+    expect(onAdd).not.toHaveBeenCalled();
+  });
+});

package/src/tests/groupParts.test.ts

@@ -0,0 +1,114 @@
+import { describe, expect, it } from "vitest";
+import {
+  buildGroupTree,
+  normalizeGroupKey,
+  type GroupNode,
+} from "../react/utils/groupParts";
+
+const asPaths = (keys: readonly (string | readonly string[] | null)[]) =>
+  keys.map((k) => normalizeGroupKey(k));
+
+// Compact tree dump: "G:key#nodeKey[i,j]{...}" | "P:#nodeKey(i)"
+const dump = (nodes: readonly GroupNode[]): string =>
+  nodes
+    .map((n) => {
+      if (n.type === "part") {
+        return `P:#${n.nodeKey}(${n.index})`;
+      }
+      const inner = dump(n.children);
+      return `G:${n.key}#${n.nodeKey}[${n.indices.join(",")}]{${inner}}`;
+    })
+    .join(",");
+
+describe("normalizeGroupKey", () => {
+  it("maps null/undefined/[] to []", () => {
+    expect(normalizeGroupKey(null)).toEqual([]);
+    expect(normalizeGroupKey(undefined)).toEqual([]);
+    expect(normalizeGroupKey([])).toEqual([]);
+  });
+
+  it("wraps a string into a single-element array", () => {
+    expect(normalizeGroupKey("foo")).toEqual(["foo"]);
+  });
+
+  it("passes arrays through", () => {
+    expect(normalizeGroupKey(["a", "b"])).toEqual(["a", "b"]);
+  });
+});
+
+describe("buildGroupTree", () => {
+  it("returns an empty list for no parts", () => {
+    expect(buildGroupTree([])).toEqual([]);
+  });
+
+  it("emits one part leaf per ungrouped part (no coalescing)", () => {
+    const tree = buildGroupTree(asPaths([null, null, null]));
+    expect(dump(tree)).toBe("P:#0(0),P:#1(1),P:#2(2)");
+  });
+
+  it("wraps adjacent same-key parts in one group with one part child each", () => {
+    const tree = buildGroupTree(asPaths(["a", "a", "a"]));
+    expect(dump(tree)).toBe("G:a#0[0,1,2]{P:#0.0(0),P:#0.1(1),P:#0.2(2)}");
+  });
+
+  it("splits non-adjacent runs of the same key into separate groups", () => {
+    const tree = buildGroupTree(asPaths(["a", null, "a"]));
+    expect(dump(tree)).toBe("G:a#0[0]{P:#0.0(0)},P:#1(1),G:a#2[2]{P:#2.0(2)}");
+  });
+
+  it("nests groups: parts at depth 1 sit alongside depth-2 subgroups", () => {
+    // ["A","B"], ["A","B"], ["A"], ["A"], ["A","C"]:
+    // Outer A spans 0..4. Inside A: a B subgroup (0,1), two depth-1 parts
+    // (2,3), then a C subgroup (4).
+    const tree = buildGroupTree(
+      asPaths([["A", "B"], ["A", "B"], ["A"], ["A"], ["A", "C"]]),
+    );
+    expect(dump(tree)).toBe(
+      "G:A#0[0,1,2,3,4]{G:B#0.0[0,1]{P:#0.0.0(0),P:#0.0.1(1)},P:#0.1(2),P:#0.2(3),G:C#0.3[4]{P:#0.3.0(4)}}",
+    );
+  });
+
+  it("treats longer prefix changes as group close+open", () => {
+    // ["A","B"], ["A","B","C"], ["A","B"]: opens C under B, closes back.
+    const tree = buildGroupTree(
+      asPaths([
+        ["A", "B"],
+        ["A", "B", "C"],
+        ["A", "B"],
+      ]),
+    );
+    expect(dump(tree)).toBe(
+      "G:A#0[0,1,2]{G:B#0.0[0,1,2]{P:#0.0.0(0),G:C#0.0.1[1]{P:#0.0.1.0(1)},P:#0.0.2(2)}}",
+    );
+  });
+
+  it("does not coalesce same-keyed groups separated by a divergent sibling", () => {
+    const tree = buildGroupTree(
+      asPaths([
+        ["A", "B"],
+        ["A", "C"],
+        ["A", "B"],
+      ]),
+    );
+    expect(dump(tree)).toBe(
+      "G:A#0[0,1,2]{G:B#0.0[0]{P:#0.0.0(0)},G:C#0.1[1]{P:#0.1.0(1)},G:B#0.2[2]{P:#0.2.0(2)}}",
+    );
+  });
+
+  it("accepts strings and arrays interchangeably via normalizeGroupKey", () => {
+    const tree = buildGroupTree([
+      normalizeGroupKey("A"),
+      normalizeGroupKey(["A"]),
+    ]);
+    expect(dump(tree)).toBe("G:A#0[0,1]{P:#0.0(0),P:#0.1(1)}");
+  });
+
+  it("assigns stable nodeKeys under append (existing keys do not shift)", () => {
+    const before = buildGroupTree(asPaths([["A"], null]));
+    const after = buildGroupTree(asPaths([["A"], null, ["B"]]));
+
+    expect(before[0]!.nodeKey).toBe(after[0]!.nodeKey);
+    expect(before[1]!.nodeKey).toBe(after[1]!.nodeKey);
+    expect(after[2]!.nodeKey).toBe("2");
+  });
+});