@yh-ui/components 0.1.21 → 0.1.23

package/dist/infinite-scroll/__tests__/infinite-scroll.ssr.test.cjs

@@ -1,59 +0,0 @@
-"use strict";
-
-var _serverRenderer = require("@vue/server-renderer");
-var _vitest = require("vitest");
-var _vue = require("vue");
-var _infiniteScroll = _interopRequireDefault(require("../src/infinite-scroll.vue"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-(0, _vitest.describe)("YhInfiniteScroll SSR", () => {
-  (0, _vitest.it)("should render on server without errors", async () => {
-    const html = await (0, _serverRenderer.renderToString)((0, _vue.h)(_infiniteScroll.default, {
-      loading: false,
-      finished: false
-    }, {
-      default: () => (0, _vue.h)("div", {
-        class: "list"
-      }, "List Items")
-    }));
-    (0, _vitest.expect)(html).toContain("yh-infinite-scroll");
-    (0, _vitest.expect)(html).toContain("List Items");
-  });
-  (0, _vitest.it)("should render loading state on server", async () => {
-    const html = await (0, _serverRenderer.renderToString)((0, _vue.h)(_infiniteScroll.default, {
-      loading: true,
-      loadingText: "\u52A0\u8F7D\u4E2D..."
-    }, {
-      default: () => (0, _vue.h)("div", "Content")
-    }));
-    (0, _vitest.expect)(html).toContain("yh-infinite-scroll__loading");
-    (0, _vitest.expect)(html).toContain("\u52A0\u8F7D\u4E2D...");
-  });
-  (0, _vitest.it)("should render finished state on server", async () => {
-    const html = await (0, _serverRenderer.renderToString)((0, _vue.h)(_infiniteScroll.default, {
-      finished: true,
-      finishedText: "\u6CA1\u6709\u66F4\u591A\u4E86"
-    }, {
-      default: () => (0, _vue.h)("div", "Content")
-    }));
-    (0, _vitest.expect)(html).toContain("yh-infinite-scroll__finished");
-    (0, _vitest.expect)(html).toContain("\u6CA1\u6709\u66F4\u591A\u4E86");
-  });
-  (0, _vitest.it)("should render error state on server", async () => {
-    const html = await (0, _serverRenderer.renderToString)((0, _vue.h)(_infiniteScroll.default, {
-      error: true,
-      errorText: "\u52A0\u8F7D\u5931\u8D25"
-    }, {
-      default: () => (0, _vue.h)("div", "Content")
-    }));
-    (0, _vitest.expect)(html).toContain("yh-infinite-scroll__error");
-    (0, _vitest.expect)(html).toContain("\u52A0\u8F7D\u5931\u8D25");
-  });
-  (0, _vitest.it)("should render horizontal direction on server", async () => {
-    const html = await (0, _serverRenderer.renderToString)((0, _vue.h)(_infiniteScroll.default, {
-      direction: "horizontal"
-    }, {
-      default: () => (0, _vue.h)("div", "Content")
-    }));
-    (0, _vitest.expect)(html).toContain("is-horizontal");
-  });
-});

package/dist/infinite-scroll/__tests__/infinite-scroll.ssr.test.mjs

@@ -1,84 +0,0 @@
-import { renderToString } from "@vue/server-renderer";
-import { describe, it, expect } from "vitest";
-import { h } from "vue";
-import YhInfiniteScroll from "../src/infinite-scroll.vue";
-describe("YhInfiniteScroll SSR", () => {
-  it("should render on server without errors", async () => {
-    const html = await renderToString(
-      h(
-        YhInfiniteScroll,
-        {
-          loading: false,
-          finished: false
-        },
-        {
-          default: () => h("div", { class: "list" }, "List Items")
-        }
-      )
-    );
-    expect(html).toContain("yh-infinite-scroll");
-    expect(html).toContain("List Items");
-  });
-  it("should render loading state on server", async () => {
-    const html = await renderToString(
-      h(
-        YhInfiniteScroll,
-        {
-          loading: true,
-          loadingText: "\u52A0\u8F7D\u4E2D..."
-        },
-        {
-          default: () => h("div", "Content")
-        }
-      )
-    );
-    expect(html).toContain("yh-infinite-scroll__loading");
-    expect(html).toContain("\u52A0\u8F7D\u4E2D...");
-  });
-  it("should render finished state on server", async () => {
-    const html = await renderToString(
-      h(
-        YhInfiniteScroll,
-        {
-          finished: true,
-          finishedText: "\u6CA1\u6709\u66F4\u591A\u4E86"
-        },
-        {
-          default: () => h("div", "Content")
-        }
-      )
-    );
-    expect(html).toContain("yh-infinite-scroll__finished");
-    expect(html).toContain("\u6CA1\u6709\u66F4\u591A\u4E86");
-  });
-  it("should render error state on server", async () => {
-    const html = await renderToString(
-      h(
-        YhInfiniteScroll,
-        {
-          error: true,
-          errorText: "\u52A0\u8F7D\u5931\u8D25"
-        },
-        {
-          default: () => h("div", "Content")
-        }
-      )
-    );
-    expect(html).toContain("yh-infinite-scroll__error");
-    expect(html).toContain("\u52A0\u8F7D\u5931\u8D25");
-  });
-  it("should render horizontal direction on server", async () => {
-    const html = await renderToString(
-      h(
-        YhInfiniteScroll,
-        {
-          direction: "horizontal"
-        },
-        {
-          default: () => h("div", "Content")
-        }
-      )
-    );
-    expect(html).toContain("is-horizontal");
-  });
-});

package/dist/infinite-scroll/__tests__/infinite-scroll.test.cjs

@@ -1,255 +0,0 @@
-"use strict";
-
-var _vitest = require("vitest");
-var _testUtils = require("@vue/test-utils");
-var _vue = require("vue");
-var _index = require("../index.cjs");
-var _directive = require("../src/directive.cjs");
-class MockIntersectionObserver {
-  callback;
-  elements = /* @__PURE__ */new Set();
-  constructor(callback) {
-    this.callback = callback;
-  }
-  observe(el) {
-    this.elements.add(el);
-  }
-  unobserve(el) {
-    this.elements.delete(el);
-  }
-  disconnect() {
-    this.elements.clear();
-  }
-  trigger(entry = {
-    isIntersecting: true
-  }) {
-    this.callback([entry], this);
-  }
-}
-global.IntersectionObserver = MockIntersectionObserver;
-(0, _vitest.describe)("InfiniteScroll Component", () => {
-  (0, _vitest.it)("should render correctly", () => {
-    const wrapper = (0, _testUtils.mount)(_index.YhInfiniteScroll, {
-      props: {
-        loading: false,
-        finished: false
-      },
-      slots: {
-        default: () => (0, _vue.h)("div", {
-          class: "list-item"
-        }, "Item")
-      }
-    });
-    (0, _vitest.expect)(wrapper.find(".yh-infinite-scroll").exists()).toBe(true);
-    (0, _vitest.expect)(wrapper.find(".list-item").exists()).toBe(true);
-  });
-  (0, _vitest.it)("should show loading state", () => {
-    const wrapper = (0, _testUtils.mount)(_index.YhInfiniteScroll, {
-      props: {
-        loading: true
-      }
-    });
-    (0, _vitest.expect)(wrapper.find(".yh-infinite-scroll__loading").exists()).toBe(true);
-  });
-  (0, _vitest.it)("should show finished state", async () => {
-    const wrapper = (0, _testUtils.mount)(_index.YhInfiniteScroll, {
-      props: {
-        finished: true,
-        loading: false
-      }
-    });
-    (0, _vitest.expect)(wrapper.find(".yh-infinite-scroll__finished").exists()).toBe(true);
-  });
-  (0, _vitest.it)("should handle retry click", async () => {
-    const wrapper = (0, _testUtils.mount)(_index.YhInfiniteScroll, {
-      props: {
-        error: true
-      }
-    });
-    await wrapper.find(".yh-infinite-scroll__error").trigger("click");
-    (0, _vitest.expect)(wrapper.emitted("update:error")[0]).toEqual([false]);
-    (0, _vitest.expect)(wrapper.emitted("load")).toBeTruthy();
-  });
-  (0, _vitest.it)("should support manual check method", async () => {
-    const wrapper = (0, _testUtils.mount)(_index.YhInfiniteScroll, {
-      props: {
-        useObserver: false,
-        threshold: 50
-      }
-    });
-    (0, _vitest.expect)(typeof wrapper.vm.check).toBe("function");
-    wrapper.vm.check();
-  });
-  (0, _vitest.it)("should fallback to scroll listener when useObserver is false", async () => {
-    const wrapper = (0, _testUtils.mount)(_index.YhInfiniteScroll, {
-      attachTo: document.body,
-      props: {
-        useObserver: false,
-        target: ".yh-infinite-scroll",
-        threshold: 100
-      }
-    });
-    await (0, _vue.nextTick)();
-    const container = wrapper.element;
-    Object.defineProperty(container, "scrollHeight", {
-      value: 1e3,
-      configurable: true
-    });
-    Object.defineProperty(container, "clientHeight", {
-      value: 500,
-      configurable: true
-    });
-    Object.defineProperty(container, "scrollTop", {
-      value: 490,
-      configurable: true,
-      writable: true
-    });
-    wrapper.vm.check();
-    (0, _vitest.expect)(wrapper.emitted("load")).toBeTruthy();
-  });
-  (0, _vitest.it)("should handle horizontal scroll correctly", async () => {
-    const wrapper = (0, _testUtils.mount)(_index.YhInfiniteScroll, {
-      attachTo: document.body,
-      props: {
-        useObserver: false,
-        target: ".yh-infinite-scroll",
-        direction: "horizontal",
-        threshold: 100
-      }
-    });
-    await (0, _vue.nextTick)();
-    const container = wrapper.element;
-    Object.defineProperty(container, "scrollWidth", {
-      value: 1e3,
-      configurable: true
-    });
-    Object.defineProperty(container, "clientWidth", {
-      value: 500,
-      configurable: true
-    });
-    Object.defineProperty(container, "scrollLeft", {
-      value: 490,
-      configurable: true,
-      writable: true
-    });
-    wrapper.vm.check();
-    (0, _vitest.expect)(wrapper.emitted("load")).toBeTruthy();
-  });
-  (0, _vitest.it)("should handle dynamic useObserver switching", async () => {
-    const wrapper = (0, _testUtils.mount)(_index.YhInfiniteScroll, {
-      attachTo: document.body,
-      props: {
-        useObserver: false,
-        target: ".yh-infinite-scroll",
-        threshold: 100
-      }
-    });
-    await wrapper.setProps({
-      useObserver: true
-    });
-    (0, _vitest.expect)(wrapper.vm).toBeDefined();
-    await wrapper.setProps({
-      useObserver: false
-    });
-  });
-  (0, _vitest.it)("should handle loading change and re-evaluate", async () => {
-    const wrapper = (0, _testUtils.mount)(_index.YhInfiniteScroll, {
-      attachTo: document.body,
-      props: {
-        loading: true,
-        immediateCheck: true,
-        useObserver: false,
-        target: ".yh-infinite-scroll",
-        threshold: 100
-      }
-    });
-    await (0, _vue.nextTick)();
-    const container = wrapper.element;
-    Object.defineProperty(container, "scrollHeight", {
-      value: 1e3,
-      configurable: true
-    });
-    Object.defineProperty(container, "clientHeight", {
-      value: 500,
-      configurable: true
-    });
-    Object.defineProperty(container, "scrollTop", {
-      value: 490,
-      configurable: true,
-      writable: true
-    });
-    await wrapper.setProps({
-      loading: false
-    });
-    await (0, _vue.nextTick)();
-    await (0, _vue.nextTick)();
-    (0, _vitest.expect)(wrapper.emitted("load")).toBeTruthy();
-  });
-});
-(0, _vitest.describe)("InfiniteScroll Directive", () => {
-  (0, _vitest.it)("should trigger callback when intersecting", async () => {
-    const onLoad = _vitest.vi.fn();
-    const instances = [];
-    const Original = global.IntersectionObserver;
-    global.IntersectionObserver = class extends MockIntersectionObserver {
-      constructor(cb) {
-        super(cb);
-        instances.push(this);
-      }
-    };
-    const TestComponent = (0, _vue.defineComponent)({
-      directives: {
-        InfiniteScroll: _directive.vInfiniteScroll
-      },
-      setup() {
-        return {
-          onLoad
-        };
-      },
-      template: '<div v-infinite-scroll="onLoad"></div>'
-    });
-    const wrapper = (0, _testUtils.mount)(TestComponent);
-    (0, _vitest.expect)(instances.length).toBeGreaterThan(0);
-    instances[0].trigger({
-      isIntersecting: true
-    });
-    (0, _vitest.expect)(onLoad).toHaveBeenCalled();
-    global.IntersectionObserver = Original;
-  });
-  (0, _vitest.it)("should handle disabled attribute in directive", async () => {
-    const onLoad = _vitest.vi.fn();
-    const disabled = (0, _vue.ref)(true);
-    const instances = [];
-    const Original = global.IntersectionObserver;
-    global.IntersectionObserver = class extends MockIntersectionObserver {
-      constructor(cb) {
-        super(cb);
-        instances.push(this);
-      }
-    };
-    const TestComponent = (0, _vue.defineComponent)({
-      directives: {
-        InfiniteScroll: _directive.vInfiniteScroll
-      },
-      setup() {
-        return {
-          onLoad,
-          disabled
-        };
-      },
-      template: '<div v-infinite-scroll="onLoad" :infinite-scroll-disabled="disabled"></div>'
-    });
-    const wrapper = (0, _testUtils.mount)(TestComponent);
-    instances[0].trigger({
-      isIntersecting: true
-    });
-    (0, _vitest.expect)(onLoad).not.toHaveBeenCalled();
-    disabled.value = false;
-    await (0, _vue.nextTick)();
-    instances[0].trigger({
-      isIntersecting: true
-    });
-    (0, _vitest.expect)(onLoad).toHaveBeenCalled();
-    global.IntersectionObserver = Original;
-  });
-});

package/dist/infinite-scroll/__tests__/infinite-scroll.test.mjs

@@ -1,187 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-import { mount } from "@vue/test-utils";
-import { nextTick, h, ref, defineComponent } from "vue";
-import { YhInfiniteScroll } from "../index.mjs";
-import { vInfiniteScroll } from "../src/directive.mjs";
-class MockIntersectionObserver {
-  callback;
-  elements = /* @__PURE__ */ new Set();
-  constructor(callback) {
-    this.callback = callback;
-  }
-  observe(el) {
-    this.elements.add(el);
-  }
-  unobserve(el) {
-    this.elements.delete(el);
-  }
-  disconnect() {
-    this.elements.clear();
-  }
-  trigger(entry = { isIntersecting: true }) {
-    this.callback([entry], this);
-  }
-}
-global.IntersectionObserver = MockIntersectionObserver;
-describe("InfiniteScroll Component", () => {
-  it("should render correctly", () => {
-    const wrapper = mount(YhInfiniteScroll, {
-      props: { loading: false, finished: false },
-      slots: { default: () => h("div", { class: "list-item" }, "Item") }
-    });
-    expect(wrapper.find(".yh-infinite-scroll").exists()).toBe(true);
-    expect(wrapper.find(".list-item").exists()).toBe(true);
-  });
-  it("should show loading state", () => {
-    const wrapper = mount(YhInfiniteScroll, {
-      props: { loading: true }
-    });
-    expect(wrapper.find(".yh-infinite-scroll__loading").exists()).toBe(true);
-  });
-  it("should show finished state", async () => {
-    const wrapper = mount(YhInfiniteScroll, {
-      props: { finished: true, loading: false }
-    });
-    expect(wrapper.find(".yh-infinite-scroll__finished").exists()).toBe(true);
-  });
-  it("should handle retry click", async () => {
-    const wrapper = mount(YhInfiniteScroll, {
-      props: { error: true }
-    });
-    await wrapper.find(".yh-infinite-scroll__error").trigger("click");
-    expect(wrapper.emitted("update:error")[0]).toEqual([false]);
-    expect(wrapper.emitted("load")).toBeTruthy();
-  });
-  it("should support manual check method", async () => {
-    const wrapper = mount(YhInfiniteScroll, {
-      props: { useObserver: false, threshold: 50 }
-    });
-    expect(typeof wrapper.vm.check).toBe("function");
-    wrapper.vm.check();
-  });
-  it("should fallback to scroll listener when useObserver is false", async () => {
-    const wrapper = mount(YhInfiniteScroll, {
-      attachTo: document.body,
-      props: { useObserver: false, target: ".yh-infinite-scroll", threshold: 100 }
-    });
-    await nextTick();
-    const container = wrapper.element;
-    Object.defineProperty(container, "scrollHeight", { value: 1e3, configurable: true });
-    Object.defineProperty(container, "clientHeight", { value: 500, configurable: true });
-    Object.defineProperty(container, "scrollTop", {
-      value: 490,
-      configurable: true,
-      writable: true
-    });
-    wrapper.vm.check();
-    expect(wrapper.emitted("load")).toBeTruthy();
-  });
-  it("should handle horizontal scroll correctly", async () => {
-    const wrapper = mount(YhInfiniteScroll, {
-      attachTo: document.body,
-      props: {
-        useObserver: false,
-        target: ".yh-infinite-scroll",
-        direction: "horizontal",
-        threshold: 100
-      }
-    });
-    await nextTick();
-    const container = wrapper.element;
-    Object.defineProperty(container, "scrollWidth", { value: 1e3, configurable: true });
-    Object.defineProperty(container, "clientWidth", { value: 500, configurable: true });
-    Object.defineProperty(container, "scrollLeft", {
-      value: 490,
-      configurable: true,
-      writable: true
-    });
-    wrapper.vm.check();
-    expect(wrapper.emitted("load")).toBeTruthy();
-  });
-  it("should handle dynamic useObserver switching", async () => {
-    const wrapper = mount(YhInfiniteScroll, {
-      attachTo: document.body,
-      props: { useObserver: false, target: ".yh-infinite-scroll", threshold: 100 }
-    });
-    await wrapper.setProps({ useObserver: true });
-    expect(wrapper.vm).toBeDefined();
-    await wrapper.setProps({ useObserver: false });
-  });
-  it("should handle loading change and re-evaluate", async () => {
-    const wrapper = mount(YhInfiniteScroll, {
-      attachTo: document.body,
-      props: {
-        loading: true,
-        immediateCheck: true,
-        useObserver: false,
-        target: ".yh-infinite-scroll",
-        threshold: 100
-      }
-    });
-    await nextTick();
-    const container = wrapper.element;
-    Object.defineProperty(container, "scrollHeight", { value: 1e3, configurable: true });
-    Object.defineProperty(container, "clientHeight", { value: 500, configurable: true });
-    Object.defineProperty(container, "scrollTop", {
-      value: 490,
-      configurable: true,
-      writable: true
-    });
-    await wrapper.setProps({ loading: false });
-    await nextTick();
-    await nextTick();
-    expect(wrapper.emitted("load")).toBeTruthy();
-  });
-});
-describe("InfiniteScroll Directive", () => {
-  it("should trigger callback when intersecting", async () => {
-    const onLoad = vi.fn();
-    const instances = [];
-    const Original = global.IntersectionObserver;
-    global.IntersectionObserver = class extends MockIntersectionObserver {
-      constructor(cb) {
-        super(cb);
-        instances.push(this);
-      }
-    };
-    const TestComponent = defineComponent({
-      directives: { InfiniteScroll: vInfiniteScroll },
-      setup() {
-        return { onLoad };
-      },
-      template: '<div v-infinite-scroll="onLoad"></div>'
-    });
-    const wrapper = mount(TestComponent);
-    expect(instances.length).toBeGreaterThan(0);
-    instances[0].trigger({ isIntersecting: true });
-    expect(onLoad).toHaveBeenCalled();
-    global.IntersectionObserver = Original;
-  });
-  it("should handle disabled attribute in directive", async () => {
-    const onLoad = vi.fn();
-    const disabled = ref(true);
-    const instances = [];
-    const Original = global.IntersectionObserver;
-    global.IntersectionObserver = class extends MockIntersectionObserver {
-      constructor(cb) {
-        super(cb);
-        instances.push(this);
-      }
-    };
-    const TestComponent = defineComponent({
-      directives: { InfiniteScroll: vInfiniteScroll },
-      setup() {
-        return { onLoad, disabled };
-      },
-      template: '<div v-infinite-scroll="onLoad" :infinite-scroll-disabled="disabled"></div>'
-    });
-    const wrapper = mount(TestComponent);
-    instances[0].trigger({ isIntersecting: true });
-    expect(onLoad).not.toHaveBeenCalled();
-    disabled.value = false;
-    await nextTick();
-    instances[0].trigger({ isIntersecting: true });
-    expect(onLoad).toHaveBeenCalled();
-    global.IntersectionObserver = Original;
-  });
-});

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

@@ -1,77 +0,0 @@
-"use strict";
-
-var _vitest = require("vitest");
-var _utils = require("../src/utils.cjs");
-(0, _vitest.describe)("calcTextareaHeight", () => {
-  let textarea;
-  (0, _vitest.beforeEach)(() => {
-    textarea = document.createElement("textarea");
-    _vitest.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);
-  });
-  (0, _vitest.afterEach)(() => {
-    _vitest.vi.restoreAllMocks();
-    document.body.innerHTML = "";
-  });
-  (0, _vitest.it)("should return height string", () => {
-    const result = (0, _utils.calcTextareaHeight)(textarea);
-    (0, _vitest.expect)(result).toHaveProperty("height");
-    (0, _vitest.expect)(typeof result.height).toBe("string");
-    (0, _vitest.expect)(result.height).toMatch(/px$/);
-  });
-  (0, _vitest.it)("should return minHeight when minRows > 0", () => {
-    const result = (0, _utils.calcTextareaHeight)(textarea, 2);
-    (0, _vitest.expect)(result).toHaveProperty("minHeight");
-    (0, _vitest.expect)(result.minHeight).toMatch(/px$/);
-  });
-  (0, _vitest.it)("should handle maxRows constraint", () => {
-    const result = (0, _utils.calcTextareaHeight)(textarea, 1, 3);
-    (0, _vitest.expect)(result.height).toMatch(/px$/);
-  });
-  (0, _vitest.it)("should handle content-box sizing", () => {
-    _vitest.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 = (0, _utils.calcTextareaHeight)(textarea, 1);
-    (0, _vitest.expect)(result.height).toMatch(/px$/);
-  });
-  (0, _vitest.it)("should handle minRows = 0 (no minHeight)", () => {
-    const result = (0, _utils.calcTextareaHeight)(textarea, 0);
-    (0, _vitest.expect)(result.height).toMatch(/px$/);
-  });
-});