@ndscnj/roomkit-web-vue3 3.2.0

package/es/components/common/SwitchTheme.vue2.mjs

@@ -0,0 +1,127 @@
+import { defineComponent, ref, computed, withDirectives, createElementBlock, openBlock, createBlock, createCommentVNode, unref, createElementVNode, toDisplayString, normalizeClass } from "vue";
+import IconButton from "./base/IconButton.vue.mjs";
+import { IconButtonLayout } from "../../constants/room.mjs";
+import { useI18n } from "../../locales/index.mjs";
+import "../../services/main.mjs";
+import { roomService } from "../../services/roomService.mjs";
+import "@tencentcloud/tuiroom-engine-js";
+import { isMobile } from "../../utils/environment.mjs";
+import "mitt";
+import "../../services/manager/roomActionManager.mjs";
+import "@tencentcloud/tui-core";
+import { useBasicStore } from "../../stores/basic.mjs";
+import { useUIKit, IconSwitchTheme } from "@tencentcloud/uikit-base-component-vue3";
+import vClickOutside from "../../directives/vClickOutside.mjs";
+const _hoisted_1 = { class: "theme-container" };
+const _hoisted_2 = {
+  key: 1,
+  class: "switch-theme-container"
+};
+const _hoisted_3 = { class: "switch-theme-item" };
+const _hoisted_4 = { class: "color-blocks two-blocks" };
+const _hoisted_5 = { class: "switch-theme-item" };
+const _hoisted_6 = { class: "color-blocks four-blocks" };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "SwitchTheme",
+  props: {
+    visible: { type: Boolean, default: true }
+  },
+  setup(__props) {
+    const { t } = useI18n();
+    const basicStore = useBasicStore();
+    const { theme, setTheme } = useUIKit();
+    const isShowThemeColorContainer = ref(false);
+    const switchThemeConfig = roomService.getComponentConfig("SwitchTheme");
+    const currentCustomTheme = ref("theme");
+    const currentTheme = computed(() => theme.value || basicStore.defaultTheme);
+    function handleSwitchTheme() {
+      if (!isMobile) {
+        isShowThemeColorContainer.value = !isShowThemeColorContainer.value;
+        return;
+      }
+      const newTheme = currentTheme.value === "light" ? "dark" : "light";
+      theme.value ? setTheme(newTheme) : roomService.setTheme(newTheme);
+    }
+    function toggleCustomTheme(newTheme) {
+      if (!theme.value) {
+        roomService.setTheme(newTheme);
+        return;
+      }
+      const isBaseTheme = newTheme === "light" || newTheme === "dark";
+      const themeConfig = isBaseTheme ? newTheme : { themeStyle: theme.value, primaryColor: newTheme };
+      setTheme(themeConfig);
+      if (!isBaseTheme) {
+        currentCustomTheme.value = newTheme;
+      }
+    }
+    function handleClickOutSide() {
+      if (isShowThemeColorContainer.value) {
+        isShowThemeColorContainer.value = false;
+      }
+    }
+    return (_ctx, _cache) => {
+      return withDirectives((openBlock(), createElementBlock("div", _hoisted_1, [
+        __props.visible && unref(switchThemeConfig).visible ? (openBlock(), createBlock(IconButton, {
+          key: 0,
+          title: unref(t)("Switch Theme"),
+          layout: unref(IconButtonLayout).HORIZONTAL,
+          icon: unref(IconSwitchTheme),
+          onClickIcon: handleSwitchTheme
+        }, null, 8, ["title", "layout", "icon"])) : createCommentVNode("", true),
+        isShowThemeColorContainer.value && !unref(isMobile) ? (openBlock(), createElementBlock("div", _hoisted_2, [
+          createElementVNode("div", _hoisted_3, [
+            createElementVNode("span", null, toDisplayString(unref(t)("Theme Colours")), 1),
+            createElementVNode("div", _hoisted_4, [
+              createElementVNode("div", {
+                class: normalizeClass(["color-block black", { active: currentTheme.value === "dark" }]),
+                onClick: _cache[0] || (_cache[0] = ($event) => toggleCustomTheme("dark"))
+              }, null, 2),
+              createElementVNode("div", {
+                class: normalizeClass(["color-block white", { active: currentTheme.value === "light" }]),
+                onClick: _cache[1] || (_cache[1] = ($event) => toggleCustomTheme("light"))
+              }, null, 2)
+            ])
+          ]),
+          createElementVNode("div", _hoisted_5, [
+            createElementVNode("span", null, toDisplayString(unref(t)("Custom Themes")), 1),
+            createElementVNode("div", _hoisted_6, [
+              createElementVNode("div", {
+                class: normalizeClass([
+                  "color-block theme",
+                  { active: currentCustomTheme.value === "theme" }
+                ]),
+                onClick: _cache[2] || (_cache[2] = ($event) => toggleCustomTheme("#1c66e5"))
+              }, null, 2),
+              createElementVNode("div", {
+                class: normalizeClass([
+                  "color-block green",
+                  { active: currentCustomTheme.value === "green" }
+                ]),
+                onClick: _cache[3] || (_cache[3] = ($event) => toggleCustomTheme("#0abf77"))
+              }, null, 2),
+              createElementVNode("div", {
+                class: normalizeClass([
+                  "color-block red",
+                  { active: currentCustomTheme.value === "red" }
+                ]),
+                onClick: _cache[4] || (_cache[4] = ($event) => toggleCustomTheme("#e54545"))
+              }, null, 2),
+              createElementVNode("div", {
+                class: normalizeClass([
+                  "color-block orange",
+                  { active: currentCustomTheme.value === "orange" }
+                ]),
+                onClick: _cache[5] || (_cache[5] = ($event) => toggleCustomTheme("#ff7200"))
+              }, null, 2)
+            ])
+          ])
+        ])) : createCommentVNode("", true)
+      ])), [
+        [unref(vClickOutside), handleClickOutSide]
+      ]);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/es/components/common/base/ActionSheep.vue.d.ts

@@ -0,0 +1,65 @@
+declare function __VLS_template(): {
+    default?(_: {}): any;
+};
+declare const __VLS_component: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    visible: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    title: {
+        type: StringConstructor;
+        default: string;
+    };
+    showClose: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showMask: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    height: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    input: (...args: any[]) => void;
+    close: (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    visible: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    title: {
+        type: StringConstructor;
+        default: string;
+    };
+    showClose: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showMask: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    height: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{
+    onInput?: ((...args: any[]) => any) | undefined;
+    onClose?: ((...args: any[]) => any) | undefined;
+}>, {
+    title: string;
+    visible: boolean;
+    height: string;
+    showClose: boolean;
+    showMask: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/es/components/common/base/ActionSheep.vue2.mjs

@@ -0,0 +1,7 @@
+import _sfc_main from "./ActionSheep.vue3.mjs";
+/* empty css                 */
+import _export_sfc from "../../../_virtual/_plugin-vue_export-helper.mjs";
+const ActionSheep = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-2467680f"]]);
+export {
+  ActionSheep as default
+};

package/es/components/common/base/ActionSheep.vue3.mjs

@@ -0,0 +1,90 @@
+import { defineComponent, ref, watch, resolveComponent, createElementBlock, openBlock, withDirectives, createElementVNode, vShow, unref, normalizeStyle, createCommentVNode, renderSlot, createVNode, toDisplayString } from "vue";
+import { IconArrowDown } from "@tencentcloud/uikit-base-component-vue3";
+import vTap from "../../../directives/vTap.mjs";
+const _hoisted_1 = { class: "mask" };
+const _hoisted_2 = {
+  key: 0,
+  class: "container-close"
+};
+const _hoisted_3 = {
+  key: 1,
+  class: "container-header"
+};
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "ActionSheep",
+  props: {
+    visible: {
+      type: Boolean,
+      default: false
+    },
+    title: {
+      type: String,
+      default: ""
+    },
+    showClose: {
+      type: Boolean,
+      default: true
+    },
+    showMask: {
+      type: Boolean,
+      default: true
+    },
+    height: {
+      type: String,
+      default: ""
+    }
+  },
+  emits: ["input", "close"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const show = ref(false);
+    watch(
+      () => props.visible,
+      (val) => show.value = val,
+      { immediate: true }
+    );
+    watch(
+      show,
+      (val) => {
+        emit("input", val);
+      },
+      { immediate: true }
+    );
+    const toggleShow = () => {
+      show.value = !show.value;
+      if (!show.value) {
+        emit("close");
+      }
+    };
+    return (_ctx, _cache) => {
+      const _component_TUIIcon = resolveComponent("TUIIcon");
+      return openBlock(), createElementBlock("div", null, [
+        withDirectives(createElementVNode("div", _hoisted_1, null, 512), [
+          [vShow, show.value && __props.showMask],
+          [unref(vTap), toggleShow]
+        ]),
+        withDirectives(createElementVNode("div", {
+          class: "container",
+          style: normalizeStyle({ height: props.height })
+        }, [
+          __props.showClose ? withDirectives((openBlock(), createElementBlock("div", _hoisted_2, [
+            createVNode(_component_TUIIcon, {
+              icon: unref(IconArrowDown),
+              size: "28"
+            }, null, 8, ["icon"])
+          ])), [
+            [unref(vTap), toggleShow]
+          ]) : createCommentVNode("", true),
+          __props.title ? (openBlock(), createElementBlock("div", _hoisted_3, toDisplayString(__props.title), 1)) : createCommentVNode("", true),
+          renderSlot(_ctx.$slots, "default", {}, void 0, true)
+        ], 4), [
+          [vShow, show.value]
+        ])
+      ]);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/es/components/common/base/Badge.vue.d.ts

@@ -0,0 +1,53 @@
+interface Props {
+    type?: 'primary' | 'danger';
+    value?: string | number;
+    max?: number;
+    hidden?: boolean;
+    isDot?: boolean;
+}
+declare function __VLS_template(): {
+    default?(_: {}): any;
+};
+declare const __VLS_component: import('vue').DefineComponent<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<Props>, {
+    type: string;
+    value: string;
+    max: number;
+    hidden: boolean;
+    isDot: boolean;
+}>>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<Props>, {
+    type: string;
+    value: string;
+    max: number;
+    hidden: boolean;
+    isDot: boolean;
+}>>> & Readonly<{}>, {
+    max: number;
+    type: "primary" | "danger";
+    value: string | number;
+    hidden: boolean;
+    isDot: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/es/components/common/base/Badge.vue.mjs

@@ -0,0 +1,7 @@
+import _sfc_main from "./Badge.vue2.mjs";
+/* empty css            */
+import _export_sfc from "../../../_virtual/_plugin-vue_export-helper.mjs";
+const TuiBadge = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-91e57237"]]);
+export {
+  TuiBadge as default
+};

package/es/components/common/base/Badge.vue2.mjs

@@ -0,0 +1,42 @@
+import { defineComponent, computed, createElementBlock, openBlock, normalizeClass, renderSlot, createCommentVNode, toDisplayString } from "vue";
+const _hoisted_1 = {
+  key: 0,
+  class: "tui-badge-count"
+};
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "Badge",
+  props: {
+    type: { default: "primary" },
+    value: { default: "" },
+    max: { default: 99 },
+    hidden: { type: Boolean, default: false },
+    isDot: { type: Boolean, default: false }
+  },
+  setup(__props) {
+    const props = __props;
+    const showBadge = computed(() => !props.hidden && (props.value || props.isDot));
+    const content = computed(() => {
+      if (props.isDot) return "";
+      if (typeof props.value === "number" && typeof props.max === "number") {
+        return props.value > props.max ? `${props.max}+` : props.value;
+      }
+      return props.value;
+    });
+    const badgeClass = computed(() => [
+      "tui-badge",
+      `tui-badge-${props.type}`,
+      props.isDot ? "tui-badge-isDot" : ""
+    ]);
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass(badgeClass.value)
+      }, [
+        renderSlot(_ctx.$slots, "default", {}, void 0, true),
+        showBadge.value ? (openBlock(), createElementBlock("sup", _hoisted_1, toDisplayString(content.value), 1)) : createCommentVNode("", true)
+      ], 2);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/es/components/common/base/Button.vue.d.ts

@@ -0,0 +1,68 @@
+import { StyleValue } from 'vue';
+
+interface Props {
+    size?: 'large' | 'default';
+    type?: 'primary' | 'success' | 'warning' | 'danger' | 'info' | 'text';
+    customStyle?: StyleValue;
+    loading?: boolean;
+    disabled?: boolean;
+    round?: boolean;
+    plain?: boolean;
+}
+declare function __VLS_template(): {
+    icon?(_: {}): any;
+    default?(_: {}): any;
+};
+declare const __VLS_component: import('vue').DefineComponent<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<Props>, {
+    size: undefined;
+    type: undefined;
+    customStyle: () => {};
+    loading: boolean;
+    disabled: boolean;
+    round: boolean;
+    plain: boolean;
+}>>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    click: (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<Props>, {
+    size: undefined;
+    type: undefined;
+    customStyle: () => {};
+    loading: boolean;
+    disabled: boolean;
+    round: boolean;
+    plain: boolean;
+}>>> & Readonly<{
+    onClick?: ((...args: any[]) => any) | undefined;
+}>, {
+    size: "large" | "default";
+    type: "primary" | "success" | "warning" | "danger" | "info" | "text";
+    disabled: boolean;
+    loading: boolean;
+    customStyle: string | false | import('vue').CSSProperties | StyleValue[] | null;
+    round: boolean;
+    plain: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/es/components/common/base/Button.vue.mjs

@@ -0,0 +1,7 @@
+import _sfc_main from "./Button.vue2.mjs";
+/* empty css             */
+import _export_sfc from "../../../_virtual/_plugin-vue_export-helper.mjs";
+const Button = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-fb978059"]]);
+export {
+  Button as default
+};

package/es/components/common/base/Button.vue2.mjs

@@ -0,0 +1,51 @@
+import { defineComponent, computed, createElementBlock, openBlock, normalizeStyle, normalizeClass, createCommentVNode, renderSlot } from "vue";
+const _hoisted_1 = {
+  key: 0,
+  class: "button-icon"
+};
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "Button",
+  props: {
+    size: { default: void 0 },
+    type: { default: void 0 },
+    customStyle: { type: [Boolean, null, String, Object, Array], default: () => ({}) },
+    loading: { type: Boolean, default: false },
+    disabled: { type: Boolean, default: false },
+    round: { type: Boolean, default: true },
+    plain: { type: Boolean, default: false }
+  },
+  emits: ["click"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    function handleClick(event) {
+      if (!props.disabled) {
+        emit("click", event);
+      }
+    }
+    const buttonClassList = computed(() => [
+      "tui-button",
+      `tui-button-${props.type}`,
+      `tui-button-${props.size}`,
+      { "tui-button-round": props.round },
+      { "tui-button-loading": props.loading },
+      { "tui-button-disabled": props.disabled },
+      { "tui-button-plain": props.plain }
+    ]);
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("button", {
+        class: normalizeClass(buttonClassList.value),
+        style: normalizeStyle(__props.customStyle),
+        onClick: handleClick
+      }, [
+        _ctx.$slots.icon ? (openBlock(), createElementBlock("span", _hoisted_1, [
+          renderSlot(_ctx.$slots, "icon", {}, void 0, true)
+        ])) : createCommentVNode("", true),
+        renderSlot(_ctx.$slots, "default", {}, void 0, true)
+      ], 6);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/es/components/common/base/Checkbox/CheckboxPC.vue.d.ts

@@ -0,0 +1,47 @@
+interface Props {
+    modelValue: boolean;
+    disabled?: boolean;
+}
+declare function __VLS_template(): {
+    default?(_: {}): any;
+};
+declare const __VLS_component: import('vue').DefineComponent<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<Props>, {
+    modelValue: boolean;
+    disabled: boolean;
+    slotCustomStyle: () => {};
+}>>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    input: (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<Props>, {
+    modelValue: boolean;
+    disabled: boolean;
+    slotCustomStyle: () => {};
+}>>> & Readonly<{
+    onInput?: ((...args: any[]) => any) | undefined;
+}>, {
+    disabled: boolean;
+    modelValue: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/es/components/common/base/Checkbox/CheckboxPC.vue.mjs

@@ -0,0 +1,7 @@
+import _sfc_main from "./CheckboxPC.vue2.mjs";
+/* empty css                 */
+import _export_sfc from "../../../../_virtual/_plugin-vue_export-helper.mjs";
+const CheckboxPC = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-1bbd737a"]]);
+export {
+  CheckboxPC as default
+};

package/es/components/common/base/Checkbox/CheckboxPC.vue2.mjs

@@ -0,0 +1,52 @@
+import { defineComponent, ref, watch, createElementBlock, openBlock, withDirectives, createElementVNode, vModelCheckbox, renderSlot } from "vue";
+const _hoisted_1 = { class: "tui-checkbox" };
+const _hoisted_2 = ["disabled"];
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "CheckboxPC",
+  props: {
+    modelValue: { type: Boolean, default: false },
+    disabled: { type: Boolean, default: false }
+  },
+  emits: ["input"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const checked = ref(props.modelValue);
+    const emit = __emit;
+    watch(
+      () => props.modelValue,
+      (value) => {
+        checked.value = props.disabled ? true : value;
+      },
+      { immediate: true }
+    );
+    function handleCheckBoxClick() {
+      checked.value = !checked.value;
+      emit("input", checked.value);
+    }
+    function handleValueChange(event) {
+      checked.value = event.target.checked;
+      emit("input", event.target.checked);
+    }
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1, [
+        withDirectives(createElementVNode("input", {
+          "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => checked.value = $event),
+          type: "checkbox",
+          disabled: props.disabled,
+          onChange: handleValueChange
+        }, null, 40, _hoisted_2), [
+          [vModelCheckbox, checked.value]
+        ]),
+        createElementVNode("span", {
+          class: "tui-checkbox-slot-container",
+          onClick: handleCheckBoxClick
+        }, [
+          renderSlot(_ctx.$slots, "default", {}, void 0, true)
+        ])
+      ]);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};