@varlet/use/lib/index.d.ts

composable utils of varlet

import { MotionState } from "@varlet/shared";
import { ComponentInternalInstance, ComputedRef, Ref, WatchSource, WritableComputedRef } from "vue";
//#region src/useEventListener.d.ts
type UseEventListenerTarget = EventTarget | Ref<EventTarget | undefined | null> | (() => EventTarget);
interface UseEventListenerOptions {
  capture?: boolean;
  passive?: boolean;
}
declare function useEventListener<T extends keyof DocumentEventMap>(target: UseEventListenerTarget, type: T, listener: (event: DocumentEventMap[T]) => void, options?: UseEventListenerOptions): () => void;
declare function useEventListener(target: UseEventListenerTarget, type: string, listener: EventListener, options?: UseEventListenerOptions): () => void;
//#endregion
//#region src/useClickOutside.d.ts
type UseClickOutsideTarget = Element | Ref<Element | undefined | null> | (() => Element);
declare function useClickOutside(target: UseClickOutsideTarget, type: string, listener: EventListener): void;
//#endregion
//#region src/onSmartMounted.d.ts
declare function onSmartMounted(hook: () => void): void;
//#endregion
//#region src/onSmartUnmounted.d.ts
declare function onSmartUnmounted(hook: () => void): void;
//#endregion
//#region src/useChildren.d.ts
interface UseChildrenBaseProvider<C> {
  childInstances: ComponentInternalInstance[];
  collect(instance: ComponentInternalInstance, childProvider: C): void;
  clear(instance: ComponentInternalInstance, childProvider: C): void;
}
declare function useChildren<P, C>(key: symbol | string): {
  length: ComputedRef<number>;
  childInstances: ComponentInternalInstance[];
  childProviders: C[];
  bindChildren: (parentProvider: P) => void;
};
//#endregion
//#region src/useParent.d.ts
declare function keyInProvides(key: symbol | string): boolean;
declare function useParent<P, C>(key: symbol | string): {
  index: null;
  parentProvider: null;
  bindParent: null;
} | {
  index: ComputedRef<number>;
  parentProvider: Omit<P & UseChildrenBaseProvider<C>, "childInstances" | "collect" | "clear">;
  bindParent: (childProvider: C) => void;
};
//#endregion
//#region src/onWindowResize.d.ts
declare function onWindowResize(listener: EventListener): void;
//#endregion
//#region src/useInitialized.d.ts
declare function useInitialized<T>(source: WatchSource<T>, value: T): import("vue").Ref<boolean, boolean>;
//#endregion
//#region src/useTouch.d.ts
type TouchDirection = 'horizontal' | 'vertical';
declare function useTouch(): {
  startX: import("vue").Ref<number, number>;
  startY: import("vue").Ref<number, number>;
  deltaX: import("vue").Ref<number, number>;
  deltaY: import("vue").Ref<number, number>;
  offsetX: import("vue").Ref<number, number>;
  offsetY: import("vue").Ref<number, number>;
  prevX: import("vue").Ref<number, number>;
  prevY: import("vue").Ref<number, number>;
  moveX: import("vue").Ref<number, number>;
  moveY: import("vue").Ref<number, number>;
  direction: import("vue").Ref<TouchDirection | undefined, TouchDirection | undefined>;
  touching: import("vue").Ref<boolean, boolean>;
  dragging: import("vue").Ref<boolean, boolean>;
  startTime: import("vue").Ref<number, number>;
  distance: import("vue").Ref<number, number>;
  resetTouch: () => void;
  startTouch: (event: TouchEvent) => void;
  moveTouch: (event: TouchEvent) => void;
  endTouch: () => void;
  isReachTop: (element: Element | Window) => boolean;
  isReachBottom: (element: Element, offset?: number) => boolean;
};
//#endregion
//#region src/useId.d.ts
declare function useId(): import("vue").Ref<string | undefined, string | undefined>;
//#endregion
//#region src/useClientId.d.ts
declare function useClientId(): import("vue").Ref<string | undefined, string | undefined>;
//#endregion
//#region src/useWindowSize.d.ts
interface UseWindowSizeOptions {
  initialWidth?: number;
  initialHeight?: number;
}
declare function useWindowSize(options?: UseWindowSizeOptions): {
  width: import("vue").Ref<number, number>;
  height: import("vue").Ref<number, number>;
};
//#endregion
//#region src/useVModel.d.ts
interface UseVModelOptions<P, K extends keyof P> {
  passive?: boolean;
  eventName?: string;
  defaultValue?: P[K];
  emit?: (event: string, value: P[K]) => void;
}
declare function useVModel<P extends Record<string, any>, K extends keyof P>(props: P, key: K, options?: UseVModelOptions<P, K>): WritableComputedRef<P[K]> | Ref<P[K]>;
//#endregion
//#region src/useMotion.d.ts
interface UseMotionOptions {
  from: number | (() => number);
  to: number | (() => number);
  duration?: number | (() => number);
  timingFunction?: (v: number) => number;
  onFinished?: (value: number) => void;
}
declare function useMotion(options: UseMotionOptions): {
  value: import("vue").Ref<number, number>;
  state: import("vue").Ref<MotionState, MotionState>;
  start: () => void;
  pause: () => void;
  reset: () => void;
};
//#endregion
//#region src/useResizeObserver.d.ts
type UseResizeObserverTarget = Element | Ref<Element | undefined | null> | (() => Element | undefined | null);
declare function useResizeObserver(target: UseResizeObserverTarget, callback: ResizeObserverCallback): (() => void) | undefined;
//#endregion
export { TouchDirection, UseChildrenBaseProvider, UseClickOutsideTarget, UseEventListenerOptions, UseEventListenerTarget, UseMotionOptions, UseResizeObserverTarget, UseVModelOptions, UseWindowSizeOptions, keyInProvides, onSmartMounted, onSmartUnmounted, onWindowResize, useChildren, useClickOutside, useClientId, useEventListener, useId, useInitialized, useMotion, useParent, useResizeObserver, useTouch, useVModel, useWindowSize };