@repliqo/sdk-react-native 0.3.8 → 0.4.0

package/android/src/main/java/com/repliqo/screencapture/ScreenCaptureModule.java

@@ -1,94 +1,94 @@
-package com.repliqo.screencapture;
-
-import android.app.Activity;
-import android.os.Handler;
-import android.os.Looper;
-import android.util.Log;
-
-import androidx.annotation.NonNull;
-
-import com.facebook.react.bridge.Arguments;
-import com.facebook.react.bridge.Promise;
-import com.facebook.react.bridge.ReactApplicationContext;
-import com.facebook.react.bridge.ReactContextBaseJavaModule;
-import com.facebook.react.bridge.ReactMethod;
-import com.facebook.react.bridge.WritableMap;
-
-/**
- * React Native native module for full-screen capture INCLUDING modals,
- * alerts, and system dialogs.
- *
- * Uses MultiWindowCapture which draws all app windows via View.draw()
- * and composites them. NO permissions required. NO MediaProjection.
- * NO foreground service.
- *
- * JS API:
- *   NativeModules.ScreenCaptureModule.captureFrame() → Promise<{image,width,height,format}>
- *
- * The TS wrapper (NativeScreenCapture.ts) detects availability via
- * NativeModules.ScreenCaptureModule != null, so isAvailable() is kept
- * for explicit checks but not required.
- */
-public class ScreenCaptureModule extends ReactContextBaseJavaModule {
-    private static final String TAG = "RepliqoCapture";
-    private static final String MODULE_NAME = "ScreenCaptureModule";
-
-    private final Handler mainHandler = new Handler(Looper.getMainLooper());
-
-    public ScreenCaptureModule(ReactApplicationContext reactContext) {
-        super(reactContext);
-    }
-
-    @NonNull
-    @Override
-    public String getName() {
-        return MODULE_NAME;
-    }
-
-    /**
-     * Check if the native capture module is available.
-     * Always true on Android (no permissions needed).
-     */
-    @ReactMethod
-    public void isAvailable(Promise promise) {
-        promise.resolve(true);
-    }
-
-    /**
-     * Capture a single frame including all visible windows.
-     * Must run View.draw() on the UI thread, so we post to the main handler.
-     *
-     * Returns: { image: base64, width: int, height: int, format: "jpeg" }
-     */
-    @ReactMethod
-    public void captureFrame(Promise promise) {
-        Activity activity = getCurrentActivity();
-        if (activity == null) {
-            promise.resolve(null);
-            return;
-        }
-
-        // View.draw() must run on the UI thread
-        mainHandler.post(() -> {
-            try {
-                MultiWindowCapture.CaptureResult result =
-                        MultiWindowCapture.capture(activity);
-
-                if (result == null) {
-                    promise.resolve(null);
-                    return;
-                }
-
-                WritableMap map = Arguments.createMap();
-                map.putString("image", result.image);
-                map.putInt("width", result.width);
-                map.putInt("height", result.height);
-                map.putString("format", "jpeg");
-                promise.resolve(map);
-            } catch (Exception e) {
-                Log.w(TAG, "captureFrame failed: " + e.getMessage());
-                promise.resolve(null);
-            }
-        });
-    }
-}
+package com.repliqo.screencapture;
+
+import android.app.Activity;
+import android.os.Handler;
+import android.os.Looper;
+import android.util.Log;
+
+import androidx.annotation.NonNull;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.WritableMap;
+
+/**
+ * React Native native module for full-screen capture INCLUDING modals,
+ * alerts, and system dialogs.
+ *
+ * Uses MultiWindowCapture which draws all app windows via View.draw()
+ * and composites them. NO permissions required. NO MediaProjection.
+ * NO foreground service.
+ *
+ * JS API:
+ *   NativeModules.ScreenCaptureModule.captureFrame() → Promise<{image,width,height,format}>
+ *
+ * The TS wrapper (NativeScreenCapture.ts) detects availability via
+ * NativeModules.ScreenCaptureModule != null, so isAvailable() is kept
+ * for explicit checks but not required.
+ */
+public class ScreenCaptureModule extends ReactContextBaseJavaModule {
+    private static final String TAG = "RepliqoCapture";
+    private static final String MODULE_NAME = "ScreenCaptureModule";
+
+    private final Handler mainHandler = new Handler(Looper.getMainLooper());
+
+    public ScreenCaptureModule(ReactApplicationContext reactContext) {
+        super(reactContext);
+    }
+
+    @NonNull
+    @Override
+    public String getName() {
+        return MODULE_NAME;
+    }
+
+    /**
+     * Check if the native capture module is available.
+     * Always true on Android (no permissions needed).
+     */
+    @ReactMethod
+    public void isAvailable(Promise promise) {
+        promise.resolve(true);
+    }
+
+    /**
+     * Capture a single frame including all visible windows.
+     * Must run View.draw() on the UI thread, so we post to the main handler.
+     *
+     * Returns: { image: base64, width: int, height: int, format: "jpeg" }
+     */
+    @ReactMethod
+    public void captureFrame(Promise promise) {
+        Activity activity = getCurrentActivity();
+        if (activity == null) {
+            promise.resolve(null);
+            return;
+        }
+
+        // View.draw() must run on the UI thread
+        mainHandler.post(() -> {
+            try {
+                MultiWindowCapture.CaptureResult result =
+                        MultiWindowCapture.capture(activity);
+
+                if (result == null) {
+                    promise.resolve(null);
+                    return;
+                }
+
+                WritableMap map = Arguments.createMap();
+                map.putString("image", result.image);
+                map.putInt("width", result.width);
+                map.putInt("height", result.height);
+                map.putString("format", "jpeg");
+                promise.resolve(map);
+            } catch (Exception e) {
+                Log.w(TAG, "captureFrame failed: " + e.getMessage());
+                promise.resolve(null);
+            }
+        });
+    }
+}

package/dist/components/RepliqoFlatList.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import { FlatList, type FlatListProps } from 'react-native';
+export declare const RepliqoFlatList: <ItemT>(props: FlatListProps<ItemT> & {
+    ref?: React.Ref<FlatList<ItemT>>;
+}) => React.ReactElement;

package/dist/components/RepliqoFlatList.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RepliqoFlatList = void 0;
+const react_1 = __importDefault(require("react"));
+const react_native_1 = require("react-native");
+const useRepliqoScrollTracking_1 = require("./useRepliqoScrollTracking");
+/**
+ * Drop-in replacement for React Native's FlatList with the same analytics
+ * behavior as RepliqoScrollView:
+ *
+ *  1. Reports scroll offset for accurate heatmap touch coords
+ *  2. Captures viewport tiles on scroll stops AND during continuous
+ *     scroll for collaborative screen building
+ *  3. Registers its window-relative bounds with the SDK so touches can
+ *     be auto-classified as "content" (inside the list) or "fixed" UI
+ *
+ * Note on tiles: FlatList virtualizes — off-screen rows aren't rendered —
+ * but that's exactly why the collaborative tile approach works here too:
+ * tiles are captured from what's ON screen as the user naturally scrolls.
+ *
+ * Note on contentHeight: with virtualization, RN estimates the content
+ * size until rows render; onContentSizeChange keeps our metadata in sync
+ * as the estimate refines.
+ */
+function RepliqoFlatListInner({ onScroll, onMomentumScrollEnd, onScrollEndDrag, onLayout, onContentSizeChange, ...props }, ref) {
+    const tracking = (0, useRepliqoScrollTracking_1.useRepliqoScrollTracking)(ref, {
+        onScroll,
+        onMomentumScrollEnd,
+        onScrollEndDrag,
+        onLayout,
+        onContentSizeChange,
+    });
+    return (<react_native_1.FlatList ref={tracking.setRef} {...props} onScroll={tracking.onScroll} onScrollEndDrag={tracking.onScrollEndDrag} onMomentumScrollEnd={tracking.onMomentumScrollEnd} onLayout={tracking.onLayout} onContentSizeChange={tracking.onContentSizeChange} scrollEventThrottle={props.scrollEventThrottle ?? 16}/>);
+}
+exports.RepliqoFlatList = react_1.default.forwardRef(RepliqoFlatListInner);
+exports.RepliqoFlatList.displayName = 'RepliqoFlatList';

package/dist/components/RepliqoScrollView.d.ts

@@ -9,5 +9,8 @@ import { ScrollView, type ScrollViewProps } from 'react-native';
  *  3. Registers its window-relative bounds with the SDK so touches can
  *     be auto-classified as "content" (inside ScrollView) or "fixed"
  *     (outside, e.g. nav bars/headers)
+ *
+ * All analytics behavior lives in useRepliqoScrollTracking (shared with
+ * RepliqoFlatList).
  */
 export declare const RepliqoScrollView: React.ForwardRefExoticComponent<ScrollViewProps & React.RefAttributes<ScrollView>>;

package/dist/components/RepliqoScrollView.js

@@ -1,62 +1,12 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RepliqoScrollView = void 0;
-const react_1 = __importStar(require("react"));
+const react_1 = __importDefault(require("react"));
 const react_native_1 = require("react-native");
-const client_1 = require("../core/client");
-/** Minimum scroll delta (px) to trigger a new tile capture. */
-const MIN_DELTA_PX = 20;
-/** Debounce: wait this long after scroll stops before capturing. */
-const DEBOUNCE_MS = 250;
-/** Throttle: minimum time between tile captures. */
-const THROTTLE_MS = 400;
-/**
- * During continuous scroll, force a capture every this many ms.
- * Ensures tiles are captured even during fast, uninterrupted scrolls
- * where the user never pauses long enough for the debounce to fire.
- */
-const SCROLL_INTERVAL_MS = 1200;
-/**
- * During scroll, throttle window-bounds re-measurement to at most once per
- * this many ms. Bounds rarely change while scrolling, but we still want to
- * catch orientation changes / keyboard / overlay animations.
- */
-const REMEASURE_THROTTLE_MS = 500;
-let scrollViewIdCounter = 0;
-const nextScrollViewId = () => `repliqo-scroll-${++scrollViewIdCounter}`;
+const useRepliqoScrollTracking_1 = require("./useRepliqoScrollTracking");
 /**
  * Drop-in replacement for React Native's ScrollView that:
  *
@@ -66,217 +16,18 @@ const nextScrollViewId = () => `repliqo-scroll-${++scrollViewIdCounter}`;
  *  3. Registers its window-relative bounds with the SDK so touches can
  *     be auto-classified as "content" (inside ScrollView) or "fixed"
  *     (outside, e.g. nav bars/headers)
+ *
+ * All analytics behavior lives in useRepliqoScrollTracking (shared with
+ * RepliqoFlatList).
  */
 exports.RepliqoScrollView = react_1.default.forwardRef(({ onScroll, onMomentumScrollEnd, onScrollEndDrag, onLayout, onContentSizeChange, ...props }, ref) => {
-    const debounceTimer = (0, react_1.useRef)(null);
-    const scrollIntervalTimer = (0, react_1.useRef)(null);
-    const initialLayoutTimer = (0, react_1.useRef)(null);
-    const lastCaptureTime = (0, react_1.useRef)(0);
-    const lastCaptureY = (0, react_1.useRef)(-999);
-    const lastMeasureTime = (0, react_1.useRef)(0);
-    const initialCaptured = (0, react_1.useRef)(false);
-    const realContentHeight = (0, react_1.useRef)(0);
-    const scrollViewId = (0, react_1.useRef)(nextScrollViewId());
-    const innerRef = (0, react_1.useRef)(null);
-    const isMounted = (0, react_1.useRef)(true);
-    // Last measured window-relative top Y of the ScrollView — passed to
-    // captureScrollTile so the backend can crop each tile to just the
-    // scroll viewport area (no fixed header/footer duplication).
-    const lastViewportTop = (0, react_1.useRef)(null);
-    const scrollState = (0, react_1.useRef)(null);
-    // Forward the inner ref to the parent's ref (if provided).
-    // IMPORTANT: do NOT clear innerRef on cleanup — RN sometimes calls the
-    // ref callback with null mid-update, and clearing would break async
-    // measurement callbacks that fire after the ref reattaches.
-    const setRef = (0, react_1.useCallback)((node) => {
-        if (node !== null) {
-            innerRef.current = node;
-        }
-        if (typeof ref === 'function') {
-            ref(node);
-        }
-        else if (ref) {
-            ref.current = node;
-        }
-    }, [ref]);
-    /**
-     * Measure window-relative bounds and register with SDK.
-     * Idempotent + safe to call after unmount (guards via isMounted).
-     */
-    const measureAndRegister = (0, react_1.useCallback)(() => {
-        if (!isMounted.current)
-            return;
-        const node = innerRef.current;
-        if (!node || typeof node.measureInWindow !== 'function')
-            return;
-        node.measureInWindow((x, y, width, height) => {
-            if (!isMounted.current)
-                return;
-            // RN sometimes returns 0/0 dims before the view is positioned —
-            // ignore those, the next onLayout/onScroll will re-measure.
-            if (width <= 0 || height <= 0)
-                return;
-            lastViewportTop.current = y;
-            try {
-                client_1.AppAnalytics.getInstance().registerScrollView(scrollViewId.current, {
-                    x, y, width, height,
-                });
-            }
-            catch { }
-        });
-    }, []);
-    // Cleanup all timers + unregister + listeners on unmount
-    (0, react_1.useEffect)(() => {
-        const id = scrollViewId.current;
-        isMounted.current = true;
-        // Re-measure when keyboard appears/disappears (causes layout shift)
-        const showSub = react_native_1.Keyboard.addListener('keyboardDidShow', measureAndRegister);
-        const hideSub = react_native_1.Keyboard.addListener('keyboardDidHide', measureAndRegister);
-        return () => {
-            isMounted.current = false;
-            if (debounceTimer.current)
-                clearTimeout(debounceTimer.current);
-            if (scrollIntervalTimer.current)
-                clearInterval(scrollIntervalTimer.current);
-            if (initialLayoutTimer.current)
-                clearTimeout(initialLayoutTimer.current);
-            showSub.remove();
-            hideSub.remove();
-            try {
-                client_1.AppAnalytics.getInstance().unregisterScrollView(id);
-            }
-            catch { }
-        };
-    }, [measureAndRegister]);
-    /**
-     * Core tile capture logic. Reads from refs (stable across renders).
-     * Checks throttle + delta before capturing.
-     *
-     * @param force Skip throttle check (used for interval captures)
-     */
-    const doCapture = (force = false) => {
-        if (!isMounted.current)
-            return;
-        const state = scrollState.current;
-        if (!state || state.viewportHeight <= 0)
-            return;
-        const now = Date.now();
-        if (!force && now - lastCaptureTime.current < THROTTLE_MS)
-            return;
-        // Always check delta — no point re-capturing the same position
-        if (Math.abs(state.offsetY - lastCaptureY.current) < MIN_DELTA_PX &&
-            initialCaptured.current)
-            return;
-        lastCaptureTime.current = now;
-        lastCaptureY.current = state.offsetY;
-        initialCaptured.current = true;
-        try {
-            const windowHeight = react_native_1.Dimensions.get('window').height;
-            client_1.AppAnalytics.getInstance().captureScrollTile(state.offsetY, state.viewportHeight, state.contentHeight, lastViewportTop.current ?? undefined, windowHeight);
-        }
-        catch { }
-    };
-    /** Start the interval timer for continuous scroll captures. */
-    const startScrollInterval = () => {
-        if (scrollIntervalTimer.current !== null)
-            return;
-        scrollIntervalTimer.current = setInterval(() => {
-            doCapture(true); // force=true skips throttle
-        }, SCROLL_INTERVAL_MS);
-    };
-    /** Stop the interval timer. */
-    const stopScrollInterval = () => {
-        if (scrollIntervalTimer.current !== null) {
-            clearInterval(scrollIntervalTimer.current);
-            scrollIntervalTimer.current = null;
-        }
-    };
-    const handleScroll = (0, react_1.useCallback)((event) => {
-        const { contentOffset, layoutMeasurement, contentSize } = event.nativeEvent;
-        // Update SDK with current scroll offset (both legacy + new registry)
-        try {
-            const sdk = client_1.AppAnalytics.getInstance();
-            sdk.setScrollOffset(contentOffset.y);
-            sdk.updateScrollViewOffset(scrollViewId.current, contentOffset.y);
-        }
-        catch { }
-        // Re-measure bounds occasionally during scroll — catches layout
-        // shifts from animations, keyboard, orientation changes, etc.
-        const now = Date.now();
-        if (now - lastMeasureTime.current > REMEASURE_THROTTLE_MS) {
-            lastMeasureTime.current = now;
-            measureAndRegister();
-        }
-        // Update scroll state — use realContentHeight if available
-        const bestContentHeight = realContentHeight.current > 0
-            ? realContentHeight.current
-            : contentSize.height;
-        scrollState.current = {
-            offsetY: contentOffset.y,
-            viewportHeight: layoutMeasurement.height,
-            contentHeight: bestContentHeight,
-        };
-        // Debounce: capture after scroll stops
-        if (debounceTimer.current)
-            clearTimeout(debounceTimer.current);
-        debounceTimer.current = setTimeout(() => doCapture(), DEBOUNCE_MS);
-        // Start interval for continuous scroll captures
-        startScrollInterval();
-        // Capture initial tile (Y~0) on first scroll event with real dims
-        if (!initialCaptured.current && contentOffset.y < 10) {
-            if (initialLayoutTimer.current)
-                clearTimeout(initialLayoutTimer.current);
-            initialLayoutTimer.current = setTimeout(() => doCapture(), 200);
-        }
-        onScroll?.(event);
-    }, [onScroll, measureAndRegister]);
-    const handleScrollEndDrag = (0, react_1.useCallback)((event) => {
-        // User lifted finger — capture immediately
-        stopScrollInterval();
-        doCapture(true);
-        onScrollEndDrag?.(event);
-    }, [onScrollEndDrag]);
-    const handleMomentumEnd = (0, react_1.useCallback)((event) => {
-        if (debounceTimer.current) {
-            clearTimeout(debounceTimer.current);
-            debounceTimer.current = null;
-        }
-        stopScrollInterval();
-        doCapture(true);
-        onMomentumScrollEnd?.(event);
-    }, [onMomentumScrollEnd]);
-    const handleLayout = (0, react_1.useCallback)((event) => {
-        const { height } = event.nativeEvent.layout;
-        if (!initialCaptured.current && height > 0) {
-            scrollState.current = {
-                offsetY: 0,
-                viewportHeight: height,
-                contentHeight: realContentHeight.current || height,
-            };
-            // Clear any prior pending initial-capture timer before scheduling
-            if (initialLayoutTimer.current)
-                clearTimeout(initialLayoutTimer.current);
-            initialLayoutTimer.current = setTimeout(() => doCapture(), 1000);
-        }
-        // Register window-relative bounds immediately (no setTimeout).
-        // measureInWindow itself is async; if it returns 0/0 dims, the
-        // next onLayout / onScroll will retry — no race window.
-        measureAndRegister();
-        onLayout?.(event);
-    }, [onLayout, measureAndRegister]);
-    /**
-     * Track the real content height from onContentSizeChange.
-     * This is more reliable than the first scroll event and ensures
-     * the initial tile at Y=0 has correct contentHeight metadata.
-     */
-    const handleContentSizeChange = (0, react_1.useCallback)((w, h) => {
-        realContentHeight.current = h;
-        // Update scroll state if it exists
-        if (scrollState.current) {
-            scrollState.current.contentHeight = h;
-        }
-        onContentSizeChange?.(w, h);
-    }, [onContentSizeChange]);
-    return (<react_native_1.ScrollView ref={setRef} {...props} onScroll={handleScroll} onScrollEndDrag={handleScrollEndDrag} onMomentumScrollEnd={handleMomentumEnd} onLayout={handleLayout} onContentSizeChange={handleContentSizeChange} scrollEventThrottle={props.scrollEventThrottle ?? 16}/>);
+    const tracking = (0, useRepliqoScrollTracking_1.useRepliqoScrollTracking)(ref, {
+        onScroll,
+        onMomentumScrollEnd,
+        onScrollEndDrag,
+        onLayout,
+        onContentSizeChange,
+    });
+    return (<react_native_1.ScrollView ref={tracking.setRef} {...props} onScroll={tracking.onScroll} onScrollEndDrag={tracking.onScrollEndDrag} onMomentumScrollEnd={tracking.onMomentumScrollEnd} onLayout={tracking.onLayout} onContentSizeChange={tracking.onContentSizeChange} scrollEventThrottle={props.scrollEventThrottle ?? 16}/>);
 });
 exports.RepliqoScrollView.displayName = 'RepliqoScrollView';

package/dist/components/useRepliqoScrollTracking.d.ts

@@ -0,0 +1,33 @@
+import { type NativeSyntheticEvent, type NativeScrollEvent, type LayoutChangeEvent } from 'react-native';
+export interface RepliqoScrollHandlers {
+    /** Attach as the scrollable's ref (also forwards to the user's ref). */
+    setRef: (node: unknown) => void;
+    onScroll: (event: NativeSyntheticEvent<NativeScrollEvent>) => void;
+    onScrollEndDrag: (event: NativeSyntheticEvent<NativeScrollEvent>) => void;
+    onMomentumScrollEnd: (event: NativeSyntheticEvent<NativeScrollEvent>) => void;
+    onLayout: (event: LayoutChangeEvent) => void;
+    onContentSizeChange: (w: number, h: number) => void;
+}
+interface ForwardedHandlers {
+    onScroll?: (event: NativeSyntheticEvent<NativeScrollEvent>) => void;
+    onScrollEndDrag?: (event: NativeSyntheticEvent<NativeScrollEvent>) => void;
+    onMomentumScrollEnd?: (event: NativeSyntheticEvent<NativeScrollEvent>) => void;
+    onLayout?: (event: LayoutChangeEvent) => void;
+    onContentSizeChange?: (w: number, h: number) => void;
+}
+/**
+ * Shared scroll-analytics behavior behind RepliqoScrollView and
+ * RepliqoFlatList:
+ *
+ *  1. Reports scroll offset for accurate heatmap touch coords
+ *  2. Captures viewport tiles on scroll stops AND during continuous
+ *     scroll for collaborative screen building
+ *  3. Registers window-relative bounds with the SDK so touches are
+ *     auto-classified as content (inside) vs fixed UI (outside)
+ *
+ * @param forwardedRef  The consumer's ref (function or object).
+ * @param userHandlers  The consumer's own scroll/layout handlers — always
+ *                      called after the SDK's.
+ */
+export declare function useRepliqoScrollTracking(forwardedRef: React.Ref<unknown>, userHandlers: ForwardedHandlers): RepliqoScrollHandlers;
+export {};