@yh-ui/components 0.1.21 → 0.1.23

package/dist/input/__tests__/input-utils.test.mjs

@@ -1,75 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { calcTextareaHeight } from "../src/utils.mjs";
-describe("calcTextareaHeight", () => {
-  let textarea;
-  beforeEach(() => {
-    textarea = document.createElement("textarea");
-    vi.spyOn(window, "getComputedStyle").mockReturnValue({
-      getPropertyValue: (prop) => {
-        const map = {
-          "box-sizing": "border-box",
-          "padding-top": "4",
-          "padding-bottom": "4",
-          "border-top-width": "1",
-          "border-bottom-width": "1",
-          "letter-spacing": "normal",
-          "line-height": "20px",
-          "font-family": "sans-serif",
-          "font-weight": "normal",
-          "font-size": "14px",
-          "text-rendering": "auto",
-          "text-transform": "none",
-          width: "200px",
-          "text-indent": "0px",
-          "padding-left": "8px",
-          "padding-right": "8px"
-        };
-        return map[prop] ?? "";
-      }
-    });
-    Object.defineProperty(HTMLTextAreaElement.prototype, "scrollHeight", {
-      configurable: true,
-      get() {
-        return 24;
-      }
-    });
-    document.body.appendChild(textarea);
-  });
-  afterEach(() => {
-    vi.restoreAllMocks();
-    document.body.innerHTML = "";
-  });
-  it("should return height string", () => {
-    const result = calcTextareaHeight(textarea);
-    expect(result).toHaveProperty("height");
-    expect(typeof result.height).toBe("string");
-    expect(result.height).toMatch(/px$/);
-  });
-  it("should return minHeight when minRows > 0", () => {
-    const result = calcTextareaHeight(textarea, 2);
-    expect(result).toHaveProperty("minHeight");
-    expect(result.minHeight).toMatch(/px$/);
-  });
-  it("should handle maxRows constraint", () => {
-    const result = calcTextareaHeight(textarea, 1, 3);
-    expect(result.height).toMatch(/px$/);
-  });
-  it("should handle content-box sizing", () => {
-    vi.spyOn(window, "getComputedStyle").mockReturnValue({
-      getPropertyValue: (prop) => {
-        if (prop === "box-sizing") return "content-box";
-        if (prop === "padding-top") return "4";
-        if (prop === "padding-bottom") return "4";
-        if (prop === "border-top-width") return "1";
-        if (prop === "border-bottom-width") return "1";
-        return "";
-      }
-    });
-    const result = calcTextareaHeight(textarea, 1);
-    expect(result.height).toMatch(/px$/);
-  });
-  it("should handle minRows = 0 (no minHeight)", () => {
-    const result = calcTextareaHeight(textarea, 0);
-    expect(result.height).toMatch(/px$/);
-  });
-});

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

@@ -1,100 +0,0 @@
-"use strict";
-
-var _vitest = require("vitest");
-var _input = _interopRequireDefault(require("../src/input.vue"));
-var _ssr = require("../../__tests__/utils/ssr.cjs");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-(0, _vitest.describe)("YhInput SSR", () => {
-  (0, _vitest.it)("should render correctly in SSR", async () => {
-    const html = await (0, _ssr.renderSSR)(_input.default, {
-      modelValue: "test value"
-    });
-    (0, _ssr.expectSSRHasClass)(html, "yh-input");
-    (0, _vitest.expect)(html).toContain("test value");
-  });
-  (0, _vitest.it)("should render with placeholder in SSR", async () => {
-    const html = await (0, _ssr.renderSSR)(_input.default, {
-      placeholder: "Enter text"
-    });
-    (0, _vitest.expect)(html).toContain('placeholder="Enter text"');
-  });
-  (0, _vitest.it)("should render disabled state in SSR", async () => {
-    const html = await (0, _ssr.renderSSR)(_input.default, {
-      disabled: true
-    });
-    (0, _ssr.expectSSRHasClass)(html, "is-disabled");
-    (0, _vitest.expect)(html).toContain("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)(_input.default, {
-        size
-      });
-      if (size !== "default") {
-        (0, _ssr.expectSSRHasClass)(html, `yh-input--${size}`);
-      }
-    }
-  });
-  (0, _vitest.it)("should render clearable input in SSR", async () => {
-    const html = await (0, _ssr.renderSSR)(_input.default, {
-      modelValue: "clearable",
-      clearable: true
-    });
-    (0, _ssr.expectSSRHasClass)(html, "yh-input");
-  });
-  (0, _vitest.it)("should render prefix icon in SSR", async () => {
-    const html = await (0, _ssr.renderSSR)(_input.default, {
-      prefixIcon: "search"
-    });
-    (0, _ssr.expectSSRHasClass)(html, "yh-input__prefix");
-  });
-  (0, _vitest.it)("should render suffix icon in SSR", async () => {
-    const html = await (0, _ssr.renderSSR)(_input.default, {
-      suffixIcon: "close"
-    });
-    (0, _ssr.expectSSRHasClass)(html, "yh-input__suffix");
-  });
-  (0, _vitest.it)("should hydrate without mismatch", async () => {
-    const result = await (0, _ssr.testHydration)(_input.default, {
-      modelValue: "Hydration Test",
-      placeholder: "Enter text",
-      clearable: true
-    });
-    (0, _vitest.expect)(result.isMatch).toBe(true);
-  });
-  (0, _vitest.it)("should render textarea in SSR", async () => {
-    const html = await (0, _ssr.renderSSR)(_input.default, {
-      type: "textarea",
-      modelValue: "Textarea content",
-      rows: 4
-    });
-    (0, _vitest.expect)(html).toContain("textarea");
-    (0, _vitest.expect)(html).toContain("Textarea content");
-  });
-  (0, _vitest.it)("should render maxlength in SSR", async () => {
-    const html = await (0, _ssr.renderSSR)(_input.default, {
-      maxlength: 100,
-      showWordLimit: true,
-      modelValue: "test"
-    });
-    (0, _vitest.expect)(html).toContain('maxlength="100"');
-  });
-  (0, _vitest.it)("should render password input in SSR", async () => {
-    const html = await (0, _ssr.renderSSR)(_input.default, {
-      type: "password",
-      showPassword: true
-    });
-    (0, _vitest.expect)(html).toContain('type="password"');
-  });
-  (0, _vitest.it)("should hydrate textarea without mismatch", async () => {
-    const result = await (0, _ssr.testHydration)(_input.default, {
-      type: "textarea",
-      modelValue: "Multi-line\ntext content",
-      rows: 5,
-      maxlength: 200,
-      showWordLimit: true
-    });
-    (0, _vitest.expect)(result.isMatch).toBe(true);
-  });
-});

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

@@ -1,85 +0,0 @@
-import { describe, it, expect } from "vitest";
-import Input from "../src/input.vue";
-import { renderSSR, expectSSRHasClass, testHydration } from "../../__tests__/utils/ssr.mjs";
-describe("YhInput SSR", () => {
-  it("should render correctly in SSR", async () => {
-    const html = await renderSSR(Input, { modelValue: "test value" });
-    expectSSRHasClass(html, "yh-input");
-    expect(html).toContain("test value");
-  });
-  it("should render with placeholder in SSR", async () => {
-    const html = await renderSSR(Input, { placeholder: "Enter text" });
-    expect(html).toContain('placeholder="Enter text"');
-  });
-  it("should render disabled state in SSR", async () => {
-    const html = await renderSSR(Input, { disabled: true });
-    expectSSRHasClass(html, "is-disabled");
-    expect(html).toContain("disabled");
-  });
-  it("should render different sizes in SSR", async () => {
-    const sizes = ["small", "default", "large"];
-    for (const size of sizes) {
-      const html = await renderSSR(Input, { size });
-      if (size !== "default") {
-        expectSSRHasClass(html, `yh-input--${size}`);
-      }
-    }
-  });
-  it("should render clearable input in SSR", async () => {
-    const html = await renderSSR(Input, {
-      modelValue: "clearable",
-      clearable: true
-    });
-    expectSSRHasClass(html, "yh-input");
-  });
-  it("should render prefix icon in SSR", async () => {
-    const html = await renderSSR(Input, { prefixIcon: "search" });
-    expectSSRHasClass(html, "yh-input__prefix");
-  });
-  it("should render suffix icon in SSR", async () => {
-    const html = await renderSSR(Input, { suffixIcon: "close" });
-    expectSSRHasClass(html, "yh-input__suffix");
-  });
-  it("should hydrate without mismatch", async () => {
-    const result = await testHydration(Input, {
-      modelValue: "Hydration Test",
-      placeholder: "Enter text",
-      clearable: true
-    });
-    expect(result.isMatch).toBe(true);
-  });
-  it("should render textarea in SSR", async () => {
-    const html = await renderSSR(Input, {
-      type: "textarea",
-      modelValue: "Textarea content",
-      rows: 4
-    });
-    expect(html).toContain("textarea");
-    expect(html).toContain("Textarea content");
-  });
-  it("should render maxlength in SSR", async () => {
-    const html = await renderSSR(Input, {
-      maxlength: 100,
-      showWordLimit: true,
-      modelValue: "test"
-    });
-    expect(html).toContain('maxlength="100"');
-  });
-  it("should render password input in SSR", async () => {
-    const html = await renderSSR(Input, {
-      type: "password",
-      showPassword: true
-    });
-    expect(html).toContain('type="password"');
-  });
-  it("should hydrate textarea without mismatch", async () => {
-    const result = await testHydration(Input, {
-      type: "textarea",
-      modelValue: "Multi-line\ntext content",
-      rows: 5,
-      maxlength: 200,
-      showWordLimit: true
-    });
-    expect(result.isMatch).toBe(true);
-  });
-});

package/dist/input/__tests__/input.test.cjs

@@ -1,127 +0,0 @@
-"use strict";
-
-var _vitest = require("vitest");
-var _testUtils = require("@vue/test-utils");
-var _vue = require("vue");
-var _input = _interopRequireDefault(require("../src/input.vue"));
-var _input2 = require("../src/input.cjs");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-(0, _vitest.describe)("YhInput", () => {
-  (0, _vitest.it)("should render correctly", () => {
-    const wrapper = (0, _testUtils.mount)(_input.default);
-    (0, _vitest.expect)(wrapper.classes()).toContain("yh-input");
-    (0, _vitest.expect)(wrapper.find("input").exists()).toBe(true);
-  });
-  (0, _vitest.it)("should work with v-model", async () => {
-    const wrapper = (0, _testUtils.mount)(_input.default, {
-      props: {
-        modelValue: "test",
-        "onUpdate:modelValue": val => wrapper.setProps({
-          modelValue: val
-        })
-      }
-    });
-    (0, _vitest.expect)(wrapper.find("input").element.value).toBe("test");
-    await wrapper.find("input").setValue("new value");
-    (0, _vitest.expect)(wrapper.props("modelValue")).toBe("new value");
-  });
-  (0, _vitest.it)("should display placeholder", () => {
-    const wrapper = (0, _testUtils.mount)(_input.default, {
-      props: {
-        placeholder: "\u8BF7\u8F93\u5165\u5185\u5BB9"
-      }
-    });
-    (0, _vitest.expect)(wrapper.find("input").attributes("placeholder")).toBe("\u8BF7\u8F93\u5165\u5185\u5BB9");
-  });
-  (0, _vitest.it)("should be disabled when disabled prop is true", () => {
-    const wrapper = (0, _testUtils.mount)(_input.default, {
-      props: {
-        disabled: true
-      }
-    });
-    (0, _vitest.expect)(wrapper.classes()).toContain("is-disabled");
-    (0, _vitest.expect)(wrapper.find("input").attributes("disabled")).toBeDefined();
-  });
-  (0, _vitest.it)("should be readonly when readonly prop is true", () => {
-    const wrapper = (0, _testUtils.mount)(_input.default, {
-      props: {
-        readonly: true
-      }
-    });
-    (0, _vitest.expect)(wrapper.find("input").attributes("readonly")).toBeDefined();
-  });
-  (0, _vitest.it)("should apply size class", () => {
-    const wrapper = (0, _testUtils.mount)(_input.default, {
-      props: {
-        size: "large"
-      }
-    });
-    (0, _vitest.expect)(wrapper.classes()).toContain("yh-input--large");
-  });
-  (0, _vitest.it)("should show clear button when clearable", async () => {
-    const wrapper = (0, _testUtils.mount)(_input.default, {
-      props: {
-        modelValue: "test",
-        clearable: true
-      }
-    });
-    await wrapper.find("input").trigger("focus");
-    await (0, _vue.nextTick)();
-    (0, _vitest.expect)(wrapper.find(".yh-input__clear").exists()).toBe(true);
-  });
-  (0, _vitest.it)("should toggle password visibility", async () => {
-    const wrapper = (0, _testUtils.mount)(_input.default, {
-      props: {
-        type: "password",
-        modelValue: "password123",
-        showPassword: true
-      }
-    });
-    (0, _vitest.expect)(wrapper.find("input").attributes("type")).toBe("password");
-    await wrapper.find(".yh-input__password").trigger("click");
-    (0, _vitest.expect)(wrapper.find("input").attributes("type")).toBe("text");
-  });
-  (0, _vitest.it)("should export valid constants", () => {
-    (0, _vitest.expect)(_input2.inputTypes).toBeTruthy();
-    (0, _vitest.expect)(_input2.inputSizes).toBeTruthy();
-    (0, _vitest.expect)(_input2.inputVariants).toBeTruthy();
-    (0, _vitest.expect)(_input2.inputStatuses).toBeTruthy();
-  });
-  (0, _vitest.it)("should show word limit count", () => {
-    const wrapper = (0, _testUtils.mount)(_input.default, {
-      props: {
-        modelValue: "hello",
-        maxlength: 10,
-        showWordLimit: true
-      }
-    });
-    (0, _vitest.expect)(wrapper.find(".yh-input__count").exists()).toBe(true);
-    (0, _vitest.expect)(wrapper.find(".yh-input__count").text()).toBe("5 / 10");
-  });
-  (0, _vitest.it)("should render textarea when type is textarea", () => {
-    const wrapper = (0, _testUtils.mount)(_input.default, {
-      props: {
-        type: "textarea"
-      }
-    });
-    (0, _vitest.expect)(wrapper.find("textarea").exists()).toBe(true);
-    (0, _vitest.expect)(wrapper.find("input").exists()).toBe(false);
-  });
-  (0, _vitest.it)("should emit focus and blur events", async () => {
-    const wrapper = (0, _testUtils.mount)(_input.default);
-    await wrapper.find("input").trigger("focus");
-    (0, _vitest.expect)(wrapper.emitted("focus")).toBeTruthy();
-    await wrapper.find("input").trigger("blur");
-    (0, _vitest.expect)(wrapper.emitted("blur")).toBeTruthy();
-  });
-  (0, _vitest.it)("should render prepend and append slots", () => {
-    const wrapper = (0, _testUtils.mount)(_input.default, {
-      slots: {
-        prepend: "<span>http://</span>",
-        append: "<span>.com</span>"
-      }
-    });
-    (0, _vitest.expect)(wrapper.find(".yh-input__prepend").exists()).toBe(true);
-    (0, _vitest.expect)(wrapper.find(".yh-input__append").exists()).toBe(true);
-  });
-});

package/dist/input/__tests__/input.test.mjs

@@ -1,112 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { mount } from "@vue/test-utils";
-import { nextTick } from "vue";
-import Input from "../src/input.vue";
-import { inputTypes, inputSizes, inputVariants, inputStatuses } from "../src/input.mjs";
-describe("YhInput", () => {
-  it("should render correctly", () => {
-    const wrapper = mount(Input);
-    expect(wrapper.classes()).toContain("yh-input");
-    expect(wrapper.find("input").exists()).toBe(true);
-  });
-  it("should work with v-model", async () => {
-    const wrapper = mount(Input, {
-      props: {
-        modelValue: "test",
-        "onUpdate:modelValue": (val) => wrapper.setProps({ modelValue: val })
-      }
-    });
-    expect(wrapper.find("input").element.value).toBe("test");
-    await wrapper.find("input").setValue("new value");
-    expect(wrapper.props("modelValue")).toBe("new value");
-  });
-  it("should display placeholder", () => {
-    const wrapper = mount(Input, {
-      props: { placeholder: "\u8BF7\u8F93\u5165\u5185\u5BB9" }
-    });
-    expect(wrapper.find("input").attributes("placeholder")).toBe("\u8BF7\u8F93\u5165\u5185\u5BB9");
-  });
-  it("should be disabled when disabled prop is true", () => {
-    const wrapper = mount(Input, {
-      props: { disabled: true }
-    });
-    expect(wrapper.classes()).toContain("is-disabled");
-    expect(wrapper.find("input").attributes("disabled")).toBeDefined();
-  });
-  it("should be readonly when readonly prop is true", () => {
-    const wrapper = mount(Input, {
-      props: { readonly: true }
-    });
-    expect(wrapper.find("input").attributes("readonly")).toBeDefined();
-  });
-  it("should apply size class", () => {
-    const wrapper = mount(Input, {
-      props: { size: "large" }
-    });
-    expect(wrapper.classes()).toContain("yh-input--large");
-  });
-  it("should show clear button when clearable", async () => {
-    const wrapper = mount(Input, {
-      props: {
-        modelValue: "test",
-        clearable: true
-      }
-    });
-    await wrapper.find("input").trigger("focus");
-    await nextTick();
-    expect(wrapper.find(".yh-input__clear").exists()).toBe(true);
-  });
-  it("should toggle password visibility", async () => {
-    const wrapper = mount(Input, {
-      props: {
-        type: "password",
-        modelValue: "password123",
-        showPassword: true
-      }
-    });
-    expect(wrapper.find("input").attributes("type")).toBe("password");
-    await wrapper.find(".yh-input__password").trigger("click");
-    expect(wrapper.find("input").attributes("type")).toBe("text");
-  });
-  it("should export valid constants", () => {
-    expect(inputTypes).toBeTruthy();
-    expect(inputSizes).toBeTruthy();
-    expect(inputVariants).toBeTruthy();
-    expect(inputStatuses).toBeTruthy();
-  });
-  it("should show word limit count", () => {
-    const wrapper = mount(Input, {
-      props: {
-        modelValue: "hello",
-        maxlength: 10,
-        showWordLimit: true
-      }
-    });
-    expect(wrapper.find(".yh-input__count").exists()).toBe(true);
-    expect(wrapper.find(".yh-input__count").text()).toBe("5 / 10");
-  });
-  it("should render textarea when type is textarea", () => {
-    const wrapper = mount(Input, {
-      props: { type: "textarea" }
-    });
-    expect(wrapper.find("textarea").exists()).toBe(true);
-    expect(wrapper.find("input").exists()).toBe(false);
-  });
-  it("should emit focus and blur events", async () => {
-    const wrapper = mount(Input);
-    await wrapper.find("input").trigger("focus");
-    expect(wrapper.emitted("focus")).toBeTruthy();
-    await wrapper.find("input").trigger("blur");
-    expect(wrapper.emitted("blur")).toBeTruthy();
-  });
-  it("should render prepend and append slots", () => {
-    const wrapper = mount(Input, {
-      slots: {
-        prepend: "<span>http://</span>",
-        append: "<span>.com</span>"
-      }
-    });
-    expect(wrapper.find(".yh-input__prepend").exists()).toBe(true);
-    expect(wrapper.find(".yh-input__append").exists()).toBe(true);
-  });
-});

package/dist/input-number/__tests__/input-number.hydration.test.cjs

@@ -1,24 +0,0 @@
-"use strict";
-
-var _vitest = require("vitest");
-var _inputNumber = _interopRequireDefault(require("../src/input-number.vue"));
-var _ssr = require("../../__tests__/utils/ssr.cjs");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-(0, _vitest.describe)("YhInputNumber Hydration", () => {
-  (0, _vitest.it)("should hydrate without mismatch", async () => {
-    const result = await (0, _ssr.testHydration)(_inputNumber.default, {
-      modelValue: 100,
-      min: 0,
-      max: 200,
-      step: 10
-    });
-    (0, _vitest.expect)(result.ssrHtml).toBe(result.csrHtml);
-  });
-  (0, _vitest.it)("should hydrate with precision", async () => {
-    const result = await (0, _ssr.testHydration)(_inputNumber.default, {
-      modelValue: 3.14159,
-      precision: 2
-    });
-    (0, _vitest.expect)(result.ssrHtml).toBe(result.csrHtml);
-  });
-});

package/dist/input-number/__tests__/input-number.hydration.test.mjs

@@ -1,21 +0,0 @@
-import { describe, it, expect } from "vitest";
-import InputNumber from "../src/input-number.vue";
-import { testHydration } from "../../__tests__/utils/ssr.mjs";
-describe("YhInputNumber Hydration", () => {
-  it("should hydrate without mismatch", async () => {
-    const result = await testHydration(InputNumber, {
-      modelValue: 100,
-      min: 0,
-      max: 200,
-      step: 10
-    });
-    expect(result.ssrHtml).toBe(result.csrHtml);
-  });
-  it("should hydrate with precision", async () => {
-    const result = await testHydration(InputNumber, {
-      modelValue: 3.14159,
-      precision: 2
-    });
-    expect(result.ssrHtml).toBe(result.csrHtml);
-  });
-});

package/dist/input-number/__tests__/input-number.ssr.test.cjs

@@ -1,95 +0,0 @@
-"use strict";
-
-var _vitest = require("vitest");
-var _inputNumber = _interopRequireDefault(require("../src/input-number.vue"));
-var _ssr = require("../../__tests__/utils/ssr.cjs");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-(0, _vitest.describe)("YhInputNumber SSR", () => {
-  (0, _vitest.it)("should render correctly in SSR", async () => {
-    const html = await (0, _ssr.renderSSR)(_inputNumber.default, {
-      modelValue: 0
-    });
-    (0, _ssr.expectSSRHasClass)(html, "yh-input-number");
-  });
-  (0, _vitest.it)("should render with initial value in SSR", async () => {
-    const html = await (0, _ssr.renderSSR)(_inputNumber.default, {
-      modelValue: 10
-    });
-    (0, _vitest.expect)(html).toContain("10");
-  });
-  (0, _vitest.it)("should render disabled state in SSR", async () => {
-    const html = await (0, _ssr.renderSSR)(_inputNumber.default, {
-      modelValue: 5,
-      disabled: true
-    });
-    (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)(_inputNumber.default, {
-        modelValue: 0,
-        size
-      });
-      if (size !== "default") {
-        (0, _ssr.expectSSRHasClass)(html, `yh-input-number--${size}`);
-      }
-    }
-  });
-  (0, _vitest.it)("should render with min value in SSR", async () => {
-    const html = await (0, _ssr.renderSSR)(_inputNumber.default, {
-      modelValue: 5,
-      min: 0
-    });
-    (0, _ssr.expectSSRHasClass)(html, "yh-input-number");
-  });
-  (0, _vitest.it)("should render with max value in SSR", async () => {
-    const html = await (0, _ssr.renderSSR)(_inputNumber.default, {
-      modelValue: 5,
-      max: 10
-    });
-    (0, _ssr.expectSSRHasClass)(html, "yh-input-number");
-  });
-  (0, _vitest.it)("should render with step in SSR", async () => {
-    const html = await (0, _ssr.renderSSR)(_inputNumber.default, {
-      modelValue: 0,
-      step: 2
-    });
-    (0, _ssr.expectSSRHasClass)(html, "yh-input-number");
-  });
-  (0, _vitest.it)("should render with precision in SSR", async () => {
-    const html = await (0, _ssr.renderSSR)(_inputNumber.default, {
-      modelValue: 1.5,
-      precision: 2
-    });
-    (0, _vitest.expect)(html).toContain("1.50");
-  });
-  (0, _vitest.it)("should render controls position in SSR", async () => {
-    const html = await (0, _ssr.renderSSR)(_inputNumber.default, {
-      modelValue: 0,
-      controlsPosition: "right"
-    });
-    (0, _ssr.expectSSRHasClass)(html, "is-controls-right");
-  });
-  (0, _vitest.it)("should render without controls in SSR", async () => {
-    const html = await (0, _ssr.renderSSR)(_inputNumber.default, {
-      modelValue: 0,
-      controls: false
-    });
-    (0, _ssr.expectSSRHasClass)(html, "yh-input-number");
-  });
-  (0, _vitest.it)("should render readonly state in SSR", async () => {
-    const html = await (0, _ssr.renderSSR)(_inputNumber.default, {
-      modelValue: 10,
-      readonly: true
-    });
-    (0, _ssr.expectSSRHasClass)(html, "yh-input-number");
-  });
-  (0, _vitest.it)("should render placeholder in SSR", async () => {
-    const html = await (0, _ssr.renderSSR)(_inputNumber.default, {
-      modelValue: void 0,
-      placeholder: "Enter number"
-    });
-    (0, _vitest.expect)(html).toContain("Enter number");
-  });
-});