yc-design-vue 1.0.1

package/lib/Cascader/index.d.ts

@@ -0,0 +1,336 @@
+import { App } from 'vue';
+import { default as _Cascader } from './Cascader.vue';
+export type CascaderInstance = InstanceType<typeof _Cascader>;
+export * from './type';
+declare const Cascader: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./type').CascaderProps> & Readonly<{
+        onChange?: ((value: import('./type').CascaderValue) => any) | undefined;
+        onFocus?: ((ev: FocusEvent) => any) | undefined;
+        "onUpdate:popupVisible"?: ((value: boolean) => any) | undefined;
+        "onPopup-visible-change"?: ((value: boolean) => any) | undefined;
+        onClear?: (() => any) | undefined;
+        onBlur?: ((ev: FocusEvent) => any) | undefined;
+        onSearch?: ((value: string) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: import('./type').CascaderValue) => any) | undefined;
+        "onUpdate:inputValue"?: ((value: string) => any) | undefined;
+        "onInput-value-change"?: ((value: string) => any) | undefined;
+    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+        change: (value: import('./type').CascaderValue) => any;
+        focus: (ev: FocusEvent) => any;
+        "update:popupVisible": (value: boolean) => any;
+        "popup-visible-change": (value: boolean) => any;
+        clear: () => any;
+        blur: (ev: FocusEvent) => any;
+        search: (value: string) => any;
+        "update:modelValue": (value: import('./type').CascaderValue) => any;
+        "update:inputValue": (value: string) => any;
+        "input-value-change": (value: string) => any;
+    }, import('vue').PublicProps, {
+        size: import('..').Size;
+        popupVisible: boolean;
+        defaultPopupVisible: boolean;
+        disabled: boolean;
+        popupContainer: import('..').PopupContainer;
+        loading: boolean;
+        error: boolean;
+        multiple: boolean;
+        placeholder: string;
+        triggerProps: import('..').TriggerProps;
+        modelValue: import('./type').CascaderValue;
+        defaultValue: import('./type').CascaderValue;
+        allowClear: boolean;
+        options: import('./type').CascaderOption[];
+        formatLabel: (options: import('./type').CascaderOption[]) => string;
+        inputValue: string;
+        defaultInputValue: string;
+        fieldNames: Record<string, string>;
+        allowSearch: boolean;
+        valueKey: string;
+        maxTagCount: number;
+        filterOption: (inputValue: string, option: import('./type').CascaderOption) => boolean;
+        searchDelay: number;
+        tagNowrap: boolean;
+        pathMode: boolean;
+        expandTrigger: import('./type').ExpandTrigger;
+        expandChild: boolean;
+        searchOptionOnlyLabel: boolean;
+        loadMore: import('./type').LoadMore;
+        fallback: import('./type').FallBack;
+    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+        inputRef: ({
+            $: import('vue').ComponentInternalInstance;
+            $data: {};
+            $props: {
+                readonly modelValue?: string | undefined;
+                readonly defaultValue?: string | undefined;
+                readonly size?: import('..').Size | undefined;
+                readonly allowClear?: boolean | undefined;
+                readonly disabled?: boolean | undefined;
+                readonly readonly?: boolean | undefined;
+                readonly error?: boolean | undefined;
+                readonly placeholder?: string | undefined;
+                readonly maxLength?: import('..').MaxLength | undefined;
+                readonly wordLength?: import('..').WordLength | undefined;
+                readonly wordSlice?: import('..').WordSlice | undefined;
+                readonly showWordLimit?: boolean | undefined;
+                readonly inputAttrs?: import('../_shared/type').ObjectData | undefined;
+                readonly isPassword?: boolean | undefined;
+                readonly visibility?: boolean | undefined;
+                readonly defaultVisibility?: boolean | undefined;
+                readonly invisibleButton?: boolean | undefined;
+                readonly showInput?: boolean | undefined;
+                readonly onChange?: ((value: string, ev: Event) => any) | undefined;
+                readonly onFocus?: ((ev: FocusEvent) => any) | undefined;
+                readonly onClear?: ((ev: MouseEvent) => any) | undefined;
+                readonly onBlur?: ((ev: FocusEvent) => any) | undefined;
+                readonly onInput?: ((value: string, ev: Event) => any) | undefined;
+                readonly onKeydown?: ((ev: KeyboardEvent) => any) | undefined;
+                readonly "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+                readonly "onUpdate:visibility"?: ((value: boolean) => any) | undefined;
+                readonly "onVisibility-change"?: ((value: boolean) => any) | undefined;
+                readonly onPressEnter?: ((ev: KeyboardEvent) => any) | undefined;
+            } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+            $attrs: {
+                [x: string]: unknown;
+            };
+            $refs: {
+                [x: string]: unknown;
+            } & {
+                inputRef: HTMLInputElement;
+            };
+            $slots: Readonly<{
+                [name: string]: import('vue').Slot<any> | undefined;
+            }>;
+            $root: import('vue').ComponentPublicInstance | null;
+            $parent: import('vue').ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: ((event: "change", value: string, ev: Event) => void) & ((event: "focus", ev: FocusEvent) => void) & ((event: "clear", ev: MouseEvent) => void) & ((event: "blur", ev: FocusEvent) => void) & ((event: "input", value: string, ev: Event) => void) & ((event: "keydown", ev: KeyboardEvent) => void) & ((event: "update:modelValue", value: string) => void) & ((event: "update:visibility", value: boolean) => void) & ((event: "visibility-change", value: boolean) => void) & ((event: "pressEnter", ev: KeyboardEvent) => void);
+            $el: HTMLDivElement;
+            $options: import('vue').ComponentOptionsBase<Readonly<import('..').InputProps> & Readonly<{
+                onChange?: ((value: string, ev: Event) => any) | undefined;
+                onFocus?: ((ev: FocusEvent) => any) | undefined;
+                onClear?: ((ev: MouseEvent) => any) | undefined;
+                onBlur?: ((ev: FocusEvent) => any) | undefined;
+                onInput?: ((value: string, ev: Event) => any) | undefined;
+                onKeydown?: ((ev: KeyboardEvent) => any) | undefined;
+                "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+                "onUpdate:visibility"?: ((value: boolean) => any) | undefined;
+                "onVisibility-change"?: ((value: boolean) => any) | undefined;
+                onPressEnter?: ((ev: KeyboardEvent) => any) | undefined;
+            }>, {
+                focus(): void;
+                blur(): void;
+                getInputRef(): HTMLInputElement;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+                change: (value: string, ev: Event) => any;
+                focus: (ev: FocusEvent) => any;
+                clear: (ev: MouseEvent) => any;
+                blur: (ev: FocusEvent) => any;
+                input: (value: string, ev: Event) => any;
+                keydown: (ev: KeyboardEvent) => any;
+                "update:modelValue": (value: string) => any;
+                "update:visibility": (value: boolean) => any;
+                "visibility-change": (value: boolean) => any;
+                pressEnter: (ev: KeyboardEvent) => any;
+            }, string, {
+                size: import('..').Size;
+                disabled: boolean;
+                error: boolean;
+                placeholder: string;
+                visibility: boolean;
+                modelValue: string;
+                defaultValue: string;
+                maxLength: import('..').MaxLength;
+                showWordLimit: boolean;
+                allowClear: boolean;
+                readonly: boolean;
+                wordLength: import('..').WordLength;
+                wordSlice: import('..').WordSlice;
+                inputAttrs: import('../_shared/type').ObjectData;
+                isPassword: boolean;
+                defaultVisibility: boolean;
+                invisibleButton: boolean;
+                showInput: boolean;
+            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+                beforeCreate?: (() => void) | (() => void)[];
+                created?: (() => void) | (() => void)[];
+                beforeMount?: (() => void) | (() => void)[];
+                mounted?: (() => void) | (() => void)[];
+                beforeUpdate?: (() => void) | (() => void)[];
+                updated?: (() => void) | (() => void)[];
+                activated?: (() => void) | (() => void)[];
+                deactivated?: (() => void) | (() => void)[];
+                beforeDestroy?: (() => void) | (() => void)[];
+                beforeUnmount?: (() => void) | (() => void)[];
+                destroyed?: (() => void) | (() => void)[];
+                unmounted?: (() => void) | (() => void)[];
+                renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+            };
+            $forceUpdate: () => void;
+            $nextTick: typeof import('vue').nextTick;
+            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+        } & Readonly<{
+            size: import('..').Size;
+            disabled: boolean;
+            error: boolean;
+            placeholder: string;
+            visibility: boolean;
+            modelValue: string;
+            defaultValue: string;
+            maxLength: import('..').MaxLength;
+            showWordLimit: boolean;
+            allowClear: boolean;
+            readonly: boolean;
+            wordLength: import('..').WordLength;
+            wordSlice: import('..').WordSlice;
+            inputAttrs: import('../_shared/type').ObjectData;
+            isPassword: boolean;
+            defaultVisibility: boolean;
+            invisibleButton: boolean;
+            showInput: boolean;
+        }> & Omit<Readonly<import('..').InputProps> & Readonly<{
+            onChange?: ((value: string, ev: Event) => any) | undefined;
+            onFocus?: ((ev: FocusEvent) => any) | undefined;
+            onClear?: ((ev: MouseEvent) => any) | undefined;
+            onBlur?: ((ev: FocusEvent) => any) | undefined;
+            onInput?: ((value: string, ev: Event) => any) | undefined;
+            onKeydown?: ((ev: KeyboardEvent) => any) | undefined;
+            "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+            "onUpdate:visibility"?: ((value: boolean) => any) | undefined;
+            "onVisibility-change"?: ((value: boolean) => any) | undefined;
+            onPressEnter?: ((ev: KeyboardEvent) => any) | undefined;
+        }>, "focus" | "blur" | "getInputRef" | ("size" | "disabled" | "error" | "placeholder" | "visibility" | "modelValue" | "defaultValue" | "maxLength" | "showWordLimit" | "allowClear" | "readonly" | "wordLength" | "wordSlice" | "inputAttrs" | "isPassword" | "defaultVisibility" | "invisibleButton" | "showInput")> & import('vue').ShallowUnwrapRef<{
+            focus(): void;
+            blur(): void;
+            getInputRef(): HTMLInputElement;
+        }> & {} & import('vue').ComponentCustomProperties & {} & {
+            $slots: Readonly<import('..').InputSlots> & import('..').InputSlots;
+        }) | null;
+    }, any, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('./type').CascaderProps> & Readonly<{
+        onChange?: ((value: import('./type').CascaderValue) => any) | undefined;
+        onFocus?: ((ev: FocusEvent) => any) | undefined;
+        "onUpdate:popupVisible"?: ((value: boolean) => any) | undefined;
+        "onPopup-visible-change"?: ((value: boolean) => any) | undefined;
+        onClear?: (() => any) | undefined;
+        onBlur?: ((ev: FocusEvent) => any) | undefined;
+        onSearch?: ((value: string) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: import('./type').CascaderValue) => any) | undefined;
+        "onUpdate:inputValue"?: ((value: string) => any) | undefined;
+        "onInput-value-change"?: ((value: string) => any) | undefined;
+    }>, {}, {}, {}, {}, {
+        size: import('..').Size;
+        popupVisible: boolean;
+        defaultPopupVisible: boolean;
+        disabled: boolean;
+        popupContainer: import('..').PopupContainer;
+        loading: boolean;
+        error: boolean;
+        multiple: boolean;
+        placeholder: string;
+        triggerProps: import('..').TriggerProps;
+        modelValue: import('./type').CascaderValue;
+        defaultValue: import('./type').CascaderValue;
+        allowClear: boolean;
+        options: import('./type').CascaderOption[];
+        formatLabel: (options: import('./type').CascaderOption[]) => string;
+        inputValue: string;
+        defaultInputValue: string;
+        fieldNames: Record<string, string>;
+        allowSearch: boolean;
+        valueKey: string;
+        maxTagCount: number;
+        filterOption: (inputValue: string, option: import('./type').CascaderOption) => boolean;
+        searchDelay: number;
+        tagNowrap: boolean;
+        pathMode: boolean;
+        expandTrigger: import('./type').ExpandTrigger;
+        expandChild: boolean;
+        searchOptionOnlyLabel: boolean;
+        loadMore: import('./type').LoadMore;
+        fallback: import('./type').FallBack;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('./type').CascaderProps> & Readonly<{
+    onChange?: ((value: import('./type').CascaderValue) => any) | undefined;
+    onFocus?: ((ev: FocusEvent) => any) | undefined;
+    "onUpdate:popupVisible"?: ((value: boolean) => any) | undefined;
+    "onPopup-visible-change"?: ((value: boolean) => any) | undefined;
+    onClear?: (() => any) | undefined;
+    onBlur?: ((ev: FocusEvent) => any) | undefined;
+    onSearch?: ((value: string) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: import('./type').CascaderValue) => any) | undefined;
+    "onUpdate:inputValue"?: ((value: string) => any) | undefined;
+    "onInput-value-change"?: ((value: string) => any) | undefined;
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    change: (value: import('./type').CascaderValue) => any;
+    focus: (ev: FocusEvent) => any;
+    "update:popupVisible": (value: boolean) => any;
+    "popup-visible-change": (value: boolean) => any;
+    clear: () => any;
+    blur: (ev: FocusEvent) => any;
+    search: (value: string) => any;
+    "update:modelValue": (value: import('./type').CascaderValue) => any;
+    "update:inputValue": (value: string) => any;
+    "input-value-change": (value: string) => any;
+}, string, {
+    size: import('..').Size;
+    popupVisible: boolean;
+    defaultPopupVisible: boolean;
+    disabled: boolean;
+    popupContainer: import('..').PopupContainer;
+    loading: boolean;
+    error: boolean;
+    multiple: boolean;
+    placeholder: string;
+    triggerProps: import('..').TriggerProps;
+    modelValue: import('./type').CascaderValue;
+    defaultValue: import('./type').CascaderValue;
+    allowClear: boolean;
+    options: import('./type').CascaderOption[];
+    formatLabel: (options: import('./type').CascaderOption[]) => string;
+    inputValue: string;
+    defaultInputValue: string;
+    fieldNames: Record<string, string>;
+    allowSearch: boolean;
+    valueKey: string;
+    maxTagCount: number;
+    filterOption: (inputValue: string, option: import('./type').CascaderOption) => boolean;
+    searchDelay: number;
+    tagNowrap: boolean;
+    pathMode: boolean;
+    expandTrigger: import('./type').ExpandTrigger;
+    expandChild: boolean;
+    searchOptionOnlyLabel: boolean;
+    loadMore: import('./type').LoadMore;
+    fallback: import('./type').FallBack;
+}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+    $slots: {
+        label?(_: {
+            tag: import('../_shared/type').ObjectData;
+        }): any;
+        label?(_: {
+            data: any;
+        }): any;
+        prefix?(_: {}): any;
+        prefix?(_: {}): any;
+    };
+}) & {
+    install: (app: App) => void;
+};
+declare module 'vue' {
+    interface GlobalComponents {
+        YcCascader: typeof Cascader;
+    }
+}
+export default Cascader;

package/lib/Cascader/index.js

@@ -0,0 +1 @@
+"use strict";const e=require("./Cascader.vue.js"),s=Object.assign(e,{install:s=>{s.component("Yc"+e.name,e)}});module.exports=s;

package/lib/Cascader/type.d.ts

@@ -0,0 +1,80 @@
+import { RenderFunction } from 'vue';
+import { PopupContainer, Size } from '../_shared/type';
+import { TagProps } from '../Tag';
+import { TriggerProps } from '../Trigger';
+export interface CascaderProps {
+    pathMode?: boolean;
+    multiple?: boolean;
+    modelValue?: CascaderValue;
+    defaultValue?: CascaderValue;
+    options?: CascaderOption[];
+    disabled?: boolean;
+    error?: boolean;
+    size?: Size;
+    allowSearch?: boolean;
+    allowClear?: boolean;
+    inputValue?: string;
+    defaultInputValue?: string;
+    popupVisible?: boolean;
+    defaultPopupVisible?: boolean;
+    expandTrigger?: ExpandTrigger;
+    placeholder?: string;
+    filterOption?: (inputValue: string, option: CascaderOption) => boolean;
+    popupContainer?: PopupContainer;
+    maxTagCount?: number;
+    formatLabel?: (options: CascaderOption[]) => string;
+    triggerProps?: TriggerProps;
+    loadMore?: LoadMore;
+    loading?: boolean;
+    searchOptionOnlyLabel?: boolean;
+    searchDelay?: number;
+    fieldNames?: Record<string, string>;
+    valueKey?: string;
+    fallback?: FallBack;
+    expandChild?: boolean;
+    tagNowrap?: boolean;
+}
+export interface CascaderEmits {
+    (e: 'update:modelValue', value: CascaderValue): void;
+    (e: 'update:inputValue', value: string): void;
+    (e: 'update:popupVisible', value: boolean): void;
+    (e: 'change', value: CascaderValue): void;
+    (e: 'input-value-change', value: string): void;
+    (e: 'clear'): void;
+    (e: 'search', value: string): void;
+    (e: 'popup-visible-change', value: boolean): void;
+    (e: 'focus', ev: FocusEvent): void;
+    (e: 'blur', ev: FocusEvent): void;
+}
+export interface CascaderSlots {
+    label(scope: {
+        data: CascaderOption;
+    }): void;
+    prefix(): void;
+    ['arrow-icon'](): void;
+    ['loading-icon'](): void;
+    ['search-icon'](): void;
+    empty(): void;
+    option(scope: {
+        data: CascaderOption;
+    }): void;
+}
+export type CascaderValue = CascaderOptionValue | CascaderOptionValue[] | CascaderOptionValue[][];
+export type CascaderOptionValue = string | number | Record<string, any>;
+export type CascaderOption = {
+    label?: string;
+    value?: CascaderOptionValue;
+    render?: RenderFunction;
+    disabled?: boolean;
+    tagProps?: TagProps;
+    children?: CascaderOption[];
+    isLeaf?: boolean;
+};
+export type CascaderOptionProps = {
+    level?: number;
+    index?: number;
+    nodePath?: CascaderOptionProps[];
+} & CascaderOption;
+export type ExpandTrigger = 'click' | 'hover';
+export type LoadMore = (option: CascaderOption, done: (children?: CascaderOption[]) => void) => void;
+export type FallBack = boolean | ((value: CascaderOptionValue | CascaderOptionValue[]) => string);

package/lib/Checkbox/Checkbox.vue.d.ts

@@ -0,0 +1,28 @@
+import { CheckboxProps, CheckboxSlots } from './type';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<CheckboxSlots> & CheckboxSlots;
+    refs: {};
+    rootEl: HTMLLabelElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<CheckboxProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    change: (value: boolean, ev: Event) => any;
+    "update:modelValue": (value: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<CheckboxProps> & Readonly<{
+    onChange?: ((value: boolean, ev: Event) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+}>, {
+    disabled: boolean;
+    value: import('./type').CheckboxValue;
+    defaultChecked: boolean;
+    modelValue: boolean;
+    indeterminate: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLLabelElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/lib/Checkbox/Checkbox.vue.js

@@ -0,0 +1 @@
+"use strict";const e=require("./Checkbox.vue2.js");;/* empty css               */const r=require("../_virtual/_plugin-vue_export-helper.js")(e,[["__scopeId","data-v-a7abd74d"]]);module.exports=r;

package/lib/Checkbox/Checkbox.vue2.js

@@ -0,0 +1 @@
+"use strict";const e=require("vue");require("../node_modules/tinycolor2/esm/tinycolor.js"),require("../_shared/utils/dom.js");const l=require("../_shared/utils/is.js");require("../_shared/utils/time.js"),require("../Empty/index.js");/* empty css                           */const a=require("../_shared/icons/IconCheckboxChecked.vue.js"),o=require("../_shared/utils/control.js"),t=require("./hooks/useContext.js"),u=require("../_shared/components/IconButton.vue.js");;/* empty css                                          */const c=["value","disabled","checked"],s={class:"yc-checkbox-icon"},n={key:0,class:"yc-checkbox-label text-ellipsis"},d=e.defineComponent({name:"Checkbox",__name:"Checkbox",props:{modelValue:{type:Boolean,default:void 0},defaultChecked:{type:Boolean,default:!1},disabled:{type:Boolean,default:!1},value:{type:[String,Number,Boolean],default:""},indeterminate:{type:Boolean,default:!1}},emits:["update:modelValue","change"],setup(d,{emit:r}){const i=d,v=r,{modelValue:h,defaultChecked:m,value:k,disabled:p}=e.toRefs(i),{computedValue:b,max:x,hasGroup:y,disabled:f}=t().inject(),_=o(h,m.value,e=>{v("update:modelValue",e)}),j=e.computed(()=>y.value?b.value.includes(k.value):_.value),q=e.computed(()=>p.value||f.value||!l.isUndefined(x.value)&&!j.value&&b.value.length>=x.value),C=e=>{var l;if(y.value)b.value=j.value?b.value.filter(e=>e!=k.value):[...b.value,k.value];else{const a=null==(l=e.target)?void 0:l.checked;_.value=a,v("change",a,e)}};return(l,o)=>(e.openBlock(),e.createElementBlock("label",{class:e.normalizeClass(["yc-checkbox",{"yc-checkbox-disabled":q.value,"yc-checkbox-unchecked":!j.value&&!l.indeterminate,"yc-checkbox-indeterminate":!j.value&&l.indeterminate,"yc-checkbox-checked":j.value}])},[e.createElementVNode("input",{type:"checkbox",class:"yc-checkbox-target",value:l.value,disabled:q.value,checked:j.value,onChange:C},null,40,c),e.renderSlot(l.$slots,"checkbox",{checked:j.value,disabled:q.value},()=>[e.createVNode(e.unref(u),{"hover-size":24,"hover-color":j.value||q.value?"transparent":"rgb(242, 243, 245)"},{default:e.withCtx(()=>[e.createElementVNode("span",s,[e.createVNode(e.unref(a),{size:[8,10]})])]),_:1},8,["hover-color"]),l.$slots.default?(e.openBlock(),e.createElementBlock("span",n,[e.renderSlot(l.$slots,"default",{},void 0,!0)])):e.createCommentVNode("",!0)],!0)],2))}});module.exports=d;

package/lib/Checkbox/CheckboxGroup.vue.d.ts

@@ -0,0 +1,29 @@
+import { CheckboxGroupProps, CheckboxGroupSlots } from './type';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<CheckboxGroupSlots> & CheckboxGroupSlots;
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<CheckboxGroupProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    change: (value: import('./type').CheckboxValue[]) => any;
+    "update:modelValue": (value: import('./type').CheckboxValue[]) => any;
+}, string, import('vue').PublicProps, Readonly<CheckboxGroupProps> & Readonly<{
+    onChange?: ((value: import('./type').CheckboxValue[]) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: import('./type').CheckboxValue[]) => any) | undefined;
+}>, {
+    disabled: boolean;
+    direction: import('..').Direction;
+    modelValue: import('./type').CheckboxValue[];
+    defaultValue: import('./type').CheckboxValue[];
+    options: (import('./type').CheckboxOption | import('./type').CheckboxValue)[];
+    max: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/lib/Checkbox/CheckboxGroup.vue.js

@@ -0,0 +1 @@
+"use strict";const e=require("vue"),o=require("./hooks/useContext.js"),t=require("./Checkbox.vue.js"),l=e.defineComponent({name:"CheckboxGroup",__name:"CheckboxGroup",props:{modelValue:{default:void 0},defaultValue:{default:()=>[]},max:{default:void 0},options:{default:()=>[]},direction:{default:"horizontal"},disabled:{type:Boolean,default:!1}},emits:["update:modelValue","change"],setup(l,{emit:a}){const r=l,d=a,{options:n}=o().provide(r,d);return(o,l)=>(e.openBlock(),e.createElementBlock("div",{class:e.normalizeClass(["yc-checkbox-group",`yc-checkbox-group-direction-${o.direction}`])},[e.renderSlot(o.$slots,"default"),(e.openBlock(!0),e.createElementBlock(e.Fragment,null,e.renderList(e.unref(n),(l,a)=>(e.openBlock(),e.createBlock(t,{key:a,value:l.value,disabled:l.disabled,indeterminate:l.indeterminate},e.createSlots({default:e.withCtx(()=>[e.renderSlot(o.$slots,"label",{data:l},()=>[e.createTextVNode(e.toDisplayString(l.label),1)])]),_:2},[o.$slots.checkbox?{name:"checkbox",fn:e.withCtx(t=>[e.renderSlot(o.$slots,"checkbox",e.mergeProps({ref_for:!0},t))]),key:"0"}:void 0]),1032,["value","disabled","indeterminate"]))),128))],2))}});module.exports=l;

package/lib/Checkbox/CheckboxGroup.vue3.js

@@ -0,0 +1 @@
+"use strict";const e=require("./CheckboxGroup.vue.js");,/* empty css                    */module.exports=e;

package/lib/Checkbox/hooks/useContext.d.ts

@@ -0,0 +1,19 @@
+import { Ref } from 'vue';
+import { CheckboxValue, CheckboxGroupEmits } from '../type';
+import { Props } from '../../_shared/type';
+type CheckboxContext = {
+    computedValue: Ref<CheckboxValue[]>;
+    max: Ref<number>;
+    disabled: Ref<boolean>;
+    hasGroup: Ref<boolean>;
+};
+declare const _default: () => {
+    provide: (props: Props, emits: CheckboxGroupEmits) => {
+        options: import('vue').ComputedRef<((string & Record<string, unknown>) | (number & Record<string, unknown>) | (false & Record<string, unknown>) | (true & Record<string, unknown>) | (import('..').CheckboxOption & Record<string, unknown>) | {
+            label: CheckboxValue | import('..').CheckboxOption;
+            value: CheckboxValue | import('..').CheckboxOption;
+        })[]>;
+    };
+    inject: () => CheckboxContext;
+};
+export default _default;

package/lib/Checkbox/hooks/useContext.js

@@ -0,0 +1 @@
+"use strict";const e=require("vue");require("../../node_modules/tinycolor2/esm/tinycolor.js"),require("../../_shared/utils/dom.js");const r=require("../../_shared/utils/is.js");require("../../_shared/utils/time.js"),require("../../Empty/index.js");/* empty css                              */const s=require("../../_shared/utils/control.js"),o="checkbox-group-context";module.exports=()=>({provide:(u,t)=>{const{modelValue:i,defaultValue:a,disabled:d,max:l,options:c}=e.toRefs(u),n=s(i,a.value,e=>{t("update:modelValue",e),t("change",e)}),m=e.computed(()=>c.value.map(e=>r.isObject(e)?e:{label:e,value:e}));return e.provide(o,{computedValue:n,max:l,disabled:d,hasGroup:e.ref(!0)}),{options:m}},inject:()=>e.inject(o,{computedValue:e.ref([]),max:e.ref(1e5),disabled:e.ref(!1),hasGroup:e.ref(!1)})});

package/lib/Checkbox/index.d.ts

@@ -0,0 +1,115 @@
+import { App } from 'vue';
+import { default as _Checkbox } from './Checkbox.vue';
+import { default as _CheckboxGroup } from './CheckboxGroup.vue';
+export type CheckboxInstance = InstanceType<typeof _Checkbox>;
+export type CheckboxGroupInstance = InstanceType<typeof _CheckboxGroup>;
+export * from './type';
+declare const Checkbox: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./type').CheckboxProps> & Readonly<{
+        onChange?: ((value: boolean, ev: Event) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+        change: (value: boolean, ev: Event) => any;
+        "update:modelValue": (value: boolean) => any;
+    }, import('vue').PublicProps, {
+        disabled: boolean;
+        value: import('./type').CheckboxValue;
+        defaultChecked: boolean;
+        modelValue: boolean;
+        indeterminate: boolean;
+    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, HTMLLabelElement, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('./type').CheckboxProps> & Readonly<{
+        onChange?: ((value: boolean, ev: Event) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+    }>, {}, {}, {}, {}, {
+        disabled: boolean;
+        value: import('./type').CheckboxValue;
+        defaultChecked: boolean;
+        modelValue: boolean;
+        indeterminate: boolean;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('./type').CheckboxProps> & Readonly<{
+    onChange?: ((value: boolean, ev: Event) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    change: (value: boolean, ev: Event) => any;
+    "update:modelValue": (value: boolean) => any;
+}, string, {
+    disabled: boolean;
+    value: import('./type').CheckboxValue;
+    defaultChecked: boolean;
+    modelValue: boolean;
+    indeterminate: boolean;
+}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+    $slots: Readonly<import('./type').CheckboxSlots> & import('./type').CheckboxSlots;
+}) & {
+    group: {
+        new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./type').CheckboxGroupProps> & Readonly<{
+            onChange?: ((value: import('./type').CheckboxValue[]) => any) | undefined;
+            "onUpdate:modelValue"?: ((value: import('./type').CheckboxValue[]) => any) | undefined;
+        }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+            change: (value: import('./type').CheckboxValue[]) => any;
+            "update:modelValue": (value: import('./type').CheckboxValue[]) => any;
+        }, import('vue').PublicProps, {
+            disabled: boolean;
+            direction: import('..').Direction;
+            modelValue: import('./type').CheckboxValue[];
+            defaultValue: import('./type').CheckboxValue[];
+            options: (import('./type').CheckboxOption | import('./type').CheckboxValue)[];
+            max: number;
+        }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, HTMLDivElement, import('vue').ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import('./type').CheckboxGroupProps> & Readonly<{
+            onChange?: ((value: import('./type').CheckboxValue[]) => any) | undefined;
+            "onUpdate:modelValue"?: ((value: import('./type').CheckboxValue[]) => any) | undefined;
+        }>, {}, {}, {}, {}, {
+            disabled: boolean;
+            direction: import('..').Direction;
+            modelValue: import('./type').CheckboxValue[];
+            defaultValue: import('./type').CheckboxValue[];
+            options: (import('./type').CheckboxOption | import('./type').CheckboxValue)[];
+            max: number;
+        }>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import('vue').ComponentOptionsBase<Readonly<import('./type').CheckboxGroupProps> & Readonly<{
+        onChange?: ((value: import('./type').CheckboxValue[]) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: import('./type').CheckboxValue[]) => any) | undefined;
+    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+        change: (value: import('./type').CheckboxValue[]) => any;
+        "update:modelValue": (value: import('./type').CheckboxValue[]) => any;
+    }, string, {
+        disabled: boolean;
+        direction: import('..').Direction;
+        modelValue: import('./type').CheckboxValue[];
+        defaultValue: import('./type').CheckboxValue[];
+        options: (import('./type').CheckboxOption | import('./type').CheckboxValue)[];
+        max: number;
+    }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+        $slots: Readonly<import('./type').CheckboxGroupSlots> & import('./type').CheckboxGroupSlots;
+    });
+    install: (app: App) => void;
+};
+export { _CheckboxGroup as CheckboxGroup };
+declare module 'vue' {
+    interface GlobalComponents {
+        YcCheckbox: typeof Checkbox;
+        YcCheckboxGroup: typeof _CheckboxGroup;
+    }
+}
+export default Checkbox;

package/lib/Checkbox/index.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}});const e=require("./Checkbox.vue.js"),o=require("./CheckboxGroup.vue.js");;/* empty css                    */const r=Object.assign(e,{group:o,install:r=>{r.component("Yc"+e.name,e),r.component("Yc"+o.name,o)}});exports.CheckboxGroup=o,exports.default=r;