@xhub-reel/feed 0.1.0

package/dist/index.d.mts

@@ -0,0 +1,652 @@
+import * as react from 'react';
+import { CSSProperties, ReactNode, HTMLAttributes, RefObject } from 'react';
+import { Video, XHubReelConfig, VideoFetchParams } from '@xhub-reel/core';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { useQueryClient } from '@tanstack/react-query';
+export { UsePreloadOptions, UsePreloadReturn, usePreload } from '@xhub-reel/player';
+
+interface VideoFeedProps {
+    /** Videos to display */
+    videos: Video[];
+    /** Initial video index */
+    initialIndex?: number;
+    /** Called when more videos should be loaded */
+    onLoadMore?: () => void | Promise<void>;
+    /** Called when the current video changes */
+    onVideoChange?: (video: Video, index: number) => void;
+    /** Called when a video is liked */
+    onLike?: (video: Video) => void;
+    /** Called when comments should be shown */
+    onComment?: (video: Video) => void;
+    /** Called when share sheet should be shown */
+    onShare?: (video: Video) => void;
+    /** Called when author profile should be shown */
+    onAuthorClick?: (video: Video) => void;
+    /** Loading state */
+    isLoading?: boolean;
+    /** Has more videos to load */
+    hasMore?: boolean;
+    /** Threshold to trigger load more (videos before end) */
+    loadMoreThreshold?: number;
+    /** Animation duration in ms */
+    transitionDuration?: number;
+    /** Swipe threshold in pixels */
+    swipeThreshold?: number;
+    /** Swipe velocity threshold in px/ms */
+    velocityThreshold?: number;
+    /** Disable swipe gestures */
+    gesturesDisabled?: boolean;
+    /** Enable haptic feedback on swipe */
+    hapticEnabled?: boolean;
+    /** Custom styles override */
+    style?: CSSProperties;
+    /** Custom className (for external CSS if needed) */
+    className?: string;
+}
+interface VideoFeedRef {
+    slideTo: (index: number, animated?: boolean) => void;
+    slideNext: (animated?: boolean) => void;
+    slidePrev: (animated?: boolean) => void;
+    activeIndex: number;
+    totalSlides: number;
+    isBeginning: boolean;
+    isEnd: boolean;
+}
+declare const VideoFeed: react.ForwardRefExoticComponent<VideoFeedProps & react.RefAttributes<VideoFeedRef>>;
+
+/**
+ * usePreloader - Feed-specific video preloading layer
+ *
+ * ARCHITECTURE:
+ * This module re-exports core preload functionality from @xhub-reel/player-core
+ * and adds FEED-SPECIFIC abstractions:
+ * - PreloadPriority type (high/medium/low/metadata/none)
+ * - Priority calculation helpers based on video index distance
+ *
+ * LAYERED DESIGN (Big Tech Pattern):
+ * ┌─────────────────────────────────────────┐
+ * │ @xhub-reel/feed (Domain Layer)             │
+ * │ - Feed-specific priority enum           │
+ * │ - Distance-based priority calculation   │
+ * └──────────────┬──────────────────────────┘
+ *                │ re-exports + extends
+ *                ↓
+ * ┌─────────────────────────────────────────┐
+ * │ @xhub-reel/player (UI Layer)               │
+ * │ - Re-exports core + UI components       │
+ * └──────────────┬──────────────────────────┘
+ *                │ re-exports
+ *                ↓
+ * ┌─────────────────────────────────────────┐
+ * │ @xhub-reel/player-core (Core Layer)        │
+ * │ - usePreload hook                       │
+ * │ - PreloadManager service                │
+ * │ - Generic, reusable logic               │
+ * └─────────────────────────────────────────┘
+ *
+ * FEED PRELOAD STRATEGY:
+ * - Current - 1: Keep in memory, paused
+ * - Current: Playing
+ * - Current + 1: Pre-load first 3 segments (high)
+ * - Current + 2: Pre-load first segment (medium)
+ * - Current + 3: Fetch metadata only (low)
+ * - Current ± 4+: Dispose (none)
+ */
+
+/**
+ * Priority levels for feed preloading
+ */
+type PreloadPriority = 'high' | 'medium' | 'low' | 'metadata' | 'none';
+/**
+ * Calculate preload priority based on distance from current video
+ *
+ * @param index - Video index to check
+ * @param currentIndex - Current active video index
+ * @returns Numeric priority (1 = highest, 10 = none/dispose)
+ */
+declare function getPreloadPriorityForFeed(index: number, currentIndex: number): number;
+/**
+ * Map PreloadPriority enum to numeric priority
+ *
+ * @param priority - Priority enum
+ * @returns Numeric priority for PreloadManager
+ */
+declare function mapPriorityToNumeric(priority: PreloadPriority): number;
+/**
+ * Get PreloadPriority enum based on distance from current
+ *
+ * @param index - Video index to check
+ * @param currentIndex - Current active video index
+ * @returns PreloadPriority enum
+ */
+declare function getPreloadPriority(index: number, currentIndex: number): PreloadPriority;
+
+interface VideoFeedItemProps {
+    /** Video data */
+    video: Video;
+    /** Whether this is the currently active video */
+    isActive?: boolean;
+    /** Preload priority */
+    priority?: PreloadPriority;
+    /** Show timeline (default: true, only used with default children) */
+    showTimeline?: boolean;
+    /** Called when video is liked */
+    onLike?: () => void;
+    /** Called when comments button is pressed */
+    onComment?: () => void;
+    /** Called when share button is pressed */
+    onShare?: () => void;
+    /** Called when author is clicked */
+    onAuthorClick?: () => void;
+    /** Custom styles override */
+    style?: CSSProperties;
+    /** Custom className (for external CSS if needed) */
+    className?: string;
+    /** Custom children for compound component pattern */
+    children?: ReactNode;
+}
+/**
+ * VideoFeedItem - Root container for video feed items
+ *
+ * Provides context for all child components.
+ * Use with VideoFeedItemPlayer, VideoFeedItemActions, etc.
+ */
+declare const VideoFeedItem: react.ForwardRefExoticComponent<VideoFeedItemProps & react.RefAttributes<HTMLDivElement>>;
+
+interface VideoFeedItemPlayerProps extends HTMLAttributes<HTMLDivElement> {
+    /** Custom placeholder element */
+    placeholder?: React.ReactNode;
+}
+declare const VideoFeedItemPlayer: react.ForwardRefExoticComponent<VideoFeedItemPlayerProps & react.RefAttributes<HTMLVideoElement>>;
+
+interface VideoFeedItemActionsProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onShare'> {
+    /** Override like callback from context */
+    onLike?: () => void;
+    /** Override comment callback from context */
+    onComment?: () => void;
+    /** Override share callback from context */
+    onShare?: () => void;
+}
+declare const VideoFeedItemActions: react.ForwardRefExoticComponent<VideoFeedItemActionsProps & react.RefAttributes<HTMLDivElement>>;
+
+interface VideoFeedItemTimelineProps extends HTMLAttributes<HTMLDivElement> {
+    /** Override expanded state */
+    expanded?: boolean;
+}
+declare const VideoFeedItemTimeline: react.ForwardRefExoticComponent<VideoFeedItemTimelineProps & react.RefAttributes<HTMLDivElement>>;
+
+interface VideoFeedItemOverlayProps extends HTMLAttributes<HTMLDivElement> {
+    /** Show play/pause overlay. Default: true */
+    showPlayPause?: boolean;
+    /** Show heart animation on double tap. Default: true */
+    showDoubleTapHeart?: boolean;
+    /** Show video info overlay (author, description). Default: true */
+    showVideoInfo?: boolean;
+}
+declare const VideoFeedItemOverlay: react.ForwardRefExoticComponent<VideoFeedItemOverlayProps & react.RefAttributes<HTMLDivElement>>;
+
+interface VideoFeedItemContextValue {
+    video: Video;
+    isActive: boolean;
+    shouldRenderVideo: boolean;
+    preload: '' | 'none' | 'metadata' | 'auto';
+    /** Video has been preloaded and first frame is ready */
+    isPreloaded: boolean;
+    containerRef: RefObject<HTMLDivElement | null>;
+    videoRef: RefObject<HTMLVideoElement | null>;
+    isPlaying: boolean;
+    showPauseOverlay: boolean;
+    timelineExpanded: boolean;
+    play: () => Promise<void>;
+    pause: () => void;
+    seek: (time: number) => void;
+    setShowPauseOverlay: (show: boolean) => void;
+    setTimelineExpanded: (expanded: boolean) => void;
+    gestureBindings: () => Record<string, unknown>;
+    showHeart: boolean;
+    heartPosition: {
+        x: number;
+        y: number;
+    };
+    triggerHeart: (x: number, y: number) => void;
+    onLike?: () => void;
+    onComment?: () => void;
+    onShare?: () => void;
+    onAuthorClick?: () => void;
+    handleSeekStart: () => void;
+    handleSeekEnd: (time: number) => void;
+}
+declare function useVideoFeedItemContext(): VideoFeedItemContextValue;
+
+interface VideoOverlayProps {
+    /** Video data */
+    video: Video;
+    /** Called when author is clicked */
+    onAuthorClick?: () => void;
+    /** Whether timeline is expanded (affects bottom padding) */
+    timelineExpanded?: boolean;
+    /** Custom styles override */
+    style?: CSSProperties;
+    /** Custom className */
+    className?: string;
+}
+declare function VideoOverlay({ video, timelineExpanded, style, className, }: VideoOverlayProps): react_jsx_runtime.JSX.Element;
+
+interface ConnectedVideoFeedProps extends Omit<VideoFeedProps, 'videos' | 'isLoading' | 'hasMore' | 'onLoadMore'> {
+    /**
+     * XHubReelConfig for API connection
+     * Optional if wrapped in XHubReelProvider with config
+     */
+    config?: XHubReelConfig;
+    /**
+     * User ID for user-specific feed
+     */
+    userId?: string;
+    /**
+     * Tag/hashtag filter
+     */
+    tag?: string;
+    /**
+     * Search query
+     */
+    searchQuery?: string;
+    /**
+     * Number of videos per page
+     * @default 10
+     */
+    pageSize?: number;
+    /**
+     * Initial videos to show while loading (optional)
+     */
+    initialVideos?: Video[];
+    /**
+     * Called when videos are successfully fetched
+     */
+    onFetchSuccess?: (videos: Video[]) => void;
+    /**
+     * Called when fetch fails
+     */
+    onFetchError?: (error: Error) => void;
+    /**
+     * Render custom loading state
+     */
+    renderLoading?: () => React.ReactNode;
+    /**
+     * Render custom error state
+     */
+    renderError?: (error: Error, retry: () => void) => React.ReactNode;
+    /**
+     * Render custom empty state
+     */
+    renderEmpty?: () => React.ReactNode;
+}
+declare const ConnectedVideoFeed: react.ForwardRefExoticComponent<ConnectedVideoFeedProps & react.RefAttributes<VideoFeedRef>>;
+
+/**
+ * useVideoVisibility - Track video visibility using IntersectionObserver
+ */
+
+interface UseVideoVisibilityOptions {
+    /** Element to observe */
+    elementRef: RefObject<HTMLElement | null>;
+    /** Threshold to activate (default: 50%) */
+    activateThreshold?: number;
+    /** Threshold to deactivate (default: 30%) */
+    deactivateThreshold?: number;
+    /** Root margin */
+    rootMargin?: string;
+    /** Callback when visibility changes */
+    onVisibilityChange?: (isVisible: boolean, ratio: number) => void;
+}
+interface UseVideoVisibilityReturn {
+    isVisible: boolean;
+    isActive: boolean;
+    visibilityRatio: number;
+}
+declare function useVideoVisibility({ elementRef, activateThreshold, deactivateThreshold, rootMargin, onVisibilityChange, }: UseVideoVisibilityOptions): UseVideoVisibilityReturn;
+
+/**
+ * useVideoActivation - Control video play/pause based on isCurrentVideo prop
+ *
+ * For carousel/swipe feeds: Uses index-based activation from VideoFeed (no IntersectionObserver)
+ * For scroll feeds: Enable `trackVisibility` to get viewport-based analytics
+ *
+ * Note: For infinite scroll loading, use `useInfiniteScroll` instead.
+ * For standalone visibility tracking, use `useVideoVisibility` directly.
+ */
+
+interface UseVideoActivationOptions {
+    /** Video container element ref (required if trackVisibility is true) */
+    containerRef?: RefObject<HTMLElement | null>;
+    /** Video element ref */
+    videoRef: RefObject<HTMLVideoElement | null>;
+    /** Whether this video is the current active one (from parent feed) */
+    isCurrentVideo?: boolean;
+    /** Callback when video should activate */
+    onActivate?: () => void;
+    /** Callback when video should deactivate */
+    onDeactivate?: () => void;
+    /** Whether auto-activation is enabled */
+    autoActivate?: boolean;
+    /**
+     * Enable visibility tracking via IntersectionObserver
+     * Use this for:
+     * - Analytics (track how much of video is visible)
+     * - Scroll-based feeds (non-carousel)
+     * - Lazy loading based on viewport
+     * Default: false (carousel mode)
+     */
+    trackVisibility?: boolean;
+    /** Callback for visibility changes (requires trackVisibility: true) */
+    onVisibilityChange?: (isVisible: boolean, ratio: number) => void;
+}
+interface UseVideoActivationReturn {
+    /** Whether this video is currently active */
+    isActive: boolean;
+    /** Whether video is visible in viewport (only when trackVisibility: true) */
+    isVisible: boolean;
+    /** Visibility ratio 0-1 (only when trackVisibility: true) */
+    visibilityRatio: number;
+    /** Manually activate the video */
+    activate: () => void;
+    /** Manually deactivate the video */
+    deactivate: () => void;
+}
+declare function useVideoActivation({ containerRef, videoRef, isCurrentVideo, onActivate, onDeactivate, autoActivate, trackVisibility, onVisibilityChange, }: UseVideoActivationOptions): UseVideoActivationReturn;
+
+/**
+ * Memory Manager - Control memory usage for video feed
+ *
+ * Limits:
+ * - Max 5 videos in DOM
+ * - Max 3 videos with decoded frames
+ * - Total memory cap 150MB
+ */
+interface MemoryState {
+    videosInDom: number;
+    decodedVideos: number;
+    estimatedMemoryMB: number;
+    isLowMemory: boolean;
+}
+interface VideoMemoryEntry {
+    videoId: string;
+    inDom: boolean;
+    hasDecodedFrames: boolean;
+    estimatedSizeMB: number;
+    lastAccessed: number;
+}
+declare class MemoryManager {
+    private entries;
+    private listeners;
+    private memoryWarningThreshold;
+    constructor();
+    /**
+     * Register a video
+     */
+    register(videoId: string, estimatedSizeMB?: number): void;
+    /**
+     * Unregister a video
+     */
+    unregister(videoId: string): void;
+    /**
+     * Mark video as in DOM
+     */
+    setInDom(videoId: string, inDom: boolean): void;
+    /**
+     * Mark video as having decoded frames
+     */
+    setHasDecodedFrames(videoId: string, hasFrames: boolean): void;
+    /**
+     * Get current memory state
+     */
+    getState(): MemoryState;
+    /**
+     * Get videos that should be disposed (LRU)
+     */
+    getVideosToDispose(): string[];
+    /**
+     * Subscribe to memory state changes
+     */
+    subscribe(listener: (state: MemoryState) => void): () => void;
+    /**
+     * Force cleanup
+     */
+    forceCleanup(): string[];
+    private notifyListeners;
+    private setupMemoryPressureListener;
+}
+declare const memoryManager: MemoryManager;
+
+/**
+ * useMemoryManager - Hook for memory management in feed
+ */
+
+interface UseMemoryManagerOptions {
+    /** Video ID to track */
+    videoId: string;
+    /** Estimated video size in MB */
+    estimatedSizeMB?: number;
+    /** Callback when video should be disposed due to memory pressure */
+    onShouldDispose?: () => void;
+}
+interface UseMemoryManagerReturn {
+    memoryState: MemoryState;
+    setInDom: (inDom: boolean) => void;
+    setHasDecodedFrames: (hasFrames: boolean) => void;
+    shouldDispose: boolean;
+}
+declare function useMemoryManager({ videoId, estimatedSizeMB, onShouldDispose, }: UseMemoryManagerOptions): UseMemoryManagerReturn;
+/**
+ * useGlobalMemoryState - Get global memory state without tracking a specific video
+ */
+declare function useGlobalMemoryState(): MemoryState;
+
+/**
+ * useFeedScroll - Scroll management hook with snap behavior
+ */
+
+interface UseFeedScrollOptions {
+    /** Scroll container ref */
+    scrollRef: RefObject<HTMLElement | null>;
+    /** Total number of items */
+    itemCount: number;
+    /** Height of each item (default: viewport height) */
+    itemHeight?: number;
+    /** Callback when scroll position changes */
+    onScrollChange?: (scrollTop: number, velocity: number) => void;
+    /** Callback when current index changes */
+    onIndexChange?: (index: number) => void;
+}
+interface UseFeedScrollReturn {
+    currentIndex: number;
+    scrollVelocity: number;
+    isScrolling: boolean;
+    scrollToIndex: (index: number, smooth?: boolean) => void;
+    scrollToNext: () => void;
+    scrollToPrev: () => void;
+}
+declare function useFeedScroll({ scrollRef, itemCount, itemHeight, onScrollChange, onIndexChange, }: UseFeedScrollOptions): UseFeedScrollReturn;
+
+/**
+ * useInfiniteScroll - Hook for infinite scroll loading
+ */
+interface UseInfiniteScrollOptions {
+    /** Called when more content should be loaded */
+    onLoadMore?: () => void | Promise<void>;
+    /** Whether currently loading */
+    isLoading?: boolean;
+    /** Whether there's more content to load */
+    hasMore?: boolean;
+    /** Number of items from end to trigger load */
+    threshold?: number;
+    /** Root margin for intersection observer */
+    rootMargin?: string;
+}
+interface UseInfiniteScrollReturn {
+    /** Ref to attach to sentinel element */
+    sentinelRef: (element: HTMLElement | null) => void;
+    /** Whether currently in loading state */
+    isLoadingMore: boolean;
+}
+declare function useInfiniteScroll({ onLoadMore, isLoading, hasMore, threshold: _threshold, rootMargin, }: UseInfiniteScrollOptions): UseInfiniteScrollReturn;
+
+/**
+ * useVideoFeed - Hook for fetching videos from API with infinite scroll support
+ *
+ * Uses XHubReelProvider config to fetch videos. Falls back to manual mode if no config.
+ *
+ * @example
+ * ```tsx
+ * // API Mode (requires XHubReelProvider with config)
+ * function FeedPage() {
+ *   const {
+ *     videos,
+ *     isLoading,
+ *     hasMore,
+ *     fetchNextPage,
+ *     error,
+ *   } = useVideoFeed()
+ *
+ *   return <VideoFeed videos={videos} onLoadMore={fetchNextPage} />
+ * }
+ *
+ * // Manual Mode (pass videos directly)
+ * function FeedPage() {
+ *   const localVideos = [...]
+ *   return <VideoFeed videos={localVideos} />
+ * }
+ * ```
+ */
+
+interface UseVideoFeedOptions {
+    /**
+     * XHubReelConfig - required for API mode
+     * If not provided, the hook returns empty data (use manual mode)
+     */
+    config?: XHubReelConfig;
+    /**
+     * Enable/disable the query (default: true)
+     */
+    enabled?: boolean;
+    /**
+     * Initial videos to show while loading
+     */
+    initialVideos?: Video[];
+    /**
+     * Stale time in ms (default: 5 minutes)
+     */
+    staleTime?: number;
+    /**
+     * Refetch on window focus (default: false)
+     */
+    refetchOnWindowFocus?: boolean;
+    /**
+     * Callback when videos are fetched
+     */
+    onSuccess?: (videos: Video[]) => void;
+    /**
+     * Callback on error
+     */
+    onError?: (error: Error) => void;
+    /** User ID filter */
+    userId?: string;
+    /** Tag/hashtag filter */
+    tag?: string;
+    /** Search query */
+    searchQuery?: string;
+    /** Number of videos per page */
+    limit?: number;
+    /** Pagination cursor */
+    cursor?: string;
+}
+interface UseVideoFeedReturn {
+    /** Flattened array of all fetched videos */
+    videos: Video[];
+    /** Loading state for initial fetch */
+    isLoading: boolean;
+    /** Loading state for fetching more */
+    isFetchingMore: boolean;
+    /** Whether there are more videos to load */
+    hasMore: boolean;
+    /** Fetch next page of videos */
+    fetchNextPage: () => Promise<void>;
+    /** Refetch all videos */
+    refetch: () => Promise<void>;
+    /** Error if any */
+    error: Error | null;
+    /** Whether API mode is active */
+    isApiMode: boolean;
+    /** Total count of videos (if provided by API) */
+    totalCount?: number;
+}
+/**
+ * useVideoFeed - Fetch videos with infinite scroll support
+ */
+declare function useVideoFeed(options?: UseVideoFeedOptions): UseVideoFeedReturn;
+/**
+ * Prefetch videos for a feed type
+ * Call this in a Server Component or before navigation to pre-warm cache
+ *
+ * @example
+ * ```tsx
+ * // In a page component
+ * export async function generateStaticParams() {
+ *   const queryClient = new QueryClient()
+ *   await prefetchVideoFeed(queryClient, config)
+ *   return { props: { dehydratedState: dehydrate(queryClient) } }
+ * }
+ * ```
+ */
+declare function prefetchVideoFeed(queryClient: ReturnType<typeof useQueryClient>, config: XHubReelConfig, params?: VideoFetchParams): Promise<void>;
+
+/**
+ * useSwipeAnimation - High-performance swipe animation hook
+ *
+ * Features:
+ * - Direct DOM manipulation (bypasses React re-renders)
+ * - RAF batching (max 1 update per frame)
+ * - Cached viewport height (no layout thrashing)
+ * - transitionend event (no setTimeout race conditions)
+ * - Design system easing curve
+ *
+ * @example
+ * ```tsx
+ * const { setTranslateY, animateTo, snapBack, viewportHeight } = useSwipeAnimation({
+ *   trackRef,
+ *   transitionDuration: 300,
+ * })
+ *
+ * // During swipe (hot path - no React re-render)
+ * setTranslateY(movement)
+ *
+ * // Complete swipe with animation
+ * await animateTo(-viewportHeight)
+ * ```
+ */
+interface UseSwipeAnimationOptions {
+    /** Ref to the track element that will be animated */
+    trackRef: React.RefObject<HTMLDivElement | null>;
+    /** Transition duration in ms. Default: 300 */
+    transitionDuration?: number;
+    /** CSS easing function. Default: design system spring */
+    easing?: string;
+    /** Called when any transition completes */
+    onTransitionEnd?: () => void;
+}
+interface UseSwipeAnimationReturn {
+    /** Set translateY directly (no React, RAF batched) - use during swipe */
+    setTranslateY: (y: number) => void;
+    /** Animate to target Y with CSS transition - returns Promise */
+    animateTo: (y: number) => Promise<void>;
+    /** Snap back to 0 with transition */
+    snapBack: () => Promise<void>;
+    /** Get current translateY value (sync, no DOM read) */
+    getCurrentY: () => number;
+    /** Cached viewport height - use this instead of window.innerHeight */
+    viewportHeight: number;
+    /** Whether currently animating */
+    isAnimating: boolean;
+}
+declare function useSwipeAnimation({ trackRef, transitionDuration, easing, onTransitionEnd, }: UseSwipeAnimationOptions): UseSwipeAnimationReturn;
+
+export { ConnectedVideoFeed, type ConnectedVideoFeedProps, type MemoryState, type PreloadPriority, type UseFeedScrollOptions, type UseFeedScrollReturn, type UseInfiniteScrollOptions, type UseInfiniteScrollReturn, type UseMemoryManagerOptions, type UseMemoryManagerReturn, type UseSwipeAnimationOptions, type UseSwipeAnimationReturn, type UseVideoActivationOptions, type UseVideoActivationReturn, type UseVideoFeedOptions, type UseVideoFeedReturn, type UseVideoVisibilityOptions, type UseVideoVisibilityReturn, VideoFeed, VideoFeedItem, VideoFeedItemActions, type VideoFeedItemActionsProps, type VideoFeedItemContextValue, VideoFeedItemOverlay, type VideoFeedItemOverlayProps, VideoFeedItemPlayer, type VideoFeedItemPlayerProps, type VideoFeedItemProps, VideoFeedItemTimeline, type VideoFeedItemTimelineProps, type VideoFeedProps, type VideoFeedRef, type VideoMemoryEntry, VideoOverlay, type VideoOverlayProps, getPreloadPriority, getPreloadPriorityForFeed, mapPriorityToNumeric, memoryManager, prefetchVideoFeed, useFeedScroll, useGlobalMemoryState, useInfiniteScroll, useMemoryManager, useSwipeAnimation, useVideoActivation, useVideoFeed, useVideoFeedItemContext, useVideoVisibility };