@yh-ui/components 0.1.21 → 0.1.23

package/dist/progress/__tests__/progress.test.mjs

@@ -1,77 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { mount } from "@vue/test-utils";
-import { YhProgress } from "../index.mjs";
-describe("Progress", () => {
-  it("should render correctly", () => {
-    const wrapper = mount(YhProgress, {
-      props: { percentage: 50 }
-    });
-    expect(wrapper.classes()).toContain("yh-progress");
-    expect(wrapper.find(".yh-progress__inner").element.style.width).toBe("50%");
-  });
-  it("should support different types", () => {
-    const line = mount(YhProgress, { props: { type: "line", percentage: 50 } });
-    expect(line.find(".yh-progress__bar").exists()).toBe(true);
-    const circle = mount(YhProgress, { props: { type: "circle", percentage: 50 } });
-    expect(circle.find(".yh-progress__circle").exists()).toBe(true);
-    const dashboard = mount(YhProgress, { props: { type: "dashboard", percentage: 50 } });
-    expect(dashboard.classes()).toContain("yh-progress--dashboard");
-  });
-  it("should support linear gradients", () => {
-    const wrapper = mount(YhProgress, {
-      props: {
-        percentage: 50,
-        color: { "0%": "#f56c6c", "100%": "#67c23a" }
-      }
-    });
-    const inner = wrapper.find(".yh-progress__inner");
-    expect(inner.element.style.backgroundImage).toContain("linear-gradient");
-  });
-  it("should support multi-ring progress", () => {
-    const wrapper = mount(YhProgress, {
-      props: {
-        type: "circle",
-        percentage: [30, 60, 90],
-        color: ["red", "green", "blue"]
-      }
-    });
-    expect(wrapper.findAll(".yh-progress__circle-path").length).toBe(3);
-    expect(wrapper.findAll(".yh-progress__circle-path")[0].attributes("stroke")).toBe("red");
-  });
-  it("should show status icons", () => {
-    const success = mount(YhProgress, { props: { percentage: 100, status: "success" } });
-    expect(success.find("svg").exists()).toBe(true);
-    expect(success.classes()).toContain("is-success");
-    const exception = mount(YhProgress, { props: { percentage: 50, status: "exception" } });
-    expect(exception.classes()).toContain("is-exception");
-  });
-  it("should support secondary percentage", () => {
-    const wrapper = mount(YhProgress, {
-      props: { percentage: 50, secondaryPercentage: 80 }
-    });
-    const secondary = wrapper.find(".yh-progress__secondary-inner");
-    expect(secondary.element.style.width).toBe("80%");
-  });
-  it("should support steps", () => {
-    const wrapper = mount(YhProgress, {
-      props: { percentage: 50, steps: 5 }
-    });
-    expect(wrapper.findAll(".yh-progress__step-item").length).toBe(5);
-  });
-  it("should respect text-inside", () => {
-    const wrapper = mount(YhProgress, {
-      props: { percentage: 50, textInside: true, strokeWidth: 20 }
-    });
-    expect(wrapper.classes()).toContain("is-text-inside");
-    expect(wrapper.find(".yh-progress__innerText").exists()).toBe(true);
-  });
-  it("should handle custom format", () => {
-    const wrapper = mount(YhProgress, {
-      props: {
-        percentage: 50,
-        format: (p) => `Value is ${p}`
-      }
-    });
-    expect(wrapper.find(".yh-progress__text").text()).toBe("Value is 50");
-  });
-});

package/dist/radio/__tests__/radio-button.test.cjs

@@ -1,99 +0,0 @@
-"use strict";
-
-var _vitest = require("vitest");
-var _testUtils = require("@vue/test-utils");
-var _vue = require("vue");
-var _radioGroup = _interopRequireDefault(require("../src/radio-group.vue"));
-var _radioButton = _interopRequireDefault(require("../src/radio-button.vue"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-(0, _vitest.describe)("YhRadioButton", () => {
-  (0, _vitest.it)("renders properly", () => {
-    const wrapper = (0, _testUtils.mount)(_radioButton.default, {
-      props: {
-        label: "Option 1",
-        value: "1"
-      }
-    });
-    (0, _vitest.expect)(wrapper.text()).toContain("Option 1");
-  });
-  (0, _vitest.it)("works with RadioGroup", async () => {
-    const modelValue = (0, _vue.ref)("1");
-    const wrapper = (0, _testUtils.mount)(_radioGroup.default, {
-      props: {
-        modelValue: modelValue.value,
-        "onUpdate:modelValue": async val => {
-          modelValue.value = val;
-          await wrapper.setProps({
-            modelValue: val
-          });
-        }
-      },
-      slots: {
-        default: () => [
-        // @ts-ignore
-        (0, _vue.h)(_radioButton.default, {
-          value: "1",
-          label: "Option 1"
-        }),
-        // @ts-ignore
-        (0, _vue.h)(_radioButton.default, {
-          value: "2",
-          label: "Option 2"
-        })]
-      }
-    });
-    const radios = wrapper.findAll(".yh-radio-button");
-    (0, _vitest.expect)(radios.length).toBe(2);
-    (0, _vitest.expect)(radios[0].classes()).toContain("is-checked");
-    (0, _vitest.expect)(radios[1].classes()).not.toContain("is-checked");
-    await radios[1].find("input").trigger("change");
-    (0, _vitest.expect)(modelValue.value).toBe("2");
-    (0, _vitest.expect)(radios[0].classes()).not.toContain("is-checked");
-    (0, _vitest.expect)(radios[1].classes()).toContain("is-checked");
-  });
-  (0, _vitest.it)("disabled state", async () => {
-    const wrapper = (0, _testUtils.mount)(_radioGroup.default, {
-      props: {
-        modelValue: "1",
-        disabled: true
-      },
-      slots: {
-        default: () => [
-        // @ts-ignore
-        (0, _vue.h)(_radioButton.default, {
-          value: "1",
-          label: "Option 1"
-        }),
-        // @ts-ignore
-        (0, _vue.h)(_radioButton.default, {
-          value: "2",
-          label: "Option 2"
-        })]
-      }
-    });
-    const radios = wrapper.findAll(".yh-radio-button");
-    (0, _vitest.expect)(radios[0].classes()).toContain("is-disabled");
-    (0, _vitest.expect)(radios[0].find("input").element.disabled).toBe(true);
-  });
-  (0, _vitest.it)("custom colors", async () => {
-    const wrapper = (0, _testUtils.mount)(_radioGroup.default, {
-      props: {
-        modelValue: "1",
-        fill: "#ff0000",
-        textColor: "#00ff00"
-      },
-      slots: {
-        default: () => [
-        // @ts-ignore
-        (0, _vue.h)(_radioButton.default, {
-          value: "1",
-          label: "Option 1"
-        })]
-      }
-    });
-    await (0, _vue.nextTick)();
-    const label = wrapper.find("label");
-    (0, _vitest.expect)(label.attributes("style")).toContain("--yh-radio-button-checked-bg-color: #ff0000");
-    (0, _vitest.expect)(label.attributes("style")).toContain("--yh-radio-button-checked-text-color: #00ff00");
-  });
-});

package/dist/radio/__tests__/radio-button.test.mjs

@@ -1,83 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { mount } from "@vue/test-utils";
-import { ref, nextTick } from "vue";
-import YhRadioGroup from "../src/radio-group.vue";
-import YhRadioButton from "../src/radio-button.vue";
-describe("YhRadioButton", () => {
-  it("renders properly", () => {
-    const wrapper = mount(YhRadioButton, {
-      props: {
-        label: "Option 1",
-        value: "1"
-      }
-    });
-    expect(wrapper.text()).toContain("Option 1");
-  });
-  it("works with RadioGroup", async () => {
-    const modelValue = ref("1");
-    const wrapper = mount(YhRadioGroup, {
-      props: {
-        modelValue: modelValue.value,
-        "onUpdate:modelValue": async (val) => {
-          modelValue.value = val;
-          await wrapper.setProps({ modelValue: val });
-        }
-      },
-      slots: {
-        default: () => [
-          // @ts-ignore
-          h(YhRadioButton, { value: "1", label: "Option 1" }),
-          // @ts-ignore
-          h(YhRadioButton, { value: "2", label: "Option 2" })
-        ]
-      }
-    });
-    const radios = wrapper.findAll(".yh-radio-button");
-    expect(radios.length).toBe(2);
-    expect(radios[0].classes()).toContain("is-checked");
-    expect(radios[1].classes()).not.toContain("is-checked");
-    await radios[1].find("input").trigger("change");
-    expect(modelValue.value).toBe("2");
-    expect(radios[0].classes()).not.toContain("is-checked");
-    expect(radios[1].classes()).toContain("is-checked");
-  });
-  it("disabled state", async () => {
-    const wrapper = mount(YhRadioGroup, {
-      props: {
-        modelValue: "1",
-        disabled: true
-      },
-      slots: {
-        default: () => [
-          // @ts-ignore
-          h(YhRadioButton, { value: "1", label: "Option 1" }),
-          // @ts-ignore
-          h(YhRadioButton, { value: "2", label: "Option 2" })
-        ]
-      }
-    });
-    const radios = wrapper.findAll(".yh-radio-button");
-    expect(radios[0].classes()).toContain("is-disabled");
-    expect(radios[0].find("input").element.disabled).toBe(true);
-  });
-  it("custom colors", async () => {
-    const wrapper = mount(YhRadioGroup, {
-      props: {
-        modelValue: "1",
-        fill: "#ff0000",
-        textColor: "#00ff00"
-      },
-      slots: {
-        default: () => [
-          // @ts-ignore
-          h(YhRadioButton, { value: "1", label: "Option 1" })
-        ]
-      }
-    });
-    await nextTick();
-    const label = wrapper.find("label");
-    expect(label.attributes("style")).toContain("--yh-radio-button-checked-bg-color: #ff0000");
-    expect(label.attributes("style")).toContain("--yh-radio-button-checked-text-color: #00ff00");
-  });
-});
-import { h } from "vue";

package/dist/radio/__tests__/radio.ssr.test.cjs

@@ -1,132 +0,0 @@
-"use strict";
-
-var _vitest = require("vitest");
-var _radio = _interopRequireDefault(require("../src/radio.vue"));
-var _radioButton = _interopRequireDefault(require("../src/radio-button.vue"));
-var _radioGroup = _interopRequireDefault(require("../src/radio-group.vue"));
-var _ssr = require("../../__tests__/utils/ssr.cjs");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-(0, _vitest.describe)("YhRadio SSR", () => {
-  (0, _vitest.it)("should render correctly in SSR", async () => {
-    const html = await (0, _ssr.renderSSR)(_radio.default, {
-      modelValue: "option1",
-      label: "option1"
-    }, {
-      default: () => "Radio Label"
-    });
-    (0, _ssr.expectSSRHasClass)(html, "yh-radio");
-    (0, _vitest.expect)(html).toContain("Radio Label");
-  });
-  (0, _vitest.it)("should render checked state in SSR", async () => {
-    const html = await (0, _ssr.renderSSR)(_radio.default, {
-      modelValue: "selected",
-      label: "selected",
-      value: "selected"
-    }, {
-      default: () => "Selected"
-    });
-    (0, _ssr.expectSSRHasClass)(html, "is-checked");
-  });
-  (0, _vitest.it)("should render unchecked state in SSR", async () => {
-    const html = await (0, _ssr.renderSSR)(_radio.default, {
-      modelValue: "other",
-      label: "selected"
-    }, {
-      default: () => "Not Selected"
-    });
-    (0, _ssr.expectSSRHasClass)(html, "yh-radio");
-  });
-  (0, _vitest.it)("should render disabled state in SSR", async () => {
-    const html = await (0, _ssr.renderSSR)(_radio.default, {
-      modelValue: "",
-      label: "option",
-      disabled: true
-    }, {
-      default: () => "Disabled"
-    });
-    (0, _ssr.expectSSRHasClass)(html, "is-disabled");
-  });
-  (0, _vitest.it)("should render different sizes in SSR", async () => {
-    const sizes = ["small", "default", "large"];
-    for (const size of sizes) {
-      const html = await (0, _ssr.renderSSR)(_radio.default, {
-        modelValue: "",
-        label: "test",
-        size
-      }, {
-        default: () => `Size ${size}`
-      });
-      if (size !== "default") {
-        (0, _ssr.expectSSRHasClass)(html, `yh-radio--${size}`);
-      }
-    }
-  });
-  (0, _vitest.it)("should render border style in SSR", async () => {
-    const html = await (0, _ssr.renderSSR)(_radio.default, {
-      modelValue: "",
-      label: "bordered",
-      border: true
-    }, {
-      default: () => "Bordered"
-    });
-    (0, _ssr.expectSSRHasClass)(html, "is-bordered");
-  });
-  (0, _vitest.it)("should hydrate without mismatch", async () => {
-    const result = await (0, _ssr.testHydration)(_radio.default, {
-      modelValue: "test",
-      label: "test"
-    }, {
-      default: () => "Hydration Test"
-    });
-    (0, _vitest.expect)(result.isMatch).toBe(true);
-  });
-});
-(0, _vitest.describe)("YhRadioButton SSR", () => {
-  (0, _vitest.it)("should render button style in SSR", async () => {
-    const html = await (0, _ssr.renderSSR)(_radioButton.default, {
-      modelValue: "button1",
-      label: "button1"
-    }, {
-      default: () => "Button Radio"
-    });
-    (0, _ssr.expectSSRHasClass)(html, "yh-radio-button");
-  });
-  (0, _vitest.it)("should render checked button in SSR", async () => {
-    const html = await (0, _ssr.renderSSR)(_radioButton.default, {
-      modelValue: "active",
-      label: "active",
-      value: "active"
-    }, {
-      default: () => "Active Button"
-    });
-    (0, _ssr.expectSSRHasClass)(html, "is-checked");
-  });
-});
-(0, _vitest.describe)("YhRadioGroup SSR", () => {
-  (0, _vitest.it)("should render group correctly in SSR", async () => {
-    const html = await (0, _ssr.renderSSR)(_radioGroup.default, {
-      modelValue: "option1"
-    });
-    (0, _ssr.expectSSRHasClass)(html, "yh-radio-group");
-  });
-  (0, _vitest.it)("should hydrate group without mismatch", async () => {
-    const result = await (0, _ssr.testHydration)(_radioGroup.default, {
-      modelValue: "option2"
-    });
-    (0, _vitest.expect)(result.isMatch).toBe(true);
-  });
-  (0, _vitest.it)("should render group with size in SSR", async () => {
-    const html = await (0, _ssr.renderSSR)(_radioGroup.default, {
-      modelValue: "",
-      size: "large"
-    });
-    (0, _ssr.expectSSRHasClass)(html, "yh-radio-group--large");
-  });
-  (0, _vitest.it)("should render disabled group in SSR", async () => {
-    const html = await (0, _ssr.renderSSR)(_radioGroup.default, {
-      modelValue: "",
-      disabled: true
-    });
-    (0, _ssr.expectSSRHasClass)(html, "yh-radio-group");
-  });
-});

package/dist/radio/__tests__/radio.ssr.test.mjs

@@ -1,165 +0,0 @@
-import { describe, it, expect } from "vitest";
-import Radio from "../src/radio.vue";
-import RadioButton from "../src/radio-button.vue";
-import RadioGroup from "../src/radio-group.vue";
-import { renderSSR, expectSSRHasClass, testHydration } from "../../__tests__/utils/ssr.mjs";
-describe("YhRadio SSR", () => {
-  it("should render correctly in SSR", async () => {
-    const html = await renderSSR(
-      Radio,
-      {
-        modelValue: "option1",
-        label: "option1"
-      },
-      {
-        default: () => "Radio Label"
-      }
-    );
-    expectSSRHasClass(html, "yh-radio");
-    expect(html).toContain("Radio Label");
-  });
-  it("should render checked state in SSR", async () => {
-    const html = await renderSSR(
-      Radio,
-      {
-        modelValue: "selected",
-        label: "selected",
-        value: "selected"
-      },
-      {
-        default: () => "Selected"
-      }
-    );
-    expectSSRHasClass(html, "is-checked");
-  });
-  it("should render unchecked state in SSR", async () => {
-    const html = await renderSSR(
-      Radio,
-      {
-        modelValue: "other",
-        label: "selected"
-      },
-      {
-        default: () => "Not Selected"
-      }
-    );
-    expectSSRHasClass(html, "yh-radio");
-  });
-  it("should render disabled state in SSR", async () => {
-    const html = await renderSSR(
-      Radio,
-      {
-        modelValue: "",
-        label: "option",
-        disabled: true
-      },
-      {
-        default: () => "Disabled"
-      }
-    );
-    expectSSRHasClass(html, "is-disabled");
-  });
-  it("should render different sizes in SSR", async () => {
-    const sizes = ["small", "default", "large"];
-    for (const size of sizes) {
-      const html = await renderSSR(
-        Radio,
-        {
-          modelValue: "",
-          label: "test",
-          size
-        },
-        {
-          default: () => `Size ${size}`
-        }
-      );
-      if (size !== "default") {
-        expectSSRHasClass(html, `yh-radio--${size}`);
-      }
-    }
-  });
-  it("should render border style in SSR", async () => {
-    const html = await renderSSR(
-      Radio,
-      {
-        modelValue: "",
-        label: "bordered",
-        border: true
-      },
-      {
-        default: () => "Bordered"
-      }
-    );
-    expectSSRHasClass(html, "is-bordered");
-  });
-  it("should hydrate without mismatch", async () => {
-    const result = await testHydration(
-      Radio,
-      {
-        modelValue: "test",
-        label: "test"
-      },
-      {
-        default: () => "Hydration Test"
-      }
-    );
-    expect(result.isMatch).toBe(true);
-  });
-});
-describe("YhRadioButton SSR", () => {
-  it("should render button style in SSR", async () => {
-    const html = await renderSSR(
-      RadioButton,
-      {
-        modelValue: "button1",
-        label: "button1"
-      },
-      {
-        default: () => "Button Radio"
-      }
-    );
-    expectSSRHasClass(html, "yh-radio-button");
-  });
-  it("should render checked button in SSR", async () => {
-    const html = await renderSSR(
-      RadioButton,
-      {
-        modelValue: "active",
-        label: "active",
-        value: "active"
-      },
-      {
-        default: () => "Active Button"
-      }
-    );
-    expectSSRHasClass(html, "is-checked");
-  });
-});
-describe("YhRadioGroup SSR", () => {
-  it("should render group correctly in SSR", async () => {
-    const html = await renderSSR(RadioGroup, {
-      modelValue: "option1"
-    });
-    expectSSRHasClass(html, "yh-radio-group");
-  });
-  it("should hydrate group without mismatch", async () => {
-    const result = await testHydration(RadioGroup, {
-      modelValue: "option2"
-    });
-    expect(result.isMatch).toBe(true);
-  });
-  it("should render group with size in SSR", async () => {
-    const html = await renderSSR(RadioGroup, {
-      modelValue: "",
-      size: "large"
-    });
-    expectSSRHasClass(html, "yh-radio-group--large");
-  });
-  it("should render disabled group in SSR", async () => {
-    const html = await renderSSR(RadioGroup, {
-      modelValue: "",
-      disabled: true
-    });
-    expectSSRHasClass(html, "yh-radio-group");
-  });
-});