@yh-ui/components 0.1.10 → 0.1.12

package/dist/ai-sources/src/ai-sources.vue.d.ts

@@ -0,0 +1,45 @@
+import { type AiSourceItem } from './ai-sources';
+declare var __VLS_77: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_77) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    readonly sources: {
+        readonly type: import("vue").PropType<AiSourceItem[]>;
+        readonly default: () => never[];
+    };
+    readonly mode: {
+        readonly type: import("vue").PropType<"inline" | "card" | "badge">;
+        readonly default: "inline";
+    };
+    readonly maxVisible: {
+        readonly type: NumberConstructor;
+        readonly default: 5;
+    };
+    readonly showScore: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly showFileType: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly themeOverrides: {
+        readonly type: import("vue").PropType<import("@yh-ui/theme").ComponentThemeVars>;
+        readonly default: undefined;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, any, string, import("vue").PublicProps, any, {
+    readonly themeOverrides: import("@yh-ui/theme").ComponentThemeVars;
+    readonly mode: "inline" | "card" | "badge";
+    readonly sources: AiSourceItem[];
+    readonly maxVisible: number;
+    readonly showScore: boolean;
+    readonly showFileType: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/ai-thinking/__tests__/ai-thinking.ssr.test.cjs

@@ -0,0 +1,56 @@
+"use strict";
+
+var _vitest = require("vitest");
+var _serverRenderer = require("@vue/server-renderer");
+var _vue = require("vue");
+var _aiThinking = _interopRequireDefault(require("../src/ai-thinking.vue"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+(0, _vitest.describe)("YhAiThinking SSR", () => {
+  (0, _vitest.it)("should render to string on server", async () => {
+    const html = await (0, _serverRenderer.renderToString)((0, _vue.h)(_aiThinking.default));
+    (0, _vitest.expect)(html).toContain("yh-ai-thinking");
+  });
+  (0, _vitest.it)("should render header on server", async () => {
+    const html = await (0, _serverRenderer.renderToString)((0, _vue.h)(_aiThinking.default));
+    (0, _vitest.expect)(html).toContain("yh-ai-thinking__header");
+  });
+  (0, _vitest.it)("should render thinking status class on server", async () => {
+    const html = await (0, _serverRenderer.renderToString)((0, _vue.h)(_aiThinking.default, {
+      status: "thinking"
+    }));
+    (0, _vitest.expect)(html).toContain("yh-ai-thinking--thinking");
+  });
+  (0, _vitest.it)("should render end status class on server", async () => {
+    const html = await (0, _serverRenderer.renderToString)((0, _vue.h)(_aiThinking.default, {
+      status: "end"
+    }));
+    (0, _vitest.expect)(html).toContain("yh-ai-thinking--end");
+  });
+  (0, _vitest.it)("should render error status class on server", async () => {
+    const html = await (0, _serverRenderer.renderToString)((0, _vue.h)(_aiThinking.default, {
+      status: "error"
+    }));
+    (0, _vitest.expect)(html).toContain("yh-ai-thinking--error");
+  });
+  (0, _vitest.it)("should render custom title on server", async () => {
+    const html = await (0, _serverRenderer.renderToString)((0, _vue.h)(_aiThinking.default, {
+      title: "SSR Thinking Title",
+      status: "thinking"
+    }));
+    (0, _vitest.expect)(html).toContain("SSR Thinking Title");
+  });
+  (0, _vitest.it)("should render expanded class on server when modelValue=true", async () => {
+    const html = await (0, _serverRenderer.renderToString)((0, _vue.h)(_aiThinking.default, {
+      modelValue: true,
+      content: "some thought"
+    }));
+    (0, _vitest.expect)(html).toContain("is-expanded");
+  });
+  (0, _vitest.it)("should render content on server", async () => {
+    const html = await (0, _serverRenderer.renderToString)((0, _vue.h)(_aiThinking.default, {
+      modelValue: true,
+      content: "Server thought content"
+    }));
+    (0, _vitest.expect)(html).toContain("Server thought content");
+  });
+});

package/dist/ai-thinking/__tests__/ai-thinking.ssr.test.d.ts

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

package/dist/ai-thinking/__tests__/ai-thinking.ssr.test.mjs

@@ -0,0 +1,42 @@
+import { describe, it, expect } from "vitest";
+import { renderToString } from "@vue/server-renderer";
+import { h } from "vue";
+import AiThinking from "../src/ai-thinking.vue";
+describe("YhAiThinking SSR", () => {
+  it("should render to string on server", async () => {
+    const html = await renderToString(h(AiThinking));
+    expect(html).toContain("yh-ai-thinking");
+  });
+  it("should render header on server", async () => {
+    const html = await renderToString(h(AiThinking));
+    expect(html).toContain("yh-ai-thinking__header");
+  });
+  it("should render thinking status class on server", async () => {
+    const html = await renderToString(h(AiThinking, { status: "thinking" }));
+    expect(html).toContain("yh-ai-thinking--thinking");
+  });
+  it("should render end status class on server", async () => {
+    const html = await renderToString(h(AiThinking, { status: "end" }));
+    expect(html).toContain("yh-ai-thinking--end");
+  });
+  it("should render error status class on server", async () => {
+    const html = await renderToString(h(AiThinking, { status: "error" }));
+    expect(html).toContain("yh-ai-thinking--error");
+  });
+  it("should render custom title on server", async () => {
+    const html = await renderToString(
+      h(AiThinking, { title: "SSR Thinking Title", status: "thinking" })
+    );
+    expect(html).toContain("SSR Thinking Title");
+  });
+  it("should render expanded class on server when modelValue=true", async () => {
+    const html = await renderToString(h(AiThinking, { modelValue: true, content: "some thought" }));
+    expect(html).toContain("is-expanded");
+  });
+  it("should render content on server", async () => {
+    const html = await renderToString(
+      h(AiThinking, { modelValue: true, content: "Server thought content" })
+    );
+    expect(html).toContain("Server thought content");
+  });
+});

package/dist/ai-thinking/__tests__/ai-thinking.test.cjs

@@ -0,0 +1,151 @@
+"use strict";
+
+var _vitest = require("vitest");
+var _testUtils = require("@vue/test-utils");
+var _vue = require("vue");
+var _aiThinking = _interopRequireDefault(require("../src/ai-thinking.vue"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+(0, _vitest.describe)("YhAiThinking", () => {
+  (0, _vitest.it)("should render with base class", () => {
+    const wrapper = (0, _testUtils.mount)(_aiThinking.default);
+    (0, _vitest.expect)(wrapper.find(".yh-ai-thinking").exists()).toBe(true);
+  });
+  (0, _vitest.it)("should render header", () => {
+    const wrapper = (0, _testUtils.mount)(_aiThinking.default);
+    (0, _vitest.expect)(wrapper.find(".yh-ai-thinking__header").exists()).toBe(true);
+  });
+  (0, _vitest.it)("should apply thinking status class by default", () => {
+    const wrapper = (0, _testUtils.mount)(_aiThinking.default, {
+      props: {
+        status: "thinking"
+      }
+    });
+    (0, _vitest.expect)(wrapper.classes()).toContain("yh-ai-thinking--thinking");
+  });
+  (0, _vitest.it)("should apply start status class", () => {
+    const wrapper = (0, _testUtils.mount)(_aiThinking.default, {
+      props: {
+        status: "start"
+      }
+    });
+    (0, _vitest.expect)(wrapper.classes()).toContain("yh-ai-thinking--start");
+  });
+  (0, _vitest.it)("should apply end status class", () => {
+    const wrapper = (0, _testUtils.mount)(_aiThinking.default, {
+      props: {
+        status: "end"
+      }
+    });
+    (0, _vitest.expect)(wrapper.classes()).toContain("yh-ai-thinking--end");
+  });
+  (0, _vitest.it)("should apply error status class", () => {
+    const wrapper = (0, _testUtils.mount)(_aiThinking.default, {
+      props: {
+        status: "error"
+      }
+    });
+    (0, _vitest.expect)(wrapper.classes()).toContain("yh-ai-thinking--error");
+  });
+  (0, _vitest.it)("should render custom title when provided", () => {
+    const wrapper = (0, _testUtils.mount)(_aiThinking.default, {
+      props: {
+        title: "My Custom Title",
+        status: "thinking"
+      }
+    });
+    (0, _vitest.expect)(wrapper.find(".yh-ai-thinking__title").text()).toBe("My Custom Title");
+  });
+  (0, _vitest.it)("should show default title based on status when no title provided", () => {
+    const wrapper = (0, _testUtils.mount)(_aiThinking.default, {
+      props: {
+        status: "end"
+      }
+    });
+    (0, _vitest.expect)(wrapper.find(".yh-ai-thinking__title").text().length).toBeGreaterThan(0);
+  });
+  (0, _vitest.it)("should start collapsed when modelValue=false", () => {
+    const wrapper = (0, _testUtils.mount)(_aiThinking.default, {
+      props: {
+        modelValue: false,
+        content: "Some content"
+      }
+    });
+    (0, _vitest.expect)(wrapper.classes()).not.toContain("is-expanded");
+  });
+  (0, _vitest.it)("should start expanded when modelValue=true", () => {
+    const wrapper = (0, _testUtils.mount)(_aiThinking.default, {
+      props: {
+        modelValue: true,
+        content: "Some content"
+      }
+    });
+    (0, _vitest.expect)(wrapper.classes()).toContain("is-expanded");
+  });
+  (0, _vitest.it)("should toggle expansion on header click and emit update:modelValue", async () => {
+    const wrapper = (0, _testUtils.mount)(_aiThinking.default, {
+      props: {
+        modelValue: false
+      }
+    });
+    await wrapper.find(".yh-ai-thinking__header").trigger("click");
+    (0, _vitest.expect)(wrapper.emitted("update:modelValue")).toBeTruthy();
+    (0, _vitest.expect)(wrapper.emitted("update:modelValue")[0][0]).toBe(true);
+  });
+  (0, _vitest.it)("should collapse when header clicked again", async () => {
+    const wrapper = (0, _testUtils.mount)(_aiThinking.default, {
+      props: {
+        modelValue: true
+      }
+    });
+    await wrapper.find(".yh-ai-thinking__header").trigger("click");
+    (0, _vitest.expect)(wrapper.emitted("update:modelValue")[0][0]).toBe(false);
+  });
+  (0, _vitest.it)("should render content in body when expanded", () => {
+    const wrapper = (0, _testUtils.mount)(_aiThinking.default, {
+      props: {
+        modelValue: true,
+        content: "Detailed thought process"
+      }
+    });
+    (0, _vitest.expect)(wrapper.find(".yh-ai-thinking__content").text()).toBe("Detailed thought process");
+  });
+  (0, _vitest.it)("should auto collapse when status changes to end and autoCollapse=true", async () => {
+    const wrapper = (0, _testUtils.mount)(_aiThinking.default, {
+      props: {
+        status: "thinking",
+        modelValue: true,
+        autoCollapse: true
+      }
+    });
+    await wrapper.setProps({
+      status: "end"
+    });
+    await (0, _vue.nextTick)();
+    (0, _vitest.expect)(wrapper.emitted("update:modelValue")[0][0]).toBe(false);
+  });
+  (0, _vitest.it)("should NOT auto collapse when autoCollapse=false", async () => {
+    const wrapper = (0, _testUtils.mount)(_aiThinking.default, {
+      props: {
+        status: "thinking",
+        modelValue: true,
+        autoCollapse: false
+      }
+    });
+    await wrapper.setProps({
+      status: "end"
+    });
+    await (0, _vue.nextTick)();
+    (0, _vitest.expect)(wrapper.emitted("update:modelValue")).toBeFalsy();
+  });
+  (0, _vitest.it)("should render default slot as body content", () => {
+    const wrapper = (0, _testUtils.mount)(_aiThinking.default, {
+      props: {
+        modelValue: true
+      },
+      slots: {
+        default: '<p class="custom-thought">Custom content</p>'
+      }
+    });
+    (0, _vitest.expect)(wrapper.find(".custom-thought").exists()).toBe(true);
+  });
+});

package/dist/ai-thinking/__tests__/ai-thinking.test.d.ts

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

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

@@ -0,0 +1,96 @@
+import { describe, it, expect } from "vitest";
+import { mount } from "@vue/test-utils";
+import { nextTick } from "vue";
+import AiThinking from "../src/ai-thinking.vue";
+describe("YhAiThinking", () => {
+  it("should render with base class", () => {
+    const wrapper = mount(AiThinking);
+    expect(wrapper.find(".yh-ai-thinking").exists()).toBe(true);
+  });
+  it("should render header", () => {
+    const wrapper = mount(AiThinking);
+    expect(wrapper.find(".yh-ai-thinking__header").exists()).toBe(true);
+  });
+  it("should apply thinking status class by default", () => {
+    const wrapper = mount(AiThinking, { props: { status: "thinking" } });
+    expect(wrapper.classes()).toContain("yh-ai-thinking--thinking");
+  });
+  it("should apply start status class", () => {
+    const wrapper = mount(AiThinking, { props: { status: "start" } });
+    expect(wrapper.classes()).toContain("yh-ai-thinking--start");
+  });
+  it("should apply end status class", () => {
+    const wrapper = mount(AiThinking, { props: { status: "end" } });
+    expect(wrapper.classes()).toContain("yh-ai-thinking--end");
+  });
+  it("should apply error status class", () => {
+    const wrapper = mount(AiThinking, { props: { status: "error" } });
+    expect(wrapper.classes()).toContain("yh-ai-thinking--error");
+  });
+  it("should render custom title when provided", () => {
+    const wrapper = mount(AiThinking, {
+      props: { title: "My Custom Title", status: "thinking" }
+    });
+    expect(wrapper.find(".yh-ai-thinking__title").text()).toBe("My Custom Title");
+  });
+  it("should show default title based on status when no title provided", () => {
+    const wrapper = mount(AiThinking, { props: { status: "end" } });
+    expect(wrapper.find(".yh-ai-thinking__title").text().length).toBeGreaterThan(0);
+  });
+  it("should start collapsed when modelValue=false", () => {
+    const wrapper = mount(AiThinking, {
+      props: { modelValue: false, content: "Some content" }
+    });
+    expect(wrapper.classes()).not.toContain("is-expanded");
+  });
+  it("should start expanded when modelValue=true", () => {
+    const wrapper = mount(AiThinking, {
+      props: { modelValue: true, content: "Some content" }
+    });
+    expect(wrapper.classes()).toContain("is-expanded");
+  });
+  it("should toggle expansion on header click and emit update:modelValue", async () => {
+    const wrapper = mount(AiThinking, {
+      props: { modelValue: false }
+    });
+    await wrapper.find(".yh-ai-thinking__header").trigger("click");
+    expect(wrapper.emitted("update:modelValue")).toBeTruthy();
+    expect(wrapper.emitted("update:modelValue")[0][0]).toBe(true);
+  });
+  it("should collapse when header clicked again", async () => {
+    const wrapper = mount(AiThinking, {
+      props: { modelValue: true }
+    });
+    await wrapper.find(".yh-ai-thinking__header").trigger("click");
+    expect(wrapper.emitted("update:modelValue")[0][0]).toBe(false);
+  });
+  it("should render content in body when expanded", () => {
+    const wrapper = mount(AiThinking, {
+      props: { modelValue: true, content: "Detailed thought process" }
+    });
+    expect(wrapper.find(".yh-ai-thinking__content").text()).toBe("Detailed thought process");
+  });
+  it("should auto collapse when status changes to end and autoCollapse=true", async () => {
+    const wrapper = mount(AiThinking, {
+      props: { status: "thinking", modelValue: true, autoCollapse: true }
+    });
+    await wrapper.setProps({ status: "end" });
+    await nextTick();
+    expect(wrapper.emitted("update:modelValue")[0][0]).toBe(false);
+  });
+  it("should NOT auto collapse when autoCollapse=false", async () => {
+    const wrapper = mount(AiThinking, {
+      props: { status: "thinking", modelValue: true, autoCollapse: false }
+    });
+    await wrapper.setProps({ status: "end" });
+    await nextTick();
+    expect(wrapper.emitted("update:modelValue")).toBeFalsy();
+  });
+  it("should render default slot as body content", () => {
+    const wrapper = mount(AiThinking, {
+      props: { modelValue: true },
+      slots: { default: '<p class="custom-thought">Custom content</p>' }
+    });
+    expect(wrapper.find(".custom-thought").exists()).toBe(true);
+  });
+});

package/dist/ai-thinking/index.cjs

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

package/dist/ai-thinking/index.d.ts

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

package/dist/ai-thinking/index.mjs

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

package/dist/ai-thinking/src/ai-thinking.cjs

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.aiThinkingProps = exports.aiThinkingEmits = void 0;
+const aiThinkingProps = exports.aiThinkingProps = {
+  /**
+   * @description 思考状态
+   */
+  status: {
+    type: String,
+    default: "thinking"
+  },
+  /**
+   * @description 思考标题
+   */
+  title: String,
+  /**
+   * @description 思考详情内容
+   */
+  content: String,
+  /**
+   * @description 是否展开详情 (v-model)
+   */
+  modelValue: Boolean,
+  /**
+   * @description 完成后是否自动收起
+   */
+  autoCollapse: {
+    type: Boolean,
+    default: true
+  },
+  /**
+   * @description 主题覆盖变量
+   */
+  themeOverrides: {
+    type: Object,
+    default: void 0
+  }
+};
+const aiThinkingEmits = exports.aiThinkingEmits = {
+  "update:modelValue": value => typeof value === "boolean"
+};