@ironsource/shared-ui 1.4.2-test.4 → 1.4.2-test.5

package/src/components/autocompleteDropdown/useKeyboardNavigation.vue.js

@@ -0,0 +1,79 @@
+import { ref, computed, watch, toRaw } from 'vue';
+
+const useKeyboardNavigation = ({
+  options,
+  canFocus,
+  scrollTo,
+  selectItem
+}) => {
+  const focusedIndex = ref(-1);
+  const focusedOption = computed(() => options.value[focusedIndex.value]);
+  const optionAfterFocused = computed(
+    () => options.value[focusedIndex.value + 1]
+  );
+  const optionBeforeFocused = computed(
+    () => options.value[focusedIndex.value - 1]
+  );
+  const isFocused = (option) => {
+    return toRaw(option) === toRaw(focusedOption.value);
+  };
+  const focusNext = () => {
+    if (focusedIndex.value > options.value.length - 1)
+      return -1;
+    if (!canFocus(optionAfterFocused.value)) {
+      focusedIndex.value += 2;
+    } else {
+      focusedIndex.value += 1;
+    }
+  };
+  const focusPrev = () => {
+    if (focusedIndex.value < 0)
+      return -1;
+    if (!canFocus(optionBeforeFocused.value)) {
+      focusedIndex.value -= 2;
+    } else {
+      focusedIndex.value -= 1;
+    }
+  };
+  const selectFocused = () => {
+    if (!focusedOption.value || !canFocus(focusedOption.value))
+      return;
+    selectItem(focusedOption.value);
+  };
+  watch(options, () => {
+    focusedIndex.value = -1;
+  });
+  watch(focusedIndex, () => {
+    const scrollToIndex = focusedIndex.value - 5;
+    if (scrollToIndex >= 0) {
+      scrollTo(scrollToIndex);
+    }
+  });
+  function keyDownHandler(event) {
+    switch (event.key) {
+      case "ArrowUp": {
+        focusPrev();
+        event.preventDefault();
+        event.stopPropagation();
+        break;
+      }
+      case "ArrowDown": {
+        focusNext();
+        event.preventDefault();
+        event.stopPropagation();
+        break;
+      }
+      case "Enter": {
+        selectFocused();
+        event.preventDefault();
+        break;
+      }
+    }
+  }
+  return {
+    isFocused,
+    keyDownHandler
+  };
+};
+
+export { useKeyboardNavigation };

package/src/components/banner/Banner.vue.js

@@ -0,0 +1,58 @@
+import { defineComponent, computed, openBlock, createElementBlock, normalizeClass, createElementVNode, createBlock, unref, withCtx, renderSlot, pushScopeId, popScopeId } from 'vue';
+import Icon from '../icon/Icon.vue.js';
+/* empty css                                                        */import _export_sfc from '../../../_virtual/plugin-vue_export-helper.vue.js';
+
+////import "../../Banner.vue_vue_type_style_index_0_scoped_true_lang.css";
+const _withScopeId = (n) => (pushScopeId("data-v-b94b49ec"), n = n(), popScopeId(), n);
+const _hoisted_1 = /* @__PURE__ */ _withScopeId(() => /* @__PURE__ */ createElementVNode("div", { class: "left-border" }, null, -1));
+const _hoisted_2 = { class: "content-wrapper" };
+const _hoisted_3 = { class: "icon-container" };
+const _hoisted_4 = { class: "content" };
+const _sfc_main = defineComponent({
+  __name: "Banner",
+  props: {
+    type: {
+      type: String,
+      default: "info"
+    },
+    iconSize: {
+      type: String,
+      default: "sm"
+    }
+  },
+  setup(__props) {
+    const props = __props;
+    const iconClass = computed(() => `${props.type}`);
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass(["banner", `banner-type-${__props.type}`])
+      }, [
+        _hoisted_1,
+        createElementVNode("div", _hoisted_2, [
+          createElementVNode("div", _hoisted_3, [
+            _ctx.$slots.icon ? (openBlock(), createBlock(unref(Icon), {
+              key: 0,
+              class: normalizeClass(iconClass.value)
+            }, {
+              default: withCtx(() => [
+                renderSlot(_ctx.$slots, "icon", {}, void 0, true)
+              ]),
+              _: 3
+            }, 8, ["class"])) : (openBlock(), createBlock(unref(Icon), {
+              key: 1,
+              name: iconClass.value,
+              class: normalizeClass(iconClass.value),
+              "font-size": __props.iconSize
+            }, null, 8, ["name", "class", "font-size"]))
+          ]),
+          createElementVNode("div", _hoisted_4, [
+            renderSlot(_ctx.$slots, "default", {}, void 0, true)
+          ])
+        ])
+      ], 2);
+    };
+  }
+});
+var Banner = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-b94b49ec"]]);
+
+export { Banner as default };

package/src/components/banner/index.vue.js

@@ -0,0 +1,6 @@
+import Banner from './Banner.vue.js';
+export { default as Banner } from './Banner.vue.js';
+
+const BannerTypes = () => [Banner];
+
+export { BannerTypes };

package/src/components/button/Button.vue.js

@@ -0,0 +1,63 @@
+import { defineComponent, computed, openBlock, createBlock, mergeProps, createSlots, withCtx, createElementVNode, normalizeClass, unref, createCommentVNode, renderSlot } from 'vue';
+import Icon from '../icon/Icon.vue.js';
+import ButtonBase from './ButtonBase.vue.js';
+import { iconSizeMap } from './consts.vue.js';
+/* empty css                                                        */import _export_sfc from '../../../_virtual/plugin-vue_export-helper.vue.js';
+
+////import "../../Button.vue_vue_type_style_index_0_scoped_true_lang.css";
+const _sfc_main = defineComponent({
+  __name: "Button",
+  props: {
+    leftIconName: { default: null },
+    rightIconName: { default: null },
+    size: { default: "md" }
+  },
+  setup(__props) {
+    const props = __props;
+    const computedIconWidth = computed(() => `${iconSizeMap[props.size]}px`);
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(ButtonBase, mergeProps({
+        class: [
+          _ctx.size,
+          {
+            "with-left-icon": !!_ctx.leftIconName,
+            "with-right-icon": !!_ctx.rightIconName
+          }
+        ],
+        size: _ctx.size
+      }, _ctx.$attrs), createSlots({
+        default: withCtx(() => [
+          createElementVNode("div", {
+            class: normalizeClass({
+              flex: _ctx.leftIconName || _ctx.rightIconName
+            })
+          }, [
+            _ctx.leftIconName ? (openBlock(), createBlock(unref(Icon), {
+              key: 0,
+              name: _ctx.leftIconName,
+              "font-size": computedIconWidth.value
+            }, null, 8, ["name", "font-size"])) : createCommentVNode("", true),
+            renderSlot(_ctx.$slots, "default", {}, void 0, true),
+            _ctx.rightIconName ? (openBlock(), createBlock(unref(Icon), {
+              key: 1,
+              name: _ctx.rightIconName,
+              "font-size": computedIconWidth.value
+            }, null, 8, ["name", "font-size"])) : createCommentVNode("", true)
+          ], 2)
+        ]),
+        _: 2
+      }, [
+        _ctx.$slots.loader ? {
+          name: "loader",
+          fn: withCtx(() => [
+            renderSlot(_ctx.$slots, "loader", {}, void 0, true)
+          ]),
+          key: "0"
+        } : void 0
+      ]), 1040, ["class", "size"]);
+    };
+  }
+});
+var Button = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-8e54ca3e"]]);
+
+export { Button as default };

package/src/components/button/ButtonBase.vue.js

@@ -0,0 +1,64 @@
+import { defineComponent, computed, openBlock, createElementBlock, mergeProps, renderSlot, createVNode, unref, withCtx, createCommentVNode } from 'vue';
+import '../typography/Heading.vue.js';
+import Text from '../typography/Text.vue.js';
+import Icon from '../icon/Icon.vue.js';
+import { sizeToFont } from './consts.vue.js';
+import LoaderDotsIcon from './icon/LoaderDotsIcon.vue.js';
+/* empty css                                                            */import _export_sfc from '../../../_virtual/plugin-vue_export-helper.vue.js';
+
+////import "../../ButtonBase.vue_vue_type_style_index_0_scoped_true_lang.css";
+const _hoisted_1 = { key: 0 };
+const loaderWidthLargeInPixel = 32;
+const loaderWidthMedSmallInPixel = 24;
+const _sfc_main = defineComponent({
+  __name: "ButtonBase",
+  props: {
+    size: { default: "md" },
+    variant: { default: "solid" },
+    theme: { default: "primary" },
+    loading: { type: Boolean, default: false },
+    isTruncated: { type: Boolean },
+    strong: { type: Boolean, default: true }
+  },
+  setup(__props) {
+    const props = __props;
+    const loaderWidth = computed(
+      () => props.size === "lg" ? loaderWidthLargeInPixel + "px" : loaderWidthMedSmallInPixel + "px"
+    );
+    const textSize = computed(() => sizeToFont[props.size]);
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("button", mergeProps({
+        class: [[_ctx.size, _ctx.theme, _ctx.variant, { loading: _ctx.loading }], "button-wrap"]
+      }, _ctx.$attrs), [
+        !_ctx.loading ? (openBlock(), createElementBlock("span", _hoisted_1, [
+          renderSlot(_ctx.$slots, "content", {}, () => [
+            createVNode(unref(Text), {
+              size: textSize.value,
+              strong: _ctx.strong,
+              class: "content"
+            }, {
+              default: withCtx(() => [
+                renderSlot(_ctx.$slots, "default", {}, void 0, true)
+              ]),
+              _: 3
+            }, 8, ["size", "strong"])
+          ], true)
+        ])) : createCommentVNode("", true),
+        _ctx.loading ? renderSlot(_ctx.$slots, "loader", { key: 1 }, () => [
+          createVNode(unref(Icon), {
+            "font-size": loaderWidth.value,
+            class: "loading"
+          }, {
+            default: withCtx(() => [
+              createVNode(LoaderDotsIcon)
+            ]),
+            _: 1
+          }, 8, ["font-size"])
+        ], true) : createCommentVNode("", true)
+      ], 16);
+    };
+  }
+});
+var ButtonBase = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-2650dac1"]]);
+
+export { ButtonBase as default };

package/src/components/button/IconButton.vue.js

@@ -0,0 +1,51 @@
+import { defineComponent, computed, openBlock, createBlock, mergeProps, withCtx, createElementVNode, normalizeClass, renderSlot, createVNode, unref } from 'vue';
+import Icon from '../icon/Icon.vue.js';
+import ButtonBase from './ButtonBase.vue.js';
+import { loaderSizeMap } from './consts.vue.js';
+import LoaderCircleIcon from './icon/LoaderCircleIcon.vue.js';
+/* empty css                                                            */import _export_sfc from '../../../_virtual/plugin-vue_export-helper.vue.js';
+
+////import "../../IconButton.vue_vue_type_style_index_0_scoped_true_lang.css";
+const _sfc_main = defineComponent({
+  __name: "IconButton",
+  props: {
+    size: { default: "md" },
+    variant: { default: "solid" }
+  },
+  setup(__props) {
+    const props = __props;
+    const loaderSize = computed(() => loaderSizeMap[props.size] + "px");
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(ButtonBase, mergeProps({
+        size: _ctx.size,
+        "is-truncated": false
+      }, _ctx.$attrs, {
+        variant: _ctx.variant,
+        class: "icon-base"
+      }), {
+        content: withCtx(() => [
+          createElementVNode("div", {
+            class: normalizeClass(["icon", { [_ctx.size]: true, [_ctx.variant]: true }])
+          }, [
+            renderSlot(_ctx.$slots, "default", {}, void 0, true)
+          ], 2)
+        ]),
+        loader: withCtx(() => [
+          createVNode(unref(Icon), {
+            "font-size": loaderSize.value,
+            class: "loading"
+          }, {
+            default: withCtx(() => [
+              createVNode(LoaderCircleIcon)
+            ]),
+            _: 1
+          }, 8, ["font-size"])
+        ]),
+        _: 3
+      }, 16, ["size", "variant"]);
+    };
+  }
+});
+var IconButton = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-1d38d347"]]);
+
+export { IconButton as default };

package/src/components/button/ScrollButton.vue.js

@@ -0,0 +1,49 @@
+import { defineComponent, openBlock, createBlock, unref, normalizeClass, withCtx, createVNode, createCommentVNode } from 'vue';
+import Icon from '../icon/Icon.vue.js';
+import './Button.vue.js';
+import IconButton from './IconButton.vue.js';
+import _sfc_main$1 from '../tooltip/Tooltip.vue.js';
+/* empty css                                                              */import _export_sfc from '../../../_virtual/plugin-vue_export-helper.vue.js';
+
+////import "../../ScrollButton.vue_vue_type_style_index_0_scoped_true_lang.css";
+const _sfc_main = defineComponent({
+  __name: "ScrollButton",
+  props: {
+    show: { type: Boolean, default: false },
+    iconName: { default: "angle-up" },
+    tooltipText: { default: "Back to top" },
+    position: { default: "bottom-right" }
+  },
+  emits: ["scrolled"],
+  setup(__props, { emit }) {
+    const onScroll = () => {
+      emit("scrolled");
+    };
+    return (_ctx, _cache) => {
+      return _ctx.show ? (openBlock(), createBlock(unref(IconButton), {
+        key: 0,
+        class: normalizeClass(["scroll-button", _ctx.position]),
+        theme: "third",
+        variant: "borderless",
+        size: "lg",
+        onClick: onScroll
+      }, {
+        default: withCtx(() => [
+          createVNode(unref(_sfc_main$1), {
+            text: _ctx.tooltipText,
+            delay: 400
+          }, {
+            default: withCtx(() => [
+              createVNode(unref(Icon), { name: _ctx.iconName }, null, 8, ["name"])
+            ]),
+            _: 1
+          }, 8, ["text"])
+        ]),
+        _: 1
+      }, 8, ["class"])) : createCommentVNode("", true);
+    };
+  }
+});
+var ScrollButton = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-1a43437e"]]);
+
+export { ScrollButton as default };

package/src/components/button/consts.vue.js

@@ -0,0 +1,17 @@
+const sizeToFont = {
+  lg: "md",
+  md: "sm",
+  sm: "xs"
+};
+const iconSizeMap = {
+  lg: 24,
+  md: 16,
+  sm: 16
+};
+const loaderSizeMap = {
+  lg: 22,
+  md: 16,
+  sm: 11
+};
+
+export { iconSizeMap, loaderSizeMap, sizeToFont };

package/src/components/button/icon/LoaderCircleIcon.vue.js

@@ -0,0 +1,39 @@
+import { openBlock, createElementBlock, createElementVNode } from 'vue';
+import _export_sfc from '../../../../_virtual/plugin-vue_export-helper.vue.js';
+
+////import "../../LoaderCircleIcon.vue_vue_type_style_index_0_scoped_true_lang.css";
+const _sfc_main = {};
+
+const _hoisted_1 = {
+  width: "100",
+  height: "100",
+  viewBox: "0 0 100 100"
+};
+const _hoisted_2 = /*#__PURE__*/createElementVNode("circle", {
+  cx: "50",
+  cy: "50",
+  fill: "none",
+  stroke: "currentColor",
+  "stroke-width": "6",
+  r: "35",
+  "stroke-dasharray": "164.93361431346415 56.97787143782138"
+}, [
+  /*#__PURE__*/createElementVNode("animateTransform", {
+    attributeName: "transform",
+    type: "rotate",
+    repeatCount: "indefinite",
+    dur: "1s",
+    values: "0 50 50;360 50 50",
+    keyTimes: "0;1"
+  })
+], -1);
+const _hoisted_3 = [
+  _hoisted_2
+];
+
+function _sfc_render(_ctx, _cache) {
+  return (openBlock(), createElementBlock("svg", _hoisted_1, _hoisted_3))
+}
+var LoaderCircleIcon = /*#__PURE__*/_export_sfc(_sfc_main, [['render',_sfc_render]]);
+
+export { LoaderCircleIcon as default };

package/src/components/button/icon/LoaderDotsIcon.vue.js

@@ -0,0 +1,22 @@
+import { openBlock, createElementBlock, createStaticVNode } from 'vue';
+import _export_sfc from '../../../../_virtual/plugin-vue_export-helper.vue.js';
+
+////import "../../LoaderDotsIcon.vue_vue_type_style_index_0_scoped_true_lang.css";
+const _sfc_main = {};
+
+const _hoisted_1 = {
+  width: "52",
+  height: "14",
+  viewBox: "0 0 52 14"
+};
+const _hoisted_2 = /*#__PURE__*/createStaticVNode("<circle fill=\"currentColor\" cx=\"6\" cy=\"7\" r=\"6\"><animate attributeName=\"opacity\" dur=\"1s\" values=\"0;1;0\" repeatCount=\"indefinite\" begin=\".1\"></animate></circle><circle fill=\"currentColor\" cx=\"26\" cy=\"7\" r=\"6\"><animate attributeName=\"opacity\" dur=\"1s\" values=\"0;1;0\" repeatCount=\"indefinite\" begin=\".2\"></animate></circle><circle fill=\"currentColor\" cx=\"46\" cy=\"7\" r=\"6\"><animate attributeName=\"opacity\" dur=\"1s\" values=\"0;1;0\" repeatCount=\"indefinite\" begin=\".3\"></animate></circle>", 3);
+const _hoisted_5 = [
+  _hoisted_2
+];
+
+function _sfc_render(_ctx, _cache) {
+  return (openBlock(), createElementBlock("svg", _hoisted_1, _hoisted_5))
+}
+var LoaderDotsIcon = /*#__PURE__*/_export_sfc(_sfc_main, [['render',_sfc_render]]);
+
+export { LoaderDotsIcon as default };

package/src/components/button/index.vue.js

@@ -0,0 +1,10 @@
+import Button from './Button.vue.js';
+export { default as Button } from './Button.vue.js';
+import IconButton from './IconButton.vue.js';
+export { default as IconButton } from './IconButton.vue.js';
+import ScrollButton from './ScrollButton.vue.js';
+export { default as ScrollButton } from './ScrollButton.vue.js';
+
+const ButtonTypes = () => [Button, IconButton, ScrollButton];
+
+export { ButtonTypes };

package/src/components/checkbox/Checkbox.vue.js

@@ -0,0 +1,111 @@
+import { defineComponent, ref, computed, openBlock, createElementBlock, normalizeClass, createElementVNode, mergeProps, createVNode, unref, withCtx, createBlock, createCommentVNode, renderSlot, createTextVNode, toDisplayString, pushScopeId, popScopeId } from 'vue';
+import '../typography/Heading.vue.js';
+import Text from '../typography/Text.vue.js';
+import Icon from '../icon/Icon.vue.js';
+import Unchecked from './icons/unchecked.vue.js';
+import Checked from './icons/checked.vue.js';
+import Indeterminate from './icons/indeterminate.vue.js';
+import useIsFocusVisible from '../../composables/useIsFocusVisible.vue.js';
+import { useId } from '../../composables/useId.vue.js';
+/* empty css                                                          */import _export_sfc from '../../../_virtual/plugin-vue_export-helper.vue.js';
+
+////import "../../Checkbox.vue_vue_type_style_index_0_scoped_true_lang.css";
+const _withScopeId = (n) => (pushScopeId("data-v-2662240e"), n = n(), popScopeId(), n);
+const _hoisted_1 = { class: "checkboxes" };
+const _hoisted_2 = ["disabled", "checked", ".indeterminate"];
+const _hoisted_3 = /* @__PURE__ */ _withScopeId(() => /* @__PURE__ */ createElementVNode("span", { class: "checkbox__inner" }, null, -1));
+const _sfc_main = defineComponent({
+  __name: "Checkbox",
+  props: {
+    isChecked: { type: Boolean },
+    isIndeterminate: { type: Boolean },
+    disabled: { type: Boolean },
+    size: { default: "md" },
+    label: { default: "" }
+  },
+  emits: ["update:isChecked", "click"],
+  setup(__props, { emit }) {
+    const props = __props;
+    const checkbox = ref(null);
+    const id = `checkbox-${useId().value}`;
+    const {
+      isFocusVisibleRef,
+      onFocus: handleFocusVisible,
+      onBlur: handleBlurVisible
+    } = useIsFocusVisible();
+    const isFocusVisible = ref(false);
+    const handleFocus = (event) => {
+      handleFocusVisible(event);
+      if (isFocusVisibleRef.value === true) {
+        isFocusVisible.value = true;
+      }
+    };
+    const handleBlur = (event) => {
+      handleBlurVisible(event);
+      if (isFocusVisibleRef.value === false) {
+        isFocusVisible.value = false;
+      }
+    };
+    const indeterminate = computed(() => !props.isChecked && props.isIndeterminate);
+    const checked = computed(() => props.isChecked);
+    const unchecked = computed(() => !checked.value && !props.isIndeterminate);
+    const updateValue = (e) => {
+      emit("update:isChecked", e.target.checked);
+    };
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("label", {
+        for: id,
+        class: normalizeClass([[_ctx.size, { "focus-visible": isFocusVisible.value, disabled: _ctx.disabled }], "checkbox"])
+      }, [
+        createElementVNode("span", _hoisted_1, [
+          createElementVNode("input", mergeProps(_ctx.$attrs, {
+            id,
+            ref: checkbox.value,
+            disabled: _ctx.disabled,
+            checked: checked.value,
+            class: "input",
+            ".indeterminate": indeterminate.value,
+            type: "checkbox",
+            onBlur: handleBlur,
+            onFocus: handleFocus,
+            onClick: _cache[0] || (_cache[0] = ($event) => emit("click", $event)),
+            onInput: updateValue
+          }), null, 16, _hoisted_2),
+          _hoisted_3,
+          createVNode(unref(Icon), { "font-size": _ctx.size }, {
+            default: withCtx(() => [
+              checked.value ? (openBlock(), createBlock(Checked, {
+                key: 0,
+                class: "checkbox-icon checked"
+              })) : createCommentVNode("", true),
+              indeterminate.value ? (openBlock(), createBlock(Indeterminate, {
+                key: 1,
+                class: "checkbox-icon indeterminate"
+              })) : createCommentVNode("", true),
+              unchecked.value && !indeterminate.value ? (openBlock(), createBlock(Unchecked, {
+                key: 2,
+                class: "checkbox-icon unchecked"
+              })) : createCommentVNode("", true)
+            ]),
+            _: 1
+          }, 8, ["font-size"])
+        ]),
+        _ctx.label || _ctx.$slots.default ? (openBlock(), createBlock(unref(Text), {
+          key: 0,
+          size: _ctx.size,
+          class: "checkbox-text"
+        }, {
+          default: withCtx(() => [
+            renderSlot(_ctx.$slots, "default", {}, () => [
+              createTextVNode(toDisplayString(_ctx.label), 1)
+            ], true)
+          ]),
+          _: 3
+        }, 8, ["size"])) : createCommentVNode("", true)
+      ], 2);
+    };
+  }
+});
+var Checkbox = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-2662240e"]]);
+
+export { Checkbox as default };

package/src/components/checkbox/icons/checked.vue.js

@@ -0,0 +1,34 @@
+import { openBlock, createElementBlock, createElementVNode } from 'vue';
+import _export_sfc from '../../../../_virtual/plugin-vue_export-helper.vue.js';
+
+////import "../../Checked.vue_vue_type_style_index_0_scoped_true_lang.css";
+const _sfc_main = {};
+
+const _hoisted_1 = {
+  viewBox: "0 0 16 16",
+  fill: "none",
+  xmlns: "http://www.w3.org/2000/svg"
+};
+const _hoisted_2 = /*#__PURE__*/createElementVNode("rect", {
+  width: "16",
+  height: "16",
+  rx: "4",
+  fill: "currentColor"
+}, null, -1);
+const _hoisted_3 = /*#__PURE__*/createElementVNode("path", {
+  "fill-rule": "evenodd",
+  "clip-rule": "evenodd",
+  d: "M7.10356 11.8625L12.8536 6.46499C13.0488 6.28171 13.0488 5.98452 12.8536 5.80124L12.1465 5.13748C11.9512 4.95417 11.6346 4.95417 11.4393 5.13748L6.75 9.53936L4.56066 7.48422C4.36541 7.30093 4.04881 7.30093 3.85353 7.48422L3.14644 8.14797C2.95119 8.33125 2.95119 8.62844 3.14644 8.81172L6.39644 11.8625C6.59172 12.0458 6.90828 12.0458 7.10356 11.8625Z",
+  fill: "white"
+}, null, -1);
+const _hoisted_4 = [
+  _hoisted_2,
+  _hoisted_3
+];
+
+function _sfc_render(_ctx, _cache) {
+  return (openBlock(), createElementBlock("svg", _hoisted_1, _hoisted_4))
+}
+var Checked = /*#__PURE__*/_export_sfc(_sfc_main, [['render',_sfc_render]]);
+
+export { Checked as default };

package/src/components/checkbox/icons/indeterminate.vue.js

@@ -0,0 +1,35 @@
+import { openBlock, createElementBlock, createElementVNode } from 'vue';
+import _export_sfc from '../../../../_virtual/plugin-vue_export-helper.vue.js';
+
+////import "../../Indeterminate.vue_vue_type_style_index_0_scoped_true_lang.css";
+const _sfc_main = {};
+
+const _hoisted_1 = {
+  viewBox: "0 0 16 16",
+  fill: "none",
+  xmlns: "http://www.w3.org/2000/svg"
+};
+const _hoisted_2 = /*#__PURE__*/createElementVNode("rect", {
+  width: "16",
+  height: "16",
+  rx: "4",
+  fill: "currentColor"
+}, null, -1);
+const _hoisted_3 = /*#__PURE__*/createElementVNode("rect", {
+  x: "4",
+  y: "7",
+  width: "8",
+  height: "2",
+  fill: "white"
+}, null, -1);
+const _hoisted_4 = [
+  _hoisted_2,
+  _hoisted_3
+];
+
+function _sfc_render(_ctx, _cache) {
+  return (openBlock(), createElementBlock("svg", _hoisted_1, _hoisted_4))
+}
+var Indeterminate = /*#__PURE__*/_export_sfc(_sfc_main, [['render',_sfc_render]]);
+
+export { Indeterminate as default };