@yh-ui/components 0.1.21 → 0.1.22

package/dist/ai-bubble/__tests__/ai-bubble.test.mjs

@@ -1,393 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { mount } from "@vue/test-utils";
-import AiBubble from "../src/ai-bubble.vue";
-describe("YhAiBubble", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-  it("should render with base class", () => {
-    const wrapper = mount(AiBubble, { props: { content: "hello", role: "assistant" } });
-    expect(wrapper.find(".yh-ai-bubble").exists()).toBe(true);
-  });
-  it("should apply role class for user", () => {
-    const wrapper = mount(AiBubble, { props: { content: "hi", role: "user" } });
-    expect(wrapper.classes()).toContain("yh-ai-bubble--user");
-  });
-  it("should apply role class for assistant", () => {
-    const wrapper = mount(AiBubble, { props: { content: "hi", role: "assistant" } });
-    expect(wrapper.classes()).toContain("yh-ai-bubble--assistant");
-  });
-  it("should not render avatar for system role", () => {
-    const wrapper = mount(AiBubble, { props: { content: "sys msg", role: "system" } });
-    expect(wrapper.find(".yh-ai-bubble__avatar").exists()).toBe(false);
-  });
-  it("should default placement to end for user role", () => {
-    const wrapper = mount(AiBubble, { props: { content: "hi", role: "user" } });
-    expect(wrapper.classes()).toContain("yh-ai-bubble--placement-end");
-  });
-  it("should default placement to start for assistant role", () => {
-    const wrapper = mount(AiBubble, { props: { content: "hi", role: "assistant" } });
-    expect(wrapper.classes()).toContain("yh-ai-bubble--placement-start");
-  });
-  it("should override placement via prop", () => {
-    const wrapper = mount(AiBubble, { props: { content: "hi", role: "user", placement: "start" } });
-    expect(wrapper.classes()).toContain("yh-ai-bubble--placement-start");
-  });
-  it("should apply shape class", () => {
-    const wrapper = mount(AiBubble, { props: { content: "hi", shape: "round" } });
-    expect(wrapper.classes()).toContain("yh-ai-bubble--shape-round");
-  });
-  it("should apply variant class", () => {
-    const wrapper = mount(AiBubble, { props: { content: "hi", variant: "borderless" } });
-    expect(wrapper.classes()).toContain("yh-ai-bubble--variant-borderless");
-  });
-  it("should show loading indicator when loading=true and content is empty", () => {
-    const wrapper = mount(AiBubble, { props: { loading: true, content: "" } });
-    expect(wrapper.classes()).toContain("is-loading");
-    expect(wrapper.find(".yh-ai-bubble__typing-indicator").exists()).toBe(true);
-  });
-  it("should not show typing indicator when content exists even if loading=true", () => {
-    const wrapper = mount(AiBubble, { props: { loading: true, content: "some text" } });
-    expect(wrapper.find(".yh-ai-bubble__typing-indicator").exists()).toBe(false);
-  });
-  it("should render plain text when markdown=false", () => {
-    const wrapper = mount(AiBubble, { props: { content: "plain text", markdown: false } });
-    expect(wrapper.find(".yh-ai-bubble__text").text()).toBe("plain text");
-    expect(wrapper.find(".yh-ai-bubble__markdown").exists()).toBe(false);
-  });
-  it("should render markdown container when markdown=true", () => {
-    const wrapper = mount(AiBubble, { props: { content: "hello", markdown: true } });
-    expect(wrapper.find(".yh-ai-bubble__markdown").exists()).toBe(true);
-  });
-  it("should render time when provided", () => {
-    const wrapper = mount(AiBubble, { props: { content: "hi", time: "10:00" } });
-    expect(wrapper.find(".yh-ai-bubble__time").text()).toBe("10:00");
-  });
-  it("should not render header without time and header slot", () => {
-    const wrapper = mount(AiBubble, { props: { content: "hi" } });
-    expect(wrapper.find(".yh-ai-bubble__header").exists()).toBe(false);
-  });
-  it("should apply is-typing class when typing=true", () => {
-    const wrapper = mount(AiBubble, { props: { content: "hi", typing: true } });
-    expect(wrapper.classes()).toContain("is-typing");
-  });
-  it("should render content via default slot", () => {
-    const wrapper = mount(AiBubble, {
-      slots: { default: '<span class="custom-content">Custom</span>' }
-    });
-    expect(wrapper.find(".custom-content").exists()).toBe(true);
-  });
-  it("should render footer slot when provided", () => {
-    const wrapper = mount(AiBubble, {
-      props: { content: "hi" },
-      slots: { footer: '<div class="custom-footer">Actions</div>' }
-    });
-    expect(wrapper.find(".yh-ai-bubble__footer").exists()).toBe(true);
-    expect(wrapper.find(".custom-footer").exists()).toBe(true);
-  });
-  it("should render header slot when provided", () => {
-    const wrapper = mount(AiBubble, {
-      props: { content: "hi" },
-      slots: { header: '<span class="custom-header">Header</span>' }
-    });
-    expect(wrapper.find(".yh-ai-bubble__header").exists()).toBe(true);
-    expect(wrapper.find(".custom-header").exists()).toBe(true);
-  });
-  it("should render avatar slot when provided", () => {
-    const wrapper = mount(AiBubble, {
-      props: { content: "hi", role: "user" },
-      slots: { avatar: '<img class="custom-avatar" src="test.png" />' }
-    });
-    expect(wrapper.find(".custom-avatar").exists()).toBe(true);
-  });
-  it("should render multimodal content - image", () => {
-    const multimodal = [{ type: "image", url: "img.png", title: "test image" }];
-    const wrapper = mount(AiBubble, { props: { content: "", multimodal } });
-    expect(wrapper.find(".yh-ai-bubble__image-grid").exists()).toBe(true);
-  });
-  it("should render multimodal content - audio", async () => {
-    const multimodal = [{ type: "audio", url: "audio.mp3", title: "test audio" }];
-    const wrapper = mount(AiBubble, { props: { content: "", multimodal } });
-    expect(wrapper.find(".yh-ai-bubble__audio-player").exists()).toBe(true);
-    const playMock = vi.fn().mockResolvedValue(void 0);
-    const pauseMock = vi.fn();
-    class MockAudio {
-      play = playMock;
-      pause = pauseMock;
-      onended = null;
-    }
-    vi.stubGlobal("Audio", MockAudio);
-    await wrapper.find(".yh-ai-bubble__audio-player button").trigger("click");
-    expect(playMock).toHaveBeenCalled();
-    await wrapper.find(".yh-ai-bubble__audio-player button").trigger("click");
-    expect(pauseMock).toHaveBeenCalled();
-  });
-  it("should render multimodal content - file", () => {
-    const multimodal = [{ type: "file", url: "test.pdf", title: "test.pdf", size: "10KB" }];
-    const wrapper = mount(AiBubble, { props: { content: "", multimodal } });
-    expect(wrapper.find(".yh-ai-bubble__file-card").exists()).toBe(true);
-    expect(wrapper.html()).toContain("10KB");
-  });
-  it("should render JSON structured data", () => {
-    const structuredData = { type: "json", data: { name: "test" } };
-    const wrapper = mount(AiBubble, { props: { content: "", structuredData } });
-    expect(wrapper.find(".yh-ai-bubble__json-viewer").exists()).toBe(true);
-  });
-  it("should render thought-chain structured data", () => {
-    const structuredData = { type: "thought-chain", data: [] };
-    const wrapper = mount(AiBubble, { props: { content: "", structuredData } });
-    expect(wrapper.findComponent({ name: "YhAiThoughtChain" }).exists()).toBe(true);
-  });
-  it("should handle citation click", async () => {
-    const onCitationClick = vi.fn();
-    const cita = { id: 1, title: "link", url: "http://x.com" };
-    const wrapper = mount(AiBubble, {
-      props: { content: "test [1]", citations: [cita], onCitationClick }
-    });
-    await wrapper.find(".yh-ai-bubble__citation-item").trigger("click");
-    expect(onCitationClick).toHaveBeenCalledWith(cita);
-    const openSpy = vi.spyOn(window, "open").mockImplementation(() => null);
-    const wrapper2 = mount(AiBubble, {
-      props: { content: "test", citations: [cita] }
-    });
-    await wrapper2.find(".yh-ai-bubble__citation-item").trigger("click");
-    expect(openSpy).toHaveBeenCalledWith("http://x.com", "_blank");
-  });
-  it("should show citation tooltip on hover", async () => {
-    vi.useFakeTimers();
-    const cita = { id: "1", title: "ref 1", content: "detailed info" };
-    const wrapper = mount(AiBubble, {
-      props: { content: "test", citations: [cita] }
-    });
-    const mockEvent = {
-      target: {
-        classList: { contains: (c) => c === "yh-ai-citation" },
-        getAttribute: (a) => a === "data-id" ? "1" : null,
-        getBoundingClientRect: () => ({ top: 100, left: 100, width: 20 })
-      }
-    };
-    wrapper.vm.handleCitationHover(mockEvent);
-    expect(wrapper.vm.hoveredCitation).toEqual(cita);
-    wrapper.vm.handleCitationLeave(mockEvent);
-    vi.advanceTimersByTime(300);
-    expect(wrapper.vm.hoveredCitation).toBeNull();
-    vi.useRealTimers();
-  });
-  it("should handle code block actions - collapse", async () => {
-    const wrapper = mount(AiBubble);
-    const mockEvent = {
-      target: {
-        classList: { contains: (c) => c === "collapse-btn" || c === "code-action-btn" },
-        getAttribute: (a) => a === "data-id" ? "cb-1" : null
-      }
-    };
-    await wrapper.vm.handleCodeBlockAction(mockEvent);
-    expect(wrapper.vm.expandedCodeBlocks.has("cb-1")).toBe(true);
-  });
-  it("should trigger download on button click", async () => {
-    const openSpy = vi.spyOn(window, "open").mockImplementation(() => null);
-    const multimodal = [{ type: "file", url: "test.zip", title: "test" }];
-    const wrapper = mount(AiBubble, { props: { content: "", multimodal } });
-    await wrapper.find(".yh-ai-bubble__file-card button").trigger("click");
-    expect(openSpy).toHaveBeenCalledWith("test.zip", "_blank");
-  });
-  it("getFileIcon should return correct icons", () => {
-    const wrapper = mount(AiBubble);
-    const getFileIcon = wrapper.vm.getFileIcon;
-    expect(getFileIcon("test.pdf")).toBe("file-pdf");
-    expect(getFileIcon("test.xlsx")).toBe("file-excel");
-    expect(getFileIcon("test.docx")).toBe("file-word");
-    expect(getFileIcon("test.mp4")).toBe("file-video");
-    expect(getFileIcon("test.mp3")).toBe("file-audio");
-    expect(getFileIcon("test.txt")).toBe("file-txt");
-    expect(getFileIcon("unknown")).toBe("document");
-  });
-  it("should handle code block actions - copy", async () => {
-    const wrapper = mount(AiBubble, { props: { content: "```js\nconsole.log(1)\n```" } });
-    const copySpy = vi.spyOn(navigator.clipboard, "writeText").mockResolvedValue(void 0);
-    const mockEvent = {
-      target: {
-        classList: { contains: (c) => c === "code-action-btn" || c === "copy-btn" },
-        getAttribute: (a) => {
-          if (a === "data-code") return encodeURIComponent("console.log(1)");
-          if (a === "data-id") return "cb-1";
-          return null;
-        }
-      }
-    };
-    await wrapper.vm.handleCodeBlockAction(mockEvent);
-    expect(copySpy).toHaveBeenCalledWith("console.log(1)");
-  });
-  it("should handle code block actions - run", async () => {
-    const onRunCode = vi.fn().mockResolvedValue({ output: "done" });
-    const wrapper = mount(AiBubble, { props: { content: "```js\n1+1\n```", onRunCode } });
-    const mockEvent = {
-      target: {
-        classList: { contains: (c) => c === "code-action-btn" || c === "run-btn" },
-        getAttribute: (a) => {
-          if (a === "data-code") return encodeURIComponent("1+1");
-          if (a === "data-lang") return "js";
-          if (a === "data-id") return "cb-1";
-          return null;
-        }
-      }
-    };
-    await wrapper.vm.handleCodeBlockAction(mockEvent);
-    expect(onRunCode).toHaveBeenCalled();
-  });
-  it("should toggle code block expansion", () => {
-    const wrapper = mount(AiBubble);
-    wrapper.vm.toggleCodeBlock("cb-1");
-    expect(wrapper.vm.expandedCodeBlocks.has("cb-1")).toBe(true);
-    wrapper.vm.toggleCodeBlock("cb-1");
-    expect(wrapper.vm.expandedCodeBlocks.has("cb-1")).toBe(false);
-  });
-  it("should handle explain code block", async () => {
-    const onExplainCode = vi.fn().mockResolvedValue("explanation");
-    const wrapper = mount(AiBubble, { props: { onExplainCode } });
-    const mockEvent = {
-      target: {
-        classList: { contains: (c) => c === "explain-btn" || c === "code-action-btn" },
-        getAttribute: (a) => {
-          if (a === "data-code") return "code";
-          if (a === "data-lang") return "js";
-          if (a === "data-id") return "cb-1";
-          return null;
-        }
-      }
-    };
-    await wrapper.vm.handleCodeBlockAction(mockEvent);
-    expect(onExplainCode).toHaveBeenCalled();
-    expect(wrapper.vm.codeOutput["cb-1"]).toEqual(["explanation"]);
-  });
-  it("should handle code block actions - edit", async () => {
-    const mockEditor = {
-      dispose: vi.fn(),
-      getValue: vi.fn().mockReturnValue("edited code")
-    };
-    const mockMonaco = {
-      editor: {
-        create: vi.fn().mockReturnValue(mockEditor)
-      }
-    };
-    const wrapper = mount(AiBubble);
-    wrapper.vm.monaco = mockMonaco;
-    const mockEvent = {
-      target: {
-        classList: { contains: (c) => c === "code-action-btn" || c === "edit-btn" },
-        getAttribute: (a) => {
-          if (a === "data-code") return encodeURIComponent("raw context");
-          if (a === "data-lang") return "javascript";
-          if (a === "data-id") return "cb-1";
-          return null;
-        }
-      }
-    };
-    await wrapper.vm.handleCodeBlockAction(mockEvent);
-    expect(wrapper.vm.editingCodeBlock).toBe("cb-1");
-    await wrapper.vm.saveEditCode("cb-1");
-    expect(wrapper.vm.editingCodeBlock).toBeNull();
-  });
-  it("should handle onRunCode with async iterator", async () => {
-    const mockGenerator = async function* () {
-      yield { output: "chunk 1" };
-      yield { output: "chunk 2" };
-    };
-    const onRunCode = vi.fn().mockResolvedValue(mockGenerator());
-    const wrapper = mount(AiBubble, { props: { onRunCode } });
-    const mockEvent = {
-      target: {
-        classList: { contains: (c) => c === "run-btn" || c === "code-action-btn" },
-        getAttribute: (a) => {
-          if (a === "data-code") return "code";
-          if (a === "data-lang") return "js";
-          if (a === "data-id") return "cb-1";
-          return null;
-        }
-      }
-    };
-    await wrapper.vm.handleCodeBlockAction(mockEvent);
-    expect(onRunCode).toHaveBeenCalled();
-  });
-  it("should support streaming increments", async () => {
-    vi.useFakeTimers();
-    const onStreamComplete = vi.fn();
-    const wrapper = mount(AiBubble, {
-      props: {
-        content: "hello world",
-        typing: true,
-        streaming: true,
-        streamSpeed: 2,
-        streamInterval: 10,
-        onStreamComplete
-      }
-    });
-    vi.advanceTimersByTime(100);
-    await wrapper.vm.$nextTick();
-    expect(onStreamComplete).toHaveBeenCalled();
-    vi.useRealTimers();
-  });
-  it("should render table structured data", () => {
-    const structuredData = {
-      type: "table",
-      data: { headers: ["A", "B"], rows: [["1", "2"]] }
-    };
-    const wrapper = mount(AiBubble, { props: { content: "", structuredData } });
-    expect(wrapper.find("table").exists()).toBe(true);
-    expect(wrapper.find("th").text()).toBe("A");
-  });
-  it("should handle markdown=true but no mdi initialized", async () => {
-    const wrapper = mount(AiBubble, { props: { content: "hi", markdown: true } });
-    expect(wrapper.find(".yh-ai-bubble__markdown").exists()).toBe(true);
-  });
-  it("should handle multimodal download", async () => {
-    const openSpy = vi.spyOn(window, "open").mockImplementation(() => null);
-    const wrapper = mount(AiBubble);
-    wrapper.vm.handleDownload("test.zip");
-    expect(openSpy).toHaveBeenCalledWith("test.zip", "_blank");
-  });
-  it("should hit onBeforeUnmount", () => {
-    const wrapper = mount(AiBubble, { props: { content: "test" } });
-    wrapper.unmount();
-  });
-  it("should test escapeHtml utility", () => {
-    const wrapper = mount(AiBubble);
-    const escapeHtml = wrapper.vm.escapeHtml;
-    expect(escapeHtml(`<div>&"'</div>`)).toBe("&lt;div&gt;&amp;&quot;&#39;&lt;/div&gt;");
-  });
-  it("should support sentence stream mode", async () => {
-    vi.useFakeTimers();
-    const onStreamComplete = vi.fn();
-    mount(AiBubble, {
-      props: {
-        content: "Sentence one. Sentence two!",
-        typing: true,
-        streaming: true,
-        streamMode: "sentence",
-        onStreamComplete
-      }
-    });
-    vi.advanceTimersByTime(1e3);
-    expect(onStreamComplete).toHaveBeenCalled();
-    vi.useRealTimers();
-  });
-  it("should support paragraph stream mode", async () => {
-    vi.useFakeTimers();
-    const onStreamComplete = vi.fn();
-    mount(AiBubble, {
-      props: {
-        content: "Para one\n\nPara two",
-        typing: true,
-        streaming: true,
-        streamMode: "paragraph",
-        onStreamComplete
-      }
-    });
-    vi.advanceTimersByTime(1e3);
-    expect(onStreamComplete).toHaveBeenCalled();
-    vi.useRealTimers();
-  });
-});

package/dist/ai-bubble-list/__tests__/ai-bubble-list.ssr.test.cjs

@@ -1,51 +0,0 @@
-"use strict";
-
-var _vitest = require("vitest");
-var _serverRenderer = require("@vue/server-renderer");
-var _vue = require("vue");
-var _aiBubbleList = _interopRequireDefault(require("../src/ai-bubble-list.vue"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-(0, _vitest.describe)("YhAiBubbleList SSR", () => {
-  const mockItems = [{
-    id: 1,
-    content: "Hello",
-    role: "user"
-  }, {
-    id: 2,
-    content: "Hi there!",
-    role: "assistant"
-  }];
-  (0, _vitest.it)("should render to string on server", async () => {
-    const html = await (0, _serverRenderer.renderToString)((0, _vue.h)(_aiBubbleList.default, {
-      items: mockItems
-    }));
-    (0, _vitest.expect)(html).toContain("yh-ai-bubble-list");
-    (0, _vitest.expect)(html).toContain("yh-ai-bubble");
-    (0, _vitest.expect)(html).toContain("Hello");
-    (0, _vitest.expect)(html).toContain("Hi there!");
-  });
-  (0, _vitest.it)("should render custom height on server", async () => {
-    const html = await (0, _serverRenderer.renderToString)((0, _vue.h)(_aiBubbleList.default, {
-      items: mockItems,
-      height: "600px"
-    }));
-    (0, _vitest.expect)(html).toContain('style="height:600px;"');
-  });
-  (0, _vitest.it)("should render loading state on server", async () => {
-    const html = await (0, _serverRenderer.renderToString)((0, _vue.h)(_aiBubbleList.default, {
-      items: [],
-      loading: true
-    }));
-    (0, _vitest.expect)(html).toContain("yh-ai-bubble-list__loading");
-  });
-  (0, _vitest.it)("should render virtual scroll skeleton on server", async () => {
-    const html = await (0, _serverRenderer.renderToString)((0, _vue.h)(_aiBubbleList.default, {
-      items: mockItems,
-      virtualScroll: true,
-      height: 400
-    }));
-    (0, _vitest.expect)(html).toContain("is-virtual");
-    (0, _vitest.expect)(html).toContain("yh-ai-bubble-list__virtual-phantom");
-    (0, _vitest.expect)(html).toContain("yh-ai-bubble-list__virtual-content");
-  });
-});

package/dist/ai-bubble-list/__tests__/ai-bubble-list.ssr.test.mjs

@@ -1,51 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { renderToString } from "@vue/server-renderer";
-import { h } from "vue";
-import AiBubbleList from "../src/ai-bubble-list.vue";
-describe("YhAiBubbleList SSR", () => {
-  const mockItems = [
-    { id: 1, content: "Hello", role: "user" },
-    { id: 2, content: "Hi there!", role: "assistant" }
-  ];
-  it("should render to string on server", async () => {
-    const html = await renderToString(
-      h(AiBubbleList, {
-        items: mockItems
-      })
-    );
-    expect(html).toContain("yh-ai-bubble-list");
-    expect(html).toContain("yh-ai-bubble");
-    expect(html).toContain("Hello");
-    expect(html).toContain("Hi there!");
-  });
-  it("should render custom height on server", async () => {
-    const html = await renderToString(
-      h(AiBubbleList, {
-        items: mockItems,
-        height: "600px"
-      })
-    );
-    expect(html).toContain('style="height:600px;"');
-  });
-  it("should render loading state on server", async () => {
-    const html = await renderToString(
-      h(AiBubbleList, {
-        items: [],
-        loading: true
-      })
-    );
-    expect(html).toContain("yh-ai-bubble-list__loading");
-  });
-  it("should render virtual scroll skeleton on server", async () => {
-    const html = await renderToString(
-      h(AiBubbleList, {
-        items: mockItems,
-        virtualScroll: true,
-        height: 400
-      })
-    );
-    expect(html).toContain("is-virtual");
-    expect(html).toContain("yh-ai-bubble-list__virtual-phantom");
-    expect(html).toContain("yh-ai-bubble-list__virtual-content");
-  });
-});

package/dist/ai-bubble-list/__tests__/ai-bubble-list.test.cjs

@@ -1,138 +0,0 @@
-"use strict";
-
-var _vitest = require("vitest");
-var _testUtils = require("@vue/test-utils");
-var _aiBubbleList = _interopRequireDefault(require("../src/ai-bubble-list.vue"));
-var _aiBubble = _interopRequireDefault(require("../../ai-bubble/src/ai-bubble.vue"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-(0, _vitest.describe)("YhAiBubbleList", () => {
-  (0, _vitest.beforeEach)(() => {
-    _vitest.vi.clearAllMocks();
-  });
-  (0, _vitest.afterEach)(() => {
-    _vitest.vi.restoreAllMocks();
-  });
-  const mockItems = [{
-    id: 1,
-    content: "Hello",
-    role: "user"
-  }, {
-    id: 2,
-    content: "Hi there!",
-    role: "assistant"
-  }, {
-    id: 3,
-    content: "How can I help you?",
-    role: "assistant"
-  }];
-  (0, _vitest.it)("should render correct number of items", () => {
-    const wrapper = (0, _testUtils.mount)(_aiBubbleList.default, {
-      props: {
-        items: mockItems
-      }
-    });
-    (0, _vitest.expect)(wrapper.findAll(".yh-ai-bubble-list__item")).toHaveLength(3);
-    (0, _vitest.expect)(wrapper.findAllComponents(_aiBubble.default)).toHaveLength(3);
-  });
-  (0, _vitest.it)("should apply custom height", () => {
-    const wrapper = (0, _testUtils.mount)(_aiBubbleList.default, {
-      props: {
-        items: mockItems,
-        height: 500
-      }
-    });
-    const el = wrapper.element;
-    (0, _vitest.expect)(el.style.height).toBe("500px");
-  });
-  (0, _vitest.it)("should render loading state", () => {
-    const wrapper = (0, _testUtils.mount)(_aiBubbleList.default, {
-      props: {
-        items: mockItems,
-        loading: true
-      }
-    });
-    (0, _vitest.expect)(wrapper.find(".yh-ai-bubble-list__loading").exists()).toBe(true);
-  });
-  (0, _vitest.it)("should use virtual scroll when virtualScroll=true", () => {
-    const wrapper = (0, _testUtils.mount)(_aiBubbleList.default, {
-      props: {
-        items: Array.from({
-          length: 100
-        }).map((_, i) => ({
-          id: i,
-          content: `msg ${i}`,
-          role: "user"
-        })),
-        virtualScroll: true,
-        height: 400,
-        itemHeight: 50
-      }
-    });
-    (0, _vitest.expect)(wrapper.classes()).toContain("is-virtual");
-    (0, _vitest.expect)(wrapper.find(".yh-ai-bubble-list__virtual-phantom").exists()).toBe(true);
-    (0, _vitest.expect)(wrapper.findAll(".yh-ai-bubble-list__item").length).toBeLessThan(100);
-  });
-  (0, _vitest.it)("should support custom bubble slot", () => {
-    const wrapper = (0, _testUtils.mount)(_aiBubbleList.default, {
-      props: {
-        items: [{
-          id: 1,
-          content: "test",
-          role: "user"
-        }]
-      },
-      slots: {
-        bubble: `
-          <template #bubble="{ item }">
-            <div class="custom-bubble">{{ item.content }}</div>
-          </template>
-        `
-      }
-    });
-    (0, _vitest.expect)(wrapper.find(".custom-bubble").exists()).toBe(true);
-    (0, _vitest.expect)(wrapper.find(".custom-bubble").text()).toBe("test");
-  });
-  (0, _vitest.it)("should support custom loading slot", () => {
-    const wrapper = (0, _testUtils.mount)(_aiBubbleList.default, {
-      props: {
-        items: [],
-        loading: true
-      },
-      slots: {
-        loading: '<div class="custom-loading">Loading...</div>'
-      }
-    });
-    (0, _vitest.expect)(wrapper.find(".custom-loading").exists()).toBe(true);
-  });
-  (0, _vitest.it)("should expose scrollToBottom method", async () => {
-    const wrapper = (0, _testUtils.mount)(_aiBubbleList.default, {
-      props: {
-        items: mockItems
-      }
-    });
-    (0, _vitest.expect)(typeof wrapper.vm.scrollToBottom).toBe("function");
-  });
-  (0, _vitest.it)("should automatically scroll to bottom when items change", async () => {
-    const wrapper = (0, _testUtils.mount)(_aiBubbleList.default, {
-      props: {
-        items: mockItems,
-        autoScroll: true
-      }
-    });
-    const scrollRef = {
-      value: {
-        scrollTop: 0,
-        scrollHeight: 1e3
-      }
-    };
-    wrapper.vm.scrollRef = scrollRef;
-    await wrapper.setProps({
-      items: [...mockItems, {
-        id: 4,
-        content: "new msg",
-        role: "user"
-      }]
-    });
-    await new Promise(resolve => setTimeout(resolve, 0));
-  });
-});