@central-design-system/components 3.0.0-alpha.8 → 3.0.0-beta.0

package/dist/composable/status.d.ts

@@ -1,3 +1,4 @@
+import { MaybeRef } from '../utils';
 import type { ComputedRef, PropType } from 'vue';
 export declare type TStatus = typeof allowedStatus[number];
 export interface IStatusProps {
@@ -10,6 +11,9 @@ export declare const allowedStatus: readonly ["info", "success", "warning", "err
 export declare const makeStatusProps: <Defaults extends {
     status?: unknown;
 } = {}>(defaults?: Defaults | undefined) => import('../utils').AppendDefault<{
+    /**
+     * Статус состояния
+     */
     status: {
         type: PropType<"error" | "info" | "success" | "warning" | "progress">;
         default: string;
@@ -18,4 +22,4 @@ export declare const makeStatusProps: <Defaults extends {
         validator: (value: TStatus) => boolean;
     };
 }, Defaults>;
-export declare function useStatus(props: IStatusProps, name: string): IUseStatus;
+export declare function useStatus(props: MaybeRef<IStatusProps>, name: string): IUseStatus;

package/dist/composable/text.d.ts

@@ -1,8 +1,9 @@
-import type { PropType } from 'vue';
+import type { PropType, ComputedRef } from 'vue';
 export interface ITextProps {
     text: string | undefined;
 }
 export interface IUseText {
+    hasText: ComputedRef<boolean>;
 }
 export declare const makeTextProps: <Defaults extends {
     text?: unknown;
@@ -15,3 +16,4 @@ export declare const makeTextProps: <Defaults extends {
         default: undefined;
     };
 }, Defaults>;
+export declare function useText(props: ITextProps, slots: Record<string, unknown>): IUseText;

package/dist/composable/variant.d.ts

@@ -0,0 +1,26 @@
+import { MaybeRef } from '../utils';
+import type { ComputedRef, PropType } from 'vue';
+export declare type TVariant = typeof allowedVariant[number];
+export interface IVariantProps {
+    variant: TVariant;
+}
+export interface IUseVariant {
+    variantClasses: ComputedRef<string>;
+}
+export declare const allowedVariant: readonly ["default", "important"];
+export declare const makeVariantProps: <Defaults extends {
+    variant?: unknown;
+} = {}>(defaults?: Defaults | undefined) => import('../utils').AppendDefault<{
+    /**
+     * Вариант отображения
+     */
+    variant: {
+        type: PropType<any>;
+        default: string;
+        validator: (value: TVariant) => boolean;
+    };
+}, Defaults>;
+export declare function useVariant(props: MaybeRef<IVariantProps>, name: string): IUseVariant;
+export declare function genOverlays(isClickable: boolean, name: string): import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>;

package/dist/create.d.ts

@@ -1,3 +1,4 @@
+import { ILocale, TAvailableLocale } from './locale';
 import type { App } from 'vue';
 import type { IDisplayOptions } from './composable';
 export interface ICdsOptions {
@@ -8,6 +9,7 @@ export interface ICdsOptions {
     display?: IDisplayOptions;
     cssGrid?: boolean;
     ssr?: boolean;
+    locale?: TAvailableLocale | ILocale;
 }
 interface NuxtApp {
     $nuxt?: {

package/dist/directives/index.d.ts

@@ -1 +1,2 @@
 export { ClickOutside } from './click-outside';
+export { Touch } from './touch';

package/dist/directives/touch/index.d.ts

@@ -0,0 +1,46 @@
+import type { DirectiveBinding } from 'vue';
+export interface ITouchHandlers {
+    start?: (wrapperEvent: {
+        originalEvent: TouchEvent;
+    } & ITouchData) => void;
+    end?: (wrapperEvent: {
+        originalEvent: TouchEvent;
+    } & ITouchData) => void;
+    move?: (wrapperEvent: {
+        originalEvent: TouchEvent;
+    } & ITouchData) => void;
+    left?: (wrapper: ITouchData) => void;
+    right?: (wrapper: ITouchData) => void;
+    up?: (wrapper: ITouchData) => void;
+    down?: (wrapper: ITouchData) => void;
+}
+export interface ITouchData {
+    touchstartX: number;
+    touchstartY: number;
+    touchmoveX: number;
+    touchmoveY: number;
+    touchendX: number;
+    touchendY: number;
+    offsetX: number;
+    offsetY: number;
+}
+export declare type TTouchWrapper = ITouchHandlers & ITouchData;
+export interface ITouchValue extends ITouchHandlers {
+    parent?: boolean;
+    options?: AddEventListenerOptions;
+}
+export interface ITouchStoredHandlers {
+    touchstart: (event: TouchEvent) => void;
+    touchend: (event: TouchEvent) => void;
+    touchmove: (event: TouchEvent) => void;
+}
+export interface ITouchDirectiveBinding extends Omit<DirectiveBinding, 'value'> {
+    value?: ITouchValue;
+}
+declare function mounted(el: HTMLElement, binding: ITouchDirectiveBinding): void;
+declare function unmounted(el: HTMLElement, binding: ITouchDirectiveBinding): void;
+export declare const Touch: {
+    mounted: typeof mounted;
+    unmounted: typeof unmounted;
+};
+export default Touch;

package/dist/globals.d.ts

@@ -1,3 +1,5 @@
+import type { ITouchStoredHandlers } from './directives/touch';
+
 declare global {
   interface HTMLCollection {
     [Symbol.iterator](): IterableIterator<Element>;
@@ -12,6 +14,9 @@ declare global {
         }
       | undefined
     > & { lastMousedownWasOutside: boolean };
+    _touchHandlers?: {
+      [_uid: number]: ITouchStoredHandlers;
+    };
   }
 
   export const __VUE_OPTIONS_API__: boolean | undefined;

package/dist/locale/en.d.ts

@@ -0,0 +1,3 @@
+import type { ILocale } from './';
+declare const _default: ILocale;
+export default _default;

package/dist/locale/index.d.ts

@@ -1,12 +1,25 @@
+import type { NTable } from '../components/CdsTable/interface';
+import type { NUploader } from '../components/CdsUploader/interface';
+import type { TNotificationLocale } from '../components/CdsNotification/composable';
+import type { TDateLocale } from '../utils';
 export interface ILocale {
-  date: {
-    days: string[];
-    daysShort: string[];
-    months: string[];
-    monthsLong: string[];
-    monthsShort: string[];
-    firstDayOfWeek: number;
-    format24h: boolean;
-    pluralDay: (day?: number) => string;
-  };
+    notification: TNotificationLocale;
+    table: NTable.ILocale;
+    date: TDateLocale;
+    container: {
+        prev?: string;
+        next?: string;
+    };
+    uploader: NUploader.ILocale;
+    dropdown: {
+        noData: string;
+        selectAll: string;
+    };
 }
+export declare const availableLocale: readonly ["ru", "en"];
+export declare type TAvailableLocale = typeof availableLocale[number];
+declare const _default: {
+    ru: ILocale;
+    en: ILocale;
+};
+export default _default;

package/dist/transitions/createTransition.d.ts

@@ -26,8 +26,8 @@ export declare function createCssTransition(name: string, origin?: string, mode?
         default: string;
     };
 }>>, {
-    mode: string;
     origin: string;
+    mode: string;
 }>;
 export declare function createJSTransition(name: string, functions: Record<string, any>, mode?: string): import("vue").DefineComponent<{
     mode: Prop<"default" | "in-out" | "out-in", "default" | "in-out" | "out-in">;

package/dist/transitions/index.d.ts

@@ -12,6 +12,7 @@ export declare const CdsTransitionExpandX: import("vue").DefineComponent<{
 }>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
     mode: import("vue").Prop<"default" | "in-out" | "out-in", "default" | "in-out" | "out-in">;
 }>>, {}>;
+export { CdsTransitionModal } from './modalTransition';
 export declare const CdsTransitionFade: import("vue").DefineComponent<{
     group: import("vue").PropType<boolean>;
     hideOnLeave: import("vue").PropType<boolean>;
@@ -39,8 +40,8 @@ export declare const CdsTransitionFade: import("vue").DefineComponent<{
         default: string;
     };
 }>>, {
-    mode: string;
     origin: string;
+    mode: string;
 }>;
 export declare const CdsTransitionSlideY: import("vue").DefineComponent<{
     group: import("vue").PropType<boolean>;
@@ -69,8 +70,8 @@ export declare const CdsTransitionSlideY: import("vue").DefineComponent<{
         default: string;
     };
 }>>, {
-    mode: string;
     origin: string;
+    mode: string;
 }>;
 export declare const CdsTransitionSlideX: import("vue").DefineComponent<{
     group: import("vue").PropType<boolean>;
@@ -99,8 +100,8 @@ export declare const CdsTransitionSlideX: import("vue").DefineComponent<{
         default: string;
     };
 }>>, {
-    mode: string;
     origin: string;
+    mode: string;
 }>;
 export declare const CdsTransitionSlideRight: import("vue").DefineComponent<{
     group: import("vue").PropType<boolean>;
@@ -129,8 +130,8 @@ export declare const CdsTransitionSlideRight: import("vue").DefineComponent<{
         default: string;
     };
 }>>, {
-    mode: string;
     origin: string;
+    mode: string;
 }>;
 export declare const CdsTransitionSlideLeft: import("vue").DefineComponent<{
     group: import("vue").PropType<boolean>;
@@ -159,8 +160,8 @@ export declare const CdsTransitionSlideLeft: import("vue").DefineComponent<{
         default: string;
     };
 }>>, {
-    mode: string;
     origin: string;
+    mode: string;
 }>;
 export declare const CdsTransitionJumpRight: import("vue").DefineComponent<{
     group: import("vue").PropType<boolean>;
@@ -189,8 +190,8 @@ export declare const CdsTransitionJumpRight: import("vue").DefineComponent<{
         default: string;
     };
 }>>, {
-    mode: string;
     origin: string;
+    mode: string;
 }>;
 export declare const CdsTransitionJumpLeft: import("vue").DefineComponent<{
     group: import("vue").PropType<boolean>;
@@ -219,8 +220,8 @@ export declare const CdsTransitionJumpLeft: import("vue").DefineComponent<{
         default: string;
     };
 }>>, {
-    mode: string;
     origin: string;
+    mode: string;
 }>;
 export declare const CdsTransitionScale: import("vue").DefineComponent<{
     group: import("vue").PropType<boolean>;
@@ -249,6 +250,66 @@ export declare const CdsTransitionScale: import("vue").DefineComponent<{
         default: string;
     };
 }>>, {
+    origin: string;
+    mode: string;
+}>;
+export declare const CdsTransitionModalBottom: import("vue").DefineComponent<{
+    group: import("vue").PropType<boolean>;
+    hideOnLeave: import("vue").PropType<boolean>;
+    leaveAbsolute: import("vue").PropType<boolean>;
+    mode: {
+        type: import("vue").PropType<string>;
+        default: string | undefined;
+    };
+    origin: {
+        type: import("vue").PropType<string>;
+        default: string;
+    };
+}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    group: import("vue").PropType<boolean>;
+    hideOnLeave: import("vue").PropType<boolean>;
+    leaveAbsolute: import("vue").PropType<boolean>;
+    mode: {
+        type: import("vue").PropType<string>;
+        default: string | undefined;
+    };
+    origin: {
+        type: import("vue").PropType<string>;
+        default: string;
+    };
+}>>, {
+    origin: string;
     mode: string;
+}>;
+export declare const CdsTransitionModalTop: import("vue").DefineComponent<{
+    group: import("vue").PropType<boolean>;
+    hideOnLeave: import("vue").PropType<boolean>;
+    leaveAbsolute: import("vue").PropType<boolean>;
+    mode: {
+        type: import("vue").PropType<string>;
+        default: string | undefined;
+    };
+    origin: {
+        type: import("vue").PropType<string>;
+        default: string;
+    };
+}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    group: import("vue").PropType<boolean>;
+    hideOnLeave: import("vue").PropType<boolean>;
+    leaveAbsolute: import("vue").PropType<boolean>;
+    mode: {
+        type: import("vue").PropType<string>;
+        default: string | undefined;
+    };
+    origin: {
+        type: import("vue").PropType<string>;
+        default: string;
+    };
+}>>, {
     origin: string;
+    mode: string;
 }>;

package/dist/transitions/modalTransition.d.ts

@@ -0,0 +1,8 @@
+import type { PropType } from 'vue';
+export declare const CdsTransitionModal: import("vue").DefineComponent<{
+    target: PropType<HTMLElement>;
+}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    target: PropType<HTMLElement>;
+}>>, {}>;

package/dist/utils/{date.d.ts → date/date.d.ts}

@@ -1,4 +1,3 @@
-import type { ILocale } from '../locale';
 export interface IRawDate {
     year?: number;
     month?: number;
@@ -13,7 +12,16 @@ export interface IRawDate {
     date?: number;
     changed?: boolean;
 }
-export declare type TDateLocale = ILocale['date'];
+export declare type TDateLocale = {
+    days: string[];
+    daysShort: string[];
+    months: string[];
+    monthsLong: string[];
+    monthsShort: string[];
+    firstDayOfWeek: number;
+    format24h: boolean;
+    pluralDay: (day?: number) => string;
+};
 /**
  * Format date by mask
  * @param value

package/dist/utils/dom/classNames.d.ts

@@ -0,0 +1,4 @@
+export declare function classNames(...args: any[]): any;
+export declare function hasClass(node: HTMLDivElement, className: string): boolean;
+export declare function addClass(node: HTMLDivElement, className: string): void;
+export declare function removeClass(node: HTMLDivElement, className: string): void;

package/dist/utils/dom/dom.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Returns:
+ *  - 'null' if the node is not attached to the DOM
+ *  - the root node (HTMLDocument | ShadowRoot) otherwise
+ */
+export declare function attachedRoot(node: Node): null | HTMLDocument | ShadowRoot;
+export declare function isVisible(element: HTMLElement | SVGGraphicsElement): boolean;
+export declare function isStyleSupport(styleName: string | string[], styleValue?: any): boolean;
+export declare function parseStyleText(cssText?: string, camel?: boolean): Record<string, any>;
+export declare function findDOMNodeByInstance(instance: any): any;
+export declare function getElement(el?: HTMLElement | string | null): any;

package/dist/utils/dom/getScrollParent.d.ts

@@ -0,0 +1,16 @@
+export declare function getScrollParent(el?: HTMLElement): HTMLElement;
+export declare function getScrollParents(el?: Element | null, stopAt?: Element | null): HTMLElement[];
+export declare function getScrollTarget(el?: HTMLElement, targetEl?: HTMLElement | string): any;
+export declare function hasScrollbar(el?: Element | null): boolean;
+export declare function getScrollBarSize(fresh?: boolean): number;
+export declare function getTargetScrollBarSize(target: HTMLElement): {
+    width: number;
+    height: number;
+};
+export declare function getOffset(node: any): {
+    left: number;
+    top: number;
+};
+export declare function getVerticalScrollPosition(el?: HTMLElement | Window): number;
+export declare function getHorizontalScrollPosition(el?: HTMLElement | Window): number;
+export declare function hasPreventedScroll(): boolean;

package/dist/utils/dom/hRender.d.ts

@@ -0,0 +1,9 @@
+import type { Slot, VNode } from 'vue';
+export declare function hSlot(slot: Slot | undefined, otherwise?: VNode[]): VNode[] | undefined;
+/**
+ * Source definitely exists,
+ * so it's merged with the possible slot
+ */
+export declare function hMergeSlot(slot: Slot | undefined, source: VNode[]): VNode[];
+export declare function hUniqueSlot(slot: Slot | undefined, otherwise: VNode[]): VNode[];
+export declare function hEmptyRender(): void;

package/dist/utils/dom/scrollTo.d.ts

@@ -0,0 +1,10 @@
+export interface IScrollToOptions {
+    /** Scroll container, default as window */
+    getContainer?: () => HTMLElement | Window | Document;
+    /** Scroll end callback */
+    callback?: () => void;
+    /** Animation duration, default as 450 */
+    duration?: number;
+}
+export declare function scrollTo(y: number, options?: IScrollToOptions): void;
+export declare function easeInOutCubic(t: number, b: number, c: number, d: number): number;

package/dist/utils/dom/warn.d.ts

@@ -0,0 +1 @@
+export declare function warn(component: string, msg: string): void;

package/dist/utils/dom/wrapperRaf.d.ts

@@ -0,0 +1,4 @@
+export declare function wrapperRaf(callback: () => void, times?: number): number;
+export declare namespace wrapperRaf {
+    var cancel: (id: number) => void;
+}

package/dist/utils/helpers.d.ts

@@ -1,5 +1,6 @@
-import type { ComponentPublicInstance, ComputedGetter, PropType, Ref, ToRefs } from 'vue';
+import type { ComponentPublicInstance, ComponentInternalInstance, ComputedGetter, InjectionKey, PropType, Ref, ToRefs, VNodeProps, VNodeChild, AllowedComponentProps, Component } from 'vue';
 import type { TItemKey } from '../composable';
+export declare const preventedScrollClass = "cds-scroll-blocked";
 export declare const keyNames: Readonly<{
     enter: "Enter";
     tab: "Tab";
@@ -31,7 +32,13 @@ export declare const classesStates: Readonly<{
     empty: "cds-state-empty";
     loading: "cds-state-loading";
     readonly: "cds-state-readonly";
+    dragging: "cds-state-dragging";
 }>;
+export declare function keys<O extends {}>(o: O): (keyof O)[];
+export declare function has<T extends string>(obj: object, key: T[]): obj is Record<T, unknown>;
+export declare function isString(value: any): boolean;
+export declare function isArray(value: any): boolean;
+export declare function isSymbol(value: any): boolean;
 /**
  * Check if value is a object.
  * @param obj
@@ -42,6 +49,23 @@ export declare function isObject(obj: any): obj is object;
  * @param value
  */
 export declare function isDate(value: any): boolean;
+/**
+ * Check if value is a Window object.
+ * @param obj
+ */
+export declare function isWindow(obj: any): boolean;
+/**
+ * Add item from array if not exists.
+ * @param array
+ * @param value
+ */
+export declare function addItemToArray<T>(array: T[], value: T): T[];
+/**
+ * Remove item from array if exists.
+ * @param array
+ * @param value
+ */
+export declare function removeItemFromArray<T>(array: T[], value: T): T[];
 /**
  * Deep merge two objects.
  * @param source
@@ -59,7 +83,8 @@ export declare function deepEqual(a: any, b: any): boolean;
  * Wrap value in array if it's not already an array
  * @param value
  */
-export declare function wrapInArray<T>(value: T | T[] | null | undefined): T[];
+declare type IfAny<T, Y, N> = 0 extends 1 & T ? Y : N;
+export declare function wrapInArray<T>(value: T | T[] | null | undefined): T extends readonly any[] ? IfAny<T, T[], T> : NonNullable<T>[];
 /**
  * Get the nested value of an object at a given path.
  * @param obj
@@ -75,6 +100,12 @@ export declare function getNestedValue(obj: any, path: (string | number)[], fall
  */
 export declare function getObjectValueByPath(obj: any, path: string, fallback?: any): any;
 export declare function getPropertyFromItem(item: any, property: SelectItemKey, fallback?: any): any;
+/**
+ * This function is used to return the scroll position of the given element.
+ * @param target
+ * @param top
+ */
+export declare function getScroll(target: HTMLElement | Window | Document | null, top: boolean): number;
 /**
  * @description This function is used to return a copy of the object that is composed of the picked object properties.
  * @param obj
@@ -94,6 +125,7 @@ export declare function destructComputed<T extends object>(getter: ComputedGette
 export declare function includes(arr: readonly any[], val: any): boolean;
 export declare function convertToUnit(str: number, unit?: string): string;
 export declare function convertToUnit(str: string | number | null | undefined, unit?: string): string | undefined;
+export declare function convertRemToPx(value: string): number;
 /**
  * Clamp a value between a min and max
  * @param value
@@ -113,6 +145,25 @@ export declare function isFixedPosition(el?: HTMLElement): boolean;
 export declare function padStart(string: number | string, targetLength: number, padString: string): string;
 export declare function pad(n: string | number, length?: number): string;
 export declare function refElement<T extends Record<string, any> | undefined>(obj: T): Exclude<T, ComponentPublicInstance> | HTMLElement;
+export declare function omit<T extends object, K extends keyof T>(obj: T, fields: K[]): Omit<T, K>;
+export declare function findChildrenWithProvide(key: InjectionKey<any> | symbol, vnode?: VNodeChild | {
+    [key: string]: any;
+}): ComponentInternalInstance[];
+export declare function focusableChildren(el: Element): HTMLElement[];
+/**
+ * https://github.com/lodash/lodash/blob/master/partition.js
+ * @param items
+ * @param predicates
+ */
+export declare function partition<T>(items: T[], predicates: (item: T) => boolean): [T[], T[]];
+export declare function matchesSelector<T>(el: T | Element | undefined, selector: string): boolean | null;
+/**
+ * Debounce function
+ * @param fn
+ * @param delay
+ */
+export declare function debounce(fn: Function, delay: number): (...args: any[]) => void;
+export declare function noop(): void;
 /**
  * Types
  */
@@ -122,4 +173,13 @@ export declare type MaybePick<T extends object, U extends Extract<keyof T, strin
 export declare type EventProp<T = (...args: any[]) => any> = T;
 declare type NotAUnion<T> = [T] extends [infer U] ? _NotAUnion<U, U> : never;
 declare type _NotAUnion<T, U> = U extends any ? ([T] extends [U] ? unknown : never) : never;
+export declare type ComponentProps<C extends Component> = C extends new (...args: any) => any ? Omit<InstanceType<C>['$props'], keyof VNodeProps | keyof AllowedComponentProps> : never;
+/**
+ * Maybe it's a ref, or a plain value, or a getter function
+ *
+ * ```ts
+ * type MaybeRefOrGetter<T> = (() => T) | T | Ref<T> | ComputedRef<T>
+ * ```
+ */
+export declare type MaybeRefOrGetter<T> = MaybeRef<T> | (() => T);
 export {};

package/dist/utils/index.d.ts

@@ -1,15 +1,24 @@
-export * from './propsFactory';
 export * from './helpers';
+export * from './propsFactory';
 export * from './getCurrentInstance';
-export * from './getScrollParent';
-export * from './globals';
-export * from './dom';
-export * from './anchor';
-export * from './box';
-export * from './animation';
-export * from './cache';
+export * from './use/reactivePick';
+export * from './use/eagerComputed';
+export * from './use/pickAttrs';
+export * from './use/cache';
+export * from './use/copyToClipboard';
 export * from './changeCase/noCase';
 export * from './changeCase/lowerCase';
 export * from './changeCase/pascalCase';
 export * from './changeCase/paramCase';
-export * from './date';
+export * from './date/date';
+export * from './dom/globals';
+export * from './dom/getScrollParent';
+export * from './dom/dom';
+export * from './dom/anchor';
+export * from './dom/box';
+export * from './dom/animation';
+export * from './dom/scrollTo';
+export * from './dom/wrapperRaf';
+export * from './dom/warn';
+export * from './dom/classNames';
+export * from './dom/hRender';

package/dist/utils/use/copyToClipboard.d.ts

@@ -0,0 +1 @@
+export declare function copyToClipboard(text: string): Promise<unknown>;

package/dist/utils/use/eagerComputed.d.ts

@@ -0,0 +1,3 @@
+import type { ComputedRef } from 'vue';
+export declare type ComputedGetter<T> = (...args: any[]) => T;
+export declare function eagerComputed<T>(fn: ComputedGetter<T>): ComputedRef<T>;

package/dist/utils/use/pickAttrs.d.ts

@@ -0,0 +1,11 @@
+export interface IAttrsPickConfig {
+    aria?: boolean;
+    data?: boolean;
+    attr?: boolean;
+}
+/**
+ * Picker props from exist props with filter
+ * @param props Passed props
+ * @param ariaOnly boolean | { aria?: boolean; data?: boolean; attr?: boolean; } filter config
+ */
+export declare function pickAttrs(props: Record<string, any>, ariaOnly?: boolean | IAttrsPickConfig): Record<string, any>;

package/dist/utils/use/reactiveComputed.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Computed reactive object.
+ */
+export declare function reactiveComputed<T extends {}>(fn: () => T): T;

package/dist/utils/use/reactivePick.d.ts

@@ -0,0 +1,8 @@
+import type { UnwrapRef } from 'vue';
+export declare type ReactivePickPredicate<T> = (value: T[keyof T], key: keyof T) => boolean;
+export declare function reactivePick<T extends object, K extends keyof T>(obj: T, ...keys: (K | K[])[]): {
+    [S in K]: UnwrapRef<T[S]>;
+};
+export declare function reactivePick<T extends object>(obj: T, predicate: ReactivePickPredicate<T>): {
+    [S in keyof T]?: UnwrapRef<T[S]>;
+};

package/dist/utils/use/toReactive.d.ts

@@ -0,0 +1,8 @@
+import type { MaybeRef } from '../';
+/**
+ * Converts ref to reactive.
+ *
+ * @see https://vueuse.org/toReactive
+ * @param objectRef A ref of object
+ */
+export declare function toReactive<T extends object>(objectRef: MaybeRef<T>): T;

package/dist/utils/use/toValue.d.ts

@@ -0,0 +1,5 @@
+import type { MaybeRefOrGetter } from '../';
+/**
+ * Get the value of value/ref/getter.
+ */
+export declare function toValue<T>(r: MaybeRefOrGetter<T>): T;