@ironsource/shared-ui 1.4.0-rc.10

package/components/autocompleteDropdown/index.d.ts

@@ -0,0 +1,82 @@
+declare const AutocompleteDropdownTypes: () => import("vue").DefineComponent<{
+    selected: {
+        type: import("vue").PropType<unknown[]>;
+    } & {
+        default: () => any[];
+    };
+    options: {
+        type: import("vue").PropType<unknown[]>;
+        required: true;
+    } & {
+        default: () => any[];
+    };
+    placeholder: {
+        type: import("vue").PropType<string>;
+        required: true;
+    } & {
+        default: string;
+    };
+    displayValue: {
+        type: import("vue").PropType<(option: unknown) => string>;
+        required: true;
+    } & {
+        default: (option: unknown) => string;
+    };
+    handleSearch: {
+        type: import("vue").PropType<(option: any, term: string) => boolean>;
+    } & {
+        default: () => true;
+    };
+    grouped: {
+        type: import("vue").PropType<boolean>;
+    } & {
+        default: boolean;
+    };
+}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:selected": (value: unknown) => void;
+}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    selected: {
+        type: import("vue").PropType<unknown[]>;
+    } & {
+        default: () => any[];
+    };
+    options: {
+        type: import("vue").PropType<unknown[]>;
+        required: true;
+    } & {
+        default: () => any[];
+    };
+    placeholder: {
+        type: import("vue").PropType<string>;
+        required: true;
+    } & {
+        default: string;
+    };
+    displayValue: {
+        type: import("vue").PropType<(option: unknown) => string>;
+        required: true;
+    } & {
+        default: (option: unknown) => string;
+    };
+    handleSearch: {
+        type: import("vue").PropType<(option: any, term: string) => boolean>;
+    } & {
+        default: () => true;
+    };
+    grouped: {
+        type: import("vue").PropType<boolean>;
+    } & {
+        default: boolean;
+    };
+}>> & {
+    "onUpdate:selected"?: (value: unknown) => any;
+}, {
+    selected: unknown[];
+    options: unknown[];
+    placeholder: string;
+    displayValue: (option: unknown) => string;
+    handleSearch: (option: any, term: string) => boolean;
+    grouped: boolean;
+}>[];
+export { default as AutocompleteDropdown } from './AutocompleteDropdown.vue';
+export { AutocompleteDropdownTypes };

package/components/autocompleteDropdown/index.vue.js

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

package/components/autocompleteDropdown/stubs.d.ts

@@ -0,0 +1,21 @@
+type OptionStub = {
+    id: number | string;
+    label: string;
+    group?: boolean;
+};
+export declare const options: OptionStub[];
+export declare const optionsWithGroups: {
+    label: string;
+    options: {
+        id: number;
+        label: string;
+    }[];
+}[];
+export declare const countryOptions: {
+    label: string;
+    options: {
+        code: string;
+        label: string;
+    }[];
+}[];
+export {};

package/components/autocompleteDropdown/useKeyboardNavigation.d.ts

@@ -0,0 +1,13 @@
+import { Ref } from 'vue';
+type UseKeyboardNavArgs = {
+    options: Ref<unknown[]>;
+    canFocus: (option: unknown) => boolean;
+    scrollTo: (index: number) => void;
+    selectItem: (option: unknown) => void;
+};
+type useKeyboardNavResult = {
+    isFocused: (option: unknown) => boolean;
+    keyDownHandler: (e: Event) => void;
+};
+export declare const useKeyboardNavigation: ({ options, canFocus, scrollTo, selectItem, }: UseKeyboardNavArgs) => useKeyboardNavResult;
+export {};

package/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/components/button/Button.vue.d.ts

@@ -0,0 +1,37 @@
+import { IconName } from '@/components/icon';
+declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
+    leftIconName?: IconName;
+    rightIconName?: IconName;
+    size?: 'sm' | 'md' | 'lg';
+}>, {
+    leftIconName: any;
+    rightIconName: any;
+    size: string;
+}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
+    leftIconName?: IconName;
+    rightIconName?: IconName;
+    size?: 'sm' | 'md' | 'lg';
+}>, {
+    leftIconName: any;
+    rightIconName: any;
+    size: string;
+}>>>, {
+    size: 'sm' | 'md' | 'lg';
+    leftIconName: IconName;
+    rightIconName: IconName;
+}>;
+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 ? P[K] & {
+        default: D[K];
+    } : P[K];
+};

package/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 = /* @__PURE__ */ 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: [
+          __props.size,
+          {
+            "with-left-icon": !!__props.leftIconName,
+            "with-right-icon": !!__props.rightIconName
+          }
+        ],
+        size: __props.size
+      }, _ctx.$attrs), createSlots({
+        default: withCtx(() => [
+          createElementVNode("div", {
+            class: normalizeClass({
+              flex: __props.leftIconName || __props.rightIconName
+            })
+          }, [
+            __props.leftIconName ? (openBlock(), createBlock(unref(Icon), {
+              key: 0,
+              name: __props.leftIconName,
+              "font-size": unref(computedIconWidth)
+            }, null, 8, ["name", "font-size"])) : createCommentVNode("", true),
+            renderSlot(_ctx.$slots, "default", {}, void 0, true),
+            __props.rightIconName ? (openBlock(), createBlock(unref(Icon), {
+              key: 1,
+              name: __props.rightIconName,
+              "font-size": unref(computedIconWidth)
+            }, 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/components/button/ButtonBase.vue.d.ts

@@ -0,0 +1,48 @@
+declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
+    size?: 'xs' | 'sm' | 'md' | 'lg';
+    variant?: 'solid' | 'border' | 'borderless' | 'ghost' | 'link' | 'colorized';
+    theme?: 'primary' | 'secondary' | 'third' | 'danger';
+    loading?: boolean;
+    isTruncated?: boolean;
+    strong?: boolean;
+}>, {
+    size: string;
+    variant: string;
+    theme: string;
+    loading: boolean;
+    strong: boolean;
+}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
+    size?: 'xs' | 'sm' | 'md' | 'lg';
+    variant?: 'solid' | 'border' | 'borderless' | 'ghost' | 'link' | 'colorized';
+    theme?: 'primary' | 'secondary' | 'third' | 'danger';
+    loading?: boolean;
+    isTruncated?: boolean;
+    strong?: boolean;
+}>, {
+    size: string;
+    variant: string;
+    theme: string;
+    loading: boolean;
+    strong: boolean;
+}>>>, {
+    size: 'xs' | 'sm' | 'md' | 'lg';
+    strong: boolean;
+    variant: 'solid' | 'border' | 'borderless' | 'ghost' | 'link' | 'colorized';
+    theme: 'primary' | 'secondary' | 'third' | 'danger';
+    loading: boolean;
+}>;
+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 ? P[K] & {
+        default: D[K];
+    } : P[K];
+};

package/components/button/ButtonBase.vue.js

@@ -0,0 +1,63 @@
+import { defineComponent, computed, openBlock, createElementBlock, mergeProps, renderSlot, createVNode, unref, withCtx, createCommentVNode } from 'vue';
+/* empty css                                                                     */import _export_sfc from '../../_virtual/plugin-vue_export-helper.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 "../../ButtonBase.vue_vue_type_style_index_0_scoped_true_lang.css";
+const _hoisted_1 = { key: 0 };
+const _sfc_main = /* @__PURE__ */ 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 loaderWidthLargeInPixel = 32;
+    const loaderWidthMedSmallInPixel = 24;
+    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: [[__props.size, __props.theme, __props.variant, { loading: __props.loading }], "button-wrap"]
+      }, _ctx.$attrs), [
+        !__props.loading ? (openBlock(), createElementBlock("span", _hoisted_1, [
+          renderSlot(_ctx.$slots, "content", {}, () => [
+            createVNode(unref(Text), {
+              size: unref(textSize),
+              strong: __props.strong,
+              class: "content"
+            }, {
+              default: withCtx(() => [
+                renderSlot(_ctx.$slots, "default", {}, void 0, true)
+              ]),
+              _: 3
+            }, 8, ["size", "strong"])
+          ], true)
+        ])) : createCommentVNode("", true),
+        __props.loading ? renderSlot(_ctx.$slots, "loader", { key: 1 }, () => [
+          createVNode(unref(Icon), {
+            "font-size": unref(loaderWidth),
+            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/components/button/IconButton.vue.d.ts

@@ -0,0 +1,31 @@
+declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
+    size?: 'sm' | 'md' | 'lg';
+    variant?: 'solid' | 'border' | 'borderless' | 'ghost' | 'link' | 'colorized';
+}>, {
+    variant: string;
+    size: string;
+}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
+    size?: 'sm' | 'md' | 'lg';
+    variant?: 'solid' | 'border' | 'borderless' | 'ghost' | 'link' | 'colorized';
+}>, {
+    variant: string;
+    size: string;
+}>>>, {
+    size: 'sm' | 'md' | 'lg';
+    variant: 'solid' | 'border' | 'borderless' | 'ghost' | 'link' | 'colorized';
+}>;
+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 ? P[K] & {
+        default: D[K];
+    } : P[K];
+};

package/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 = /* @__PURE__ */ 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: __props.size,
+        "is-truncated": false
+      }, _ctx.$attrs, {
+        variant: __props.variant,
+        class: "icon-base"
+      }), {
+        content: withCtx(() => [
+          createElementVNode("div", {
+            class: normalizeClass(["icon", { [__props.size]: true, [__props.variant]: true }])
+          }, [
+            renderSlot(_ctx.$slots, "default", {}, void 0, true)
+          ], 2)
+        ]),
+        loader: withCtx(() => [
+          createVNode(unref(Icon), {
+            "font-size": unref(loaderSize),
+            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/components/button/ScrollButton.vue.d.ts

@@ -0,0 +1,43 @@
+declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
+    show?: boolean;
+    iconName?: string;
+    tooltipText?: string;
+    position?: 'bottom-right' | 'bottom-left' | 'top-right' | 'top-left';
+}>, {
+    show: boolean;
+    iconName: string;
+    tooltipText: string;
+    position: string;
+}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "scrolled"[], "scrolled", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
+    show?: boolean;
+    iconName?: string;
+    tooltipText?: string;
+    position?: 'bottom-right' | 'bottom-left' | 'top-right' | 'top-left';
+}>, {
+    show: boolean;
+    iconName: string;
+    tooltipText: string;
+    position: string;
+}>>> & {
+    onScrolled?: (...args: any[]) => any;
+}, {
+    show: boolean;
+    iconName: string;
+    tooltipText: string;
+    position: 'bottom-right' | 'bottom-left' | 'top-right' | 'top-left';
+}>;
+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 ? P[K] & {
+        default: D[K];
+    } : P[K];
+};

package/components/button/ScrollButton.vue.js

@@ -0,0 +1,48 @@
+import { defineComponent, openBlock, createBlock, unref, normalizeClass, withCtx, createVNode, createCommentVNode } from 'vue';
+import Icon from '../icon/Icon.vue.js';
+/* empty css                                                                     */import _export_sfc from '../../_virtual/plugin-vue_export-helper.vue.js';
+/* empty css                                                                  *//* empty css                                                            *//* empty css                                                        */import IconButton from './IconButton.vue.js';
+import _sfc_main$1 from '../tooltip/Tooltip.vue.js';
+/* empty css                                                              */
+import "../../ScrollButton.vue_vue_type_style_index_0_scoped_true_lang.css";
+const _sfc_main = /* @__PURE__ */ 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 __props.show ? (openBlock(), createBlock(unref(IconButton), {
+        key: 0,
+        class: normalizeClass(["scroll-button", __props.position]),
+        theme: "third",
+        variant: "borderless",
+        size: "lg",
+        onClick: onScroll
+      }, {
+        default: withCtx(() => [
+          createVNode(unref(_sfc_main$1), {
+            text: __props.tooltipText,
+            delay: 400
+          }, {
+            default: withCtx(() => [
+              createVNode(unref(Icon), { name: __props.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/components/button/consts.d.ts

@@ -0,0 +1,16 @@
+export declare const sizeToFont: {
+    lg: string;
+    md: string;
+    sm: string;
+};
+export type TextSize = 'md' | 'sm' | 'xs';
+export declare const iconSizeMap: {
+    lg: number;
+    md: number;
+    sm: number;
+};
+export declare const loaderSizeMap: {
+    lg: number;
+    md: number;
+    sm: number;
+};

package/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/components/button/icon/LoaderCircleIcon.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/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 };