@bitrix24/b24ui-nuxt 0.5.11 → 0.6.0

package/dist/runtime/components/Tooltip.vue.d.ts

@@ -0,0 +1,186 @@
+import type { TooltipRootProps, TooltipRootEmits, TooltipContentProps, TooltipContentEmits, TooltipArrowProps } from 'reka-ui';
+import type { KbdProps } from '../types';
+import type { EmitsToProps } from '../types/utils';
+declare const tooltip: import("tailwind-variants").TVReturnType<{
+    [key: string]: {
+        [key: string]: import("tailwind-variants").ClassValue | {
+            text?: import("tailwind-variants").ClassValue;
+            content?: import("tailwind-variants").ClassValue;
+            arrow?: import("tailwind-variants").ClassValue;
+            kbds?: import("tailwind-variants").ClassValue;
+            kbdsSize?: import("tailwind-variants").ClassValue;
+            kbdsDepth?: import("tailwind-variants").ClassValue;
+        };
+    };
+} | {
+    [x: string]: {
+        [x: string]: import("tailwind-variants").ClassValue | {
+            text?: import("tailwind-variants").ClassValue;
+            content?: import("tailwind-variants").ClassValue;
+            arrow?: import("tailwind-variants").ClassValue;
+            kbds?: import("tailwind-variants").ClassValue;
+            kbdsSize?: import("tailwind-variants").ClassValue;
+            kbdsDepth?: import("tailwind-variants").ClassValue;
+        };
+    };
+} | {
+    [x: string]: {
+        [x: string]: import("tailwind-variants").ClassValue | {
+            text?: import("tailwind-variants").ClassValue;
+            content?: import("tailwind-variants").ClassValue;
+            arrow?: import("tailwind-variants").ClassValue;
+            kbds?: import("tailwind-variants").ClassValue;
+            kbdsSize?: import("tailwind-variants").ClassValue;
+            kbdsDepth?: import("tailwind-variants").ClassValue;
+        };
+    };
+} | {}, {
+    content: string;
+    arrow: string;
+    text: string;
+    kbds: string;
+    kbdsSize: string;
+    kbdsDepth: string;
+}, undefined, {
+    [key: string]: {
+        [key: string]: import("tailwind-variants").ClassValue | {
+            text?: import("tailwind-variants").ClassValue;
+            content?: import("tailwind-variants").ClassValue;
+            arrow?: import("tailwind-variants").ClassValue;
+            kbds?: import("tailwind-variants").ClassValue;
+            kbdsSize?: import("tailwind-variants").ClassValue;
+            kbdsDepth?: import("tailwind-variants").ClassValue;
+        };
+    };
+} | {
+    [x: string]: {
+        [x: string]: import("tailwind-variants").ClassValue | {
+            text?: import("tailwind-variants").ClassValue;
+            content?: import("tailwind-variants").ClassValue;
+            arrow?: import("tailwind-variants").ClassValue;
+            kbds?: import("tailwind-variants").ClassValue;
+            kbdsSize?: import("tailwind-variants").ClassValue;
+            kbdsDepth?: import("tailwind-variants").ClassValue;
+        };
+    };
+} | {}, {
+    content: string;
+    arrow: string;
+    text: string;
+    kbds: string;
+    kbdsSize: string;
+    kbdsDepth: string;
+}, import("tailwind-variants").TVReturnType<{
+    [key: string]: {
+        [key: string]: import("tailwind-variants").ClassValue | {
+            text?: import("tailwind-variants").ClassValue;
+            content?: import("tailwind-variants").ClassValue;
+            arrow?: import("tailwind-variants").ClassValue;
+            kbds?: import("tailwind-variants").ClassValue;
+            kbdsSize?: import("tailwind-variants").ClassValue;
+            kbdsDepth?: import("tailwind-variants").ClassValue;
+        };
+    };
+} | {
+    [x: string]: {
+        [x: string]: import("tailwind-variants").ClassValue | {
+            text?: import("tailwind-variants").ClassValue;
+            content?: import("tailwind-variants").ClassValue;
+            arrow?: import("tailwind-variants").ClassValue;
+            kbds?: import("tailwind-variants").ClassValue;
+            kbdsSize?: import("tailwind-variants").ClassValue;
+            kbdsDepth?: import("tailwind-variants").ClassValue;
+        };
+    };
+} | {}, {
+    content: string;
+    arrow: string;
+    text: string;
+    kbds: string;
+    kbdsSize: string;
+    kbdsDepth: string;
+}, undefined, {
+    [key: string]: {
+        [key: string]: import("tailwind-variants").ClassValue | {
+            text?: import("tailwind-variants").ClassValue;
+            content?: import("tailwind-variants").ClassValue;
+            arrow?: import("tailwind-variants").ClassValue;
+            kbds?: import("tailwind-variants").ClassValue;
+            kbdsSize?: import("tailwind-variants").ClassValue;
+            kbdsDepth?: import("tailwind-variants").ClassValue;
+        };
+    };
+} | {}, {
+    content: string;
+    arrow: string;
+    text: string;
+    kbds: string;
+    kbdsSize: string;
+    kbdsDepth: string;
+}, import("tailwind-variants").TVReturnType<unknown, {
+    content: string;
+    arrow: string;
+    text: string;
+    kbds: string;
+    kbdsSize: string;
+    kbdsDepth: string;
+}, undefined, unknown, unknown, undefined>>>;
+export interface TooltipProps extends TooltipRootProps {
+    /** The text content of the tooltip. */
+    text?: string;
+    /** The keyboard keys to display in the tooltip. */
+    kbds?: KbdProps['value'][] | KbdProps[];
+    /**
+     * The content of the tooltip.
+     * @defaultValue { side: 'bottom', sideOffset: 8, collisionPadding: 8 }
+     */
+    content?: Omit<TooltipContentProps, 'as' | 'asChild'> & Partial<EmitsToProps<TooltipContentEmits>>;
+    /**
+     * Display an arrow alongside the tooltip.
+     * @defaultValue false
+     */
+    arrow?: boolean | Omit<TooltipArrowProps, 'as' | 'asChild'>;
+    /**
+     * Render the tooltip in a portal.
+     * @defaultValue true
+     */
+    portal?: boolean;
+    class?: any;
+    b24ui?: Partial<typeof tooltip.slots>;
+}
+export interface TooltipEmits extends TooltipRootEmits {
+}
+export interface TooltipSlots {
+    default(props: {
+        open: boolean;
+    }): any;
+    content(props?: {}): any;
+}
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<TooltipProps>, {
+    portal: boolean;
+}>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, any, string, import("vue").PublicProps, any, {
+    portal: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, Readonly<TooltipSlots> & TooltipSlots>;
+export default _default;
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal<P[K] & {
+        default: D[K];
+    }> : P[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;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/runtime/components/content/TableWrapper.vue

@@ -1,74 +1,28 @@
-<script lang="ts">
-import type { VariantProps } from 'tailwind-variants'
-import type { AppConfig } from '@nuxt/schema'
-import _appConfig from '#build/app.config'
-import theme from '#build/b24ui/content/table-wrapper'
-import { tv } from '../../utils/tv'
-
-const appConfigTableWrapper = _appConfig as AppConfig & { b24ui: { content: { tableWrapper: Partial<typeof theme> } } }
-
-const tableWrapper = tv({ extend: tv(theme), ...(appConfigTableWrapper.b24ui?.content?.tableWrapper || {}) })
-
-type TableWrapperVariants = VariantProps<typeof tableWrapper>
-
-export interface TableWrapperProps {
-  /**
-   * The element or component this component should render as.
-   * @defaultValue 'div'
-   */
-  as?: any
-  /**
-   * @defaultValue 'md'
-   */
-  size?: TableWrapperVariants['size']
-  /**
-   * @defaultValue false
-   */
-  rounded?: boolean
-  /**
-   * @defaultValue false
-   */
-  zebra?: boolean
-  /**
-   * @defaultValue false
-   */
-  pinRows?: boolean
-  /**
-   * @defaultValue false
-   */
-  pinCols?: boolean
-  /**
-   * @defaultValue false
-   */
-  rowHover?: boolean
-  /**
-   * @defaultValue false
-   */
-  bordered?: boolean
-  /**
-   * @defaultValue true
-   */
-  scrollbarThin?: boolean
-  class?: any
-  b24ui?: Partial<typeof tableWrapper.slots>
-}
-
-export interface TableWrapperSlots {
-  default(props?: {}): any
-}
+<script>
+import _appConfig from "#build/app.config";
+import theme from "#build/b24ui/content/table-wrapper";
+import { tv } from "../../utils/tv";
+const appConfigTableWrapper = _appConfig;
+const tableWrapper = tv({ extend: tv(theme), ...appConfigTableWrapper.b24ui?.content?.tableWrapper || {} });
 </script>
 
-<script setup lang="ts">
-import { computed } from 'vue'
-import { Primitive } from 'reka-ui'
-
-defineOptions({ inheritAttrs: false })
-
-const props = withDefaults(defineProps<TableWrapperProps>(), {
-  as: 'div',
-  scrollbarThin: true
-})
-
+<script setup>
+import { computed } from "vue";
+import { Primitive } from "reka-ui";
+defineOptions({ inheritAttrs: false });
+const props = defineProps({
+  as: { type: null, required: false, default: "div" },
+  size: { type: null, required: false },
+  rounded: { type: Boolean, required: false },
+  zebra: { type: Boolean, required: false },
+  pinRows: { type: Boolean, required: false },
+  pinCols: { type: Boolean, required: false },
+  rowHover: { type: Boolean, required: false },
+  bordered: { type: Boolean, required: false },
+  scrollbarThin: { type: Boolean, required: false, default: true },
+  class: { type: null, required: false },
+  b24ui: { type: Object, required: false }
+});
 const b24ui = computed(() => tableWrapper({
   size: props.size,
   rounded: Boolean(props.rounded),
@@ -78,7 +32,7 @@ const b24ui = computed(() => tableWrapper({
   rowHover: Boolean(props.rowHover),
   bordered: Boolean(props.bordered),
   scrollbarThin: Boolean(props.scrollbarThin)
-}))
+}));
 </script>
 
 <template>

package/dist/runtime/components/content/TableWrapper.vue.d.ts

@@ -0,0 +1,237 @@
+import type { VariantProps } from 'tailwind-variants';
+declare const tableWrapper: import("tailwind-variants").TVReturnType<{
+    size: {
+        xs: string;
+        sm: string;
+        md: string;
+        lg: string;
+    };
+    rounded: {
+        true: string;
+        false: string;
+    };
+    zebra: {
+        true: string;
+    };
+    pinRows: {
+        true: string;
+    };
+    pinCols: {
+        true: string;
+    };
+    rowHover: {
+        true: string;
+    };
+    bordered: {
+        true: string;
+    };
+    scrollbarThin: {
+        true: string;
+    };
+}, {
+    base: string;
+}, undefined, {
+    size: {
+        xs: string;
+        sm: string;
+        md: string;
+        lg: string;
+    };
+    rounded: {
+        true: string;
+        false: string;
+    };
+    zebra: {
+        true: string;
+    };
+    pinRows: {
+        true: string;
+    };
+    pinCols: {
+        true: string;
+    };
+    rowHover: {
+        true: string;
+    };
+    bordered: {
+        true: string;
+    };
+    scrollbarThin: {
+        true: string;
+    };
+}, {
+    base: string;
+}, import("tailwind-variants").TVReturnType<{
+    size: {
+        xs: string;
+        sm: string;
+        md: string;
+        lg: string;
+    };
+    rounded: {
+        true: string;
+        false: string;
+    };
+    zebra: {
+        true: string;
+    };
+    pinRows: {
+        true: string;
+    };
+    pinCols: {
+        true: string;
+    };
+    rowHover: {
+        true: string;
+    };
+    bordered: {
+        true: string;
+    };
+    scrollbarThin: {
+        true: string;
+    };
+}, {
+    base: string;
+}, undefined, {
+    size: {
+        xs: string;
+        sm: string;
+        md: string;
+        lg: string;
+    };
+    rounded: {
+        true: string;
+        false: string;
+    };
+    zebra: {
+        true: string;
+    };
+    pinRows: {
+        true: string;
+    };
+    pinCols: {
+        true: string;
+    };
+    rowHover: {
+        true: string;
+    };
+    bordered: {
+        true: string;
+    };
+    scrollbarThin: {
+        true: string;
+    };
+}, {
+    base: string;
+}, import("tailwind-variants").TVReturnType<{
+    size: {
+        xs: string;
+        sm: string;
+        md: string;
+        lg: string;
+    };
+    rounded: {
+        true: string;
+        false: string;
+    };
+    zebra: {
+        true: string;
+    };
+    pinRows: {
+        true: string;
+    };
+    pinCols: {
+        true: string;
+    };
+    rowHover: {
+        true: string;
+    };
+    bordered: {
+        true: string;
+    };
+    scrollbarThin: {
+        true: string;
+    };
+}, {
+    base: string;
+}, undefined, unknown, unknown, undefined>>>;
+type TableWrapperVariants = VariantProps<typeof tableWrapper>;
+export interface TableWrapperProps {
+    /**
+     * The element or component this component should render as.
+     * @defaultValue 'div'
+     */
+    as?: any;
+    /**
+     * @defaultValue 'md'
+     */
+    size?: TableWrapperVariants['size'];
+    /**
+     * @defaultValue false
+     */
+    rounded?: boolean;
+    /**
+     * @defaultValue false
+     */
+    zebra?: boolean;
+    /**
+     * @defaultValue false
+     */
+    pinRows?: boolean;
+    /**
+     * @defaultValue false
+     */
+    pinCols?: boolean;
+    /**
+     * @defaultValue false
+     */
+    rowHover?: boolean;
+    /**
+     * @defaultValue false
+     */
+    bordered?: boolean;
+    /**
+     * @defaultValue true
+     */
+    scrollbarThin?: boolean;
+    class?: any;
+    b24ui?: Partial<typeof tableWrapper.slots>;
+}
+export interface TableWrapperSlots {
+    default(props?: {}): any;
+}
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<TableWrapperProps>, {
+    as: string;
+    scrollbarThin: boolean;
+}>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<TableWrapperProps>, {
+    as: string;
+    scrollbarThin: boolean;
+}>>> & Readonly<{}>, {
+    as: any;
+    scrollbarThin: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal<P[K] & {
+        default: D[K];
+    }> : P[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;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/runtime/composables/useAvatarGroup.d.ts

@@ -6,5 +6,5 @@ export declare const avatarGroupInjectionKey: InjectionKey<ComputedRef<{
 export declare function useAvatarGroup(props: {
     size: AvatarGroupProps['size'];
 }): {
-    size: ComputedRef<any>;
+    size: ComputedRef<"md" | "3xs" | "2xs" | "xs" | "sm" | "lg" | "xl" | "2xl" | "3xl" | undefined>;
 };

package/dist/runtime/composables/useButtonGroup.d.ts

@@ -10,8 +10,8 @@ type Props<T> = {
     size?: GetObjectField<T, 'size'>;
 };
 export declare function useButtonGroup<T>(props: Props<T>): {
-    orientation: ComputedRef<any>;
-    size: ComputedRef<any>;
+    orientation: ComputedRef<"horizontal" | "vertical" | undefined>;
+    size: ComputedRef<"md" | "xs" | "sm" | "lg" | NonNullable<GetObjectField<T, "size">> | undefined>;
     noSplit: ComputedRef<boolean>;
 };
 export {};

package/dist/runtime/composables/useComponentIcons.d.ts

@@ -20,8 +20,8 @@ export interface UseComponentIconsProps {
     trailingIcon?: IconComponent;
 }
 export declare function useComponentIcons(componentProps: MaybeRefOrGetter<UseComponentIconsProps>): {
-    isLeading: import("vue").ComputedRef<any>;
+    isLeading: import("vue").ComputedRef<true | AvatarProps | undefined>;
     isTrailing: import("vue").ComputedRef<boolean>;
-    leadingIconName: import("vue").ComputedRef<IconComponent | undefined>;
-    trailingIconName: import("vue").ComputedRef<IconComponent | undefined>;
+    leadingIconName: import("vue").ComputedRef<import("vue").FunctionalComponent<import("vue").HTMLAttributes & import("vue").VNodeProps, {}, any, {}> | undefined>;
+    trailingIconName: import("vue").ComputedRef<import("vue").FunctionalComponent<import("vue").HTMLAttributes & import("vue").VNodeProps, {}, any, {}> | undefined>;
 };

package/dist/runtime/composables/useFormField.d.ts

@@ -26,12 +26,12 @@ export declare function useFormField<T>(props?: Props<T>, opts?: {
 }): {
     id: ComputedRef<string | undefined>;
     name: ComputedRef<string | undefined>;
-    size: ComputedRef<any>;
+    size: ComputedRef<"md" | "xs" | "sm" | "lg" | NonNullable<GetObjectField<T, "size">> | undefined>;
     color: ComputedRef<"danger" | GetObjectField<T, "color"> | undefined>;
     highlight: ComputedRef<boolean | undefined>;
     disabled: ComputedRef<boolean | undefined>;
     emitFormBlur: () => void;
-    emitFormInput: import("@vueuse/core").PromisifyFn<() => void>;
+    emitFormInput: import("@vueuse/core").UseDebounceFnReturn<() => void>;
     emitFormChange: () => void;
     emitFormFocus: () => void;
     ariaAttrs: ComputedRef<{

package/dist/runtime/composables/useOverlay.d.ts

@@ -6,22 +6,29 @@ export type OverlayOptions<OverlayAttrs = Record<string, any>> = {
     props?: OverlayAttrs;
     destroyOnClose?: boolean;
 };
-type ManagedOverlayOptionsPrivate<T extends Component> = {
+interface ManagedOverlayOptionsPrivate<T extends Component> {
     component?: T;
     id: symbol;
     isMounted: boolean;
-    modelValue: boolean;
-    resolvePromise?: (value: unknown) => void;
-};
+    isOpen: boolean;
+    resolvePromise?: (value: any) => void;
+}
 export type Overlay = OverlayOptions<Component> & ManagedOverlayOptionsPrivate<Component>;
-interface OverlayInstance<T> {
-    open: (props?: ComponentProps<T>) => Promise<CloseEventArgType<ComponentEmit<T>>>;
+interface OverlayInstance<T extends Component> extends Omit<ManagedOverlayOptionsPrivate<T>, 'component'> {
+    id: symbol;
+    result: Promise<CloseEventArgType<ComponentEmit<T>>>;
+    open: (props?: ComponentProps<T>) => Omit<OverlayInstance<T>, 'open' | 'close' | 'patch' | 'modelValue' | 'resolvePromise'>;
     close: (value?: any) => void;
     patch: (props: Partial<ComponentProps<T>>) => void;
 }
 declare function _useOverlay(): {
     overlays: import("vue").ShallowReactive<Overlay[]>;
-    open: <T extends Component>(id: symbol, props?: ComponentProps<T>) => Promise<any>;
+    open: <T extends Component>(id: symbol, props?: ComponentProps<T>) => {
+        id: symbol;
+        isMounted: boolean;
+        isOpen: boolean;
+        result: Promise<any>;
+    };
     close: (id: symbol, value?: any) => void;
     create: <T extends Component>(component: T, _options?: OverlayOptions<ComponentProps<T>>) => OverlayInstance<T>;
     patch: <T extends Component>(id: symbol, props: Partial<ComponentProps<T>>) => void;

package/dist/runtime/composables/useOverlay.js

@@ -6,7 +6,7 @@ function _useOverlay() {
     const { props, defaultOpen, destroyOnClose } = _options || {};
     const options = reactive({
       id: Symbol(import.meta.dev ? "useOverlay" : ""),
-      modelValue: !!defaultOpen,
+      isOpen: !!defaultOpen,
       component: markRaw(component),
       isMounted: !!defaultOpen,
       destroyOnClose: !!destroyOnClose,
@@ -14,6 +14,9 @@ function _useOverlay() {
     });
     overlays.push(options);
     return {
+      ...options,
+      result: new Promise(() => {
+      }),
       open: (props2) => open(options.id, props2),
       close: (value) => close(options.id, value),
       patch: (props2) => patch(options.id, props2)
@@ -24,15 +27,20 @@ function _useOverlay() {
     if (props) {
       patch(overlay.id, props);
     }
-    overlay.modelValue = true;
+    overlay.isOpen = true;
     overlay.isMounted = true;
-    return new Promise((resolve) => {
-      overlay.resolvePromise = resolve;
-    });
+    return {
+      id,
+      isMounted: overlay.isMounted,
+      isOpen: overlay.isOpen,
+      result: new Promise((resolve) => {
+        overlay.resolvePromise = resolve;
+      })
+    };
   };
   const close = (id, value) => {
     const overlay = getOverlay(id);
-    overlay.modelValue = false;
+    overlay.isOpen = false;
     if (overlay.resolvePromise) {
       overlay.resolvePromise(value);
       overlay.resolvePromise = void 0;