ll-plus 2.0.2 → 2.0.4

package/lib/components/checkbox/index.d.ts

@@ -0,0 +1,257 @@
+import Checkbox from './src/checkbox.vue';
+import CheckboxGroup from './src/checkbox-group.vue';
+export declare const LlCheckbox: import("ll-plus/es/utils").SFCWithInstall<import("vue").DefineComponent<{
+    value: {
+        type: (BooleanConstructor | StringConstructor | NumberConstructor)[];
+        default: boolean;
+    };
+    checkedValue: {
+        type: (BooleanConstructor | StringConstructor | NumberConstructor)[];
+        default: boolean;
+    };
+    unCheckedValue: {
+        type: (BooleanConstructor | StringConstructor | NumberConstructor)[];
+        default: boolean;
+    };
+    label: {
+        type: StringConstructor;
+        default: string;
+    };
+}, {
+    props: import("@vue/shared").LooseRequired<{
+        readonly value: string | number | boolean;
+        readonly label: string;
+        readonly checkedValue: string | number | boolean;
+        readonly unCheckedValue: string | number | boolean;
+        readonly onChange?: ((...args: any[]) => any) | undefined;
+        readonly "onUpdate:value"?: ((...args: any[]) => any) | undefined;
+    } & {}>;
+    emit: (event: "change" | "update:value", ...args: any[]) => void;
+    bem: {
+        b: (blockSuffix?: string) => string;
+        e: (element?: string) => string;
+        m: (modifier?: string) => string;
+        be: (blockSuffix?: string, element?: string) => string;
+        em: (element: string, modifier: string) => string;
+        bm: (blockSuffix: string, modifier: string) => string;
+        bem: (blockSuffix: string, element: string, modifier: string) => string;
+        is: (name?: string) => string;
+    };
+    innerValue: import("vue").Ref<boolean>;
+    attrs: {
+        [x: string]: unknown;
+    };
+    setValue: (value: any) => void;
+    onChange: (e: any) => void;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("change" | "update:value")[], "change" | "update:value", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    value: {
+        type: (BooleanConstructor | StringConstructor | NumberConstructor)[];
+        default: boolean;
+    };
+    checkedValue: {
+        type: (BooleanConstructor | StringConstructor | NumberConstructor)[];
+        default: boolean;
+    };
+    unCheckedValue: {
+        type: (BooleanConstructor | StringConstructor | NumberConstructor)[];
+        default: boolean;
+    };
+    label: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & {
+    onChange?: ((...args: any[]) => any) | undefined;
+    "onUpdate:value"?: ((...args: any[]) => any) | undefined;
+}, {
+    value: string | number | boolean;
+    label: string;
+    checkedValue: string | number | boolean;
+    unCheckedValue: string | number | boolean;
+}, {}>>;
+export declare const LlCheckboxGroup: import("ll-plus/es/utils").SFCWithInstall<import("vue").DefineComponent<{
+    value: {
+        type: {
+            (arrayLength: number): any[][];
+            (...items: any[][]): any[][];
+            new (arrayLength: number): any[][];
+            new (...items: any[][]): any[][];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+            from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+            from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+            of<T_4>(...items: T_4[]): T_4[];
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default: never[];
+    };
+    options: {
+        type: {
+            (arrayLength: number): import("./src/checkbox").Options[];
+            (...items: import("./src/checkbox").Options[]): import("./src/checkbox").Options[];
+            new (arrayLength: number): import("./src/checkbox").Options[];
+            new (...items: import("./src/checkbox").Options[]): import("./src/checkbox").Options[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+            from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+            from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+            of<T_4>(...items: T_4[]): T_4[];
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default: never[];
+    };
+    direction: {
+        type: StringConstructor;
+        default: string;
+    };
+}, {
+    bem: {
+        b: (blockSuffix?: string) => string;
+        e: (element?: string) => string;
+        m: (modifier?: string) => string;
+        be: (blockSuffix?: string, element?: string) => string;
+        em: (element: string, modifier: string) => string;
+        bm: (blockSuffix: string, modifier: string) => string;
+        bem: (blockSuffix: string, element: string, modifier: string) => string;
+        is: (name?: string) => string;
+    };
+    props: import("@vue/shared").LooseRequired<{
+        readonly value: any[][];
+        readonly options: import("./src/checkbox").Options[];
+        readonly direction: string;
+        readonly onChange?: ((...args: any[]) => any) | undefined;
+        readonly "onUpdate:value"?: ((...args: any[]) => any) | undefined;
+    } & {}>;
+    emit: (event: "change" | "update:value", ...args: any[]) => void;
+    innerValue: import("vue").Ref<any[]>;
+    attrs: {
+        [x: string]: unknown;
+    };
+    onChange: (val: any[]) => void;
+    Checkbox: import("vue").DefineComponent<{
+        value: {
+            type: (BooleanConstructor | StringConstructor | NumberConstructor)[];
+            default: boolean;
+        };
+        checkedValue: {
+            type: (BooleanConstructor | StringConstructor | NumberConstructor)[];
+            default: boolean;
+        };
+        unCheckedValue: {
+            type: (BooleanConstructor | StringConstructor | NumberConstructor)[];
+            default: boolean;
+        };
+        label: {
+            type: StringConstructor;
+            default: string;
+        };
+    }, {
+        props: import("@vue/shared").LooseRequired<{
+            readonly value: string | number | boolean;
+            readonly label: string;
+            readonly checkedValue: string | number | boolean;
+            readonly unCheckedValue: string | number | boolean;
+            readonly onChange?: ((...args: any[]) => any) | undefined;
+            readonly "onUpdate:value"?: ((...args: any[]) => any) | undefined;
+        } & {}>;
+        emit: (event: "change" | "update:value", ...args: any[]) => void;
+        bem: {
+            b: (blockSuffix?: string) => string;
+            e: (element?: string) => string;
+            m: (modifier?: string) => string;
+            be: (blockSuffix?: string, element?: string) => string;
+            em: (element: string, modifier: string) => string;
+            bm: (blockSuffix: string, modifier: string) => string;
+            bem: (blockSuffix: string, element: string, modifier: string) => string;
+            is: (name?: string) => string;
+        };
+        innerValue: import("vue").Ref<boolean>;
+        attrs: {
+            [x: string]: unknown;
+        };
+        setValue: (value: any) => void;
+        onChange: (e: any) => void;
+    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("change" | "update:value")[], "change" | "update:value", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        value: {
+            type: (BooleanConstructor | StringConstructor | NumberConstructor)[];
+            default: boolean;
+        };
+        checkedValue: {
+            type: (BooleanConstructor | StringConstructor | NumberConstructor)[];
+            default: boolean;
+        };
+        unCheckedValue: {
+            type: (BooleanConstructor | StringConstructor | NumberConstructor)[];
+            default: boolean;
+        };
+        label: {
+            type: StringConstructor;
+            default: string;
+        };
+    }>> & {
+        onChange?: ((...args: any[]) => any) | undefined;
+        "onUpdate:value"?: ((...args: any[]) => any) | undefined;
+    }, {
+        value: string | number | boolean;
+        label: string;
+        checkedValue: string | number | boolean;
+        unCheckedValue: string | number | boolean;
+    }, {}>;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("change" | "update:value")[], "change" | "update:value", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    value: {
+        type: {
+            (arrayLength: number): any[][];
+            (...items: any[][]): any[][];
+            new (arrayLength: number): any[][];
+            new (...items: any[][]): any[][];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+            from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+            from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+            of<T_4>(...items: T_4[]): T_4[];
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default: never[];
+    };
+    options: {
+        type: {
+            (arrayLength: number): import("./src/checkbox").Options[];
+            (...items: import("./src/checkbox").Options[]): import("./src/checkbox").Options[];
+            new (arrayLength: number): import("./src/checkbox").Options[];
+            new (...items: import("./src/checkbox").Options[]): import("./src/checkbox").Options[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+            from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+            from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+            of<T_4>(...items: T_4[]): T_4[];
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default: never[];
+    };
+    direction: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & {
+    onChange?: ((...args: any[]) => any) | undefined;
+    "onUpdate:value"?: ((...args: any[]) => any) | undefined;
+}, {
+    value: any[][];
+    options: import("./src/checkbox").Options[];
+    direction: string;
+}, {}>>;
+export * from './src/checkbox';
+declare module 'vue' {
+    interface GlobalComponents {
+        LlCheckbox: typeof Checkbox;
+        LlCheckboxGroup: typeof CheckboxGroup;
+    }
+}

package/lib/components/checkbox/index.js

@@ -0,0 +1,17 @@
+'use strict';
+
+require('../../utils/index.js');
+var checkbox$1 = require('./src/checkbox.vue.js');
+var checkboxGroup = require('./src/checkbox-group.vue.js');
+var checkbox = require('./src/checkbox.js');
+var withInstall = require('../../utils/with-install.js');
+
+"use strict";
+const LlCheckbox = withInstall.withInstall(checkbox$1.default);
+const LlCheckboxGroup = withInstall.withInstall(checkboxGroup.default);
+
+exports.CheckboxGroupProps = checkbox.CheckboxGroupProps;
+exports.CheckboxProps = checkbox.CheckboxProps;
+exports.LlCheckbox = LlCheckbox;
+exports.LlCheckboxGroup = LlCheckboxGroup;
+//# sourceMappingURL=index.js.map

package/lib/components/checkbox/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../packages/components/checkbox/index.ts"],"sourcesContent":["import { withInstall } from '@ll-plus/utils'\r\n\r\nimport Checkbox from './src/checkbox.vue'\r\nimport CheckboxGroup from './src/checkbox-group.vue'\r\n\r\nexport const LlCheckbox = withInstall(Checkbox)\r\nexport const LlCheckboxGroup = withInstall(CheckboxGroup)\r\n\r\n// export default LlCheckbox\r\n\r\nexport * from './src/checkbox'\r\n\r\ndeclare module 'vue' {\r\n  export interface GlobalComponents {\r\n    LlCheckbox: typeof Checkbox\r\n    LlCheckboxGroup: typeof CheckboxGroup\r\n  }\r\n}"],"names":["withInstall","Checkbox","CheckboxGroup"],"mappings":";;;;;;;;;AAKa,MAAA,UAAA,GAAaA,wBAAYC,kBAAQ,EAAA;AACjC,MAAA,eAAA,GAAkBD,wBAAYE,qBAAa;;;;;;;"}

package/lib/components/checkbox/src/checkbox-group.vue.d.ts

@@ -0,0 +1,180 @@
+declare const _default: import("vue").DefineComponent<{
+    value: {
+        type: {
+            (arrayLength: number): any[][];
+            (...items: any[][]): any[][];
+            new (arrayLength: number): any[][];
+            new (...items: any[][]): any[][];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+            from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+            from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+            of<T_4>(...items: T_4[]): T_4[];
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default: never[];
+    };
+    options: {
+        type: {
+            (arrayLength: number): import("./checkbox").Options[];
+            (...items: import("./checkbox").Options[]): import("./checkbox").Options[];
+            new (arrayLength: number): import("./checkbox").Options[];
+            new (...items: import("./checkbox").Options[]): import("./checkbox").Options[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+            from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+            from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+            of<T_4>(...items: T_4[]): T_4[];
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default: never[];
+    };
+    direction: {
+        type: StringConstructor;
+        default: string;
+    };
+}, {
+    bem: {
+        b: (blockSuffix?: string) => string;
+        e: (element?: string) => string;
+        m: (modifier?: string) => string;
+        be: (blockSuffix?: string, element?: string) => string;
+        em: (element: string, modifier: string) => string;
+        bm: (blockSuffix: string, modifier: string) => string;
+        bem: (blockSuffix: string, element: string, modifier: string) => string;
+        is: (name?: string) => string;
+    };
+    props: import("@vue/shared").LooseRequired<{
+        readonly value: any[][];
+        readonly options: import("./checkbox").Options[];
+        readonly direction: string;
+        readonly onChange?: ((...args: any[]) => any) | undefined;
+        readonly "onUpdate:value"?: ((...args: any[]) => any) | undefined;
+    } & {}>;
+    emit: (event: "change" | "update:value", ...args: any[]) => void;
+    innerValue: import("vue").Ref<any[]>;
+    attrs: {
+        [x: string]: unknown;
+    };
+    onChange: (val: any[]) => void;
+    Checkbox: import("vue").DefineComponent<{
+        value: {
+            type: (BooleanConstructor | StringConstructor | NumberConstructor)[];
+            default: boolean;
+        };
+        checkedValue: {
+            type: (BooleanConstructor | StringConstructor | NumberConstructor)[];
+            default: boolean;
+        };
+        unCheckedValue: {
+            type: (BooleanConstructor | StringConstructor | NumberConstructor)[];
+            default: boolean;
+        };
+        label: {
+            type: StringConstructor;
+            default: string;
+        };
+    }, {
+        props: import("@vue/shared").LooseRequired<{
+            readonly value: string | number | boolean;
+            readonly label: string;
+            readonly checkedValue: string | number | boolean;
+            readonly unCheckedValue: string | number | boolean;
+            readonly onChange?: ((...args: any[]) => any) | undefined;
+            readonly "onUpdate:value"?: ((...args: any[]) => any) | undefined;
+        } & {}>;
+        emit: (event: "change" | "update:value", ...args: any[]) => void;
+        bem: {
+            b: (blockSuffix?: string) => string;
+            e: (element?: string) => string;
+            m: (modifier?: string) => string;
+            be: (blockSuffix?: string, element?: string) => string;
+            em: (element: string, modifier: string) => string;
+            bm: (blockSuffix: string, modifier: string) => string;
+            bem: (blockSuffix: string, element: string, modifier: string) => string;
+            is: (name?: string) => string;
+        };
+        innerValue: import("vue").Ref<boolean>;
+        attrs: {
+            [x: string]: unknown;
+        };
+        setValue: (value: any) => void;
+        onChange: (e: any) => void;
+    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("change" | "update:value")[], "change" | "update:value", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        value: {
+            type: (BooleanConstructor | StringConstructor | NumberConstructor)[];
+            default: boolean;
+        };
+        checkedValue: {
+            type: (BooleanConstructor | StringConstructor | NumberConstructor)[];
+            default: boolean;
+        };
+        unCheckedValue: {
+            type: (BooleanConstructor | StringConstructor | NumberConstructor)[];
+            default: boolean;
+        };
+        label: {
+            type: StringConstructor;
+            default: string;
+        };
+    }>> & {
+        onChange?: ((...args: any[]) => any) | undefined;
+        "onUpdate:value"?: ((...args: any[]) => any) | undefined;
+    }, {
+        value: string | number | boolean;
+        label: string;
+        checkedValue: string | number | boolean;
+        unCheckedValue: string | number | boolean;
+    }, {}>;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("change" | "update:value")[], "change" | "update:value", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    value: {
+        type: {
+            (arrayLength: number): any[][];
+            (...items: any[][]): any[][];
+            new (arrayLength: number): any[][];
+            new (...items: any[][]): any[][];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+            from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+            from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+            of<T_4>(...items: T_4[]): T_4[];
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default: never[];
+    };
+    options: {
+        type: {
+            (arrayLength: number): import("./checkbox").Options[];
+            (...items: import("./checkbox").Options[]): import("./checkbox").Options[];
+            new (arrayLength: number): import("./checkbox").Options[];
+            new (...items: import("./checkbox").Options[]): import("./checkbox").Options[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+            from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+            from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+            of<T_4>(...items: T_4[]): T_4[];
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default: never[];
+    };
+    direction: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & {
+    onChange?: ((...args: any[]) => any) | undefined;
+    "onUpdate:value"?: ((...args: any[]) => any) | undefined;
+}, {
+    value: any[][];
+    options: import("./checkbox").Options[];
+    direction: string;
+}, {}>;
+export default _default;

package/lib/components/checkbox/src/checkbox-group.vue.js

@@ -0,0 +1,12 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var checkboxGroup_vue_vue_type_script_setup_true_lang = require('./checkbox-group.vue2.js');
+var _pluginVue_exportHelper = require('../../../_virtual/_plugin-vue_export-helper.js');
+
+"use strict";
+var CheckboxGroup = /* @__PURE__ */ _pluginVue_exportHelper.default(checkboxGroup_vue_vue_type_script_setup_true_lang.default, [["__file", "checkbox-group.vue"]]);
+
+exports.default = CheckboxGroup;
+//# sourceMappingURL=checkbox-group.vue.js.map

package/lib/components/checkbox/src/checkbox-group.vue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkbox-group.vue.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;"}

package/lib/components/checkbox/src/checkbox-group.vue2.js

@@ -0,0 +1,69 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var checkbox$1 = require('./checkbox.vue.js');
+require('../../../utils/index.js');
+var checkbox = require('./checkbox.js');
+var createNamespace = require('../../../utils/create-namespace.js');
+
+"use strict";
+var _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  ...{ name: "LlCheckboxGroup" },
+  __name: "checkbox-group",
+  props: checkbox.CheckboxGroupProps,
+  emits: ["update:value", "change"],
+  setup(__props, { emit: __emit }) {
+    const bem = createNamespace.createNamespace("checkbox-group");
+    const props = __props;
+    const emit = __emit;
+    const innerValue = vue.ref(props.value);
+    const attrs = vue.useAttrs();
+    function onChange(val) {
+      emit("update:value", val);
+      emit("change", val);
+    }
+    return (_ctx, _cache) => {
+      const _component_a_checkbox_group = vue.resolveComponent("a-checkbox-group");
+      return vue.openBlock(), vue.createElementBlock(
+        "div",
+        {
+          class: vue.normalizeClass(vue.unref(bem).b())
+        },
+        [
+          vue.createVNode(_component_a_checkbox_group, vue.mergeProps({
+            value: innerValue.value,
+            "onUpdate:value": _cache[0] || (_cache[0] = ($event) => innerValue.value = $event)
+          }, vue.unref(attrs), {
+            options: _ctx.options,
+            onChange
+          }), {
+            default: vue.withCtx(() => [
+              (vue.openBlock(true), vue.createElementBlock(
+                vue.Fragment,
+                null,
+                vue.renderList(_ctx.options, (item) => {
+                  return vue.openBlock(), vue.createBlock(checkbox$1.default, {
+                    key: item.value,
+                    label: item.label,
+                    value: item.value
+                  }, null, 8, ["label", "value"]);
+                }),
+                128
+                /* KEYED_FRAGMENT */
+              ))
+            ]),
+            _: 1
+            /* STABLE */
+          }, 16, ["value", "options"])
+        ],
+        2
+        /* CLASS */
+      );
+    };
+  }
+});
+
+exports.default = _sfc_main;
+//# sourceMappingURL=checkbox-group.vue2.js.map

package/lib/components/checkbox/src/checkbox-group.vue2.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkbox-group.vue2.js","sources":["../../../../../packages/components/checkbox/src/checkbox-group.vue"],"sourcesContent":["<template>\r\n  <div :class=\"bem.b()\">\r\n    <a-checkbox-group\r\n      v-model:value=\"innerValue\"\r\n      v-bind=\"attrs\"\r\n      :options=\"options\"\r\n      @change=\"onChange\"\r\n    >\r\n      <checkbox\r\n        v-for=\"item in options\"\r\n        :key=\"item.value\"\r\n        :label=\"item.label\"\r\n        :value=\"item.value\"\r\n      ></checkbox>\r\n    </a-checkbox-group>\r\n  </div>\r\n</template>\r\n\r\n<script setup lang=\"ts\">\r\nimport { ref, useAttrs } from 'vue'\r\nimport Checkbox from './checkbox.vue'\r\n\r\nimport { createNamespace } from '@ll-plus/utils'\r\nimport { CheckboxGroupProps } from './checkbox'\r\n\r\ndefineOptions({ name: 'LlCheckboxGroup' })\r\nconst bem = createNamespace('checkbox-group')\r\nconst props = defineProps(CheckboxGroupProps)\r\nconst emit = defineEmits(['update:value', 'change'])\r\n\r\nconst innerValue = ref<any[]>(props.value)\r\nconst attrs = useAttrs()\r\n\r\nfunction onChange(val: any[]) {\r\n  emit('update:value', val)\r\n  emit('change', val)\r\n}\r\n</script>\r\n"],"names":["createNamespace","ref","useAttrs"],"mappings":";;;;;;;;;;;;;;;;;AA0BA,IAAM,MAAA,GAAA,GAAMA,gCAAgB,gBAAgB,CAAA,CAAA;AAC5C,IAAA,MAAM,KAAQ,GAAA,OAAA,CAAA;AACd,IAAA,MAAM,IAAO,GAAA,MAAA,CAAA;AAEb,IAAM,MAAA,UAAA,GAAaC,OAAW,CAAA,KAAA,CAAM,KAAK,CAAA,CAAA;AACzC,IAAA,MAAM,QAAQC,YAAS,EAAA,CAAA;AAEvB,IAAA,SAAS,SAAS,GAAY,EAAA;AAC5B,MAAA,IAAA,CAAK,gBAAgB,GAAG,CAAA,CAAA;AACxB,MAAA,IAAA,CAAK,UAAU,GAAG,CAAA,CAAA;AAAA,KACpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/lib/components/checkbox/src/checkbox.d.ts

@@ -0,0 +1,65 @@
+export declare const CheckboxProps: {
+    value: {
+        type: (BooleanConstructor | StringConstructor | NumberConstructor)[];
+        default: boolean;
+    };
+    checkedValue: {
+        type: (BooleanConstructor | StringConstructor | NumberConstructor)[];
+        default: boolean;
+    };
+    unCheckedValue: {
+        type: (BooleanConstructor | StringConstructor | NumberConstructor)[];
+        default: boolean;
+    };
+    label: {
+        type: StringConstructor;
+        default: string;
+    };
+};
+export interface Options {
+    label: string;
+    value: string;
+    disabled?: boolean;
+    indeterminate?: boolean;
+    onChange?: (...args: any[]) => any;
+}
+export declare const CheckboxGroupProps: {
+    value: {
+        type: {
+            (arrayLength: number): any[][];
+            (...items: any[][]): any[][];
+            new (arrayLength: number): any[][];
+            new (...items: any[][]): any[][];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+            from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+            from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+            of<T_4>(...items: T_4[]): T_4[];
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default: never[];
+    };
+    options: {
+        type: {
+            (arrayLength: number): Options[];
+            (...items: Options[]): Options[];
+            new (arrayLength: number): Options[];
+            new (...items: Options[]): Options[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+            from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+            from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+            of<T_4>(...items: T_4[]): T_4[];
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default: never[];
+    };
+    direction: {
+        type: StringConstructor;
+        default: string;
+    };
+};

package/lib/components/checkbox/src/checkbox.js

@@ -0,0 +1,18 @@
+'use strict';
+
+"use strict";
+const CheckboxProps = {
+  value: { type: [Number, Boolean, String], default: false },
+  checkedValue: { type: [Number, Boolean, String], default: true },
+  unCheckedValue: { type: [Number, Boolean, String], default: false },
+  label: { type: String, default: "" }
+};
+const CheckboxGroupProps = {
+  value: { type: Array, default: [] },
+  options: { type: Array, default: [] },
+  direction: { type: String, default: "vertical" }
+};
+
+exports.CheckboxGroupProps = CheckboxGroupProps;
+exports.CheckboxProps = CheckboxProps;
+//# sourceMappingURL=checkbox.js.map

package/lib/components/checkbox/src/checkbox.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkbox.js","sources":["../../../../../packages/components/checkbox/src/checkbox.ts"],"sourcesContent":["export const CheckboxProps = {\r\n  value: { type: [Number, Boolean, String], default: false },\r\n  checkedValue: { type: [Number, Boolean, String], default: true },\r\n  unCheckedValue: { type: [Number, Boolean, String], default: false },\r\n  label: { type: String, default: ''}\r\n}\r\n\r\nexport interface Options {\r\n  label: string\r\n  value: string\r\n  disabled?: boolean\r\n  indeterminate?: boolean\r\n  onChange?: (...args: any[]) => any\r\n}\r\n\r\nexport const CheckboxGroupProps = {\r\n  value: { type: Array<any[]>, default: [] },\r\n  options: { type: Array<Options>, default: [] },\r\n  direction: { type: String, default: 'vertical' }\r\n}\r\n"],"names":[],"mappings":";;;AAAO,MAAM,aAAgB,GAAA;AAAA,EAC3B,KAAA,EAAO,EAAE,IAAM,EAAA,CAAC,QAAQ,OAAS,EAAA,MAAM,CAAG,EAAA,OAAA,EAAS,KAAM,EAAA;AAAA,EACzD,YAAA,EAAc,EAAE,IAAM,EAAA,CAAC,QAAQ,OAAS,EAAA,MAAM,CAAG,EAAA,OAAA,EAAS,IAAK,EAAA;AAAA,EAC/D,cAAA,EAAgB,EAAE,IAAM,EAAA,CAAC,QAAQ,OAAS,EAAA,MAAM,CAAG,EAAA,OAAA,EAAS,KAAM,EAAA;AAAA,EAClE,KAAO,EAAA,EAAE,IAAM,EAAA,MAAA,EAAQ,SAAS,EAAE,EAAA;AACpC,EAAA;AAUO,MAAM,kBAAqB,GAAA;AAAA,EAChC,OAAO,EAAE,IAAA,EAAM,KAAc,EAAA,OAAA,EAAS,EAAG,EAAA;AAAA,EACzC,SAAS,EAAE,IAAA,EAAM,KAAgB,EAAA,OAAA,EAAS,EAAG,EAAA;AAAA,EAC7C,SAAW,EAAA,EAAE,IAAM,EAAA,MAAA,EAAQ,SAAS,UAAW,EAAA;AACjD;;;;;"}