pxd 0.0.39 → 0.0.41

package/dist/src/composables/use-pointer-gesture.d.ts

@@ -0,0 +1,180 @@
+import type { MaybeElementRef } from '../types/shared/utils';
+type Axis = 'x' | 'y' | 'both';
+type Dir = 'left' | 'right' | 'up' | 'down' | null;
+/**
+ * 速度向量。
+ * @property x - X 方向速度（px/s）
+ * @property y - Y 方向速度（px/s）
+ * @property v - 合速度（px/s）
+ */
+interface Velocity {
+    x: number;
+    y: number;
+    v: number;
+}
+/**
+ * 对外公开的手势状态。
+ * @property isActive - 指针是否按下激活
+ * @property isDragging - 是否处于拖拽中（超过启动阈值）
+ * @property isLongPressing - 是否处于长按态
+ * @property direction - 当前判定的方向（可能为 null）
+ * @property delta - 自按下以来位移（px）
+ * @property velocity - 当前速度（px/s）
+ * @property progress - 触发进度（0~1，基于 triggerThreshold）
+ */
+export interface PublicState {
+    isActive: boolean;
+    isDragging: boolean;
+    isLongPressing: boolean;
+    direction: Dir;
+    delta: {
+        x: number;
+        y: number;
+    };
+    velocity: Velocity;
+    progress: number;
+}
+/**
+ * usePointerGesture 的可配置项。
+ * 如未指定，均有默认值（见 OPTIONS_DEFAULTS）。
+ */
+export interface UsePointerGestureOptions {
+    /**
+     * 限制生效轴向。
+     * 返回 'x' | 'y' | 'both'，默认为 'both'。
+     */
+    axis?: () => Axis;
+    /**
+     * 拖拽启动阈值（px）。手指移动距离超过该值后进入拖拽。
+     * 默认 6。
+     */
+    startThreshold?: number;
+    /**
+     * 触发阈值（px）。释放时若位移达到该值视为命中触发（kind='threshold'）。
+     * 默认 80。
+     */
+    triggerThreshold?: number;
+    /**
+     * 甩动触发速度阈值（px/s）。移动中若合速度超过该值将记录可能触发为 'fling'。
+     * 默认 1000。
+     */
+    velocityThreshold?: number;
+    /**
+     * 长按判定时长（ms）。到达该时长后进入长按态并触发 onLongPress。
+     * 默认 300。
+     */
+    longPressMs?: number;
+    /**
+     * 长按容忍移动距离（px）。在进入拖拽前，若移动超过该距离则取消长按。
+     * 默认 4。
+     */
+    longPressMoveTolerance?: number;
+    /**
+     * 是否在拖拽开始时锁定轴向。开启后根据初始位移较大方向锁定为 'x' 或 'y'。
+     * 默认 true。
+     */
+    lockDirectionOnStart?: boolean;
+    /**
+     * 是否允许在可滚动容器尚可继续滚动时将移动交由滚动，直到触达边缘才接管拖拽。
+     * 默认 true。
+     */
+    allowScrollUntilEdge?: boolean;
+    /**
+     * 拖拽期间是否调用 preventDefault 阻止滚动。
+     * 默认 true。
+     */
+    preventScrollOnDrag?: boolean;
+    /**
+     * 是否使用 Pointer Capture（setPointerCapture/releasePointerCapture）。
+     * 默认 true。
+     */
+    usePointerCapture?: boolean;
+    /**
+     * RTL 支持：
+     * - 若为 boolean，true 表示水平方向取反（dx>0 视为向左）；false 为自然方向
+     * - 若为函数，可根据 dx 自定义返回 'left' 或 'right'
+     * 默认 false。
+     */
+    rtl?: boolean | ((dx: number) => 'left' | 'right');
+    /**
+     * 提供一个返回可参与滚动判断的元素（通常为最近滚动容器内的滚动元素）。
+     * 若不提供，将自动查找。
+     */
+    getScrollable?: () => HTMLElement | null;
+    /**
+     * 指针按下时回调。
+     * @param e - PointerEvent
+     * @param ctx - 当前公开状态
+     */
+    onStart?: (e: PointerEvent, ctx: PublicState) => void;
+    /**
+     * 指针移动时回调（拖拽中会持续触发，可用于执行动画）。
+     * @param e - PointerEvent
+     * @param ctx - 当前公开状态
+     */
+    onMove?: (e: PointerEvent, ctx: PublicState) => void;
+    /**
+     * 指针释放时统一回调。
+     * - 命中触发条件时：hit=true，并给出方向 dir 与触发类型 kind（'threshold' | 'longpress' | 'fling'）
+     * - 未命中时：hit=false，dir=null，kind=null；此时会自动调用 onReset 便于复位动画
+     * @param hit - 是否命中触发
+     * @param dir - 方向（未命中为 null）
+     * @param kind - 触发类型（未命中为 null）
+     * @param ctx - 当前公开状态
+     */
+    onRelease?: (hit: boolean, dir: Dir, kind: null | 'threshold' | 'longpress' | 'fling', ctx: PublicState) => void;
+    /**
+     * 指针生命周期结束时回调（在 onRelease 之前调用）。
+     * @param e - PointerEvent
+     * @param ctx - 当前公开状态
+     */
+    onEnd?: (e: PointerEvent, ctx: PublicState) => void;
+    /**
+     * 手势被取消时回调（如 pointercancel 或主动 cancel）。
+     * @param e - 事件对象；由 cancel() 触发时为 null
+     * @param ctx - 当前公开状态
+     */
+    onCancel?: (e: Event | null, ctx: PublicState) => void;
+    /**
+     * 复位回调：取消或未命中触发条件时会自动调用，便于执行复位动画。
+     * @param ctx - 当前公开状态
+     */
+    onReset?: (ctx: PublicState) => void;
+    /**
+     * 长按回调：达到长按时长后触发。
+     * @param ctx - 当前公开状态
+     */
+    onLongPress?: (ctx: PublicState) => void;
+    /**
+     * 指针守卫：记录后续是否需要响应事件, 只在 pointer-down 中执行一次
+     * 返回 true 表示允许，false 表示阻止触发。
+     * @param e - PointerEvent
+     */
+    pointerGuard?: (e: PointerEvent) => boolean;
+    /**
+     * 方向守卫：在记录触发与最终释放判定处均会调用，用于限制允许的触发方向。
+     * 返回 true 表示允许，false 表示阻止触发。
+     * @param dir - 非空方向
+     * @param ctx - 当前公开状态
+     */
+    directionGuard?: (dir: Exclude<Dir, null>, ctx: PublicState) => boolean;
+}
+export declare function usePointerGesture(container: MaybeElementRef<HTMLElement>, options?: UsePointerGestureOptions): {
+    isActive: import("vue").ShallowRef<boolean, boolean>;
+    isDragging: import("vue").ShallowRef<boolean, boolean>;
+    isLongPressing: import("vue").ShallowRef<boolean, boolean>;
+    direction: import("vue").ShallowRef<Dir, Dir>;
+    delta: import("vue").ShallowRef<{
+        x: number;
+        y: number;
+    }, {
+        x: number;
+        y: number;
+    }>;
+    velocity: import("vue").ShallowRef<Velocity, Velocity>;
+    progress: import("vue").ShallowRef<number, number>;
+    reset: () => void;
+    cancel: () => void;
+    stop: () => void;
+};
+export {};

package/dist/src/composables/use-repeat-action.d.ts

@@ -0,0 +1,16 @@
+import type { MaybeRefOrGetter } from 'vue';
+import type { Callback } from '../types/shared/utils';
+interface RepeatActionReturnType {
+    start: Callback;
+    stop: Callback;
+}
+interface UseRepeatActionOptions {
+    action: Callback;
+    disabled?: MaybeRefOrGetter<boolean>;
+    finalInterval?: number;
+    initialInterval?: number;
+    accelerationDuration?: number;
+}
+export declare function useRepeatAction(action: Callback): RepeatActionReturnType;
+export declare function useRepeatAction(options: UseRepeatActionOptions): RepeatActionReturnType;
+export {};

package/dist/src/composables/use-unique-id-context.d.ts

@@ -0,0 +1,2 @@
+export declare function provideUniqueId(injectionKey?: string): string;
+export declare function useUniqueId(injectionKey?: string): string;

package/dist/src/composables/use-virtual-list.d.ts

@@ -0,0 +1,16 @@
+import type { ComponentPublicInstance } from 'vue';
+export interface VirtualListProps {
+    dataKey?: string;
+    listData: any[];
+    itemSize: number;
+}
+export declare function useVirtualList<Props extends VirtualListProps>(props: Props): {
+    containerRef: import("vue").ShallowRef<HTMLElement, HTMLElement>;
+    renderList: import("vue").ComputedRef<any[]>;
+    listHeight: import("vue").ComputedRef<number>;
+    listStyle: import("vue").ComputedRef<string>;
+    stop: () => void;
+    setItemRef: (el: Element | ComponentPublicInstance | null, key: number | string) => void;
+    updateContainerHeight: () => void;
+    getStartIndex: (scrollTop: number) => number;
+};

package/dist/src/contexts/avatar.d.ts

@@ -0,0 +1,2 @@
+import type { AvatarGroupProps } from '../types/components/avatar';
+export declare const provideAvatarGroupContext: (contextValue: AvatarGroupProps) => AvatarGroupProps, useAvatarGroupContext: (fallback?: AvatarGroupProps) => AvatarGroupProps;

package/dist/src/contexts/carousel.d.ts

@@ -0,0 +1,13 @@
+import type { Ref } from 'vue';
+import type { CarouselGroupProps } from '../types/components/carousel';
+export interface CarouselState {
+    uid: string;
+    translateItem: (index: number, activeIndex: number) => void;
+}
+export interface CarouselGroupContext {
+    props: CarouselGroupProps;
+    carousels: Ref<CarouselState[]>;
+    registerCarousel: (state: CarouselState) => void;
+    unregisterCarousel: (id: string) => void;
+}
+export declare const provideCarouselGroupContext: (contextValue: CarouselGroupContext) => CarouselGroupContext, useCarouselGroupContext: ((fallback?: CarouselGroupContext) => CarouselGroupContext) & ((fallback: null) => CarouselGroupContext);

package/dist/src/contexts/checkbox.d.ts

@@ -0,0 +1,2 @@
+import type { CheckboxGroupProps } from '../types/components/checkbox';
+export declare const provideCheckboxGroupContext: (contextValue: CheckboxGroupProps) => CheckboxGroupProps, useCheckboxGroupContext: (fallback?: CheckboxGroupProps) => CheckboxGroupProps;

package/dist/src/contexts/choicebox.d.ts

@@ -0,0 +1,4 @@
+import type { Ref } from 'vue';
+import type { ChoiceboxGroupProps } from '../types/components/choicebox';
+export declare const provideChoiceboxGroupContext: (contextValue: ChoiceboxGroupProps) => ChoiceboxGroupProps, useChoiceboxGroupContext: ((fallback?: ChoiceboxGroupProps) => ChoiceboxGroupProps) & ((fallback: null) => ChoiceboxGroupProps);
+export declare const provideChoiceboxGroupModelValue: (contextValue: Ref<import("../types/shared").ComponentValue | import("../types/shared").ComponentValue[], import("../types/shared").ComponentValue | import("../types/shared").ComponentValue[]>) => Ref<import("../types/shared").ComponentValue | import("../types/shared").ComponentValue[], import("../types/shared").ComponentValue | import("../types/shared").ComponentValue[]>, useChoiceboxGroupModelValue: ((fallback?: Ref<import("../types/shared").ComponentValue | import("../types/shared").ComponentValue[], import("../types/shared").ComponentValue | import("../types/shared").ComponentValue[]>) => Ref<import("../types/shared").ComponentValue | import("../types/shared").ComponentValue[], import("../types/shared").ComponentValue | import("../types/shared").ComponentValue[]>) & ((fallback: null) => Ref<import("../types/shared").ComponentValue | import("../types/shared").ComponentValue[], import("../types/shared").ComponentValue | import("../types/shared").ComponentValue[]>);

package/dist/src/contexts/collapse.d.ts

@@ -0,0 +1,8 @@
+import type { Ref } from 'vue';
+interface CollapseGroupContext {
+    multiple: Ref<boolean>;
+    isExpanded: (id: string) => boolean;
+    toggleItem: (id: string, expanded: boolean) => void;
+}
+export declare const provideCollapseGroupContext: (contextValue: CollapseGroupContext) => CollapseGroupContext, useCollapseGroupContext: ((fallback?: CollapseGroupContext) => CollapseGroupContext) & ((fallback: null) => CollapseGroupContext);
+export {};

package/dist/src/contexts/list.d.ts

@@ -0,0 +1,8 @@
+import type { Ref } from 'vue';
+import type { ListOption } from '../types/components/list';
+export interface ListContext {
+    activeValue: Ref<string>;
+    onOptionClick: ListOption['onClick'];
+}
+export declare const provideListContext: (contextValue: ListContext) => ListContext, useListContext: ((fallback?: ListContext) => ListContext) & ((fallback: null) => ListContext);
+export declare const provideListFilterValue: (contextValue: Ref<string, string>) => Ref<string, string>, useListFilterValue: (fallback?: Ref<string, string>) => Ref<string, string>;

package/dist/src/contexts/radio.d.ts

@@ -0,0 +1,2 @@
+import type { RadioGroupProps } from '../types/components/radio';
+export declare const provideRadioGroupContext: (contextValue: RadioGroupProps) => RadioGroupProps, useRadioGroupContext: (fallback?: RadioGroupProps) => RadioGroupProps;

package/dist/src/contexts/resizable.d.ts

@@ -0,0 +1,35 @@
+import type { Ref } from 'vue';
+import type { ComponentDirection } from '../types/shared/props';
+interface PanelConfig {
+    id: string;
+    order: number;
+    size?: number | null;
+    minSize?: number;
+}
+export interface ResizableContext {
+    direction: Ref<ComponentDirection>;
+    panelSizes: Ref<number[]>;
+    panelConfigs: Ref<PanelConfig[]>;
+    getPanelSize: (id: string) => number;
+    onHandleDrag: (id: string, delta: {
+        deltaX: number;
+        deltaY: number;
+    }) => void;
+    resetPanels: () => void;
+    registerPanel: (config: {
+        id: string;
+        size?: number | null;
+        minSize?: number;
+    }) => void;
+    registerHandle: (config: {
+        id: string;
+        onDrag: (delta: {
+            deltaX: number;
+            deltaY: number;
+        }) => void;
+    }) => void;
+    unregisterPanel: (id: string) => void;
+    unregisterHandle: (id: string) => void;
+}
+export declare const provideResizableContext: (contextValue: ResizableContext) => ResizableContext, useResizableContext: ((fallback?: ResizableContext) => ResizableContext) & ((fallback: null) => ResizableContext);
+export {};

package/dist/src/contexts/switch.d.ts

@@ -0,0 +1,4 @@
+import type { Ref } from 'vue';
+import type { SwitchGroupProps } from './../types/components/switch';
+export declare const provideSwitchGroupContext: (contextValue: SwitchGroupProps) => SwitchGroupProps, useSwitchGroupContext: ((fallback?: SwitchGroupProps) => SwitchGroupProps) & ((fallback: null) => SwitchGroupProps);
+export declare const provideSwitchGroupModelValue: (contextValue: Ref<string | number, string | number>) => Ref<string | number, string | number>, useSwitchGroupModelValue: ((fallback?: Ref<string | number, string | number>) => Ref<string | number, string | number>) & ((fallback: null) => Ref<string | number, string | number>);

package/dist/src/locales/en-us.d.ts

@@ -0,0 +1,42 @@
+declare const _default: {
+    date: {
+        now: string;
+        day: {
+            0: string;
+            1: string;
+            2: string;
+            3: string;
+            4: string;
+            5: string;
+            6: string;
+        };
+        month: {
+            0: string;
+            1: string;
+            2: string;
+            3: string;
+            4: string;
+            5: string;
+            6: string;
+            7: string;
+            8: string;
+            9: string;
+            10: string;
+            11: string;
+        };
+    };
+    compare: {
+        less: string;
+        more: string;
+        next: string;
+        prev: string;
+    };
+    empty: {
+        search: string;
+    };
+    confirm: {
+        ok: string;
+        cancel: string;
+    };
+};
+export default _default;

package/dist/src/plugins/dayjs-millisecond-token.d.ts

@@ -0,0 +1,3 @@
+import type { PluginFunc } from 'dayjs/esm/index.js';
+declare const millisecondTokenPlugin: PluginFunc;
+export default millisecondTokenPlugin;

package/dist/src/types/components/time-picker.d.ts

@@ -0,0 +1,4 @@
+export interface DateTimePreset<T = Date> {
+    label: string;
+    getDate: () => T;
+}

package/dist/src/utils/context.d.ts

@@ -0,0 +1,17 @@
+type InjectContextStrict<T> = ((fallback?: T) => T) & ((fallback: null) => T | null);
+/**
+ * @param providerComponentName - The name of the component providing the context.
+ */
+export declare function createContext<ContextValue>(providerComponentName: string): readonly [
+    (contextValue: ContextValue) => ContextValue,
+    InjectContextStrict<ContextValue>
+];
+export declare function createContext<ContextValue>(providerComponentName: string, fallbackValue: ContextValue): readonly [
+    (contextValue: ContextValue) => ContextValue,
+    InjectContextStrict<ContextValue>
+];
+export declare function createContext<ContextValue>(providerComponentName: string, fallbackValue: null): readonly [
+    (contextValue: ContextValue) => ContextValue,
+    (fallback?: ContextValue | null) => ContextValue | null
+];
+export {};

package/dist/src/utils/date.d.ts

@@ -0,0 +1,26 @@
+import dayjs from 'dayjs/esm/index.js';
+import dayjsDurationPlugin from 'dayjs/esm/plugin/duration/index.js';
+import dayjsMillisecondTokenPlugin from '../plugins/dayjs-millisecond-token.js';
+export { dayjs, dayjsDurationPlugin, dayjsMillisecondTokenPlugin, };
+interface Result<T> {
+    years: number[];
+    months: number[];
+    weeks: number[];
+    dates: T[];
+}
+/**
+ * 获取两个日期之间的所有日期
+ */
+export declare function getAllDatesBetween(startDate: Date | string, endDate: Date | string, format?: 'string'): Result<string>;
+export declare function getAllDatesBetween(startDate: Date | string, endDate: Date | string, format?: 'object'): Result<Date>;
+/**
+ * 获取指定年月的天数、第一天是周几、最后一天是周几
+ * @param year 年份
+ * @param month 月份
+ * @returns 天数、第一天是周几、最后一天是周几
+ */
+export declare function getMonthDays(year: number, month: number): {
+    days: number;
+    firstDay: 0 | 2 | 1 | 3 | 4 | 5 | 6;
+    lastDay: 0 | 2 | 1 | 3 | 4 | 5 | 6;
+};

package/dist/src/utils/debounce/index.d.ts

@@ -0,0 +1,73 @@
+interface DebounceOptions {
+    /**
+     * An optional AbortSignal to cancel the debounced function.
+     */
+    signal?: AbortSignal;
+    /**
+     * An optional array specifying whether the function should be invoked on the leading edge, trailing edge, or both.
+     * If `edges` includes "leading", the function will be invoked at the start of the delay period.
+     * If `edges` includes "trailing", the function will be invoked at the end of the delay period.
+     * If both "leading" and "trailing" are included, the function will be invoked at both the start and end of the delay period.
+     * @default ["trailing"]
+     */
+    edges?: Array<'leading' | 'trailing'>;
+}
+export interface DebouncedFunction<F extends (...args: any[]) => void> {
+    (...args: Parameters<F>): void;
+    /**
+     * Schedules the execution of the debounced function after the specified debounce delay.
+     * This method resets any existing timer, ensuring that the function is only invoked
+     * after the delay has elapsed since the last call to the debounced function.
+     * It is typically called internally whenever the debounced function is invoked.
+     *
+     * @returns {void}
+     */
+    schedule: () => void;
+    /**
+     * Cancels any pending execution of the debounced function.
+     * This method clears the active timer and resets any stored context or arguments.
+     */
+    cancel: () => void;
+    /**
+     * Immediately invokes the debounced function if there is a pending execution.
+     * This method executes the function right away if there is a pending execution.
+     */
+    flush: () => void;
+}
+/**
+ * Creates a debounced function that delays invoking the provided function until after `debounceMs` milliseconds
+ * have elapsed since the last time the debounced function was invoked. The debounced function also has a `cancel`
+ * method to cancel any pending execution.
+ *
+ * @template F - The type of function.
+ * @param {F} func - The function to debounce.
+ * @param {number} debounceMs - The number of milliseconds to delay.
+ * @param {DebounceOptions} options - The options object
+ * @param {AbortSignal} options.signal - An optional AbortSignal to cancel the debounced function.
+ * @returns A new debounced function with a `cancel` method.
+ *
+ * @example
+ * const debouncedFunction = debounce(() => {
+ *   console.log('Function executed');
+ * }, 1000);
+ *
+ * // Will log 'Function executed' after 1 second if not called again in that time
+ * debouncedFunction();
+ *
+ * // Will not log anything as the previous call is canceled
+ * debouncedFunction.cancel();
+ *
+ * // With AbortSignal
+ * const controller = new AbortController();
+ * const signal = controller.signal;
+ * const debouncedWithSignal = debounce(() => {
+ *  console.log('Function executed');
+ * }, 1000, { signal });
+ *
+ * debouncedWithSignal();
+ *
+ * // Will cancel the debounced function call
+ * controller.abort();
+ */
+export declare function debounce<F extends (...args: any[]) => void>(func: F, debounceMs: number, { signal, edges }?: DebounceOptions): DebouncedFunction<F>;
+export {};

package/dist/src/utils/debounce.d.ts

@@ -0,0 +1 @@
+export * from './debounce/index';

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

@@ -0,0 +1,40 @@
+import type { CSSProperties } from 'vue';
+export declare function getElementRectFromContainer(elementOrRect: HTMLElement | DOMRect, containerOrRect: HTMLElement | DOMRect): {
+    top: number;
+    bottom: number;
+    left: number;
+    right: number;
+    width: number;
+    height: number;
+    scrollTop: number;
+    scrollBottom: number;
+    scrollLeft: number;
+    scrollRight: number;
+};
+export declare function getStyle(element: HTMLElement, styleNames: keyof CSSProperties | (keyof CSSProperties)[]): string[];
+export declare function isScrollable(el: HTMLElement): {
+    x: boolean;
+    y: boolean;
+};
+export declare function hasScrollbar(el: HTMLElement): {
+    x: boolean;
+    y: boolean;
+};
+export declare function getScrollContainer(el: HTMLElement, isVertical?: boolean): Window | HTMLElement;
+export declare function getScrollPositions(el: HTMLElement | Window | Document): {
+    scrollTop: number;
+    scrollLeft: number;
+    scrollWidth: number;
+    scrollHeight: number;
+};
+export declare function getScrollElByContainer(target: any): HTMLElement;
+export interface ScrollbarSize {
+    width: number;
+    height: number;
+}
+/**
+ * 获取滚动条尺寸（宽度和高度）
+ * @param element - 要测量的元素，默认为document.body
+ * @returns 包含滚动条宽度和高度的对象
+ */
+export declare function getScrollbarSize(element?: HTMLElement): ScrollbarSize;

package/dist/{utils/events.d.ts → src/utils/event.d.ts}

@@ -5,4 +5,5 @@ export declare function off<E extends Event = Event>(el: Nullable<EventTarget>,
 export declare function once<E extends Event = Event>(el: Nullable<EventTarget>, event: string, handler: EventHandler<E>, options?: AddEventListenerOptions): void;
 export declare function optimizedOn<E extends Event = Event>(el: Nullable<EventTarget>, event: string, handler: EventHandler<E>, options?: AddEventListenerOptions): void;
 export declare function optimizedOff<E extends Event = Event>(el: Nullable<EventTarget>, event: string, handler: EventHandler<E>, options?: AddEventListenerOptions): void;
+export declare function sleep(ms: number): Promise<unknown>;
 export {};

package/dist/src/utils/format.d.ts

@@ -0,0 +1,25 @@
+import type { CSSValue, Nullable } from '../types/shared/utils';
+/** string -> String */
+export declare function capitalize(text: string): string;
+/** kabab-case -> kababCase */
+export declare function camelize(str: string): string;
+/** kabab-case -> KababCase */
+export declare function pascalize(text: string): string;
+/** KababCase -> kabab-case */
+export declare function uncapitalize(text: string): string;
+/** 'kabab-case' -> 'Kabab Case' */
+export declare function humanize(text: string): string;
+export declare function isTruthyProp(value: unknown): unknown;
+export declare function clampValue(n: number, min: number, max: number): number;
+export declare function isExternalLink(href: string): boolean;
+export declare function toArray(value: unknown | unknown[]): any[];
+export declare function getCssUnitValue(value: Nullable<CSSValue | string>, fallbackValue?: string): string;
+/**
+ * Increase string a value with unit
+ *
+ * @example '2px' + 1 = '3px'
+ * @example '15em' + (-2) = '13em'
+ */
+export declare function increaseWithUnit(target: number, delta: number): number;
+export declare function increaseWithUnit(target: string, delta: number): string;
+export declare function increaseWithUnit(target: string | number, delta: number): string | number;

package/dist/src/utils/get.d.ts

@@ -0,0 +1,11 @@
+import type { Nullable } from '../types/shared/utils';
+type PathArray = ReadonlyArray<PropertyKey>;
+type PathValue<T, P extends PathArray> = P extends [] ? T : P extends [infer K, ...infer R] ? K extends PropertyKey ? R extends PathArray ? PathValue<GetAtStep<NonNullable<T>, K>, R> : unknown : unknown : unknown;
+type GetAtStep<T, K> = K extends keyof T ? T[K] : K extends number ? T extends readonly (infer U)[] ? U : T extends {
+    [key: number]: infer V;
+} ? V : unknown : K extends string ? K extends keyof T ? T[K] : unknown : K extends symbol ? K extends keyof T ? T[K] : unknown : unknown;
+export declare function get<T, P extends PathArray, D = undefined>(obj: T, path: P, defaultValue?: D): PathValue<T, P> | D;
+export declare function get<T, D = undefined>(obj: T, path: string | PropertyKey, defaultValue?: D): unknown | D;
+export declare function getFallbackValue<Variants extends Record<string, any>>(variant: Nullable<string>, variants: Variants, defaultVariant?: keyof Variants): any;
+export declare function getColorByThreshold(value: number, colors: Record<string, string>): string;
+export {};

package/dist/src/utils/is.d.ts

@@ -0,0 +1,4 @@
+export declare const isVue3: boolean;
+export declare const isServer: boolean;
+export declare const isTouchDevice: () => boolean;
+export declare const isNotNullish: <T>(value: T) => value is NonNullable<T>;

package/dist/src/utils/ref.d.ts

@@ -0,0 +1,5 @@
+import type { ComponentPublicInstance, MaybeRefOrGetter } from 'vue';
+import type { MaybeElement } from '../types/shared/utils';
+export type UnRefElementReturn<T extends MaybeElement = MaybeElement> = T extends ComponentPublicInstance ? Exclude<MaybeElement, ComponentPublicInstance> : T | undefined;
+export declare function toValue<T>(source: MaybeRefOrGetter<T>): T;
+export declare function unrefElement<T extends MaybeElement>(elRef: MaybeRefOrGetter<T>): UnRefElementReturn<T>;

package/dist/src/utils/regexp.d.ts

@@ -0,0 +1,8 @@
+export declare const INTEGER_REGEX: RegExp;
+export declare const FLOATING_REGEX: RegExp;
+export declare const POSITIVE_INTEGER_REGEX: RegExp;
+export declare const SCIENCE_NUMERIC_REGEX: RegExp;
+export declare const DATE_REGEX: RegExp;
+export declare const TIME_REGEX: RegExp;
+export declare const DATE_TIME_REGEX: RegExp;
+export declare const TIME_REGEX_WITH_MILLISECONDS: RegExp;

package/dist/src/utils/responsive.d.ts

@@ -0,0 +1,3 @@
+import type { ResponsiveValue } from '../types/shared/props';
+import type { Nullable } from '../types/shared/utils';
+export declare function getResponsiveValue<V extends string | number>(prop: ResponsiveValue<V> | undefined, xsValue: Nullable<V>, valueSetter: (acc: Record<string, V>, bp: any, v: V) => void): Record<string, V>;