@applicaster/zapp-react-native-utils 13.0.0-alpha.2635505531 → 13.0.0-alpha.3244448100

package/reactHooks/player/__tests__/useAutoSeek.test.tsx

@@ -1,123 +0,0 @@
-import { act, renderHook } from "@testing-library/react-hooks";
-import { playerManager } from "@applicaster/zapp-react-native-utils/appUtils/playerManager";
-
-import { ON_HOLD_INTERVAL, SEEK_TYPE, SKIP_TIME_BASE } from "../const";
-
-import { useAutoSeek } from "../useAutoSeek";
-
-jest.useFakeTimers();
-
-const rewind = jest.fn();
-const forward = jest.fn();
-const exitDelayedSeek = jest.fn();
-const enterDelayedSeek = jest.fn();
-
-jest
-  .spyOn(playerManager, "getInstanceController")
-  // @ts-ignore
-  .mockImplementation(() => ({
-    rewind,
-    forward,
-    exitDelayedSeek,
-    enterDelayedSeek,
-  }));
-
-describe("useAutoSeek", () => {
-  beforeEach(() => {
-    rewind.mockReset();
-    forward.mockReset();
-  });
-
-  describe("autoSeekStart", () => {
-    it("should call forward method on playerInstance", () => {
-      const { result } = renderHook(() => useAutoSeek());
-
-      act(() => {
-        result.current.autoSeekStart(SEEK_TYPE.FORWARD);
-      });
-
-      expect(forward).toBeCalled();
-      result.current.autoSeekStop();
-    });
-
-    it("should call rewind method on playerManager", () => {
-      const { result } = renderHook(() => useAutoSeek());
-
-      act(() => {
-        result.current.autoSeekStart(SEEK_TYPE.REWIND);
-      });
-
-      expect(rewind).toBeCalled();
-      result.current.autoSeekStop();
-    });
-
-    it("should call rewind with default skip time", () => {
-      const { result } = renderHook(() => useAutoSeek());
-
-      act(() => {
-        result.current.autoSeekStart(SEEK_TYPE.REWIND);
-      });
-
-      expect(rewind).toBeCalledWith(SKIP_TIME_BASE);
-      result.current.autoSeekStop();
-    });
-
-    it("should call forward with default skip time", () => {
-      const { result } = renderHook(() => useAutoSeek());
-
-      act(() => {
-        result.current.autoSeekStart(SEEK_TYPE.FORWARD);
-      });
-
-      expect(forward).toBeCalledWith(SKIP_TIME_BASE);
-      result.current.autoSeekStop();
-    });
-
-    it("should call rewind in intervals set in configuration", () => {
-      const { result } = renderHook(() => useAutoSeek());
-
-      act(() => {
-        result.current.autoSeekStart(SEEK_TYPE.REWIND);
-      });
-
-      expect(rewind).toBeCalled();
-      jest.advanceTimersByTime(ON_HOLD_INTERVAL * 3);
-      expect(rewind).toBeCalledTimes(4);
-      result.current.autoSeekStop();
-    });
-
-    it("should call forward in intervals set in configuration", () => {
-      const { result } = renderHook(() => useAutoSeek());
-
-      act(() => {
-        result.current.autoSeekStart(SEEK_TYPE.FORWARD);
-      });
-
-      expect(forward).toBeCalled();
-      jest.advanceTimersByTime(ON_HOLD_INTERVAL * 3);
-      expect(forward).toBeCalledTimes(4);
-      result.current.autoSeekStop();
-    });
-  });
-
-  describe("autoSeekStop", () => {
-    it("should stop calling playerManager method after autoSeekStop is called", () => {
-      const { result } = renderHook(() => useAutoSeek());
-
-      act(() => {
-        result.current.autoSeekStart(SEEK_TYPE.FORWARD);
-      });
-
-      expect(forward).toBeCalled();
-      jest.advanceTimersByTime(ON_HOLD_INTERVAL * 3);
-      expect(forward).toBeCalledTimes(4);
-
-      act(() => {
-        result.current.autoSeekStop();
-      });
-
-      jest.advanceTimersByTime(ON_HOLD_INTERVAL * 3);
-      expect(forward).toBeCalledTimes(4);
-    });
-  });
-});

package/reactHooks/player/__tests__/useTapSeek.test.ts

@@ -1,94 +0,0 @@
-import { renderHook } from "@testing-library/react-hooks";
-import { playerManager } from "@applicaster/zapp-react-native-utils/appUtils/playerManager";
-import { useTapSeek } from "../useTapSeek";
-
-import { ON_PRESS_RESET_DURATION, SEEK_TYPE, SKIP_TIME_BASE } from "../const";
-
-const rewind = jest.fn();
-const forward = jest.fn();
-
-jest
-  .spyOn(playerManager, "getInstanceController")
-  // @ts-ignore
-  .mockImplementation(() => ({ rewind, forward }));
-
-describe("useTapSeek", () => {
-  beforeEach(() => {
-    rewind.mockReset();
-    forward.mockReset();
-  });
-
-  describe("forward", () => {
-    it("should call forward method on playerManager", () => {
-      const { result } = renderHook(() => useTapSeek());
-
-      result.current(SEEK_TYPE.FORWARD);
-      expect(forward).toBeCalled();
-    });
-
-    it("should call forward with default skip time", () => {
-      const { result } = renderHook(() => useTapSeek());
-
-      result.current(SEEK_TYPE.FORWARD);
-      expect(forward).toBeCalledWith(SKIP_TIME_BASE);
-    });
-
-    it("should multiply skip time for every call", async () => {
-      const { result } = renderHook(() => useTapSeek());
-
-      result.current(SEEK_TYPE.FORWARD);
-      expect(forward).toBeCalledWith(SKIP_TIME_BASE);
-      result.current(SEEK_TYPE.FORWARD);
-      expect(forward).toBeCalledWith(SKIP_TIME_BASE * 2);
-    });
-
-    it("should reset multiplier if waiting more then resetDuration between press actions", () => {
-      const { result, waitFor } = renderHook(() => useTapSeek());
-
-      result.current(SEEK_TYPE.FORWARD);
-      expect(forward).toBeCalledWith(SKIP_TIME_BASE);
-      waitFor(jest.fn(), { timeout: ON_PRESS_RESET_DURATION });
-      result.current(SEEK_TYPE.FORWARD);
-      expect(forward).toBeCalledWith(SKIP_TIME_BASE);
-    });
-  });
-
-  describe("rewind", () => {
-    it("should call rewind method on playerManager", () => {
-      const { result } = renderHook(() => useTapSeek());
-
-      result.current(SEEK_TYPE.REWIND);
-      expect(rewind).toBeCalled();
-    });
-
-    it("should call rewind with default skip time", () => {
-      const { result } = renderHook(() => useTapSeek());
-
-      result.current(SEEK_TYPE.REWIND);
-      expect(rewind).toBeCalledWith(SKIP_TIME_BASE);
-    });
-
-    it("should multiply skip time for every call", async () => {
-      const { result } = renderHook(() => useTapSeek());
-
-      result.current(SEEK_TYPE.REWIND);
-      expect(rewind).toBeCalledWith(SKIP_TIME_BASE);
-      result.current(SEEK_TYPE.REWIND);
-      expect(rewind).toBeCalledWith(SKIP_TIME_BASE * 2);
-    });
-  });
-
-  describe("mixed usage", () => {
-    it("should reset timer if different type of event is emitted", () => {
-      const { result } = renderHook(() => useTapSeek());
-      result.current(SEEK_TYPE.REWIND);
-      expect(rewind).toBeCalledWith(SKIP_TIME_BASE);
-
-      result.current(SEEK_TYPE.REWIND);
-      expect(rewind).toBeCalledWith(SKIP_TIME_BASE * 2);
-
-      result.current(SEEK_TYPE.FORWARD);
-      expect(forward).toBeCalledWith(SKIP_TIME_BASE);
-    });
-  });
-});

package/reactHooks/player/useAutoSeek.tsx

@@ -1,106 +0,0 @@
-import React, { useEffect, useState } from "react";
-import { usePrevious } from "@applicaster/zapp-react-native-utils/reactHooks/utils";
-import { playerManager } from "@applicaster/zapp-react-native-utils/appUtils/playerManager";
-import {
-  MAX_SEEK_TIME,
-  ON_HOLD_INTERVAL,
-  SEEK_TYPE,
-  SKIP_TIME_BASE,
-} from "./const";
-import { noop } from "../../functionUtils";
-
-export const useAutoSeek = (resetHUDTimer = noop) => {
-  const [isRunning, setIsRunning] = useState<boolean>(false);
-  const [direction, setDirection] = useState<Nullable<SEEK_TYPE>>(null);
-  const [multiplier, setMultiplier] = useState(1);
-
-  const intervalTimer = React.useRef(null);
-  const prevRunning = usePrevious(isRunning);
-
-  const setIntervalTimer = (cb) => {
-    if (intervalTimer.current) {
-      return;
-    }
-
-    intervalTimer.current = setInterval(() => {
-      intervalTimer.current = null;
-      cb();
-    }, ON_HOLD_INTERVAL);
-  };
-
-  const clearIntervalTimer = () => {
-    clearInterval(intervalTimer.current);
-    intervalTimer.current = null;
-  };
-
-  const resetState = () => {
-    setIsRunning(false);
-    setDirection(null);
-    setMultiplier(1);
-    clearIntervalTimer();
-  };
-
-  useEffect(() => {
-    const player = playerManager.getInstanceController();
-    if (!player) return;
-
-    if (isRunning) {
-      player?.enterDelayedSeek();
-    } else if (!isRunning) {
-      player.exitDelayedSeek();
-    }
-  }, [isRunning]);
-
-  useEffect(() => {
-    if (!isRunning) {
-      return;
-    }
-
-    const player = playerManager.getInstanceController();
-
-    if (!player) return;
-
-    if (direction) {
-      player[direction](Math.min(MAX_SEEK_TIME, SKIP_TIME_BASE * multiplier));
-      resetHUDTimer();
-    }
-  }, [multiplier, direction, isRunning]);
-
-  useEffect(() => {
-    if (isRunning && isRunning !== prevRunning) {
-      setIntervalTimer(() => {
-        setMultiplier((prev) => {
-          return prev + 1;
-        });
-      });
-    } else if (!isRunning && isRunning !== prevRunning) {
-      resetState();
-    }
-
-    return () => {
-      clearIntervalTimer();
-    };
-  }, [isRunning, direction]);
-
-  const autoSeekStop = React.useCallback(() => {
-    resetState();
-  }, []);
-
-  const autoSeekStart = React.useCallback(
-    (eventType: SEEK_TYPE) => {
-      // Check if there is another session running
-      if (isRunning) {
-        autoSeekStop();
-      }
-
-      setDirection(eventType);
-      setIsRunning(true);
-    },
-    [isRunning, autoSeekStop]
-  );
-
-  return React.useMemo(
-    () => ({ autoSeekStart, autoSeekStop }),
-    [autoSeekStart, autoSeekStop]
-  );
-};

package/reactHooks/player/useSeek.tsx

@@ -1,17 +0,0 @@
-import React, { useMemo } from "react";
-import { noop } from "../../functionUtils";
-import { TVSeekController } from "./TVSeekControlller/TVSeekController";
-
-export const useSeek = (resetHUDTimer = noop) => {
-  return useMemo(() => TVSeekController.getInstance().getSeekMethods(), []);
-};
-
-export const withUseSeek = (Component) =>
-  Object.assign(
-    (props) => {
-      const seekMethods = useSeek(props?.resetHUDTimer);
-
-      return <Component {...props} seekMethods={seekMethods} />;
-    },
-    { displayName: "WithUseSeek" }
-  );

package/reactHooks/player/useTapSeek.tsx

@@ -1,85 +0,0 @@
-import { useCallback, useRef, useState } from "react";
-import * as R from "ramda";
-import {
-  MAX_SEEK_TIME,
-  ON_PRESS_RESET_DURATION,
-  SEEK_TYPE,
-  SKIP_TIME_BASE,
-} from "./const";
-import { playerManager } from "@applicaster/zapp-react-native-utils/appUtils";
-
-type SeekType = SEEK_TYPE | null;
-
-const getSkipTime = (multiplier) =>
-  R.min(MAX_SEEK_TIME, SKIP_TIME_BASE * multiplier);
-
-export const useTapSeek = () => {
-  const [resumeTimer, setResumeTimer] = useState<NodeJS.Timeout>(null);
-  const onPressMultiplier = useRef(1);
-  const lastPressTime = useRef(0);
-  const currentOnPressEventType = useRef<SeekType>(null);
-
-  const resetMultiplier = useCallback(() => {
-    onPressMultiplier.current = 1;
-  }, []);
-
-  const handlePressEvent = useCallback(
-    (eventType) => {
-      const player = playerManager.getInstanceController();
-      if (!player) return;
-
-      const now = Date.now();
-      const timeSinceLastPress = now - lastPressTime.current;
-      const isSameEventType = eventType === currentOnPressEventType.current;
-
-      const isWithinResetDuration =
-        timeSinceLastPress <= ON_PRESS_RESET_DURATION;
-
-      const shouldIncreaseMultiplier = isSameEventType && isWithinResetDuration;
-
-      if (shouldIncreaseMultiplier) {
-        onPressMultiplier.current += 1;
-      } else {
-        resetMultiplier();
-      }
-
-      const seekTime = getSkipTime(onPressMultiplier.current);
-
-      player[eventType](seekTime);
-
-      if (resumeTimer) {
-        clearTimeout(resumeTimer);
-
-        const timer = setTimeout(() => {
-          player.exitDelayedSeek();
-          setResumeTimer(null);
-        }, 2000);
-
-        setResumeTimer(timer);
-      }
-
-      const clicksBeforePause = 3;
-
-      // Only pause player if user starts to seek on large increments
-      if (onPressMultiplier.current > clicksBeforePause) {
-        if (!player.isPaused()) {
-          player.enterDelayedSeek();
-
-          const timer = setTimeout(() => {
-            player.exitDelayedSeek();
-            setResumeTimer(null);
-          }, 2000);
-
-          clearTimeout(resumeTimer);
-          setResumeTimer(timer);
-        }
-      }
-
-      lastPressTime.current = now;
-      currentOnPressEventType.current = eventType;
-    },
-    [resetMultiplier, resumeTimer]
-  );
-
-  return handlePressEvent;
-};