@yh-ui/components 0.1.0

package/dist/cascader/src/cascader.vue.d.ts

@@ -0,0 +1,63 @@
+import type { CascaderProps, CascaderOption, CascaderValue } from './cascader';
+declare var __VLS_9: {}, __VLS_19: {
+    node: any;
+    data: any;
+};
+type __VLS_Slots = {} & {
+    empty?: (props: typeof __VLS_9) => any;
+} & {
+    default?: (props: typeof __VLS_19) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<CascaderProps, {
+    focus: () => void;
+    blur: () => void;
+    getCheckedNodes: (leafOnly
+    /**
+     * YhCascader - 级联选择器组件
+     * @description 从层级数据中选择一个或多个值，严格类型化
+     */
+    ?: boolean) => CascaderOption[];
+    inputRef: HTMLInputElement | undefined;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    change: (value: CascaderValue | undefined) => any;
+    clear: () => any;
+    blur: (event: FocusEvent) => any;
+    focus: (event: FocusEvent) => any;
+    "update:modelValue": (value: CascaderValue | undefined) => any;
+    "expand-change": (value: (string | number)[]) => any;
+    "visible-change": (visible: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<CascaderProps> & Readonly<{
+    onChange?: ((value: CascaderValue | undefined) => any) | undefined;
+    onClear?: (() => any) | undefined;
+    onBlur?: ((event: FocusEvent) => any) | undefined;
+    onFocus?: ((event: FocusEvent) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: CascaderValue | undefined) => any) | undefined;
+    "onExpand-change"?: ((value: (string | number)[]) => any) | undefined;
+    "onVisible-change"?: ((visible: boolean) => any) | undefined;
+}>, {
+    teleported: boolean;
+    disabled: boolean;
+    size: import("./cascader").CascaderSize;
+    separator: string;
+    multiple: boolean;
+    clearable: boolean;
+    validateEvent: boolean;
+    virtual: boolean;
+    filterable: boolean;
+    showAllLevels: boolean;
+    collapseTags: boolean;
+    collapseTagsTooltip: boolean;
+    maxCollapseTags: number;
+    checkStrictly: boolean;
+    expandTrigger: import("./cascader").CascaderExpandTrigger;
+    emitPath: boolean;
+    virtualItemHeight: number;
+    tagType: import("./cascader").CascaderTagType;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, 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/checkbox/__tests__/checkbox.ssr.test.cjs

@@ -0,0 +1,52 @@
+"use strict";
+
+var _vitest = require("vitest");
+var _checkbox = _interopRequireDefault(require("../src/checkbox.vue"));
+var _checkboxGroup = _interopRequireDefault(require("../src/checkbox-group.vue"));
+var _ssr = require("../../__tests__/utils/ssr.cjs");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+(0, _vitest.describe)("YhCheckbox SSR", () => {
+  (0, _vitest.it)("should render correctly in SSR", async () => {
+    const html = await (0, _ssr.renderSSR)(_checkbox.default, {
+      modelValue: true
+    }, {
+      default: () => "Checkbox Label"
+    });
+    (0, _ssr.expectSSRHasClass)(html, "yh-checkbox");
+    (0, _vitest.expect)(html).toContain("Checkbox Label");
+  });
+  (0, _vitest.it)("should render checked state in SSR", async () => {
+    const html = await (0, _ssr.renderSSR)(_checkbox.default, {
+      modelValue: true
+    });
+    (0, _ssr.expectSSRHasClass)(html, "is-checked");
+  });
+  (0, _vitest.it)("should render disabled state in SSR", async () => {
+    const html = await (0, _ssr.renderSSR)(_checkbox.default, {
+      disabled: true
+    });
+    (0, _ssr.expectSSRHasClass)(html, "is-disabled");
+  });
+  (0, _vitest.it)("should hydrate without mismatch", async () => {
+    const result = await (0, _ssr.testHydration)(_checkbox.default, {
+      modelValue: true
+    }, {
+      default: () => "Hydration Test"
+    });
+    (0, _vitest.expect)(result.isMatch).toBe(true);
+  });
+});
+(0, _vitest.describe)("YhCheckboxGroup SSR", () => {
+  (0, _vitest.it)("should render group correctly in SSR", async () => {
+    const html = await (0, _ssr.renderSSR)(_checkboxGroup.default, {
+      modelValue: ["opt1"]
+    });
+    (0, _ssr.expectSSRHasClass)(html, "yh-checkbox-group");
+  });
+  (0, _vitest.it)("should hydrate group without mismatch", async () => {
+    const result = await (0, _ssr.testHydration)(_checkboxGroup.default, {
+      modelValue: ["opt1"]
+    });
+    (0, _vitest.expect)(result.isMatch).toBe(true);
+  });
+});

package/dist/checkbox/__tests__/checkbox.ssr.test.d.ts

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

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

@@ -0,0 +1,57 @@
+import { describe, it, expect } from "vitest";
+import Checkbox from "../src/checkbox.vue";
+import CheckboxGroup from "../src/checkbox-group.vue";
+import { renderSSR, expectSSRHasClass, testHydration } from "../../__tests__/utils/ssr.mjs";
+describe("YhCheckbox SSR", () => {
+  it("should render correctly in SSR", async () => {
+    const html = await renderSSR(
+      Checkbox,
+      {
+        modelValue: true
+      },
+      {
+        default: () => "Checkbox Label"
+      }
+    );
+    expectSSRHasClass(html, "yh-checkbox");
+    expect(html).toContain("Checkbox Label");
+  });
+  it("should render checked state in SSR", async () => {
+    const html = await renderSSR(Checkbox, {
+      modelValue: true
+    });
+    expectSSRHasClass(html, "is-checked");
+  });
+  it("should render disabled state in SSR", async () => {
+    const html = await renderSSR(Checkbox, {
+      disabled: true
+    });
+    expectSSRHasClass(html, "is-disabled");
+  });
+  it("should hydrate without mismatch", async () => {
+    const result = await testHydration(
+      Checkbox,
+      {
+        modelValue: true
+      },
+      {
+        default: () => "Hydration Test"
+      }
+    );
+    expect(result.isMatch).toBe(true);
+  });
+});
+describe("YhCheckboxGroup SSR", () => {
+  it("should render group correctly in SSR", async () => {
+    const html = await renderSSR(CheckboxGroup, {
+      modelValue: ["opt1"]
+    });
+    expectSSRHasClass(html, "yh-checkbox-group");
+  });
+  it("should hydrate group without mismatch", async () => {
+    const result = await testHydration(CheckboxGroup, {
+      modelValue: ["opt1"]
+    });
+    expect(result.isMatch).toBe(true);
+  });
+});

package/dist/checkbox/__tests__/checkbox.test.cjs

@@ -0,0 +1,173 @@
+"use strict";
+
+var _vitest = require("vitest");
+var _testUtils = require("@vue/test-utils");
+var _vue = require("vue");
+var _checkbox = _interopRequireDefault(require("../src/checkbox.vue"));
+var _checkboxGroup = _interopRequireDefault(require("../src/checkbox-group.vue"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+(0, _vitest.describe)("YhCheckbox", () => {
+  (0, _vitest.it)("renders properly with label", () => {
+    const wrapper = (0, _testUtils.mount)(_checkbox.default, {
+      props: {
+        modelValue: false,
+        label: "Option 1"
+      }
+    });
+    (0, _vitest.expect)(wrapper.find(".yh-checkbox__label").text()).toBe("Option 1");
+  });
+  (0, _vitest.it)("supports custom true/false values", async () => {
+    const wrapper = (0, _testUtils.mount)(_checkbox.default, {
+      props: {
+        modelValue: "no",
+        trueValue: "yes",
+        falseValue: "no"
+      }
+    });
+    (0, _vitest.expect)(wrapper.classes()).not.toContain("is-checked");
+    const input = wrapper.find("input");
+    await input.setChecked(true);
+    (0, _vitest.expect)(wrapper.emitted("update:modelValue")?.[0]).toEqual(["yes"]);
+  });
+  (0, _vitest.it)("supports indeterminate state", () => {
+    const wrapper = (0, _testUtils.mount)(_checkbox.default, {
+      props: {
+        indeterminate: true
+      }
+    });
+    (0, _vitest.expect)(wrapper.classes()).toContain("is-indeterminate");
+  });
+  (0, _vitest.it)("handles focus and blur and exposes methods", async () => {
+    const wrapper = (0, _testUtils.mount)(_checkbox.default);
+    const input = wrapper.find("input");
+    await input.trigger("focus");
+    (0, _vitest.expect)(wrapper.classes()).toContain("is-focused");
+    await input.trigger("blur");
+    (0, _vitest.expect)(wrapper.classes()).not.toContain("is-focused");
+    const vm = wrapper.vm;
+    vm.focus();
+    await (0, _vue.nextTick)();
+    vm.blur();
+    await (0, _vue.nextTick)();
+  });
+  (0, _vitest.it)("watches checked prop", async () => {
+    const wrapper = (0, _testUtils.mount)(_checkbox.default, {
+      props: {
+        modelValue: false
+      }
+    });
+    await wrapper.setProps({
+      checked: true
+    });
+    await (0, _vue.nextTick)();
+    (0, _vitest.expect)(wrapper.emitted("update:modelValue")?.[0]).toEqual([true]);
+  });
+  (0, _vitest.it)("renders slot content", () => {
+    const wrapper = (0, _testUtils.mount)(_checkbox.default, {
+      slots: {
+        default: "Custom Label"
+      }
+    });
+    (0, _vitest.expect)(wrapper.find(".yh-checkbox__label").text()).toBe("Custom Label");
+  });
+});
+(0, _vitest.describe)("YhCheckboxGroup", () => {
+  (0, _vitest.it)("should work with v-model and change event", async () => {
+    const wrapper = (0, _testUtils.mount)(_checkboxGroup.default, {
+      props: {
+        modelValue: ["a"]
+      },
+      slots: {
+        default: () => [(0, _vue.h)(_checkbox.default, {
+          value: "a",
+          label: "A"
+        }), (0, _vue.h)(_checkbox.default, {
+          value: "b",
+          label: "B"
+        })]
+      },
+      global: {
+        components: {
+          YhCheckbox: _checkbox.default
+        }
+      }
+    });
+    const checkboxes = wrapper.findAllComponents(_checkbox.default);
+    (0, _vitest.expect)(checkboxes[0].classes()).toContain("is-checked");
+    await checkboxes[0].find("input").setChecked(false);
+    await (0, _vue.nextTick)();
+    const emissions1 = wrapper.emitted("update:modelValue");
+    (0, _vitest.expect)(emissions1).toBeTruthy();
+    (0, _vitest.expect)(emissions1?.[emissions1.length - 1]).toEqual([[]]);
+    await wrapper.setProps({
+      modelValue: []
+    });
+    await checkboxes[1].find("input").setChecked(true);
+    await (0, _vue.nextTick)();
+    const emissions2 = wrapper.emitted("update:modelValue");
+    (0, _vitest.expect)(emissions2?.[emissions2.length - 1]).toEqual([["b"]]);
+  });
+  (0, _vitest.it)("should respect min and max limitations", async () => {
+    const wrapper = (0, _testUtils.mount)(_checkboxGroup.default, {
+      props: {
+        modelValue: ["a", "b"],
+        min: 1,
+        max: 2
+      },
+      slots: {
+        default: () => [(0, _vue.h)(_checkbox.default, {
+          value: "a",
+          label: "A"
+        }), (0, _vue.h)(_checkbox.default, {
+          value: "b",
+          label: "B"
+        }), (0, _vue.h)(_checkbox.default, {
+          value: "c",
+          label: "C"
+        })]
+      },
+      global: {
+        components: {
+          YhCheckbox: _checkbox.default
+        }
+      }
+    });
+    await (0, _vue.nextTick)();
+    const checkboxes = wrapper.findAllComponents(_checkbox.default);
+    (0, _vitest.expect)(checkboxes[2].classes()).toContain("is-disabled");
+    const count1 = wrapper.emitted("update:modelValue")?.length || 0;
+    await checkboxes[2].find("input").trigger("click");
+    (0, _vitest.expect)(wrapper.emitted("update:modelValue")?.length || 0).toBe(count1);
+    await wrapper.setProps({
+      modelValue: ["a"]
+    });
+    await (0, _vue.nextTick)();
+    (0, _vitest.expect)(checkboxes[0].classes()).toContain("is-disabled");
+    (0, _vitest.expect)(checkboxes[1].classes()).not.toContain("is-disabled");
+    const count2 = wrapper.emitted("update:modelValue")?.length || 0;
+    await checkboxes[0].find("input").trigger("click");
+    (0, _vitest.expect)(wrapper.emitted("update:modelValue")?.length || 0).toBe(count2);
+  });
+  (0, _vitest.it)("should use size and disabled from group", async () => {
+    const wrapper = (0, _testUtils.mount)(_checkboxGroup.default, {
+      props: {
+        size: "large",
+        disabled: true
+      },
+      slots: {
+        default: () => [(0, _vue.h)(_checkbox.default, {
+          value: "a"
+        })]
+      },
+      global: {
+        components: {
+          YhCheckbox: _checkbox.default
+        }
+      }
+    });
+    await (0, _vue.nextTick)();
+    const checkbox = wrapper.findComponent(_checkbox.default);
+    (0, _vitest.expect)(checkbox.classes()).toContain("yh-checkbox--large");
+    (0, _vitest.expect)(checkbox.classes()).toContain("is-disabled");
+  });
+});

package/dist/checkbox/__tests__/checkbox.test.d.ts

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

package/dist/checkbox/__tests__/checkbox.test.mjs

@@ -0,0 +1,133 @@
+import { describe, it, expect } from "vitest";
+import { mount } from "@vue/test-utils";
+import { nextTick, h } from "vue";
+import YhCheckbox from "../src/checkbox.vue";
+import YhCheckboxGroup from "../src/checkbox-group.vue";
+describe("YhCheckbox", () => {
+  it("renders properly with label", () => {
+    const wrapper = mount(YhCheckbox, {
+      props: { modelValue: false, label: "Option 1" }
+    });
+    expect(wrapper.find(".yh-checkbox__label").text()).toBe("Option 1");
+  });
+  it("supports custom true/false values", async () => {
+    const wrapper = mount(YhCheckbox, {
+      props: {
+        modelValue: "no",
+        trueValue: "yes",
+        falseValue: "no"
+      }
+    });
+    expect(wrapper.classes()).not.toContain("is-checked");
+    const input = wrapper.find("input");
+    await input.setChecked(true);
+    expect(wrapper.emitted("update:modelValue")?.[0]).toEqual(["yes"]);
+  });
+  it("supports indeterminate state", () => {
+    const wrapper = mount(YhCheckbox, {
+      props: { indeterminate: true }
+    });
+    expect(wrapper.classes()).toContain("is-indeterminate");
+  });
+  it("handles focus and blur and exposes methods", async () => {
+    const wrapper = mount(YhCheckbox);
+    const input = wrapper.find("input");
+    await input.trigger("focus");
+    expect(wrapper.classes()).toContain("is-focused");
+    await input.trigger("blur");
+    expect(wrapper.classes()).not.toContain("is-focused");
+    const vm = wrapper.vm;
+    vm.focus();
+    await nextTick();
+    vm.blur();
+    await nextTick();
+  });
+  it("watches checked prop", async () => {
+    const wrapper = mount(YhCheckbox, {
+      props: { modelValue: false }
+    });
+    await wrapper.setProps({ checked: true });
+    await nextTick();
+    expect(wrapper.emitted("update:modelValue")?.[0]).toEqual([true]);
+  });
+  it("renders slot content", () => {
+    const wrapper = mount(YhCheckbox, {
+      slots: { default: "Custom Label" }
+    });
+    expect(wrapper.find(".yh-checkbox__label").text()).toBe("Custom Label");
+  });
+});
+describe("YhCheckboxGroup", () => {
+  it("should work with v-model and change event", async () => {
+    const wrapper = mount(YhCheckboxGroup, {
+      props: {
+        modelValue: ["a"]
+      },
+      slots: {
+        default: () => [
+          h(YhCheckbox, { value: "a", label: "A" }),
+          h(YhCheckbox, { value: "b", label: "B" })
+        ]
+      },
+      global: { components: { YhCheckbox } }
+    });
+    const checkboxes = wrapper.findAllComponents(YhCheckbox);
+    expect(checkboxes[0].classes()).toContain("is-checked");
+    await checkboxes[0].find("input").setChecked(false);
+    await nextTick();
+    const emissions1 = wrapper.emitted("update:modelValue");
+    expect(emissions1).toBeTruthy();
+    expect(emissions1?.[emissions1.length - 1]).toEqual([[]]);
+    await wrapper.setProps({ modelValue: [] });
+    await checkboxes[1].find("input").setChecked(true);
+    await nextTick();
+    const emissions2 = wrapper.emitted("update:modelValue");
+    expect(emissions2?.[emissions2.length - 1]).toEqual([["b"]]);
+  });
+  it("should respect min and max limitations", async () => {
+    const wrapper = mount(YhCheckboxGroup, {
+      props: {
+        modelValue: ["a", "b"],
+        min: 1,
+        max: 2
+      },
+      slots: {
+        default: () => [
+          h(YhCheckbox, { value: "a", label: "A" }),
+          h(YhCheckbox, { value: "b", label: "B" }),
+          h(YhCheckbox, { value: "c", label: "C" })
+        ]
+      },
+      global: { components: { YhCheckbox } }
+    });
+    await nextTick();
+    const checkboxes = wrapper.findAllComponents(YhCheckbox);
+    expect(checkboxes[2].classes()).toContain("is-disabled");
+    const count1 = wrapper.emitted("update:modelValue")?.length || 0;
+    await checkboxes[2].find("input").trigger("click");
+    expect(wrapper.emitted("update:modelValue")?.length || 0).toBe(count1);
+    await wrapper.setProps({ modelValue: ["a"] });
+    await nextTick();
+    expect(checkboxes[0].classes()).toContain("is-disabled");
+    expect(checkboxes[1].classes()).not.toContain("is-disabled");
+    const count2 = wrapper.emitted("update:modelValue")?.length || 0;
+    await checkboxes[0].find("input").trigger("click");
+    expect(wrapper.emitted("update:modelValue")?.length || 0).toBe(count2);
+  });
+  it("should use size and disabled from group", async () => {
+    const wrapper = mount(YhCheckboxGroup, {
+      props: {
+        size: "large",
+        disabled: true
+      },
+      slots: {
+        default: () => [h(YhCheckbox, { value: "a" })]
+      },
+      global: { components: { YhCheckbox } }
+    });
+    await nextTick();
+    const checkbox = wrapper.findComponent(YhCheckbox);
+    expect(checkbox.classes()).toContain("yh-checkbox--large");
+    expect(checkbox.classes()).toContain("is-disabled");
+  });
+});

package/dist/checkbox/index.cjs

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

package/dist/checkbox/index.d.ts

@@ -0,0 +1,128 @@
+/**
+ * Checkbox Component
+ * @description 复选框组件导出
+ */
+import Checkbox from './src/checkbox.vue';
+import CheckboxGroup from './src/checkbox-group.vue';
+export declare const YhCheckbox: import("@yh-ui/utils").SFCWithInstall<{
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("./src/checkbox").CheckboxProps> & Readonly<{
+        onChange?: ((value: import("./src/checkbox").CheckboxValueType) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: import("./src/checkbox").CheckboxValueType) => any) | undefined;
+    }>, {
+        ref: HTMLInputElement | undefined;
+        checked: boolean;
+        focus: () => void;
+        blur: () => void;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+        change: (value: import("./src/checkbox").CheckboxValueType) => any;
+        "update:modelValue": (value: import("./src/checkbox").CheckboxValueType) => any;
+    }, import("vue").PublicProps, {
+        disabled: boolean;
+        size: import("./src/checkbox").CheckboxSize;
+        border: boolean;
+        validateEvent: boolean;
+        trueValue: import("./src/checkbox").CheckboxValueType;
+        falseValue: import("./src/checkbox").CheckboxValueType;
+        indeterminate: boolean;
+    }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("./src/checkbox").CheckboxProps> & Readonly<{
+        onChange?: ((value: import("./src/checkbox").CheckboxValueType) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: import("./src/checkbox").CheckboxValueType) => any) | undefined;
+    }>, {
+        ref: HTMLInputElement | undefined;
+        checked: boolean;
+        focus: () => void;
+        blur: () => void;
+    }, {}, {}, {}, {
+        disabled: boolean;
+        size: import("./src/checkbox").CheckboxSize;
+        border: boolean;
+        validateEvent: boolean;
+        trueValue: import("./src/checkbox").CheckboxValueType;
+        falseValue: import("./src/checkbox").CheckboxValueType;
+        indeterminate: boolean;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("./src/checkbox").CheckboxProps> & Readonly<{
+    onChange?: ((value: import("./src/checkbox").CheckboxValueType) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: import("./src/checkbox").CheckboxValueType) => any) | undefined;
+}>, {
+    ref: HTMLInputElement | undefined;
+    checked: boolean;
+    focus: () => void;
+    blur: () => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    change: (value: import("./src/checkbox").CheckboxValueType) => any;
+    "update:modelValue": (value: import("./src/checkbox").CheckboxValueType) => any;
+}, string, {
+    disabled: boolean;
+    size: import("./src/checkbox").CheckboxSize;
+    border: boolean;
+    validateEvent: boolean;
+    trueValue: import("./src/checkbox").CheckboxValueType;
+    falseValue: import("./src/checkbox").CheckboxValueType;
+    indeterminate: boolean;
+}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+    $slots: {
+        default?: (props: {}) => any;
+    };
+})> & Record<string, unknown>;
+export declare const YhCheckboxGroup: import("@yh-ui/utils").SFCWithInstall<{
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("./src/checkbox").CheckboxGroupProps> & Readonly<{
+        onChange?: ((value: import("./src/checkbox").CheckboxValueType[]) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: import("./src/checkbox").CheckboxValueType[]) => any) | undefined;
+    }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+        change: (value: import("./src/checkbox").CheckboxValueType[]) => any;
+        "update:modelValue": (value: import("./src/checkbox").CheckboxValueType[]) => any;
+    }, import("vue").PublicProps, {
+        disabled: boolean;
+        modelValue: import("./src/checkbox").CheckboxValueType[];
+        validateEvent: boolean;
+        tag: string | import("vue").Component;
+    }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("./src/checkbox").CheckboxGroupProps> & Readonly<{
+        onChange?: ((value: import("./src/checkbox").CheckboxValueType[]) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: import("./src/checkbox").CheckboxValueType[]) => any) | undefined;
+    }>, {}, {}, {}, {}, {
+        disabled: boolean;
+        modelValue: import("./src/checkbox").CheckboxValueType[];
+        validateEvent: boolean;
+        tag: string | import("vue").Component;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("./src/checkbox").CheckboxGroupProps> & Readonly<{
+    onChange?: ((value: import("./src/checkbox").CheckboxValueType[]) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: import("./src/checkbox").CheckboxValueType[]) => any) | undefined;
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    change: (value: import("./src/checkbox").CheckboxValueType[]) => any;
+    "update:modelValue": (value: import("./src/checkbox").CheckboxValueType[]) => any;
+}, string, {
+    disabled: boolean;
+    modelValue: import("./src/checkbox").CheckboxValueType[];
+    validateEvent: boolean;
+    tag: string | import("vue").Component;
+}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+    $slots: {
+        default?: (props: {}) => any;
+    };
+})> & Record<string, unknown>;
+export default YhCheckbox;
+export * from './src/checkbox';
+export type CheckboxInstance = InstanceType<typeof Checkbox>;
+export type CheckboxGroupInstance = InstanceType<typeof CheckboxGroup>;

package/dist/checkbox/index.mjs

@@ -0,0 +1,7 @@
+import { withInstall } from "@yh-ui/utils";
+import Checkbox from "./src/checkbox.vue";
+import CheckboxGroup from "./src/checkbox-group.vue";
+export const YhCheckbox = withInstall(Checkbox);
+export const YhCheckboxGroup = withInstall(CheckboxGroup);
+export default YhCheckbox;
+export * from "./src/checkbox.mjs";