@folklore/hooks 0.0.83 → 0.0.86

package/dist/index.d.ts

@@ -0,0 +1,254 @@
+import * as react from 'react';
+import { RefObject } from 'react';
+import { EventsManager, NormalizedEventsMap } from '@folklore/events';
+import * as cancelable_promise from 'cancelable-promise';
+
+declare function useCounter(desiredValue: any, { disabled, maxDuration, speed, initialValue }: {
+    disabled?: boolean;
+    maxDuration?: number;
+    speed?: number;
+    initialValue?: any;
+}): any;
+
+type VideoPlayerMetadata = {
+    width?: number | null;
+    height?: number | null;
+    duration?: number | null;
+};
+type VideoPlayerState = {
+    playing?: boolean;
+    paused?: boolean;
+    buffering?: boolean;
+    ended?: boolean;
+    ready?: boolean;
+    loaded?: boolean;
+    currentTime?: number;
+    volume?: number;
+    muted?: boolean;
+};
+type VideoPlayerControls = {
+    play: () => void;
+    pause: () => void;
+    seek?: (time: number) => void;
+    mute?: () => void;
+    unmute?: () => void;
+    setVolume: (volume: number) => void;
+    setLoop?: (loop: boolean) => void;
+};
+type VideoPlayer<ExternalPlayer = unknown> = VideoPlayerMetadata & VideoPlayerState & VideoPlayerControls & {
+    ref: RefObject<HTMLElement>;
+    player?: ExternalPlayer;
+};
+
+type UseDailymotionPlayerOptions = {
+    width?: number;
+    height?: number;
+    duration?: number;
+    muted?: boolean;
+    initialMuted?: boolean;
+    start?: number;
+    embedPlayerId?: string | null;
+    onTimeUpdate?: (time: number) => void;
+    getVideoId?: (url: string) => string | null;
+};
+declare function useDailymotionPlayer(idOrUrl: string | null, opts?: UseDailymotionPlayerOptions): VideoPlayer;
+
+type DocumentEventsMap = NormalizedEventsMap<DocumentEventMap>;
+declare const eventsManager$1: EventsManager<NormalizedEventsMap<DocumentEventMap>>;
+declare function useDocumentEvent<Event extends keyof DocumentEventsMap>(event: Event, callback: ((event: DocumentEventsMap[Event]) => void) | null): void;
+
+declare function useIsVisible({ persist, ...opts }?: {
+    persist?: boolean;
+}): {
+    ref: react.RefObject<HTMLElement>;
+    visible: boolean;
+};
+
+declare function useKeyboard(keyMap?: any): void;
+
+declare const useItemsPaginated: (loader: any, { page, count, pages: initialPages, getPageFromResponse, onLoaded, onError, query, }?: {
+    page?: any;
+    count?: number;
+    pages?: any;
+    getPageFromResponse?: ({ pagination: { page: currentPage, last_page: lastPage, total }, data: items, }: {
+        pagination: {
+            page: any;
+            last_page: any;
+            total: any;
+        };
+        data: any;
+    }) => {
+        page: number;
+        lastPage: number;
+        total: number;
+        items: any;
+    };
+    onLoaded?: any;
+    onError?: any;
+    query?: any;
+}) => {
+    items: any;
+    pages: any;
+    currentPage: any;
+    pageItems: any;
+    total: any;
+    lastPage: any;
+    loaded: boolean;
+    allLoaded: boolean;
+    loading: boolean;
+    loadNextPage: () => cancelable_promise.CancelablePromise<void | {
+        page: number;
+        lastPage: number;
+        total: number;
+        items: any;
+    }> | Promise<void>;
+    loadPage: (pageToLoad: any) => Promise<any> | cancelable_promise.CancelablePromise<void | {
+        page: number;
+        lastPage: number;
+        total: number;
+        items: any;
+    }>;
+};
+
+type UseNativeVideoPlayerOptions = {
+    width?: number;
+    height?: number;
+    duration?: number;
+    timeUpdateInterval?: number;
+    muted?: boolean;
+    initialMuted?: boolean;
+    onTimeUpdate?: (time: number) => void;
+};
+declare function useNativeVideoPlayer(url: any, opts?: UseNativeVideoPlayerOptions): VideoPlayer<HTMLVideoElement>;
+
+declare function getObserver(Observer?: any, options?: {}): any;
+interface UseObserverOptions {
+    disabled?: boolean;
+    [key: string]: unknown;
+}
+declare function useObserver<TOptions = UseObserverOptions, TEntry = Record<string, unknown>>(Observer: any, opts: TOptions | null, initialEntry: TEntry | null): {
+    ref: RefObject<HTMLElement>;
+    entry: TEntry;
+};
+/**
+ * Intersection Observer
+ */
+type UseInterserctionObserverOptions = IntersectionObserverInit & UseObserverOptions;
+declare function useIntersectionObserver(opts?: UseInterserctionObserverOptions): {
+    ref: RefObject<HTMLElement>;
+    entry: IntersectionObserverEntry;
+};
+/**
+ * Resize Observer
+ */
+type UseResizeObserverOptions = ResizeObserverOptions & UseObserverOptions;
+declare function useResizeObserver(opts?: UseResizeObserverOptions): {
+    ref: RefObject<HTMLElement>;
+    entry: ResizeObserverEntry;
+};
+
+declare function usePlayerCurrentTime(player: any, { id, disabled, updateInterval, onUpdate: customOnUpdate, getCurrentTime, }?: {
+    id?: any;
+    disabled?: boolean;
+    updateInterval?: number;
+    onUpdate?: any;
+    getCurrentTime?: (p: any) => any;
+}): number;
+
+type UseScrollTriggerOptions = {
+    disabled?: boolean;
+    triggers?: number[];
+    useElementScroll?: boolean;
+    onTrigger?: (step: number) => void;
+};
+declare function useScrollTrigger({ disabled, triggers, useElementScroll, onTrigger, }?: UseScrollTriggerOptions): {
+    ref: RefObject<HTMLElement>;
+};
+
+declare function useSupportsWebp(defaultValue?: boolean): boolean;
+
+type UseVimeoPlayerOptions = {
+    width?: number;
+    height?: number;
+    duration?: number;
+    autoplay?: boolean;
+    autopause?: boolean;
+    byline?: boolean;
+    controls?: boolean;
+    muted?: boolean;
+    initialMuted?: boolean;
+    timeUpdateInterval?: number;
+    onTimeUpdate?: (time: number) => void;
+    getVideoId?: (url: string) => string | null;
+};
+declare function useVimeoPlayer(idOrUrl: string | null, opts?: UseVimeoPlayerOptions): VideoPlayer;
+
+type UseYouTubePlayerOptions = {
+    width?: number;
+    height?: number;
+    duration?: number;
+    autoplay?: boolean;
+    controls?: boolean;
+    timeUpdateInterval?: number;
+    muted?: boolean;
+    initialMuted?: boolean;
+    onVolumeChange?: (volume: number) => void;
+    onTimeUpdate?: (time: number) => void;
+    getVideoId?: (url: string) => string | null;
+};
+declare function useYouTubePlayer(idOrUrl: string | null, opts?: UseYouTubePlayerOptions): VideoPlayer;
+
+type UseVideoPlayerOptions = (UseNativeVideoPlayerOptions | UseVimeoPlayerOptions | UseYouTubePlayerOptions | UseDailymotionPlayerOptions) & {
+    service?: 'dailymotion' | 'youtube' | 'vimeo' | 'native' | null;
+    videoId?: string | null;
+    url?: string | null;
+    onLoaded?: (() => void) | null;
+    onPlay?: (() => void) | null;
+    onPause?: (() => void) | null;
+    onEnd?: (() => void) | null;
+    onMetadataChange?: ((metadata: VideoPlayerMetadata) => void) | null;
+    onBufferStart?: (() => void) | null;
+    onBufferEnded?: (() => void) | null;
+    [key: string]: unknown;
+};
+declare function useVideoPlayer({ service, videoId, url, onLoaded: customOnLoaded, onPlay: customOnPlay, onPause: customOnPause, onEnd: customOnEnd, onMetadataChange: customOnMetadataChange, onBufferStart: customOnBufferStart, onBufferEnded: customOnBufferEnded, ...opts }?: UseVideoPlayerOptions): VideoPlayer | null;
+
+interface VisualViewportData {
+    width: number;
+    height: number;
+    offsetTop?: number;
+    offsetLeft?: number;
+    pageLeft?: number;
+    pageTop?: number;
+}
+declare function useVisualViewport(): VisualViewportData & {
+    updateViewport: (viewPort?: VisualViewport) => void;
+};
+
+type WindowEventsMap = NormalizedEventsMap<WindowEventMap>;
+declare const eventsManager: EventsManager<NormalizedEventsMap<WindowEventMap>>;
+declare function useWindowEvent<Event extends keyof WindowEventsMap>(event: Event, callback: ((event: WindowEventsMap[Event]) => void) | null): void;
+
+type WindowScroll = {
+    x: number;
+    y: number;
+};
+type UseWindowScrollOptions = {
+    onChange?: (scroll: WindowScroll) => void;
+    onMount?: boolean;
+    memo?: boolean;
+};
+declare function useWindowScroll({ onChange, onMount, memo, }?: UseWindowScrollOptions): WindowScroll;
+
+type WindowSize = {
+    width: number;
+    height: number;
+};
+type UseWindowSizeOptions = {
+    onChange?: (size: WindowSize) => void;
+    onMount?: boolean;
+    memo?: boolean;
+};
+declare function useWindowSize({ onChange, onMount, memo, }?: UseWindowSizeOptions): WindowSize;
+
+export { eventsManager$1 as documentEventsManager, getObserver, useCounter, useDailymotionPlayer, useDocumentEvent, useIntersectionObserver, useIsVisible, useItemsPaginated, useKeyboard, useNativeVideoPlayer, useObserver, usePlayerCurrentTime, useResizeObserver, useScrollTrigger, useSupportsWebp, useVideoPlayer, useVimeoPlayer, useVisualViewport, useVisualViewport as useVisualViewportSize, useWindowEvent, useWindowScroll, useWindowSize, useYouTubePlayer, eventsManager as windowEventsManager };