@rotki/ui-library 1.3.0 → 1.5.0

package/dist/components/tabs/tab-item/RuiTabItem.vue.d.ts

@@ -5,46 +5,24 @@ export interface Props {
     reverse?: boolean;
 }
 declare function __VLS_template(): {
-    default?(_: {}): any;
-    default?(_: {}): any;
+    slots: {
+        default?(_: {}): any;
+        default?(_: {}): any;
+    };
+    refs: {};
+    attrs: Partial<{}>;
 };
-declare const __VLS_component: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<Props>, {
-    value: undefined;
-    eager: boolean;
-    active: boolean;
-    reverse: boolean;
-}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<globalThis.ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<Props>, {
-    value: undefined;
-    eager: boolean;
-    active: boolean;
-    reverse: boolean;
-}>>>, {
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{}>, {
     reverse: boolean;
     active: boolean;
     value: number | string;
     eager: boolean;
-}, {}>;
-declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;
-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;
     };
 };
-type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
-type __VLS_TypePropsToOption<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;
-    };
-};

package/dist/components/tabs/tab-items/RuiTabItems.vue.d.ts

@@ -1,24 +1,24 @@
 export interface Props<T> {
     modelValue?: T;
 }
-declare const _default: <T extends string | number>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_Prettify<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
-    props: __VLS_Prettify<Pick<Partial<{}> & Omit<{
-        "onUpdate:modelValue"?: ((modelValue: T | undefined) => any) | undefined;
-    } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & Readonly<globalThis.ExtractPropTypes<{}>> & {
-        "onUpdate:modelValue"?: ((modelValue: T | undefined) => any) | undefined;
-    }, never>, "onUpdate:modelValue"> & {
+declare const _default: <T extends string | number>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly "onUpdate:modelValue"?: ((modelValue: T | undefined) => any) | undefined;
+    } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, "onUpdate:modelValue"> & {
         modelValue?: Props<T>["modelValue"];
     }> & import("vue").PublicProps;
     expose(exposed: import("vue").ShallowUnwrapRef<{}>): void;
     attrs: any;
-    slots: ReturnType<() => {}>;
-    emit: (evt: "update:modelValue", modelValue: T | undefined) => void;
+    slots: {};
+    emit: {
+        'update:modelValue': [modelValue: Props<T>["modelValue"]];
+    };
 }>) => globalThis.VNode<import("vue").RendererNode, import("vue").RendererElement, {
     [key: string]: any;
 }> & {
     __ctx?: Awaited<typeof __VLS_setup>;
 };
 export default _default;
-type __VLS_Prettify<T> = {
+type __VLS_PrettifyLocal<T> = {
     [K in keyof T]: T[K];
 } & {};

package/dist/components/tabs/tabs/RuiTabs.vue.d.ts

@@ -6,48 +6,19 @@ export interface Props {
     grow?: boolean;
     modelValue?: number | string;
     align?: 'start' | 'center' | 'end';
+    indicatorPosition?: 'start' | 'end';
 }
-declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<Props>, {
-    color: undefined;
-    vertical: boolean;
-    disabled: boolean;
-    grow: boolean;
-    modelValue: undefined;
-    align: string;
-}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    "update:modelValue": (modelValue: string | number) => void;
-}, string, import("vue").PublicProps, Readonly<globalThis.ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<Props>, {
-    color: undefined;
-    vertical: boolean;
-    disabled: boolean;
-    grow: boolean;
-    modelValue: undefined;
-    align: string;
-}>>> & {
+declare const _default: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    "update:modelValue": (modelValue: string | number) => any;
+}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{
     "onUpdate:modelValue"?: ((modelValue: string | number) => any) | undefined;
-}, {
+}>, {
     vertical: boolean;
     color: ContextColorsType;
     disabled: boolean;
     modelValue: number | string;
     align: "start" | "center" | "end";
     grow: boolean;
-}, {}>;
+    indicatorPosition: "start" | "end";
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 export default _default;
-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_NonUndefinedable<T> = T extends undefined ? never : T;
-type __VLS_TypePropsToOption<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;
-    };
-};

package/dist/composables/dropdown-menu.d.ts

@@ -35,9 +35,9 @@ export declare function useDropdownMenu<TValue, TItem>({ appendWidth, autoFocus,
     };
     getIdentifier: (item: TItem) => TItem | TItem[KeyOfType<TItem, TValue extends (infer U)[] ? U : TValue>];
     getText: (item: TItem) => string | undefined;
-    highlightedIndex: Ref<number>;
+    highlightedIndex: Ref<number, number>;
     isActiveItem: (item: TItem) => boolean;
-    isOpen: Ref<boolean>;
+    isOpen: Ref<boolean, boolean>;
     itemIndexInValue: (item: TItem) => number;
     menuWidth: globalThis.ComputedRef<string>;
     moveHighlight: (up: boolean) => void;

package/dist/composables/icons.d.ts

@@ -1,5 +1,11 @@
 import type { GeneratedIcon } from '../types/icons';
-export declare const useIcons: () => {
-    registeredIcons: globalThis.Ref<Record<string, string>>;
-    registerIcons: (iconsToAdd: GeneratedIcon[]) => void;
-};
+import type { InjectionKey } from 'vue';
+export interface IconsOptions {
+    registeredIcons: GeneratedIcon[];
+}
+export interface UseIconsReturn {
+    registeredIcons: Readonly<Record<string, string>>;
+}
+export declare const IconsSymbol: InjectionKey<UseIconsReturn>;
+export declare function createIconDefaults(options?: Partial<IconsOptions>): UseIconsReturn;
+export declare function useIcons(): UseIconsReturn;

package/dist/composables/index--ZwAZVMb.js

@@ -0,0 +1,482 @@
+import { RiArrowDownLine as ie, RiArrowDropDownFill as se, RiArrowLeftDoubleLine as re, RiArrowLeftLine as ce, RiArrowLeftSLine as ae, RiArrowRightDoubleLine as le, RiArrowRightLine as fe, RiArrowRightSLine as ue, RiExpandUpDownLine as de } from "../icons/icons_1.es.js";
+import { RiDatabase2Line as pe } from "../icons/icons_2.es.js";
+import { RiAlertFill as me, RiAlertLine as he, RiCheckLine as ge, RiCheckboxBlankCircleFill as ye, RiCheckboxBlankCircleLine as we, RiCheckboxBlankLine as be, RiCheckboxCircleFill as Re, RiCheckboxCircleLine as Le, RiCheckboxFill as xe, RiCheckboxIndeterminateFill as Ce, RiCloseCircleLine as ve, RiCloseFill as Se, RiCloseLine as Te, RiErrorWarningFill as Ee, RiErrorWarningLine as ke, RiEyeLine as Ie, RiEyeOffLine as Pe, RiInformationFill as De, RiInformationLine as Oe } from "../icons/icons_5.es.js";
+import { RiRadioButtonLine as Ae, RiMoreFill as $e } from "../icons/icons_6.es.js";
+import { inject as ee, ref as h, computed as B, watch as V, onMounted as te, watchEffect as Be, nextTick as Y } from "vue";
+import { e as Me } from "../utils/index-Cps3W0wA.js";
+import { createSharedComposable as ze, useColorMode as Fe, useWindowSize as He, breakpointsTailwind as _e, useBreakpoints as qe, unrefElement as Z, useResizeObserver as ne, useVirtualList as je, useArrayMap as We, watchOnce as Ve, useEventListener as G, useMutationObserver as Ue } from "@vueuse/core";
+import { d as oe, T as P } from "../types/index-DSBIGM2a.js";
+import { get as e, set as l } from "@vueuse/shared";
+import { c as X, p as Ne, d as Ke, a as Ge, o as Xe, f as Je, b as Qe, e as Ye, g as Ze } from "../vendor-BRFX1hnB.js";
+const et = [
+  me,
+  he,
+  ie,
+  se,
+  re,
+  ce,
+  ae,
+  le,
+  fe,
+  ue,
+  ge,
+  ye,
+  we,
+  be,
+  Re,
+  Le,
+  xe,
+  Ce,
+  ve,
+  Se,
+  Te,
+  pe,
+  Ee,
+  ke,
+  Ie,
+  Pe,
+  De,
+  Oe,
+  Ae,
+  $e,
+  de
+], tt = Symbol.for("rui:icons");
+function gt(s) {
+  const u = (s == null ? void 0 : s.registeredIcons) || [];
+  return {
+    registeredIcons: {
+      ...Object.fromEntries(
+        [
+          ...et,
+          ...u
+        ].map(({ name: p, path: y }) => [p, y])
+      )
+    }
+  };
+}
+function yt() {
+  const s = ee(tt);
+  return Me(s, "Could not find icons injection"), s;
+}
+const W = h({ ...oe }), wt = ze(() => {
+  const { state: s, store: u } = Fe(), p = B(() => e(u) === P.auto), y = B(() => e(s) === P.light), c = B(() => e(s) === P.dark), g = B(() => e(y) ? e(W).light : e(W).dark), r = (n) => {
+    l(u, n || P.auto);
+  }, L = () => {
+    e(p) ? r(P.light) : e(y) ? r(P.dark) : e(c) && r(P.auto);
+  }, w = (n) => {
+    l(W, n);
+  };
+  return {
+    config: W,
+    init: (n) => {
+      r(n.mode ?? P.auto), w(n.config ?? { ...oe }), typeof window < "u" && V([y, g], ([a, C]) => {
+        const o = /* @__PURE__ */ new Map();
+        Object.entries(C).forEach(([x, v]) => {
+          o.set(`--rui-${x}-darker`, v.darker), o.set(`--rui-${x}-lighter`, v.lighter), o.set(`--rui-${x}-main`, v.DEFAULT);
+        });
+        const f = a ? P.light : P.dark;
+        o.set("--rui-text-disabled", `var(--rui-${f}-text-disabled)`), o.set("--rui-text-primary", `var(--rui-${f}-text-primary)`), o.set("--rui-text-secondary", `var(--rui-${f}-text-secondary)`);
+        const k = document.documentElement.style;
+        o.forEach((x, v) => {
+          k.setProperty(v, x);
+        });
+      }, { immediate: !0 });
+    },
+    isAutoControlled: p,
+    isDark: c,
+    isLight: y,
+    setThemeConfig: w,
+    state: s,
+    store: u,
+    switchThemeScheme: r,
+    theme: g,
+    toggleThemeMode: L
+  };
+});
+function bt() {
+  const { width: s } = He(), u = {
+    xs: 0,
+    ..._e
+  }, p = qe(u), y = Object.keys, c = y(u), g = c.map(
+    (n, a) => [
+      n,
+      a < c.length - 1 ? p.between(n, c[a + 1]) : p[n]
+    ]
+  ), r = g.map(([n, a]) => [
+    X(`is_${n}`),
+    a
+  ]), L = c.map((n) => [
+    X(`is_${n}_and_up`),
+    p.greaterOrEqual(n)
+  ]), w = c.map((n) => [
+    X(`is_${n}_and_down`),
+    p.smaller(n)
+  ]), d = B(() => {
+    var n;
+    return ((n = g.find((a) => e(a[1]))) == null ? void 0 : n[0]) || "";
+  });
+  return {
+    ...Object.fromEntries(r),
+    ...Object.fromEntries(L),
+    ...Object.fromEntries(w),
+    name: d,
+    width: s
+  };
+}
+const D = {
+  adaptive: !0,
+  gpuAcceleration: !0,
+  locked: !1,
+  offsetDistance: 8,
+  offsetSkid: 0,
+  overflowPadding: 8,
+  placement: "bottom",
+  resize: !0,
+  scroll: !0,
+  strategy: "absolute"
+}, nt = Ne({
+  defaultModifiers: [
+    ...Ke,
+    Ge,
+    Xe,
+    Je,
+    Qe,
+    Ye,
+    Ze
+  ]
+});
+function Rt(s, u = h(!1), p = h(0), y = h(0), c) {
+  const g = h(null), r = h(null), L = h(null), w = h(!1), d = h(), n = h(), a = h(!1), C = h(!1), o = () => {
+    l(a, !1);
+  }, f = () => {
+    var m;
+    (m = e(L)) == null || m.update();
+  }, k = (m = !1) => {
+    if (!e(u) && (e(n) && (clearTimeout(e(n)), l(n, void 0)), l(C, !1), !e(d))) {
+      l(a, !0);
+      const R = setTimeout(() => {
+        l(w, !0), l(d, void 0);
+      }, m ? 0 : e(p));
+      l(d, R);
+    }
+  }, x = (m = !1) => {
+    if (!e(u) && (e(d) && (clearTimeout(e(d)), l(d, void 0)), !e(n))) {
+      const R = setTimeout(() => {
+        e(w) || o(), l(w, !1), l(n, void 0);
+      }, m ? 0 : e(y));
+      l(n, R);
+    }
+  }, v = () => {
+    l(C, !0);
+  };
+  return te(() => {
+    Be((m) => {
+      if (!e(r) || !e(g) && !e(c))
+        return;
+      const R = Z(r), O = e(c) || Z(g);
+      if (!(R instanceof HTMLElement) || !O)
+        return;
+      const {
+        adaptive: M = D.adaptive,
+        gpuAcceleration: E = D.gpuAcceleration,
+        locked: z = D.locked,
+        offsetDistance: b = D.offsetDistance,
+        offsetSkid: U = D.offsetSkid,
+        overflowPadding: q = D.overflowPadding,
+        placement: j = D.placement,
+        resize: F = D.resize,
+        scroll: H = D.scroll,
+        strategy: N = D.strategy
+      } = e(s), K = nt(O, R, {
+        modifiers: [
+          {
+            enabled: !z,
+            name: "flip"
+          },
+          {
+            name: "preventOverflow",
+            options: {
+              padding: q
+            }
+          },
+          {
+            name: "offset",
+            options: {
+              offset: [U, b]
+            }
+          },
+          {
+            name: "computeStyles",
+            options: {
+              adaptive: M,
+              gpuAcceleration: E
+            }
+          },
+          {
+            name: "eventListeners",
+            options: {
+              resize: F,
+              scroll: H
+            }
+          },
+          {
+            name: "arrow",
+            options: {
+              padding: 4
+            }
+          }
+        ],
+        placement: j,
+        strategy: N
+      });
+      l(L, K), m(K.destroy);
+    });
+  }), ne([g, r], async () => {
+    const m = e(L);
+    e(w) && m && await m.update();
+  }), {
+    instance: L,
+    leavePending: C,
+    onClose: x,
+    onLeavePending: v,
+    onOpen: k,
+    onPopperLeave: o,
+    open: w,
+    popper: r,
+    popperEnter: a,
+    reference: g,
+    updatePopper: f
+  };
+}
+function ot({
+  keyAttr: s,
+  textAttr: u
+}) {
+  function p(c) {
+    var g;
+    return u ? typeof u == "function" ? u(c) : (g = c[u]) == null ? void 0 : g.toString() : c == null ? void 0 : c.toString();
+  }
+  function y(c) {
+    return s ? c[s] : c;
+  }
+  return {
+    getIdentifier: y,
+    getText: p
+  };
+}
+function Lt({
+  appendWidth: s,
+  autoFocus: u,
+  autoSelectFirst: p,
+  dense: y,
+  hideSelected: c,
+  itemHeight: g = 48,
+  keyAttr: r,
+  menuRef: L,
+  options: w,
+  overscan: d = 5,
+  prependWidth: n,
+  setValue: a,
+  textAttr: C,
+  value: o
+}) {
+  const f = B(() => {
+    const t = e(w);
+    return c ? t.filter((i) => !F(i)) : t;
+  }), { getIdentifier: k, getText: x } = ot({
+    keyAttr: r,
+    textAttr: C
+  }), { containerProps: v, list: m, scrollTo: R, wrapperProps: O } = je(
+    f,
+    {
+      itemHeight: g,
+      overscan: d
+    }
+  ), M = We(m, ({ data: t, index: i }) => ({ _index: i, item: t })), E = h(!1), z = B(() => {
+    const t = e(o);
+    return !r || !t ? t : Array.isArray(t) ? t.map((i) => i[r]) : t[r];
+  }), b = h(e(p) ? 0 : -1), U = B(() => {
+    const t = { max: 0, min: 0 }, i = 30, I = 1.5, S = e(y) ? 12 : 13;
+    e(f).forEach((A) => {
+      var J, Q;
+      const $ = ((Q = (J = x(A)) == null ? void 0 : J.toString()) == null ? void 0 : Q.length) ?? 0;
+      t.min === 0 && t.max === 0 ? (t.min = $, t.max = $) : $ < t.min ? t.min = $ : $ > t.max && (t.max = $);
+    });
+    const _ = t.max - t.min;
+    function T(A) {
+      const $ = (n ? n + 0.5 : 0) + (s ? s + 0.5 : 0);
+      return `${Math.min(A * S / 16 + I + $, i)}rem`;
+    }
+    return _ <= 5 ? T(t.max) : T(t.min + _ / 2);
+  });
+  function q(t = !1) {
+    l(E, t);
+  }
+  function j(t) {
+    const i = e(o), I = Array.isArray(i) ? i : i ? [i] : [];
+    return I.length === 0 ? -1 : I.findIndex((S) => r ? S[r] === t[r] : S === t);
+  }
+  function F(t) {
+    return j(t) !== -1;
+  }
+  async function H(t = !1) {
+    const i = e(b);
+    i > -1 && await Y(() => {
+      var S, _;
+      if ((S = e(L)) == null ? void 0 : S.parentElement) {
+        const T = e(L).getElementsByClassName("highlighted")[0];
+        if (T)
+          (_ = T.scrollIntoView) == null || _.call(T, { behavior: t ? "smooth" : "auto", block: "nearest" }), e(u) && "focus" in T && typeof T.focus == "function" && (T == null || T.focus());
+        else if (R(i), e(u)) {
+          const A = e(L).getElementsByClassName("highlighted")[0];
+          A && "focus" in A && typeof A.focus == "function" && A.focus();
+        }
+      }
+    });
+  }
+  async function N(t) {
+    await Y(() => {
+      if (t) {
+        const i = e(o);
+        if (Array.isArray(i) && i.length > 0 || i) {
+          const I = e(f).findIndex(F);
+          I > -1 && l(b, I);
+        }
+        Ve(m, async () => {
+          await H();
+        });
+      }
+    });
+  }
+  return V(E, N), V(b, async (t, i) => {
+    t !== i && await H(!0);
+  }), V(f, async () => {
+    e(b) !== -1 ? e(p) ? (l(b, 0), await H()) : (l(b, -1), R(0)) : R(0);
+  }), {
+    applyHighlighted: () => {
+      if (!a || !e(E))
+        return;
+      const t = e(b);
+      if (t === -1)
+        return;
+      const i = e(f).find((I, S) => t === S);
+      i && a(i);
+    },
+    containerProps: v,
+    getIdentifier: k,
+    getText: x,
+    highlightedIndex: b,
+    isActiveItem: F,
+    isOpen: E,
+    itemIndexInValue: j,
+    menuWidth: U,
+    moveHighlight: (t) => {
+      if (!e(E)) {
+        q(!0);
+        return;
+      }
+      let i = e(b);
+      i += t ? -1 : 1;
+      const S = e(f).length;
+      i >= S ? l(b, 0) : i < 0 ? l(b, S - 1) : l(b, i);
+    },
+    optionsWithSelectedHidden: f,
+    renderedData: M,
+    toggle: q,
+    valueKey: z,
+    wrapperProps: O
+  };
+}
+const it = Symbol.for("rui:table");
+function xt(s) {
+  return {
+    globalItemsPerPage: !1,
+    itemsPerPage: h(10),
+    limits: [10, 25, 50, 100],
+    stickyOffset: h(0),
+    ...s
+  };
+}
+function Ct() {
+  const s = ee(it);
+  if (!s)
+    throw new Error("Could not find rui table options injection");
+  return s;
+}
+function vt(s = h(!1), u) {
+  const p = h(null), y = h(null), c = h(!1), g = -0.5, r = {
+    head: ":scope > thead[data-id=head-main]",
+    headClone: ":scope > thead[data-id=head-clone]",
+    row: ":scope > tbody > tr:not([hidden])",
+    th: ":scope > th"
+  }, L = () => {
+    const d = e(p);
+    if (!e(s) || !d)
+      return;
+    const n = d.querySelector(
+      `${r.headClone} > tr`
+    ), a = d.querySelector(`${r.head} > tr`) ?? null, C = () => {
+      const o = a == null ? void 0 : a.querySelectorAll(
+        r.th
+      ), f = n == null ? void 0 : n.querySelectorAll(r.th);
+      f == null || f.forEach((k, x) => {
+        ne(k, (v) => {
+          const m = v[0].target.getBoundingClientRect(), R = o == null ? void 0 : o.item(x);
+          R && (R.style.width = `${m.width}px`);
+        });
+      });
+    };
+    Ue(n, (o) => {
+      for (const f of o)
+        (f.type === "childList" || f.type === "attributes") && C();
+    }, {
+      attributes: !0,
+      childList: !0,
+      subtree: !0
+    }), C();
+  }, w = () => {
+    var z;
+    const d = e(p);
+    if (!e(s) || !d)
+      return;
+    const n = d.getBoundingClientRect(), a = d.querySelector(
+      r.headClone
+    ), C = a == null ? void 0 : a.getBoundingClientRect(), o = d.querySelector(r.head) ?? null, f = o == null ? void 0 : o.getBoundingClientRect();
+    if (!n || !C || !o || !a || !f)
+      return;
+    const {
+      height: k,
+      left: x,
+      width: v
+    } = C, { bottom: m, top: R } = n, O = e(u) ?? 0;
+    o.style.width = `${v}px`;
+    const M = d.querySelectorAll(r.row), E = (z = M.item(M.length - 1)) == null ? void 0 : z.getBoundingClientRect();
+    if (R <= O && m > O && M.length > 1) {
+      l(c, !0), o.style.left = `${x + g}px`;
+      const b = (E == null ? void 0 : E.height) ?? 0;
+      m <= b + k + O ? o.style.top = `${m - b - k}px` : o.style.top = `${O}px`;
+    } else
+      l(c, !1), o.style.left = `${g}px`, o.style.top = "0";
+  };
+  return te(() => {
+    w(), G(y, "scroll", w), G(document.body, "scroll", w), G(window, "resize", w), L();
+  }), {
+    stick: c,
+    table: p,
+    tableScroller: y
+  };
+}
+export {
+  tt as I,
+  it as T,
+  Rt as a,
+  ot as b,
+  Lt as c,
+  Ct as d,
+  vt as e,
+  gt as f,
+  xt as g,
+  wt as h,
+  bt as i,
+  yt as u
+};

package/dist/composables/index.es.js

@@ -1,7 +1,6 @@
-import { u as s, a } from "../index-DIN-6VhY.js";
-import { u } from "../breakpoint-sPlgsoXp.js";
+import { i as o, u as a, h as u } from "./index--ZwAZVMb.js";
 export {
-  u as useBreakpoint,
-  s as useIcons,
-  a as useRotkiTheme
+  o as useBreakpoint,
+  a as useIcons,
+  u as useRotkiTheme
 };

package/dist/composables/popper.d.ts

@@ -17,15 +17,15 @@ export interface PopperOptions {
 export declare const DEFAULT_POPPER_OPTIONS: PopperOptions;
 export declare const createPopper: <TModifier extends Partial<import("@popperjs/core").Modifier<any, any>>>(reference: Element | VirtualElement, popper: HTMLElement, options?: Partial<import("@popperjs/core").OptionsGeneric<TModifier>>) => Instance;
 export declare function usePopper(options: Ref<PopperOptions>, disabled?: Ref<boolean>, openDelay?: Ref<number>, closeDelay?: Ref<number>, virtualReference?: Ref<Element | VirtualElement>): {
-    instance: Ref<Instance | null>;
-    leavePending: Ref<boolean>;
+    instance: Ref<Instance | null, Instance | null>;
+    leavePending: Ref<boolean, boolean>;
     onClose: (immediate?: boolean) => void;
     onLeavePending: () => void;
     onOpen: (immediate?: boolean) => void;
     onPopperLeave: () => void;
-    open: Ref<boolean>;
-    popper: Ref<MaybeElement>;
-    popperEnter: Ref<boolean>;
-    reference: Ref<MaybeElement>;
+    open: Ref<boolean, boolean>;
+    popper: Ref<MaybeElement, MaybeElement>;
+    popperEnter: Ref<boolean, boolean>;
+    reference: Ref<MaybeElement, MaybeElement>;
     updatePopper: () => void;
 };