@yh-ui/components 0.1.10 → 0.1.12

package/dist/ai-thought-chain/__tests__/ai-thought-chain.ssr.test.cjs

@@ -0,0 +1,83 @@
+"use strict";
+
+var _vitest = require("vitest");
+var _serverRenderer = require("@vue/server-renderer");
+var _vue = require("vue");
+var _aiThoughtChain = _interopRequireDefault(require("../src/ai-thought-chain.vue"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+(0, _vitest.describe)("YhAiThoughtChain SSR", () => {
+  (0, _vitest.it)("should render to string on server", async () => {
+    const html = await (0, _serverRenderer.renderToString)((0, _vue.h)(_aiThoughtChain.default));
+    (0, _vitest.expect)(html).toContain("yh-ai-thought-chain");
+  });
+  (0, _vitest.it)("should render single node header on server", async () => {
+    const html = await (0, _serverRenderer.renderToString)((0, _vue.h)(_aiThoughtChain.default, {
+      title: "SSR Thought"
+    }));
+    (0, _vitest.expect)(html).toContain("SSR Thought");
+    (0, _vitest.expect)(html).toContain("yh-ai-thought-chain__header");
+  });
+  (0, _vitest.it)("should render thinking is-thinking class on server", async () => {
+    const html = await (0, _serverRenderer.renderToString)((0, _vue.h)(_aiThoughtChain.default, {
+      thinking: true
+    }));
+    (0, _vitest.expect)(html).toContain("is-thinking");
+  });
+  (0, _vitest.it)("should render timeline items on server", async () => {
+    const items = [{
+      title: "Step One",
+      status: "complete",
+      content: "Done"
+    }, {
+      title: "Step Two",
+      status: "thinking",
+      content: "In progress"
+    }];
+    const html = await (0, _serverRenderer.renderToString)((0, _vue.h)(_aiThoughtChain.default, {
+      items
+    }));
+    (0, _vitest.expect)(html).toContain("Step One");
+    (0, _vitest.expect)(html).toContain("Step Two");
+    (0, _vitest.expect)(html).toContain("yh-ai-thought-chain__item");
+    (0, _vitest.expect)(html).toContain("is-timeline");
+  });
+  (0, _vitest.it)("should render is-last class on last item on server", async () => {
+    const items = [{
+      title: "First",
+      status: "complete"
+    }, {
+      title: "Last",
+      status: "complete"
+    }];
+    const html = await (0, _serverRenderer.renderToString)((0, _vue.h)(_aiThoughtChain.default, {
+      items
+    }));
+    (0, _vitest.expect)(html).toContain("is-last");
+  });
+  (0, _vitest.it)("should render is-active class for thinking item on server", async () => {
+    const items = [{
+      title: "Running",
+      status: "thinking"
+    }];
+    const html = await (0, _serverRenderer.renderToString)((0, _vue.h)(_aiThoughtChain.default, {
+      items
+    }));
+    (0, _vitest.expect)(html).toContain("is-active");
+  });
+  (0, _vitest.it)("should render content text on server", async () => {
+    const html = await (0, _serverRenderer.renderToString)((0, _vue.h)(_aiThoughtChain.default, {
+      content: "SSR thought content"
+    }));
+    (0, _vitest.expect)(html).toContain("SSR thought content");
+  });
+  (0, _vitest.it)("should render status icon wrappers on server in timeline mode", async () => {
+    const items = [{
+      title: "Done",
+      status: "complete"
+    }];
+    const html = await (0, _serverRenderer.renderToString)((0, _vue.h)(_aiThoughtChain.default, {
+      items
+    }));
+    (0, _vitest.expect)(html).toContain("yh-ai-thought-chain__item-dot-wrapper");
+  });
+});

package/dist/ai-thought-chain/__tests__/ai-thought-chain.ssr.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/ai-thought-chain/__tests__/ai-thought-chain.ssr.test.mjs

@@ -0,0 +1,52 @@
+import { describe, it, expect } from "vitest";
+import { renderToString } from "@vue/server-renderer";
+import { h } from "vue";
+import AiThoughtChain from "../src/ai-thought-chain.vue";
+describe("YhAiThoughtChain SSR", () => {
+  it("should render to string on server", async () => {
+    const html = await renderToString(h(AiThoughtChain));
+    expect(html).toContain("yh-ai-thought-chain");
+  });
+  it("should render single node header on server", async () => {
+    const html = await renderToString(h(AiThoughtChain, { title: "SSR Thought" }));
+    expect(html).toContain("SSR Thought");
+    expect(html).toContain("yh-ai-thought-chain__header");
+  });
+  it("should render thinking is-thinking class on server", async () => {
+    const html = await renderToString(h(AiThoughtChain, { thinking: true }));
+    expect(html).toContain("is-thinking");
+  });
+  it("should render timeline items on server", async () => {
+    const items = [
+      { title: "Step One", status: "complete", content: "Done" },
+      { title: "Step Two", status: "thinking", content: "In progress" }
+    ];
+    const html = await renderToString(h(AiThoughtChain, { items }));
+    expect(html).toContain("Step One");
+    expect(html).toContain("Step Two");
+    expect(html).toContain("yh-ai-thought-chain__item");
+    expect(html).toContain("is-timeline");
+  });
+  it("should render is-last class on last item on server", async () => {
+    const items = [
+      { title: "First", status: "complete" },
+      { title: "Last", status: "complete" }
+    ];
+    const html = await renderToString(h(AiThoughtChain, { items }));
+    expect(html).toContain("is-last");
+  });
+  it("should render is-active class for thinking item on server", async () => {
+    const items = [{ title: "Running", status: "thinking" }];
+    const html = await renderToString(h(AiThoughtChain, { items }));
+    expect(html).toContain("is-active");
+  });
+  it("should render content text on server", async () => {
+    const html = await renderToString(h(AiThoughtChain, { content: "SSR thought content" }));
+    expect(html).toContain("SSR thought content");
+  });
+  it("should render status icon wrappers on server in timeline mode", async () => {
+    const items = [{ title: "Done", status: "complete" }];
+    const html = await renderToString(h(AiThoughtChain, { items }));
+    expect(html).toContain("yh-ai-thought-chain__item-dot-wrapper");
+  });
+});

package/dist/ai-thought-chain/__tests__/ai-thought-chain.test.cjs

@@ -0,0 +1,204 @@
+"use strict";
+
+var _vitest = require("vitest");
+var _testUtils = require("@vue/test-utils");
+var _vue = require("vue");
+var _aiThoughtChain = _interopRequireDefault(require("../src/ai-thought-chain.vue"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const makeItem = (title, status = "complete", content = "") => ({
+  title,
+  status,
+  content
+});
+(0, _vitest.describe)("YhAiThoughtChain", () => {
+  (0, _vitest.it)("should render with base class", () => {
+    const wrapper = (0, _testUtils.mount)(_aiThoughtChain.default);
+    (0, _vitest.expect)(wrapper.find(".yh-ai-thought-chain").exists()).toBe(true);
+  });
+  (0, _vitest.it)("should render single node header when no items", () => {
+    const wrapper = (0, _testUtils.mount)(_aiThoughtChain.default, {
+      props: {
+        title: "My Thought"
+      }
+    });
+    (0, _vitest.expect)(wrapper.find(".yh-ai-thought-chain__header").exists()).toBe(true);
+  });
+  (0, _vitest.it)("should render title in single node mode", () => {
+    const wrapper = (0, _testUtils.mount)(_aiThoughtChain.default, {
+      props: {
+        title: "Thinking Title"
+      }
+    });
+    (0, _vitest.expect)(wrapper.find(".yh-ai-thought-chain__title").text()).toBe("Thinking Title");
+  });
+  (0, _vitest.it)("should fallback to default title when no title provided", () => {
+    const wrapper = (0, _testUtils.mount)(_aiThoughtChain.default);
+    (0, _vitest.expect)(wrapper.find(".yh-ai-thought-chain__title").text().length).toBeGreaterThan(0);
+  });
+  (0, _vitest.it)("should compute thinking status when thinking=true", () => {
+    const wrapper = (0, _testUtils.mount)(_aiThoughtChain.default, {
+      props: {
+        thinking: true
+      }
+    });
+    (0, _vitest.expect)(wrapper.classes()).toContain("is-thinking");
+  });
+  (0, _vitest.it)("should compute complete status when thinking=false", () => {
+    const wrapper = (0, _testUtils.mount)(_aiThoughtChain.default, {
+      props: {
+        thinking: false
+      }
+    });
+    (0, _vitest.expect)(wrapper.classes()).not.toContain("is-thinking");
+  });
+  (0, _vitest.it)("should use explicit status prop over thinking", () => {
+    const wrapper = (0, _testUtils.mount)(_aiThoughtChain.default, {
+      props: {
+        status: "error",
+        thinking: true
+      }
+    });
+    (0, _vitest.expect)(wrapper.classes()).not.toContain("is-thinking");
+  });
+  (0, _vitest.it)("should be collapsed by default in single mode", () => {
+    const wrapper = (0, _testUtils.mount)(_aiThoughtChain.default, {
+      props: {
+        content: "Some content"
+      }
+    });
+    (0, _vitest.expect)(wrapper.classes()).not.toContain("is-expanded");
+  });
+  (0, _vitest.it)("should expand on header click in single node mode", async () => {
+    const wrapper = (0, _testUtils.mount)(_aiThoughtChain.default, {
+      props: {
+        title: "Title",
+        content: "Detail"
+      }
+    });
+    await wrapper.find(".yh-ai-thought-chain__header").trigger("click");
+    (0, _vitest.expect)(wrapper.classes()).toContain("is-expanded");
+  });
+  (0, _vitest.it)("should collapse again on second header click", async () => {
+    const wrapper = (0, _testUtils.mount)(_aiThoughtChain.default, {
+      props: {
+        content: "Detail"
+      }
+    });
+    await wrapper.find(".yh-ai-thought-chain__header").trigger("click");
+    await wrapper.find(".yh-ai-thought-chain__header").trigger("click");
+    (0, _vitest.expect)(wrapper.classes()).not.toContain("is-expanded");
+  });
+  (0, _vitest.it)("should render content in single mode when expanded", async () => {
+    const wrapper = (0, _testUtils.mount)(_aiThoughtChain.default, {
+      props: {
+        content: "Thought Content Detail"
+      }
+    });
+    await wrapper.find(".yh-ai-thought-chain__header").trigger("click");
+    (0, _vitest.expect)(wrapper.find(".yh-ai-thought-chain__text").text()).toBe("Thought Content Detail");
+  });
+  (0, _vitest.it)("should auto-collapse when status becomes complete and autoCollapse=true", async () => {
+    const wrapper = (0, _testUtils.mount)(_aiThoughtChain.default, {
+      props: {
+        status: "thinking",
+        autoCollapse: true
+      }
+    });
+    await wrapper.find(".yh-ai-thought-chain__header").trigger("click");
+    (0, _vitest.expect)(wrapper.classes()).toContain("is-expanded");
+    await wrapper.setProps({
+      status: "complete"
+    });
+    await (0, _vue.nextTick)();
+    (0, _vitest.expect)(wrapper.classes()).not.toContain("is-expanded");
+  });
+  (0, _vitest.it)("should apply is-timeline class when items provided", () => {
+    const wrapper = (0, _testUtils.mount)(_aiThoughtChain.default, {
+      props: {
+        items: [makeItem("Step 1"), makeItem("Step 2")]
+      }
+    });
+    (0, _vitest.expect)(wrapper.classes()).toContain("is-timeline");
+  });
+  (0, _vitest.it)("should render correct number of timeline items", () => {
+    const items = [makeItem("Step 1"), makeItem("Step 2"), makeItem("Step 3")];
+    const wrapper = (0, _testUtils.mount)(_aiThoughtChain.default, {
+      props: {
+        items
+      }
+    });
+    (0, _vitest.expect)(wrapper.findAll(".yh-ai-thought-chain__item").length).toBe(3);
+  });
+  (0, _vitest.it)("should render item titles", () => {
+    const items = [makeItem("Alpha"), makeItem("Beta")];
+    const wrapper = (0, _testUtils.mount)(_aiThoughtChain.default, {
+      props: {
+        items
+      }
+    });
+    const titles = wrapper.findAll(".yh-ai-thought-chain__item-title");
+    (0, _vitest.expect)(titles[0].text()).toBe("Alpha");
+    (0, _vitest.expect)(titles[1].text()).toBe("Beta");
+  });
+  (0, _vitest.it)("should apply is-last class to last item", () => {
+    const items = [makeItem("First"), makeItem("Last")];
+    const wrapper = (0, _testUtils.mount)(_aiThoughtChain.default, {
+      props: {
+        items
+      }
+    });
+    const allItems = wrapper.findAll(".yh-ai-thought-chain__item");
+    (0, _vitest.expect)(allItems[allItems.length - 1].classes()).toContain("is-last");
+  });
+  (0, _vitest.it)("should apply is-active class to thinking item", () => {
+    const items = [makeItem("Done", "complete"), makeItem("Running", "thinking")];
+    const wrapper = (0, _testUtils.mount)(_aiThoughtChain.default, {
+      props: {
+        items
+      }
+    });
+    const allItems = wrapper.findAll(".yh-ai-thought-chain__item");
+    (0, _vitest.expect)(allItems[1].classes()).toContain("is-active");
+  });
+  (0, _vitest.it)("should expand last item by default in timeline mode", () => {
+    const items = [makeItem("Step 1", "complete", "done"), makeItem("Step 2", "complete", "also done")];
+    const wrapper = (0, _testUtils.mount)(_aiThoughtChain.default, {
+      props: {
+        items
+      }
+    });
+    const lastContent = wrapper.findAll(".yh-ai-thought-chain__item-content");
+    (0, _vitest.expect)(lastContent.length).toBeGreaterThan(0);
+  });
+  (0, _vitest.it)("should toggle item expand on item header click", async () => {
+    const items = [makeItem("Step", "complete", "content here")];
+    const wrapper = (0, _testUtils.mount)(_aiThoughtChain.default, {
+      props: {
+        items
+      }
+    });
+    const itemHeader = wrapper.find(".yh-ai-thought-chain__item-header");
+    await itemHeader.trigger("click");
+    (0, _vitest.expect)(wrapper.find(".yh-ai-thought-chain__item").exists()).toBe(true);
+  });
+  (0, _vitest.it)("should apply dotSize prop to item dots", () => {
+    const items = [makeItem("Step", "complete")];
+    const wrapper = (0, _testUtils.mount)(_aiThoughtChain.default, {
+      props: {
+        items,
+        dotSize: "large"
+      }
+    });
+    const dotEl = wrapper.find(".yh-ai-thought-chain__item-dot");
+    (0, _vitest.expect)(dotEl.exists()).toBe(true);
+    (0, _vitest.expect)(dotEl.classes().join(" ")).toContain("large");
+  });
+  (0, _vitest.it)("should render default slot in single node mode", () => {
+    const wrapper = (0, _testUtils.mount)(_aiThoughtChain.default, {
+      slots: {
+        default: '<em class="slot-content">Slot</em>'
+      }
+    });
+    (0, _vitest.expect)(wrapper.find(".slot-content").exists()).toBe(true);
+  });
+});

package/dist/ai-thought-chain/__tests__/ai-thought-chain.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/ai-thought-chain/__tests__/ai-thought-chain.test.mjs

@@ -0,0 +1,134 @@
+import { describe, it, expect } from "vitest";
+import { mount } from "@vue/test-utils";
+import { nextTick } from "vue";
+import AiThoughtChain from "../src/ai-thought-chain.vue";
+const makeItem = (title, status = "complete", content = "") => ({
+  title,
+  status,
+  content
+});
+describe("YhAiThoughtChain", () => {
+  it("should render with base class", () => {
+    const wrapper = mount(AiThoughtChain);
+    expect(wrapper.find(".yh-ai-thought-chain").exists()).toBe(true);
+  });
+  it("should render single node header when no items", () => {
+    const wrapper = mount(AiThoughtChain, { props: { title: "My Thought" } });
+    expect(wrapper.find(".yh-ai-thought-chain__header").exists()).toBe(true);
+  });
+  it("should render title in single node mode", () => {
+    const wrapper = mount(AiThoughtChain, { props: { title: "Thinking Title" } });
+    expect(wrapper.find(".yh-ai-thought-chain__title").text()).toBe("Thinking Title");
+  });
+  it("should fallback to default title when no title provided", () => {
+    const wrapper = mount(AiThoughtChain);
+    expect(wrapper.find(".yh-ai-thought-chain__title").text().length).toBeGreaterThan(0);
+  });
+  it("should compute thinking status when thinking=true", () => {
+    const wrapper = mount(AiThoughtChain, { props: { thinking: true } });
+    expect(wrapper.classes()).toContain("is-thinking");
+  });
+  it("should compute complete status when thinking=false", () => {
+    const wrapper = mount(AiThoughtChain, { props: { thinking: false } });
+    expect(wrapper.classes()).not.toContain("is-thinking");
+  });
+  it("should use explicit status prop over thinking", () => {
+    const wrapper = mount(AiThoughtChain, {
+      props: { status: "error", thinking: true }
+    });
+    expect(wrapper.classes()).not.toContain("is-thinking");
+  });
+  it("should be collapsed by default in single mode", () => {
+    const wrapper = mount(AiThoughtChain, { props: { content: "Some content" } });
+    expect(wrapper.classes()).not.toContain("is-expanded");
+  });
+  it("should expand on header click in single node mode", async () => {
+    const wrapper = mount(AiThoughtChain, {
+      props: { title: "Title", content: "Detail" }
+    });
+    await wrapper.find(".yh-ai-thought-chain__header").trigger("click");
+    expect(wrapper.classes()).toContain("is-expanded");
+  });
+  it("should collapse again on second header click", async () => {
+    const wrapper = mount(AiThoughtChain, { props: { content: "Detail" } });
+    await wrapper.find(".yh-ai-thought-chain__header").trigger("click");
+    await wrapper.find(".yh-ai-thought-chain__header").trigger("click");
+    expect(wrapper.classes()).not.toContain("is-expanded");
+  });
+  it("should render content in single mode when expanded", async () => {
+    const wrapper = mount(AiThoughtChain, {
+      props: { content: "Thought Content Detail" }
+    });
+    await wrapper.find(".yh-ai-thought-chain__header").trigger("click");
+    expect(wrapper.find(".yh-ai-thought-chain__text").text()).toBe("Thought Content Detail");
+  });
+  it("should auto-collapse when status becomes complete and autoCollapse=true", async () => {
+    const wrapper = mount(AiThoughtChain, {
+      props: { status: "thinking", autoCollapse: true }
+    });
+    await wrapper.find(".yh-ai-thought-chain__header").trigger("click");
+    expect(wrapper.classes()).toContain("is-expanded");
+    await wrapper.setProps({ status: "complete" });
+    await nextTick();
+    expect(wrapper.classes()).not.toContain("is-expanded");
+  });
+  it("should apply is-timeline class when items provided", () => {
+    const wrapper = mount(AiThoughtChain, {
+      props: { items: [makeItem("Step 1"), makeItem("Step 2")] }
+    });
+    expect(wrapper.classes()).toContain("is-timeline");
+  });
+  it("should render correct number of timeline items", () => {
+    const items = [makeItem("Step 1"), makeItem("Step 2"), makeItem("Step 3")];
+    const wrapper = mount(AiThoughtChain, { props: { items } });
+    expect(wrapper.findAll(".yh-ai-thought-chain__item").length).toBe(3);
+  });
+  it("should render item titles", () => {
+    const items = [makeItem("Alpha"), makeItem("Beta")];
+    const wrapper = mount(AiThoughtChain, { props: { items } });
+    const titles = wrapper.findAll(".yh-ai-thought-chain__item-title");
+    expect(titles[0].text()).toBe("Alpha");
+    expect(titles[1].text()).toBe("Beta");
+  });
+  it("should apply is-last class to last item", () => {
+    const items = [makeItem("First"), makeItem("Last")];
+    const wrapper = mount(AiThoughtChain, { props: { items } });
+    const allItems = wrapper.findAll(".yh-ai-thought-chain__item");
+    expect(allItems[allItems.length - 1].classes()).toContain("is-last");
+  });
+  it("should apply is-active class to thinking item", () => {
+    const items = [makeItem("Done", "complete"), makeItem("Running", "thinking")];
+    const wrapper = mount(AiThoughtChain, { props: { items } });
+    const allItems = wrapper.findAll(".yh-ai-thought-chain__item");
+    expect(allItems[1].classes()).toContain("is-active");
+  });
+  it("should expand last item by default in timeline mode", () => {
+    const items = [
+      makeItem("Step 1", "complete", "done"),
+      makeItem("Step 2", "complete", "also done")
+    ];
+    const wrapper = mount(AiThoughtChain, { props: { items } });
+    const lastContent = wrapper.findAll(".yh-ai-thought-chain__item-content");
+    expect(lastContent.length).toBeGreaterThan(0);
+  });
+  it("should toggle item expand on item header click", async () => {
+    const items = [makeItem("Step", "complete", "content here")];
+    const wrapper = mount(AiThoughtChain, { props: { items } });
+    const itemHeader = wrapper.find(".yh-ai-thought-chain__item-header");
+    await itemHeader.trigger("click");
+    expect(wrapper.find(".yh-ai-thought-chain__item").exists()).toBe(true);
+  });
+  it("should apply dotSize prop to item dots", () => {
+    const items = [makeItem("Step", "complete")];
+    const wrapper = mount(AiThoughtChain, { props: { items, dotSize: "large" } });
+    const dotEl = wrapper.find(".yh-ai-thought-chain__item-dot");
+    expect(dotEl.exists()).toBe(true);
+    expect(dotEl.classes().join(" ")).toContain("large");
+  });
+  it("should render default slot in single node mode", () => {
+    const wrapper = mount(AiThoughtChain, {
+      slots: { default: '<em class="slot-content">Slot</em>' }
+    });
+    expect(wrapper.find(".slot-content").exists()).toBe(true);
+  });
+});

package/dist/ai-thought-chain/index.cjs

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  YhAiThoughtChain: true
+};
+module.exports = exports.YhAiThoughtChain = void 0;
+var _utils = require("@yh-ui/utils");
+var _aiThoughtChain = _interopRequireDefault(require("./src/ai-thought-chain.vue"));
+var _aiThoughtChain2 = require("./src/ai-thought-chain.cjs");
+Object.keys(_aiThoughtChain2).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _aiThoughtChain2[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _aiThoughtChain2[key];
+    }
+  });
+});
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const YhAiThoughtChain = exports.YhAiThoughtChain = (0, _utils.withInstall)(_aiThoughtChain.default);
+module.exports = YhAiThoughtChain;

package/dist/ai-thought-chain/index.d.ts

@@ -0,0 +1,3 @@
+export declare const YhAiThoughtChain: any;
+export default YhAiThoughtChain;
+export * from './src/ai-thought-chain';

package/dist/ai-thought-chain/index.mjs

@@ -0,0 +1,5 @@
+import { withInstall } from "@yh-ui/utils";
+import AiThoughtChain from "./src/ai-thought-chain.vue";
+export const YhAiThoughtChain = withInstall(AiThoughtChain);
+export default YhAiThoughtChain;
+export * from "./src/ai-thought-chain.mjs";

package/dist/ai-thought-chain/src/ai-thought-chain.cjs

@@ -0,0 +1,68 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.aiThoughtChainProps = exports.aiThoughtChainEmits = void 0;
+const aiThoughtChainProps = exports.aiThoughtChainProps = {
+  /**
+   * @description 思考标题 (单节点模式)
+   */
+  title: String,
+  /**
+   * @description 是否正在思考 (兼容旧版，新版推荐 status)
+   */
+  thinking: {
+    type: Boolean,
+    default: false
+  },
+  /**
+   * @description 显示内容 (单节点模式)
+   */
+  content: String,
+  /**
+   * @description 当前总状态
+   */
+  status: {
+    type: String,
+    default: "none"
+  },
+  /**
+   * @description 推理链节点列表，如果提供了 items，将启用多节点时间轴模式
+   */
+  items: {
+    type: Array,
+    default: () => []
+  },
+  /**
+   * @description 当状态变为已完成时是否自动收起
+   */
+  autoCollapse: {
+    type: Boolean,
+    default: true
+  },
+  /**
+   * @description 节点圆点大小
+   */
+  dotSize: {
+    type: String,
+    default: "default"
+  },
+  /**
+   * @description 节点连接线是否显示渐变
+   */
+  lineGradient: {
+    type: Boolean,
+    default: false
+  },
+  /**
+   * @description 主题覆盖变量
+   */
+  themeOverrides: {
+    type: Object,
+    default: void 0
+  }
+};
+const aiThoughtChainEmits = exports.aiThoughtChainEmits = {
+  "update:items": items => Array.isArray(items)
+};