@milaboratories/uikit 1.2.3

package/dist/src/components/SliderRange.vue.d.ts

@@ -0,0 +1,59 @@
+import type { SliderMode } from '../types';
+declare function __VLS_template(): {
+    slots: {
+        tooltip?(_: {}): any;
+    };
+    refs: {
+        barRef: HTMLDivElement;
+        thumbRef1: HTMLDivElement;
+        thumbRef2: HTMLDivElement;
+    };
+    attrs: Partial<{}>;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import("vue").DefineComponent<{
+    modelValue: [number, number];
+    min?: number;
+    max: number;
+    step?: number;
+    label?: string;
+    helper?: string;
+    error?: string;
+    mode?: SliderMode;
+    measure?: string;
+    breakpoints?: boolean;
+    disabled?: boolean;
+}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (...args: any[]) => void;
+}, string, import("vue").PublicProps, Readonly<{
+    modelValue: [number, number];
+    min?: number;
+    max: number;
+    step?: number;
+    label?: string;
+    helper?: string;
+    error?: string;
+    mode?: SliderMode;
+    measure?: string;
+    breakpoints?: boolean;
+    disabled?: boolean;
+}> & Readonly<{
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+}>, {
+    error: string;
+    label: string;
+    disabled: boolean;
+    mode: SliderMode;
+    helper: string;
+    step: number;
+    min: number;
+    measure: string;
+    breakpoints: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/src/components/SliderRangeTriple.vue.d.ts

@@ -0,0 +1,61 @@
+import type { SliderMode } from '../types';
+type ModelType = [number, number, number];
+declare function __VLS_template(): {
+    slots: {
+        tooltip?(_: {}): any;
+    };
+    refs: {
+        barRef: HTMLDivElement;
+        thumbRef1: HTMLDivElement;
+        thumbRef2: HTMLDivElement;
+        thumbRef3: HTMLDivElement;
+    };
+    attrs: Partial<{}>;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import("vue").DefineComponent<{
+    modelValue: ModelType;
+    min?: number;
+    max: number;
+    step?: number;
+    label?: string;
+    helper?: string;
+    error?: string;
+    mode?: SliderMode;
+    measure?: string;
+    breakpoints?: boolean;
+    disabled?: boolean;
+}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (...args: any[]) => void;
+}, string, import("vue").PublicProps, Readonly<{
+    modelValue: ModelType;
+    min?: number;
+    max: number;
+    step?: number;
+    label?: string;
+    helper?: string;
+    error?: string;
+    mode?: SliderMode;
+    measure?: string;
+    breakpoints?: boolean;
+    disabled?: boolean;
+}> & Readonly<{
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+}>, {
+    error: string;
+    label: string;
+    disabled: boolean;
+    mode: SliderMode;
+    helper: string;
+    step: number;
+    min: number;
+    measure: string;
+    breakpoints: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/src/components/TabItem.vue.d.ts

@@ -0,0 +1,14 @@
+import type { ListOption } from '../types';
+declare const _default: import("vue").DefineComponent<{
+    item: ListOption;
+    isSelected: boolean;
+    isHovered: boolean;
+}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{
+    item: ListOption;
+    isSelected: boolean;
+    isHovered: boolean;
+}> & Readonly<{}>, {
+    isSelected: boolean;
+    isHovered: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/src/components/ThemeSwitcher.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/src/components/TransitionSlidePanel.vue.d.ts

@@ -0,0 +1,16 @@
+declare function __VLS_template(): {
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    attrs: Partial<{}>;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/src/components/VScroll.vue.d.ts

@@ -0,0 +1,14 @@
+declare const _default: import("vue").DefineComponent<{
+    scrollTop: number;
+    clientHeight: number;
+    scrollHeight: number;
+}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:scrollTop": (...args: any[]) => void;
+}, string, import("vue").PublicProps, Readonly<{
+    scrollTop: number;
+    clientHeight: number;
+    scrollHeight: number;
+}> & Readonly<{
+    "onUpdate:scrollTop"?: ((...args: any[]) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/src/components/contextMenu/Menu.vue.d.ts

@@ -0,0 +1,11 @@
+import type { ContextOption } from './types';
+declare const _default: import("vue").DefineComponent<{
+    options: readonly ContextOption[];
+}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    close: (...args: any[]) => void;
+}, string, import("vue").PublicProps, Readonly<{
+    options: readonly ContextOption[];
+}> & Readonly<{
+    onClose?: ((...args: any[]) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/src/components/contextMenu/index.d.ts

@@ -0,0 +1,2 @@
+import type { ContextOption } from './types';
+export declare function showContextMenu(ev: MouseEvent, options: readonly ContextOption[]): () => void;

package/dist/src/components/contextMenu/types.d.ts

@@ -0,0 +1,4 @@
+export type ContextOption = {
+    text: string;
+    cb: () => void;
+};

package/dist/src/composition/useClickOutside.d.ts

@@ -0,0 +1,4 @@
+import type { Ref } from 'vue';
+type HtmlRef = Ref<HTMLElement | undefined>;
+export declare function useClickOutside(el: HtmlRef | HtmlRef[], cb: () => void): void;
+export {};

package/dist/src/composition/useDraggable.d.ts

@@ -0,0 +1,2 @@
+import type { MaybeRef } from '../types';
+export declare function useDraggable<T extends HTMLElement>(elRef: MaybeRef<T | undefined>, cb: (ev: MouseEvent) => void): void;

package/dist/src/composition/useEventListener.d.ts

@@ -0,0 +1,6 @@
+import type { MaybeRef } from '../types';
+type EventMap = WindowEventMap & HTMLElementEventMap & {
+    adjust: Event;
+};
+export declare function useEventListener<T extends EventTarget, E extends EventMap[K], K extends keyof EventMap>(target: MaybeRef<T | undefined>, type: K, callback: (this: T, evt: E) => void, capture?: boolean): void;
+export {};

package/dist/src/composition/useFilteredList.d.ts

@@ -0,0 +1,3 @@
+import type { ComputedRef, Ref } from 'vue';
+import type { ListOption } from '../types';
+export declare function useFilteredList(items: Ref<ListOption[]>, searchPhrase: Ref<string>): ComputedRef<ListOption[]>;

package/dist/src/composition/useFormState.d.ts

@@ -0,0 +1,5 @@
+import type { Ref, UnwrapRef } from 'vue';
+export declare function useFormState<Source, D extends Record<string, unknown>>(source: Ref<Source>, fromSource: (source: Source) => D, update: (data: UnwrapRef<D>) => void): {
+    data: UnwrapRef<D>;
+    changed: boolean;
+};

package/dist/src/composition/useHover.d.ts

@@ -0,0 +1,7 @@
+import type { Ref } from 'vue';
+import type { MaybeRef } from '../types';
+export interface UseElementHoverOptions {
+    delayEnter?: number;
+    delayLeave?: number;
+}
+export declare function useHover(el: MaybeRef<EventTarget | undefined>, options?: UseElementHoverOptions): Ref<boolean>;

package/dist/src/composition/useInterval.d.ts

@@ -0,0 +1 @@
+export declare function useInterval(update: () => void, ms: number): void;

package/dist/src/composition/useLocalStorage.d.ts

@@ -0,0 +1,2 @@
+import type { Ref } from 'vue';
+export declare function useLocalStorage<T extends string>(key: string): Ref<T | null, T | null>;

package/dist/src/composition/useMouse.d.ts

@@ -0,0 +1,4 @@
+export declare function useMouse(): {
+    x: number;
+    y: number;
+};

package/dist/src/composition/useMouseCapture.d.ts

@@ -0,0 +1,15 @@
+import type { MaybeRef } from '../types';
+type CustomEvent = {
+    x: number;
+    y: number;
+    dx: number;
+    dy: number;
+    stop?: boolean;
+};
+type CaptureState = {
+    el: HTMLElement | undefined;
+    x: number;
+    y: number;
+};
+export declare function useMouseCapture<T extends HTMLElement>(elRef: MaybeRef<T | undefined>, cb: (ev: CustomEvent, state: CaptureState) => void): void;
+export {};

package/dist/src/composition/useNotificationPosition.d.ts

@@ -0,0 +1,2 @@
+import { type Ref } from 'vue';
+export declare function useNotificationPosition(el: Ref<HTMLElement | undefined>): Ref<string, string>;

package/dist/src/composition/usePosition.d.ts

@@ -0,0 +1,3 @@
+import { type Ref } from 'vue';
+import type { ElementPosition } from '../types';
+export declare function useElementPosition(el: Ref<HTMLElement | undefined>, cb: (pos: ElementPosition) => void): void;

package/dist/src/composition/useQuery.d.ts

@@ -0,0 +1,7 @@
+export declare function useQuery<P extends unknown[], R>(fn: (...args: P) => Promise<R>): {
+    isLoading: boolean;
+    result: import("vue").UnwrapRef<R> | undefined;
+    error: unknown;
+    run: (...args: P) => Promise<void>;
+    debounce: (cb: () => P, dt?: number) => () => void;
+};

package/dist/src/composition/useResizeObserver.d.ts

@@ -0,0 +1,2 @@
+import type { MaybeRef } from '../types';
+export declare function useResizeObserver<T extends HTMLElement>(target: MaybeRef<T | undefined>, cb: (el?: T | undefined) => void): void;

package/dist/src/composition/useRipple.d.ts

@@ -0,0 +1,2 @@
+import type { Ref } from 'vue';
+export declare function useRipple(el: Ref<HTMLElement | undefined>): void;

package/dist/src/composition/useScroll.d.ts

@@ -0,0 +1,2 @@
+import { type Ref } from 'vue';
+export declare function useScroll($el: Ref<HTMLElement | undefined>, fadeHeight?: number | null, fadeWidth?: number | null): void;

package/dist/src/composition/useSliderBreakpoints.d.ts

@@ -0,0 +1,6 @@
+import type { ComputedRef } from 'vue';
+export declare const useSliderBreakpoints: (props: ComputedRef<{
+    min: number;
+    max: number;
+    step: number;
+}>) => ComputedRef<number[]>;

package/dist/src/composition/useSortable.d.ts

@@ -0,0 +1,9 @@
+import type { Ref } from 'vue';
+export type SortableSettings = {
+    onChange: (indices: number[]) => void;
+    handle?: string;
+    shakeBuffer?: number;
+    reorderDelay?: number;
+    transitionDelay?: string;
+};
+export declare function useSortable(listRef: Ref<HTMLElement | undefined>, settings: SortableSettings): void;

package/dist/src/composition/useTheme.d.ts

@@ -0,0 +1,4 @@
+type Theme = 'light' | 'dark';
+type Callback = (mode: Theme) => void;
+export declare function useTheme(_cb?: Callback): readonly [import("vue").ComputedRef<Theme>, () => void];
+export {};

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

@@ -0,0 +1 @@
+export declare function onChanged(hook: () => unknown): void;

package/dist/src/demo-site-data/all-css-variables.d.ts

@@ -0,0 +1,8 @@
+export declare function allCssVariables(): Record<string, {
+    title: string;
+    data: Record<string, {
+        light: [boolean, boolean];
+        value: [string, string];
+        description: string;
+    }>;
+}>;

package/dist/src/drafts/FileBaseInput.vue.d.ts

@@ -0,0 +1,40 @@
+type PropsType = {
+    modelValue: File[] | null;
+    title?: string;
+    description?: string;
+    acceptedTypes?: string;
+    multiple?: boolean;
+    buttonText?: string;
+    disabled?: boolean;
+};
+declare function __VLS_template(): {
+    slots: {
+        actions?(_: {}): any;
+    };
+    refs: {
+        fileInput: HTMLInputElement;
+    };
+    attrs: Partial<{}>;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import("vue").DefineComponent<PropsType, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    "update:modelValue": (files: File[] | null) => any;
+    selected: (files: File[]) => any;
+}, string, import("vue").PublicProps, Readonly<PropsType> & Readonly<{
+    "onUpdate:modelValue"?: ((files: File[] | null) => any) | undefined;
+    onSelected?: ((files: File[]) => any) | undefined;
+}>, {
+    title: string;
+    modelValue: File[] | null;
+    description: string;
+    acceptedTypes: string;
+    multiple: boolean;
+    buttonText: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/src/global/resizeObserver.d.ts

@@ -0,0 +1,2 @@
+export declare function startResizeObserving(el: Element, cb: (entry: ResizeObserverEntry) => void): void;
+export declare function stopResizeObserving(el: Element): void;

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

@@ -0,0 +1,11 @@
+export declare function isElementVisible(parent: HTMLElement, el: HTMLElement): boolean;
+export declare function getElementScrollPosition(parent: HTMLElement, el: HTMLElement): "visible" | "ceil" | "floor";
+export declare function scrollIntoView(parent: HTMLElement, el: HTMLElement, options?: {
+    duration?: number;
+}): void;
+export declare function eventListener<K extends keyof DocumentEventMap>(el: Document, type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): () => void;
+export declare function eventListener<K extends keyof HTMLElementEventMap>(el: HTMLElement, type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): () => void;
+export declare function detectOutside(e: {
+    x: number;
+    y: number;
+}, el: HTMLElement): boolean;

package/dist/src/helpers/functions.d.ts

@@ -0,0 +1,5 @@
+export declare function tap<T, R>(v: T, cb: (v: T) => R): R;
+export declare function tapIf<T, R>(v: T | null | undefined, cb: (v: T) => R): R | undefined;
+export declare function flatValue<T>(v: T | T[]): T[];
+export declare function generate<R>(count: number, cb: (i: number) => R): R[];
+export declare function copyProps<T extends Record<string, unknown>>(target: T, source: T, ...keys: (keyof T)[]): void;

package/dist/src/helpers/index.d.ts

@@ -0,0 +1 @@
+export declare function requestTick<P>(cb: (...args: P[]) => void): (...args: P[]) => void;

package/dist/src/helpers/iterators.d.ts

@@ -0,0 +1,3 @@
+export declare function mapIterable<T, R>(it: Iterable<T>, cb: (v: T) => R): Generator<R, void, unknown>;
+export declare function filterIterable<T>(it: Iterable<T>, cb: (v: T) => boolean): Generator<T, void, unknown>;
+export declare function toList<T>(it: Iterable<T>): T[];

package/dist/src/helpers/math.d.ts

@@ -0,0 +1 @@
+export declare function clamp(n: number, lo: number, up: number): number;

package/dist/src/helpers/objects.d.ts

@@ -0,0 +1,3 @@
+export declare function isRecord<V, T extends Record<string, V>>(obj: T | unknown): obj is T;
+export declare function deepEqual(a: unknown, b: unknown): boolean;
+export declare function deepIncludes<T>(arr: T[], search: T): boolean;

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

@@ -0,0 +1,25 @@
+import type { ListOption } from '../types';
+export declare function call<R>(f: () => R): R;
+export declare function notEmpty<T>(v: T | null | undefined, message: string): T;
+export declare function requestTick<P>(cb: (...args: P[]) => void): (...args: P[]) => void;
+export declare function delay(ms: number): Promise<unknown>;
+export declare function timeout(cb: () => void, ms: number): () => void;
+export declare function randomInt(min: number, max: number): number;
+export declare function randomString(length: number): string;
+export declare function makeEaseOut(timing: (t: number) => number): (timeFraction: number) => number;
+export declare function makeEaseInOut(timing: (t: number) => number): (timeFraction: number) => number;
+export declare function animate(options: {
+    duration: number;
+    draw: (p: number) => void;
+    timing: (t: number) => number;
+}): () => void;
+export declare function animateInfinite(options: {
+    getFraction: (dt: number) => number;
+    draw: (p: number) => void;
+    timing: (t: number) => number;
+}): () => void;
+type AnyFunction = (...args: any[]) => any;
+export declare function debounce<F extends AnyFunction>(func: F, delay: number): (...args: Parameters<F>) => void;
+export declare function throttle<F extends AnyFunction>(callback: F, ms: number, trailing?: boolean): (...args: Parameters<F>) => void;
+export declare function listToOptions<T>(list: T[] | readonly T[]): ListOption<T>[];
+export {};