@profitliga/ui 1.2.90 → 2.0.1

package/dist/components/ScrollArea/ScrollAreaRoot.vue.d.ts

@@ -1,24 +1,295 @@
-import { ScrollAreaRootProps } from 'reka-ui';
-import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+import { ScrollAreaRoot, ScrollAreaRootProps, AsTag } from 'reka-ui';
+import { ComputedRef, Component, ComponentInternalInstance, VNodeProps, AllowedComponentProps, ComponentCustomProps, Attrs, Slot, ComponentPublicInstance, ComponentOptionsBase, ComponentOptionsMixin, GlobalComponents, GlobalDirectives, ComponentProvideOptions, DebuggerEvent, nextTick, WatchOptions, WatchStopHandle, ComponentCustomProperties, Ref, DefineComponent, PublicProps } from 'vue';
+import { OnCleanup } from '@vue/reactivity';
 export interface IScrollAreaRootProps extends ScrollAreaRootProps {
     maxHeight?: number | string;
 }
+declare const forwared: ComputedRef<Readonly<{
+    type: "auto" | "scroll" | "always" | "hover";
+    dir: "ltr" | "rtl";
+    scrollHideDelay: number;
+    asChild: boolean;
+    as: AsTag | Component;
+}> & {
+    readonly maxHeight: string | number;
+} & {
+    readonly asChild: boolean;
+}>;
+declare const height: ComputedRef<string>;
 declare function scrollToBottom(): void;
 declare function scrollToTop(): void;
-declare var __VLS_9: {};
-type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_9) => any;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {
+        scrollArea: ({
+            $: ComponentInternalInstance;
+            $data: {};
+            $props: {
+                readonly maxHeight?: number | string | undefined;
+                readonly type?: ("auto" | "scroll" | "always" | "hover") | undefined;
+                readonly dir?: ("ltr" | "rtl") | undefined;
+                readonly scrollHideDelay?: number | undefined;
+                readonly asChild?: boolean | undefined;
+                readonly as?: ( AsTag | Component) | undefined;
+            } & VNodeProps & AllowedComponentProps & ComponentCustomProps;
+            $attrs: Attrs;
+            $refs: {
+                [x: string]: unknown;
+            };
+            $slots: Readonly<{
+                [name: string]: Slot<any> | undefined;
+            }>;
+            $root: ComponentPublicInstance | null;
+            $parent: ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: (event: string, ...args: any[]) => void;
+            $el: any;
+            $options: ComponentOptionsBase<Readonly<IScrollAreaRootProps> & Readonly<{}>, {
+                ScrollAreaRoot: typeof ScrollAreaRoot;
+                forwared: typeof forwared;
+                height: typeof height;
+            }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
+                maxHeight: number | string;
+            }, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & {
+                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: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+                renderTriggered?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+                errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
+            };
+            $forceUpdate: () => void;
+            $nextTick: nextTick;
+            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
+        } & Readonly<{
+            maxHeight: number | string;
+        }> & Omit<Readonly<IScrollAreaRootProps> & Readonly<{}>, "forwared" | "height" | "maxHeight" | "ScrollAreaRoot"> & {
+            ScrollAreaRoot: typeof ScrollAreaRoot;
+            forwared: Readonly<{
+                type: "auto" | "scroll" | "always" | "hover";
+                dir: "ltr" | "rtl";
+                scrollHideDelay: number;
+                asChild: boolean;
+                as: AsTag | Component;
+            }> & {
+                readonly maxHeight: string | number;
+            } & {
+                readonly asChild: boolean;
+            };
+            height: string;
+        } & {} & ComponentCustomProperties & {} & {
+            $slots: {
+                default?(_: {}): any;
+            };
+        } & {
+            $: ComponentInternalInstance;
+            $data: {};
+            $props: {
+                readonly type?: ("auto" | "scroll" | "always" | "hover") | undefined;
+                readonly dir?: ("ltr" | "rtl") | undefined;
+                readonly scrollHideDelay?: number | undefined;
+                readonly asChild?: boolean | undefined;
+                readonly as?: ( AsTag | Component) | undefined;
+            } & VNodeProps & AllowedComponentProps & ComponentCustomProps;
+            $attrs: Attrs;
+            $refs: {
+                [x: string]: unknown;
+            };
+            $slots: Readonly<{
+                [name: string]: Slot<any> | undefined;
+            }>;
+            $root: ComponentPublicInstance | null;
+            $parent: ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: (event: string, ...args: any[]) => void;
+            $el: any;
+            $options: ComponentOptionsBase<Readonly<ScrollAreaRootProps> & Readonly<{}>, {
+                viewport: Ref<HTMLElement | undefined, HTMLElement | undefined>;
+                scrollTop: () => void;
+                scrollTopLeft: () => void;
+            }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
+                type: "auto" | "scroll" | "always" | "hover";
+                scrollHideDelay: number;
+            }, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & {
+                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: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+                renderTriggered?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+                errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
+            };
+            $forceUpdate: () => void;
+            $nextTick: nextTick;
+            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
+        } & Readonly<{
+            type: "auto" | "scroll" | "always" | "hover";
+            scrollHideDelay: number;
+        }> & Omit<Readonly<ScrollAreaRootProps> & Readonly<{}>, "type" | "scrollHideDelay" | "viewport" | "scrollTop" | "scrollTopLeft"> & {
+            viewport: HTMLElement | undefined;
+            scrollTop: () => void;
+            scrollTopLeft: () => void;
+        }) | null;
+    };
+    rootEl: any;
 };
-declare const __VLS_base: DefineComponent<IScrollAreaRootProps, {
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: DefineComponent<IScrollAreaRootProps, {
     scrollToBottom: typeof scrollToBottom;
     scrollToTop: typeof scrollToTop;
 }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<IScrollAreaRootProps> & Readonly<{}>, {
     maxHeight: number | string;
-}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
-declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
-declare const _default: typeof __VLS_export;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {
+    scrollArea: ({
+        $: ComponentInternalInstance;
+        $data: {};
+        $props: {
+            readonly maxHeight?: number | string | undefined;
+            readonly type?: ("auto" | "scroll" | "always" | "hover") | undefined;
+            readonly dir?: ("ltr" | "rtl") | undefined;
+            readonly scrollHideDelay?: number | undefined;
+            readonly asChild?: boolean | undefined;
+            readonly as?: ( AsTag | Component) | undefined;
+        } & VNodeProps & AllowedComponentProps & ComponentCustomProps;
+        $attrs: Attrs;
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: Slot<any> | undefined;
+        }>;
+        $root: ComponentPublicInstance | null;
+        $parent: ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: (event: string, ...args: any[]) => void;
+        $el: any;
+        $options: ComponentOptionsBase<Readonly<IScrollAreaRootProps> & Readonly<{}>, {
+            ScrollAreaRoot: typeof ScrollAreaRoot;
+            forwared: typeof forwared;
+            height: typeof height;
+        }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
+            maxHeight: number | string;
+        }, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & {
+            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: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+            renderTriggered?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
+    } & Readonly<{
+        maxHeight: number | string;
+    }> & Omit<Readonly<IScrollAreaRootProps> & Readonly<{}>, "forwared" | "height" | "maxHeight" | "ScrollAreaRoot"> & {
+        ScrollAreaRoot: typeof ScrollAreaRoot;
+        forwared: Readonly<{
+            type: "auto" | "scroll" | "always" | "hover";
+            dir: "ltr" | "rtl";
+            scrollHideDelay: number;
+            asChild: boolean;
+            as: AsTag | Component;
+        }> & {
+            readonly maxHeight: string | number;
+        } & {
+            readonly asChild: boolean;
+        };
+        height: string;
+    } & {} & ComponentCustomProperties & {} & {
+        $slots: {
+            default?(_: {}): any;
+        };
+    } & {
+        $: ComponentInternalInstance;
+        $data: {};
+        $props: {
+            readonly type?: ("auto" | "scroll" | "always" | "hover") | undefined;
+            readonly dir?: ("ltr" | "rtl") | undefined;
+            readonly scrollHideDelay?: number | undefined;
+            readonly asChild?: boolean | undefined;
+            readonly as?: ( AsTag | Component) | undefined;
+        } & VNodeProps & AllowedComponentProps & ComponentCustomProps;
+        $attrs: Attrs;
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: Slot<any> | undefined;
+        }>;
+        $root: ComponentPublicInstance | null;
+        $parent: ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: (event: string, ...args: any[]) => void;
+        $el: any;
+        $options: ComponentOptionsBase<Readonly<ScrollAreaRootProps> & Readonly<{}>, {
+            viewport: Ref<HTMLElement | undefined, HTMLElement | undefined>;
+            scrollTop: () => void;
+            scrollTopLeft: () => void;
+        }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
+            type: "auto" | "scroll" | "always" | "hover";
+            scrollHideDelay: number;
+        }, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & {
+            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: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+            renderTriggered?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
+    } & Readonly<{
+        type: "auto" | "scroll" | "always" | "hover";
+        scrollHideDelay: number;
+    }> & Omit<Readonly<ScrollAreaRootProps> & Readonly<{}>, "type" | "scrollHideDelay" | "viewport" | "scrollTop" | "scrollTopLeft"> & {
+        viewport: HTMLElement | undefined;
+        scrollTop: () => void;
+        scrollTopLeft: () => void;
+    }) | null;
+}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;
-type __VLS_WithSlots<T, S> = T & {
+type __VLS_WithTemplateSlots<T, S> = T & {
     new (): {
         $slots: S;
     };

package/dist/components/ScrollArea/ScrollAreaRoot.vue.js

@@ -0,0 +1,8 @@
+import './ScrollAreaRoot.css';
+import o from "./ScrollAreaRoot.vue2.js";
+/* empty css                    */
+import r from "../../_virtual/_plugin-vue_export-helper.js";
+const f = /* @__PURE__ */ r(o, [["__scopeId", "data-v-3aefd568"]]);
+export {
+  f as default
+};

package/dist/components/ScrollArea/ScrollAreaRoot.vue2.js

@@ -0,0 +1,54 @@
+import { defineComponent as f, useCssVars as u, computed as m, useTemplateRef as h, openBlock as d, createBlock as v, unref as l, mergeProps as x, withCtx as g, renderSlot as _ } from "vue";
+import { useForwardProps as w, ScrollAreaRoot as A } from "reka-ui";
+const y = /* @__PURE__ */ f({
+  __name: "ScrollAreaRoot",
+  props: {
+    maxHeight: { default: "100%" },
+    type: {},
+    dir: {},
+    scrollHideDelay: {},
+    asChild: { type: Boolean },
+    as: {}
+  },
+  setup(s, { expose: a }) {
+    u((o) => ({
+      v2cacafc2: p.value
+    }));
+    const e = s, c = w(e), p = m(
+      () => typeof e.maxHeight == "string" ? e.maxHeight : `${e.maxHeight}px`
+    ), t = h("scrollArea");
+    function i() {
+      const o = t.value?.viewport;
+      if (o) {
+        const r = t.value?.$el.scrollHeight;
+        o.scrollTo({
+          top: r,
+          behavior: "smooth"
+        });
+      }
+    }
+    function n() {
+      const o = t.value?.viewport;
+      o && o.scrollTo({
+        top: 0,
+        behavior: "smooth"
+      });
+    }
+    return a({
+      scrollToBottom: i,
+      scrollToTop: n
+    }), (o, r) => (d(), v(l(A), x(l(c), {
+      ref_key: "scrollArea",
+      ref: t,
+      class: "scrollArea-root"
+    }), {
+      default: g(() => [
+        _(o.$slots, "default", {}, void 0, !0)
+      ]),
+      _: 3
+    }, 16));
+  }
+});
+export {
+  y as default
+};

package/dist/components/ScrollArea/ScrollAreaScrollbar.css

@@ -0,0 +1 @@
+.scrollArea-scrollbar{--scrollbar-size:10px;-webkit-user-select:none;user-select:none;touch-action:none;background-color:var(--theme-neutral-surface-icon);transition:background-color var(--animation-duration) ease-in-out;padding:2px;display:flex}.scrollArea-scrollbar:hover{background-color:var(--theme-neutral-surface-icon)}.scrollArea-scrollbar[data-orientation=vertical]{width:var(--scrollbar-size)}.scrollArea-scrollbar[data-orientation=horizontal]{height:var(--scrollbar-size);flex-direction:column}.scrollArea-scrollbar[data-state=visible]{animation:fadeIn var(--animation-duration) ease-in-out}.scrollArea-scrollbar[data-state=hidden]{animation:fadeOut var(--animation-duration) ease-in-out}.scrollArea-thumb{background:var(--theme-neutral-icon-primary);border-radius:var(--scrollbar-size);flex:1;position:relative}.scrollArea-thumb :before{content:"";width:100%;min-width:44px;height:100%;min-height:44px;position:absolute;top:50%;left:50%;transform:translate(-50%,-50%)}

package/dist/components/ScrollArea/ScrollAreaScrollbar.vue.d.ts

@@ -1,5 +1,4 @@
 import { ScrollAreaScrollbarProps } from 'reka-ui';
 import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
-declare const __VLS_export: DefineComponent<ScrollAreaScrollbarProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ScrollAreaScrollbarProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
-declare const _default: typeof __VLS_export;
+declare const _default: DefineComponent<ScrollAreaScrollbarProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ScrollAreaScrollbarProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
 export default _default;

package/dist/components/ScrollArea/ScrollAreaScrollbar.vue.js

@@ -0,0 +1,24 @@
+import './ScrollAreaScrollbar.css';
+import { defineComponent as l, openBlock as a, createBlock as c, unref as r, mergeProps as t, withCtx as s, createVNode as n } from "vue";
+import { useForwardProps as p, ScrollAreaScrollbar as m, ScrollAreaThumb as u } from "reka-ui";
+const _ = /* @__PURE__ */ l({
+  __name: "ScrollAreaScrollbar",
+  props: {
+    orientation: {},
+    forceMount: { type: Boolean },
+    asChild: { type: Boolean },
+    as: {}
+  },
+  setup(o) {
+    const e = p(o);
+    return (b, i) => (a(), c(r(m), t(r(e), { class: "scrollArea-scrollbar" }), {
+      default: s(() => [
+        n(r(u), { class: "scrollArea-thumb" })
+      ]),
+      _: 1
+    }, 16));
+  }
+});
+export {
+  _ as default
+};

package/dist/components/ScrollArea/ScrollAreaScrollbar.vue3.js

@@ -0,0 +1,5 @@
+import o from "./ScrollAreaScrollbar.vue.js";
+/* empty css                         */
+export {
+  o as default
+};

package/dist/components/ScrollArea/ScrollAreaViewport.css

@@ -0,0 +1 @@
+.scrollAreaViewport{width:100%;height:max-content;max-height:var(--v21cddb97);border-radius:inherit}

package/dist/components/ScrollArea/ScrollAreaViewport.vue.d.ts

@@ -3,17 +3,21 @@ import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOp
 export interface IScrollAreaViewportProps extends ScrollAreaViewportProps {
     maxHeight?: number | string;
 }
-declare var __VLS_8: {};
-type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_8) => any;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
 };
-declare const __VLS_base: DefineComponent<IScrollAreaViewportProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<IScrollAreaViewportProps> & Readonly<{}>, {
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: DefineComponent<IScrollAreaViewportProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<IScrollAreaViewportProps> & Readonly<{}>, {
     maxHeight: number | string;
 }, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
-declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
-declare const _default: typeof __VLS_export;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;
-type __VLS_WithSlots<T, S> = T & {
+type __VLS_WithTemplateSlots<T, S> = T & {
     new (): {
         $slots: S;
     };

package/dist/components/ScrollArea/ScrollAreaViewport.vue.js

@@ -0,0 +1,29 @@
+import './ScrollAreaViewport.css';
+import { defineComponent as p, useCssVars as c, computed as l, openBlock as n, createBlock as i, unref as r, mergeProps as m, withCtx as d, renderSlot as u } from "vue";
+import { useForwardProps as f, ScrollAreaViewport as h } from "reka-ui";
+const w = /* @__PURE__ */ p({
+  __name: "ScrollAreaViewport",
+  props: {
+    maxHeight: { default: "100%" },
+    nonce: {},
+    asChild: { type: Boolean },
+    as: {}
+  },
+  setup(t) {
+    c((o) => ({
+      v21cddb97: s.value
+    }));
+    const e = t, a = f(e), s = l(
+      () => typeof e.maxHeight == "string" ? e.maxHeight : `${e.maxHeight}px`
+    );
+    return (o, x) => (n(), i(r(h), m(r(a), { class: "scrollAreaViewport" }), {
+      default: d(() => [
+        u(o.$slots, "default")
+      ]),
+      _: 3
+    }, 16));
+  }
+});
+export {
+  w as default
+};

package/dist/components/ScrollArea/ScrollAreaViewport.vue3.js

@@ -0,0 +1,5 @@
+import o from "./ScrollAreaViewport.vue.js";
+/* empty css                        */
+export {
+  o as default
+};

package/dist/components/Select/SelectContent.css

@@ -0,0 +1 @@
+[data-v-d82d1f63] .select-content{width:var(--reka-select-trigger-width);background-color:var(--theme-neutral-0);border-radius:8px;padding:12px 4px;box-shadow:-1px 1px 10px #8d8f9340}[data-v-d82d1f63] .select-content[data-state=open]{animation:selectContentIn-d82d1f63 var(--animation-duration) ease-in-out}[data-v-d82d1f63] .select-content[data-state=closed]{animation:selectContentOut-d82d1f63 var(--animation-duration) ease-in-out}[data-v-d82d1f63] .select-content__scroll-viewport>div{flex-direction:column;gap:8px;display:flex}@keyframes selectContentIn-d82d1f63{0%{opacity:0;visibility:hidden}to{opacity:1;visibility:visible}}@keyframes selectContentOut-d82d1f63{0%{opacity:1;visibility:visible}to{opacity:0;visibility:hidden}}

package/dist/components/Select/SelectContent.vue.d.ts

@@ -1,35 +1,28 @@
 import { SelectContentProps, PointerDownOutsideEvent } from 'reka-ui';
-import { TBreakpoints } from '../../types/global.types';
 import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
-export interface ISelectContentProps extends SelectContentProps {
-    /**
-     * Брейкпоинт, ниже которого контент открывается в BottomSheet вместо
-     * floating popper-дропдауна
-     */
-    breakpointMobile?: TBreakpoints;
-}
-declare var __VLS_32: {}, __VLS_69: {};
-type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_32) => any;
-} & {
-    default?: (props: typeof __VLS_69) => any;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
 };
-declare const __VLS_base: DefineComponent<ISelectContentProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: DefineComponent<SelectContentProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
     escapeKeyDown: (event: KeyboardEvent) => any;
     pointerDownOutside: (event: PointerDownOutsideEvent) => any;
     closeAutoFocus: (event: Event) => any;
-}, string, PublicProps, Readonly<ISelectContentProps> & Readonly<{
+}, string, PublicProps, Readonly<SelectContentProps> & Readonly<{
     onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
     onPointerDownOutside?: ((event: PointerDownOutsideEvent) => any) | undefined;
     onCloseAutoFocus?: ((event: Event) => any) | undefined;
 }>, {
-    breakpointMobile: TBreakpoints;
     sideOffset: number;
 }, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
-declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
-declare const _default: typeof __VLS_export;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;
-type __VLS_WithSlots<T, S> = T & {
+type __VLS_WithTemplateSlots<T, S> = T & {
     new (): {
         $slots: S;
     };

package/dist/components/Select/SelectContent.vue.js

@@ -0,0 +1,8 @@
+import './SelectContent.css';
+import t from "./SelectContent.vue2.js";
+/* empty css                   */
+import o from "../../_virtual/_plugin-vue_export-helper.js";
+const m = /* @__PURE__ */ o(t, [["__scopeId", "data-v-d82d1f63"]]);
+export {
+  m as default
+};

package/dist/components/Select/SelectContent.vue2.js

@@ -0,0 +1,76 @@
+import { defineComponent as a, openBlock as l, createBlock as p, unref as e, mergeProps as c, withCtx as t, createVNode as o, renderSlot as d } from "vue";
+import { useForwardPropsEmits as m, SelectContent as f, ScrollAreaCorner as u } from "reka-ui";
+import _ from "../ScrollArea/ScrollAreaRoot.vue.js";
+import y from "../ScrollArea/ScrollAreaScrollbar.vue.js";
+/* empty css                                     */
+import B from "../ScrollArea/ScrollAreaViewport.vue.js";
+/* empty css                                    */
+import h from "./SelectViewport.vue.js";
+/* empty css                    */
+const A = /* @__PURE__ */ a({
+  __name: "SelectContent",
+  props: {
+    forceMount: { type: Boolean },
+    position: {},
+    bodyLock: { type: Boolean },
+    side: {},
+    sideOffset: { default: 5 },
+    sideFlip: { type: Boolean },
+    align: {},
+    alignOffset: {},
+    alignFlip: { type: Boolean },
+    avoidCollisions: { type: Boolean },
+    collisionBoundary: {},
+    collisionPadding: {},
+    arrowPadding: {},
+    sticky: {},
+    hideWhenDetached: { type: Boolean },
+    positionStrategy: {},
+    updatePositionStrategy: {},
+    disableUpdateOnLayoutShift: { type: Boolean },
+    prioritizePosition: { type: Boolean },
+    reference: {},
+    asChild: { type: Boolean },
+    as: {},
+    disableOutsidePointerEvents: { type: Boolean }
+  },
+  emits: ["closeAutoFocus", "escapeKeyDown", "pointerDownOutside"],
+  setup(i, { emit: n }) {
+    const r = m(i, n);
+    return (s, w) => (l(), p(e(f), c(e(r), {
+      class: "select-content",
+      position: "popper"
+    }), {
+      default: t(() => [
+        o(e(_), {
+          class: "select-content__scroll",
+          type: "hover"
+        }, {
+          default: t(() => [
+            o(h, { "as-child": "" }, {
+              default: t(() => [
+                o(e(B), {
+                  "max-height": "200px",
+                  class: "select-content__scroll-viewport"
+                }, {
+                  default: t(() => [
+                    d(s.$slots, "default", {}, void 0, !0)
+                  ]),
+                  _: 3
+                })
+              ]),
+              _: 3
+            }),
+            o(e(y), { orientation: "vertical" }),
+            o(e(u))
+          ]),
+          _: 3
+        })
+      ]),
+      _: 3
+    }, 16));
+  }
+});
+export {
+  A as default
+};

package/dist/components/Select/SelectItem.css

@@ -0,0 +1 @@
+.select-item[data-v-a0ecdb4d]{cursor:pointer;width:100%;color:var(--theme-neutral-text-body);border-radius:8px;outline:none;justify-content:flex-start;align-items:center;gap:.5rem;padding:4px 8px;font-size:.9375rem;line-height:160%;display:flex}.select-item[data-v-a0ecdb4d]:hover{background-color:var(--theme-secondary-50)}

package/dist/components/Select/SelectItem.vue.d.ts

@@ -3,15 +3,19 @@ import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOp
 interface ISelectItemProps extends SelectItemProps {
     label?: string;
 }
-declare var __VLS_24: {};
-type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_24) => any;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
 };
-declare const __VLS_base: DefineComponent<ISelectItemProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ISelectItemProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
-declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
-declare const _default: typeof __VLS_export;
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: DefineComponent<ISelectItemProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ISelectItemProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;
-type __VLS_WithSlots<T, S> = T & {
+type __VLS_WithTemplateSlots<T, S> = T & {
     new (): {
         $slots: S;
     };