@applicaster/zapp-react-native-utils 12.0.2-rc.0 → 13.0.0-alpha.1552112220

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

@@ -1,116 +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();
-
-jest
-  .spyOn(playerManager, "getInstanceController")
-  // @ts-ignore
-  .mockImplementation(() => ({ rewind, forward }));
-
-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,87 +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 clearIntervalTimer = () => {
-    try {
-      clearInterval(intervalTimer.current);
-    } catch (err) {
-      intervalTimer.current = null;
-    }
-  };
-
-  const setIntervalTimer = (cb) => {
-    clearIntervalTimer();
-    intervalTimer.current = setInterval(cb, ON_HOLD_INTERVAL);
-  };
-
-  const resetState = () => {
-    setIsRunning(false);
-    setDirection(null);
-    setMultiplier(1);
-    clearIntervalTimer();
-  };
-
-  useEffect(() => {
-    const player = playerManager.getInstanceController();
-
-    if (!player) return;
-
-    if (direction) {
-      player[direction](Math.min(MAX_SEEK_TIME, SKIP_TIME_BASE * multiplier));
-      resetHUDTimer();
-    }
-  }, [multiplier, direction]);
-
-  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]
-  );
-
-  return React.useMemo(
-    () => ({ autoSeekStart, autoSeekStop }),
-    [autoSeekStart, autoSeekStop]
-  );
-};

package/reactHooks/player/useSeek.tsx

@@ -1,66 +0,0 @@
-import React from "react";
-import { SEEK_TYPE } from "./const";
-import { useTapSeek } from "./useTapSeek";
-import { useAutoSeek } from "./useAutoSeek";
-import { noop } from "../../functionUtils";
-
-export const useSeek = (resetHUDTimer = noop) => {
-  const handlePressEvent = useTapSeek();
-  const { autoSeekStart, autoSeekStop } = useAutoSeek(resetHUDTimer);
-
-  const onForwardPress = () => {
-    handlePressEvent(SEEK_TYPE.FORWARD);
-  };
-
-  const onRewindPress = () => {
-    handlePressEvent(SEEK_TYPE.REWIND);
-  };
-
-  const onForwardPressIn = () => {
-    autoSeekStart(SEEK_TYPE.FORWARD);
-  };
-
-  const onForwardPressOut = () => {
-    autoSeekStop();
-  };
-
-  const onRewindPressIn = () => {
-    autoSeekStart(SEEK_TYPE.REWIND);
-  };
-
-  const onRewindLongPress = () => {
-    autoSeekStart(SEEK_TYPE.REWIND);
-  };
-
-  const onForwardLongPress = () => {
-    autoSeekStart(SEEK_TYPE.FORWARD);
-  };
-
-  const onRewindPressOut = () => {
-    autoSeekStop();
-  };
-
-  return React.useMemo(
-    () => ({
-      onForwardPress,
-      onRewindPress,
-      onForwardPressIn,
-      onForwardPressOut,
-      onRewindPressIn,
-      onRewindPressOut,
-      onRewindLongPress,
-      onForwardLongPress,
-    }),
-    [handlePressEvent, autoSeekStart]
-  );
-};
-
-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,58 +0,0 @@
-import { useCallback, useRef } 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) => {
-  const skipTime = R.min(MAX_SEEK_TIME, SKIP_TIME_BASE * multiplier);
-
-  return skipTime;
-};
-
-export const useTapSeek = () => {
-  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);
-
-      lastPressTime.current = now;
-      currentOnPressEventType.current = eventType;
-    },
-    [resetMultiplier]
-  );
-
-  return handlePressEvent;
-};