@ironsource/shared-ui 1.4.2-vite.1 → 1.4.3-andyk.1

package/components/snackbar/Snackbar.vue.js

@@ -1,6 +1,181 @@
-import o from "./Snackbar.vue2.js";
-/* empty css               */import r from "../../_virtual/_plugin-vue_export-helper.js";
-const d = /* @__PURE__ */ r(o, [["__scopeId", "data-v-e5d8edd0"]]);
-export {
-  d as default
-};
+import { defineComponent, ref, computed, onMounted, openBlock, createBlock, Transition, withCtx, withDirectives, createElementVNode, normalizeClass, unref, normalizeStyle, createElementBlock, createVNode, resolveDynamicComponent, createCommentVNode, toDisplayString, renderSlot, createTextVNode, vShow, withModifiers } from 'vue';
+import { useEventListener, useTimeoutFn } from '@vueuse/core';
+import Icon from '../icon/Icon.vue.js';
+import Close from '../icon/icons/Close.vue.js';
+import Check from '../icon/icons/Check.vue.js';
+import IconButton from '../button/IconButton.vue.js';
+import Text from '../typography/Text.vue.js';
+/* empty css                                                          */import _export_sfc from '../../_virtual/plugin-vue_export-helper.vue.js';
+
+import "../../Snackbar.vue_vue_type_style_index_0_scoped_true_lang.css";
+const _hoisted_1 = ["id"];
+const _hoisted_2 = { class: "container" };
+const _hoisted_3 = { class: "texts" };
+const _hoisted_4 = ["innerHTML"];
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "Snackbar",
+  props: {
+    customClass: null,
+    dangerouslyUseHTMLString: { type: Boolean },
+    duration: { default: 3e3 },
+    icon: null,
+    id: null,
+    message: null,
+    offset: null,
+    onClick: null,
+    onClose: null,
+    type: { default: null },
+    position: { default: "top-right" },
+    showClose: { type: Boolean, default: true },
+    title: { default: "" },
+    zIndex: { default: 0 }
+  },
+  emits: ["destroy"],
+  setup(__props) {
+    const props = __props;
+    const TypeComponentsMap = {
+      success: Check,
+      error: Close
+    };
+    const visible = ref(false);
+    let timer = void 0;
+    const typeClass = computed(() => {
+      const type = props.type;
+      return type && TypeComponentsMap[props.type] ? type : "";
+    });
+    const iconComponent = computed(() => {
+      return TypeComponentsMap[props.type] || props.icon || "";
+    });
+    const horizontalClass = computed(
+      () => props.position.endsWith("right") ? "right" : "left"
+    );
+    const verticalProperty = computed(
+      () => props.position.startsWith("top") ? "top" : "bottom"
+    );
+    const positionStyle = computed(() => {
+      return {
+        [verticalProperty.value]: `${props.offset}px`,
+        zIndex: props.zIndex
+      };
+    });
+    function startTimer() {
+      if (props.duration > 0) {
+        ({ stop: timer } = useTimeoutFn(() => {
+          if (visible.value)
+            close();
+        }, props.duration));
+      }
+    }
+    function clearTimer() {
+      timer?.();
+    }
+    function close() {
+      visible.value = false;
+    }
+    function onKeydown({ code }) {
+      if (code === "Delete" || code === "Backspace") {
+        clearTimer();
+      } else if (code === "Escape") {
+        if (visible.value) {
+          close();
+        }
+      } else {
+        startTimer();
+      }
+    }
+    onMounted(() => {
+      startTimer();
+      visible.value = true;
+    });
+    useEventListener(document, "keydown", onKeydown);
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(Transition, {
+        name: "snackbar",
+        onBeforeLeave: __props.onClose,
+        onAfterLeave: _cache[1] || (_cache[1] = ($event) => _ctx.$emit("destroy"))
+      }, {
+        default: withCtx(() => [
+          withDirectives(createElementVNode("div", {
+            id: __props.id,
+            class: normalizeClass(["snackbar", [__props.customClass, unref(horizontalClass)]]),
+            style: normalizeStyle(unref(positionStyle)),
+            role: "alert",
+            onMouseenter: clearTimer,
+            onMouseleave: startTimer,
+            onClick: _cache[0] || (_cache[0] = (...args) => __props.onClick && __props.onClick(...args))
+          }, [
+            unref(iconComponent) ? (openBlock(), createElementBlock("div", {
+              key: 0,
+              class: normalizeClass(["start-icon-container", [unref(typeClass)]])
+            }, [
+              createVNode(unref(Icon), {
+                "font-size": unref(typeClass) ? "sm" : "lg"
+              }, {
+                default: withCtx(() => [
+                  (openBlock(), createBlock(resolveDynamicComponent(unref(iconComponent))))
+                ]),
+                _: 1
+              }, 8, ["font-size"])
+            ], 2)) : createCommentVNode("", true),
+            createElementVNode("div", _hoisted_2, [
+              createElementVNode("div", _hoisted_3, [
+                __props.title ? (openBlock(), createBlock(Text, {
+                  key: 0,
+                  size: "md",
+                  strong: "",
+                  class: "title",
+                  textContent: toDisplayString(__props.title)
+                }, null, 8, ["textContent"])) : createCommentVNode("", true),
+                withDirectives(createElementVNode("div", {
+                  class: "message",
+                  style: normalizeStyle(!!__props.title ? void 0 : { margin: 0 })
+                }, [
+                  renderSlot(_ctx.$slots, "default", {}, () => [
+                    !__props.dangerouslyUseHTMLString ? (openBlock(), createBlock(Text, {
+                      key: 0,
+                      size: "sm"
+                    }, {
+                      default: withCtx(() => [
+                        createTextVNode(toDisplayString(__props.message), 1)
+                      ]),
+                      _: 1
+                    })) : (openBlock(), createElementBlock("div", {
+                      key: 1,
+                      innerHTML: __props.message
+                    }, null, 8, _hoisted_4))
+                  ], true)
+                ], 4), [
+                  [vShow, __props.message]
+                ])
+              ]),
+              __props.showClose ? (openBlock(), createBlock(IconButton, {
+                key: 0,
+                theme: "third",
+                size: "sm",
+                class: "snackbar-close-button",
+                variant: "colorized",
+                onClick: withModifiers(close, ["stop"])
+              }, {
+                default: withCtx(() => [
+                  createVNode(unref(Icon), null, {
+                    default: withCtx(() => [
+                      createVNode(Close)
+                    ]),
+                    _: 1
+                  })
+                ]),
+                _: 1
+              }, 8, ["onClick"])) : createCommentVNode("", true)
+            ])
+          ], 46, _hoisted_1), [
+            [vShow, visible.value]
+          ])
+        ]),
+        _: 3
+      }, 8, ["onBeforeLeave"]);
+    };
+  }
+});
+var SnackbarConstructor = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-764ab56b"]]);
+
+export { SnackbarConstructor as default };

package/components/snackbar/index.vue.js

@@ -0,0 +1,5 @@
+import notify from './notify.vue.js';
+
+const Snackbar = notify;
+
+export { Snackbar, Snackbar as default };

package/components/snackbar/notify.vue.js

@@ -0,0 +1,106 @@
+import { isVNode, createVNode, render } from 'vue';
+import SnackbarConstructor from './Snackbar.vue.js';
+import { snackbarTypes } from './snackbar.types.vue.js';
+
+const notifications = {
+  "top-left": [],
+  "top-right": [],
+  "bottom-left": [],
+  "bottom-right": []
+};
+const SNACKBAR_GAP_SIZE = 16;
+let seed = 1;
+const defaultZIndex = 2e3;
+const notify = function(options = {}, context = null) {
+  if (typeof options === "string" || isVNode(options)) {
+    options = { message: options };
+  }
+  const position = options.position || "top-right";
+  let zIndex = options.zIndex || defaultZIndex;
+  let verticalOffset = notifications[position].reduce(
+    (verticalOffset2, { vm: vm2 }) => verticalOffset2 + (vm2.el?.offsetHeight || 0) + SNACKBAR_GAP_SIZE,
+    options.offset || 0
+  );
+  verticalOffset += SNACKBAR_GAP_SIZE;
+  const nextZIndex = () => zIndex++;
+  const id = `notification_${seed++}`;
+  const userOnClose = options.onClose;
+  const props = {
+    ...options,
+    zIndex: nextZIndex(),
+    offset: verticalOffset,
+    id,
+    onClose: () => {
+      close(id, position, userOnClose);
+    }
+  };
+  const appendTo = document.body;
+  const container = document.createElement("div");
+  const vm = createVNode(
+    SnackbarConstructor,
+    props,
+    isVNode(props.message) ? {
+      default: () => props.message
+    } : null
+  );
+  vm.appContext = context ?? notify._context;
+  vm.props.onDestroy = () => {
+    render(null, container);
+  };
+  render(vm, container);
+  notifications[position].push({ vm });
+  appendTo.appendChild(container?.firstElementChild);
+  return {
+    close: () => {
+      const proxy = vm.component?.proxy;
+      if (proxy)
+        proxy.visible = false;
+    }
+  };
+};
+function close(id, position, userOnClose) {
+  const orientedNotifications = notifications[position];
+  const activeNotificationIndex = orientedNotifications.findIndex(
+    ({ vm: vm2 }) => vm2.component?.props.id === id
+  );
+  if (activeNotificationIndex === -1)
+    return;
+  const { vm } = orientedNotifications[activeNotificationIndex];
+  if (!vm)
+    return;
+  userOnClose?.(vm);
+  const removedHeight = vm.el?.offsetHeight;
+  const verticalPos = position.split("-")[0];
+  orientedNotifications.splice(activeNotificationIndex, 1);
+  const len = orientedNotifications.length;
+  for (let i = activeNotificationIndex; i < len; i++) {
+    const { el, component } = orientedNotifications[i].vm;
+    component.props.offset = Number.parseInt(el.style[verticalPos], 10) - removedHeight - SNACKBAR_GAP_SIZE;
+  }
+}
+snackbarTypes.forEach((type) => {
+  notify[type] = (options = {}) => {
+    if (typeof options === "string" || isVNode(options)) {
+      options = {
+        message: options
+      };
+    }
+    return notify({
+      ...options,
+      type
+    });
+  };
+});
+function closeAll() {
+  for (const orientedNotifications of Object.values(notifications)) {
+    orientedNotifications.forEach(({ vm }) => {
+      const proxy = vm.component?.proxy;
+      if (proxy)
+        proxy.visible = false;
+    });
+  }
+}
+notify.closeAll = closeAll;
+notify._context = null;
+
+export { close, closeAll, notify as default };

package/components/snackbar/snackbar.types.vue.js

@@ -0,0 +1,6 @@
+const snackbarEmits = {
+  destroy: () => true
+};
+const snackbarTypes = ["success", "info", "error"];
+
+export { snackbarEmits, snackbarTypes };

package/components/switch/Switch.vue.d.ts

@@ -1,42 +1,37 @@
-declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{
-    size: {
-        type: import("vue").PropType<"sm" | "lg">;
-        default: string;
-    };
-    options: {
-        type: import("vue").PropType<string[]>;
-        required: true;
-    };
-    modelValue: {
-        type: import("vue").PropType<string>;
-        required: true;
-    };
-}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
-    size: {
-        type: import("vue").PropType<"sm" | "lg">;
-        default: string;
-    };
-    options: {
-        type: import("vue").PropType<string[]>;
-        required: true;
-    };
-    modelValue: {
-        type: import("vue").PropType<string>;
-        required: true;
-    };
-}>> & {
+declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
+    options: string[];
+    modelValue: string;
+    size?: 'sm' | 'lg';
+    testId?: string;
+}>, {
+    size: string;
+    testId: string;
+}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
+    options: string[];
+    modelValue: string;
+    size?: 'sm' | 'lg';
+    testId?: string;
+}>, {
+    size: string;
+    testId: string;
+}>>> & {
     "onUpdate:modelValue"?: (...args: any[]) => any;
 }, {
-    size: "sm" | "lg";
-}>, {
-    default?(_: {
-        option: string;
-        selected: boolean;
-    }): any;
+    size: 'sm' | 'lg';
+    testId: string;
 }>;
 export default _default;
-type __VLS_WithTemplateSlots<T, S> = T & {
-    new (): {
-        $slots: S;
+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/switch/Switch.vue.js

@@ -1,6 +1,87 @@
-import o from "./Switch.vue2.js";
-/* empty css             */import t from "../../_virtual/_plugin-vue_export-helper.js";
-const p = /* @__PURE__ */ t(o, [["__scopeId", "data-v-08a704b0"]]);
-export {
-  p as default
-};
+import { defineComponent, ref, computed, onMounted, openBlock, createElementBlock, normalizeClass, unref, createElementVNode, normalizeStyle, Fragment, renderList, renderSlot, createVNode, withCtx, createTextVNode, toDisplayString } from 'vue';
+import { useVModel } from '@vueuse/core';
+import Text from '../typography/Text.vue.js';
+import { SwitchTestIdModifiers } from '../../testids/index.vue.js';
+/* empty css                                                        */import _export_sfc from '../../_virtual/plugin-vue_export-helper.vue.js';
+
+import "../../Switch.vue_vue_type_style_index_0_scoped_true_lang.css";
+const _hoisted_1 = ["data-testid"];
+const _hoisted_2 = ["aria-label", "data-testid", "onClick"];
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "Switch",
+  props: {
+    options: null,
+    modelValue: null,
+    size: { default: "lg" },
+    testId: { default: "" }
+  },
+  emits: ["update:modelValue"],
+  setup(__props, { emit }) {
+    const props = __props;
+    const box = ref(null);
+    const data = useVModel(props, "modelValue", emit);
+    const optionsRefs = ref([]);
+    const skipUnwrap = { optionsRefs };
+    const selected = ref();
+    const selectedPosition = computed(() => {
+      return {
+        left: optionsRefs.value[selected.value]?.offsetLeft,
+        width: optionsRefs.value[selected.value]?.offsetWidth
+      };
+    });
+    onMounted(() => {
+      selected.value = props.options.findIndex(
+        (option) => option === props.modelValue
+      );
+    });
+    const onClick = (option, index) => {
+      selected.value = index;
+      data.value = option;
+    };
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass(["switch", { "switch--lg": __props.size === "lg", "switch--sm": __props.size === "sm" }]),
+        "data-testid": `${__props.testId}-${unref(SwitchTestIdModifiers).WRAPPER}`
+      }, [
+        createElementVNode("span", {
+          ref_key: "box",
+          ref: box,
+          class: normalizeClass(["box", { "box--lg": __props.size === "lg", "box--sm": __props.size === "sm" }]),
+          style: normalizeStyle({
+            transform: `translateX(${unref(selectedPosition)?.left}px)`,
+            width: unref(selectedPosition)?.width + "px"
+          })
+        }, null, 6),
+        (openBlock(true), createElementBlock(Fragment, null, renderList(__props.options, (option, index) => {
+          return openBlock(), createElementBlock("button", {
+            ref_for: true,
+            ref: skipUnwrap.optionsRefs,
+            key: index,
+            "aria-label": option,
+            class: normalizeClass([{ "option--selected": selected.value === index }, "option"]),
+            "data-testid": `${__props.testId}-${unref(SwitchTestIdModifiers).BUTTON}`,
+            onClick: ($event) => onClick(option, index)
+          }, [
+            renderSlot(_ctx.$slots, "default", {
+              option,
+              selected: selected.value === index
+            }, () => [
+              createVNode(Text, {
+                size: "caption",
+                "data-testid": `${__props.testId}-${unref(SwitchTestIdModifiers).TEXT}`
+              }, {
+                default: withCtx(() => [
+                  createTextVNode(toDisplayString(option), 1)
+                ]),
+                _: 2
+              }, 1032, ["data-testid"])
+            ], true)
+          ], 10, _hoisted_2);
+        }), 128))
+      ], 10, _hoisted_1);
+    };
+  }
+});
+var Switch = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-5a16f3a6"]]);
+
+export { Switch as default };

package/components/switch/index.d.ts

@@ -1,97 +1,31 @@
-declare const SwitchTypes: () => ({
-    new (...args: any[]): {
-        $: import("vue").ComponentInternalInstance;
-        $data: {};
-        $props: Partial<{
-            size: "sm" | "lg";
-        }> & Omit<Readonly<import("vue").ExtractPropTypes<{
-            size: {
-                type: import("vue").PropType<"sm" | "lg">;
-                default: string;
-            };
-            options: {
-                type: import("vue").PropType<string[]>;
-                required: true;
-            };
-            modelValue: {
-                type: import("vue").PropType<string>;
-                required: true;
-            };
-        }>> & {
-            "onUpdate:modelValue"?: (...args: any[]) => any;
-        } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "size">;
-        $attrs: {
-            [x: string]: unknown;
-        };
-        $refs: {
-            [x: string]: unknown;
-        };
-        $slots: Readonly<{
-            [name: string]: import("vue").Slot;
-        }>;
-        $root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>;
-        $parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>;
-        $emit: (event: "update:modelValue", ...args: any[]) => void;
-        $el: any;
-        $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
-            size: {
-                type: import("vue").PropType<"sm" | "lg">;
-                default: string;
-            };
-            options: {
-                type: import("vue").PropType<string[]>;
-                required: true;
-            };
-            modelValue: {
-                type: import("vue").PropType<string>;
-                required: true;
-            };
-        }>> & {
-            "onUpdate:modelValue"?: (...args: any[]) => any;
-        }, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:modelValue"[], string, {
-            size: "sm" | "lg";
-        }, {}, string> & {
-            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<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>, 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_0: R, args_1: R) => any : (...args: any) => any, options?: import("vue").WatchOptions<boolean>): import("vue").WatchStopHandle;
-    } & Readonly<import("vue").ExtractPropTypes<{
-        size: {
-            type: import("vue").PropType<"sm" | "lg">;
-            default: string;
-        };
-        options: {
-            type: import("vue").PropType<string[]>;
-            required: true;
-        };
-        modelValue: {
-            type: import("vue").PropType<string>;
-            required: true;
-        };
-    }>> & {
-        "onUpdate:modelValue"?: (...args: any[]) => any;
-    } & import("vue").ShallowUnwrapRef<{}> & {} & import("vue").ComponentCustomProperties & {};
-    __isFragment?: never;
-    __isTeleport?: never;
-    __isSuspense?: never;
-} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+declare const SwitchTypes: () => import("vue").DefineComponent<{
     size: {
         type: import("vue").PropType<"sm" | "lg">;
+    } & {
+        default: string;
+    };
+    testId: {
+        type: import("vue").PropType<string>;
+    } & {
+        default: string;
+    };
+    options: {
+        type: import("vue").PropType<string[]>;
+        required: true;
+    };
+    modelValue: {
+        type: import("vue").PropType<string>;
+        required: true;
+    };
+}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    size: {
+        type: import("vue").PropType<"sm" | "lg">;
+    } & {
+        default: string;
+    };
+    testId: {
+        type: import("vue").PropType<string>;
+    } & {
         default: string;
     };
     options: {
@@ -104,15 +38,9 @@ declare const SwitchTypes: () => ({
     };
 }>> & {
     "onUpdate:modelValue"?: (...args: any[]) => any;
-}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", {
+}, {
     size: "sm" | "lg";
-}, {}, string> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
-    $slots: {
-        default?(_: {
-            option: string;
-            selected: boolean;
-        }): any;
-    };
-}))[];
+    testId: string;
+}>[];
 export { default as Switch } from './Switch.vue';
 export { SwitchTypes };

package/components/switch/index.vue.js

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

package/components/table/SortOrderIcon.vue.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}>;
+declare const _default: any;
 export default _default;

package/components/table/SortOrderIcon.vue.js

@@ -1,21 +1,28 @@
-import { openBlock as o, createElementBlock as t, pushScopeId as c, popScopeId as r, createElementVNode as n } from "vue";
-/* empty css                    */import d from "../../_virtual/_plugin-vue_export-helper.js";
-const s = {}, _ = (e) => (c("data-v-eaa4d6ee"), e = e(), r(), e), a = {
+import { openBlock, createElementBlock, pushScopeId, popScopeId, createElementVNode } from 'vue';
+/* empty css                                                               */import _export_sfc from '../../_virtual/plugin-vue_export-helper.vue.js';
+
+import "../../SortOrderIcon.vue_vue_type_style_index_0_scoped_true_lang.css";
+const _sfc_main = {};
+
+const _withScopeId = n => (pushScopeId("data-v-14ef12bc"),n=n(),popScopeId(),n);
+const _hoisted_1 = {
   width: "8",
   height: "4",
   viewBox: "0 0 8 4",
   fill: "none",
   xmlns: "http://www.w3.org/2000/svg"
-}, p = /* @__PURE__ */ _(() => /* @__PURE__ */ n("path", {
+};
+const _hoisted_2 = /*#__PURE__*/ _withScopeId(() => /*#__PURE__*/createElementVNode("path", {
   d: "M7.94188 3.66979L4.21022 0.0771272C4.1034 -0.0257091 3.89773 -0.0257091 3.78978 0.0771272L0.0581151 3.66979C-0.0805157 3.80376 0.0444792 4 0.268334 4H7.73167C7.95552 4 8.08052 3.80376 7.94188 3.66979Z",
   fill: "currentColor"
-}, null, -1)), i = [
-  p
+}, null, -1));
+const _hoisted_3 = [
+  _hoisted_2
 ];
-function l(e, h) {
-  return o(), t("svg", a, i);
+
+function _sfc_render(_ctx, _cache) {
+  return (openBlock(), createElementBlock("svg", _hoisted_1, _hoisted_3))
 }
-const u = /* @__PURE__ */ d(s, [["render", l], ["__scopeId", "data-v-eaa4d6ee"]]);
-export {
-  u as default
-};
+var SortOrderIcon = /*#__PURE__*/_export_sfc(_sfc_main, [['render',_sfc_render],['__scopeId',"data-v-14ef12bc"]]);
+
+export { SortOrderIcon as default };