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

package/time/BackgroundTimer.ts

@@ -0,0 +1,55 @@
+import { DeviceEventEmitter, NativeModules } from "react-native";
+import { platformSelect } from "../reactUtils";
+
+const { BackgroundTimer: RNBackgroundTimer } = NativeModules;
+
+class BackgroundTimer {
+  private uniqueId: number;
+  private readonly callbacks: Record<number, () => void>;
+
+  constructor() {
+    this.uniqueId = 0;
+    this.callbacks = {};
+
+    const EventEmitter = platformSelect({
+      android: DeviceEventEmitter,
+      ios: undefined,
+      default: undefined,
+    });
+
+    EventEmitter?.addListener("BackgroundTimer.timer.fired", (id: number) => {
+      if (this.callbacks[id]) {
+        const callback = this.callbacks[id];
+        delete this.callbacks[id];
+        callback();
+      }
+    });
+  }
+
+  setTimeout(callback, timeout): number | NodeJS.Timeout {
+    if (!RNBackgroundTimer) {
+      return global.setTimeout(callback, timeout);
+    }
+
+    this.uniqueId += 1;
+    const timeoutId = this.uniqueId;
+
+    this.callbacks[timeoutId] = callback;
+    RNBackgroundTimer.setTimeout(timeoutId, timeout);
+
+    return timeoutId;
+  }
+
+  clearTimeout(timeoutId: number | NodeJS.Timeout): void {
+    if (!RNBackgroundTimer) {
+      return global.clearTimeout(timeoutId as NodeJS.Timeout);
+    }
+
+    if (this.callbacks[timeoutId as number]) {
+      delete this.callbacks[timeoutId as number];
+      RNBackgroundTimer.clearTimeout(timeoutId);
+    }
+  }
+}
+
+export default new BackgroundTimer();

package/time/Timer.ts

@@ -1,16 +1,19 @@
+import BackgroundTimer from "./BackgroundTimer";
+
 export class Timer {
   private startTime: number;
-  private remaining: number;
-  private timeoutId: NodeJS.Timeout | null;
+  private timeoutId: number | NodeJS.Timeout | null;
 
-  constructor(private callback: () => void, private duration: number) {
-    this.remaining = duration;
+  constructor(
+    private callback: () => void,
+    private remaining: number = null
+  ) {
     this.timeoutId = null;
   }
 
   start(): void {
     this.startTime = Date.now();
-    this.timeoutId = setTimeout(this.callback, this.remaining);
+    this.timeoutId = BackgroundTimer.setTimeout(this.callback, this.remaining);
 
     this.remaining = 0;
   }
@@ -26,6 +29,6 @@ export class Timer {
   }
 
   clear(): void {
-    clearTimeout(this.timeoutId);
+    BackgroundTimer.clearTimeout(this.timeoutId);
   }
 }

package/types.ts

@@ -8,4 +8,5 @@ export type ManifestField<T> = {
 
 export enum ENDPOINT_TAGS {
   allow_missing_keys = "allow_missing_keys",
+  observe_storage = "observe_storage",
 }

package/utils/README.md

@@ -0,0 +1,34 @@
+### ramda replacement utils
+
+See contribution guide below
+
+## Reference
+
+
+### _.flatten
+R.times => flatten.ts
+
+### _.times
+R.times => times.ts
+
+### _.drop
+R.drop(N,array) => array.slice(N)
+
+### _.clone
+R.clone => clone.ts
+
+### _.splitEvery
+R.splitEvery => splitEvery.ts
+
+### _.length
+R.length(data) => data?.length ?? 0
+
+## Contribution
+
+To add new helper function 
+
+1. Search for replacement ( you can reuse lodash, preferable pure JS solution), arguments should match with Ramda definition 
+2. Add new file, update exports in index file
+3. If replacement is simple enough that doesn't need a function - add snippet to this README
+4. Make sure README is updated and contains reference for newly added function
+5. Write unit test to test input/output. You can use AI's help.

package/utils/clone.ts

@@ -0,0 +1,56 @@
+/**
+ * Creates a deep copy of the value which may contain (nested) `Array`s and `Object`s,
+ * `Number`s, `String`s, `Boolean`s and `Date`s. `Function`s are assigned by reference
+ * rather than copied. Dispatches to a `clone` method if present.
+ *
+ * @param {*} value - The value to clone
+ * @return {*} A deep copy of the provided value
+ */
+export const clone = (value) => {
+  // Handle null or undefined
+  if (value == null) {
+    return value;
+  }
+
+  // Check if value has a custom clone method
+  if (typeof value.clone === "function") {
+    return value.clone();
+  }
+
+  // Handle primitive types (they're immutable so no need to clone)
+  if (typeof value !== "object") {
+    return value;
+  }
+
+  // Handle Date objects
+  if (value instanceof Date) {
+    return new Date(value.getTime());
+  }
+
+  // Handle RegExp objects
+  if (value instanceof RegExp) {
+    return new RegExp(value.source, value.flags);
+  }
+
+  // Handle Array objects
+  if (Array.isArray(value)) {
+    return value.map((item) => clone(item));
+  }
+
+  // Handle Object literals
+  if (Object.prototype.toString.call(value) === "[object Object]") {
+    const result = {};
+    const keys = Object.keys(value);
+
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i];
+      result[key] = clone(value[key]);
+    }
+
+    return result;
+  }
+
+  // For other types like Maps, Sets, etc., we would need additional handling
+  // For simplicity, we'll return the original value for unsupported types
+  return value;
+};

package/utils/flatten.ts

@@ -0,0 +1,3 @@
+export const flatten = <T>(array: (T & T[])[]) => {
+  return array.flat(Infinity);
+};

package/utils/index.ts

@@ -0,0 +1,7 @@
+export { times } from "./times";
+
+export { flatten } from "./flatten";
+
+export { clone } from "./clone";
+
+export { splitEvery } from "./splitEvery";

package/utils/splitEvery.ts

@@ -0,0 +1,27 @@
+export function splitEvery(size, collection) {
+  if (size <= 0) {
+    throw new Error("First argument to splitEvery must be a positive integer");
+  }
+
+  const result = [];
+
+  // Handle string input
+  if (typeof collection === "string") {
+    for (let i = 0; i < collection.length; i += size) {
+      result.push(collection.slice(i, i + size));
+    }
+
+    return result;
+  }
+
+  // Handle array input
+  if (Array.isArray(collection)) {
+    for (let i = 0; i < collection.length; i += size) {
+      result.push(collection.slice(i, i + size));
+    }
+
+    return result;
+  }
+
+  return result;
+}

package/utils/times.ts

@@ -0,0 +1,2 @@
+export const times = (fn, n) =>
+  Array.from({ length: n }, (_, index) => fn(index));

package/zappFrameworkUtils/presentPluginOneTime.ts

@@ -92,9 +92,8 @@ export const PresentHookPluginOneTime = (
       const presentOneTimeVersionName =
         await getLatestWatchedVersionNumberFromStorage(storageKey, namespace);
 
-      const applicationVersionName = await sessionStorage.getItem(
-        versionNameKey
-      );
+      const applicationVersionName =
+        await sessionStorage.getItem(versionNameKey);
 
       if (!presentOneTimeVersionName || !applicationVersionName) {
         log_info(

package/appUtils/keyCodes/keys.ios.js

@@ -1,46 +0,0 @@
-/* global tizen */
-const isTizen = typeof tizen !== "undefined";
-
-export const KEYS = {
-  Enter: { code: "Enter", keyCode: 13 },
-  Space: { code: "Space", keyCode: 32 },
-  m: { code: "m", keyCode: 77 },
-  ArrowLeft: { code: "ArrowLeft", keyCode: 37 },
-  ArrowUp: { code: "ArrowUp", keyCode: 38 },
-  ArrowRight: { code: "ArrowRight", keyCode: 39 },
-  ArrowDown: { code: "ArrowDown", keyCode: 40 },
-  Back: isTizen
-    ? { code: "Back", keyCode: 10009 }
-    : { code: "Backspace", keyCode: 8 },
-  Play: isTizen
-    ? { code: "MediaPlay", keyCode: 10252 }
-    : { code: "PlayPause", keyCode: 179 },
-  Pause: isTizen
-    ? { code: "MediaPause", keyCode: 19 }
-    : { code: "Pause", keyCode: 179 },
-  Forward: isTizen
-    ? { code: "MediaFastForward", keyCode: 417 }
-    : { code: "Forward", keyCode: 176 },
-  Rewind: isTizen
-    ? { code: "MediaRewind", keyCode: 412 }
-    : { code: "Rewind", keyCode: 177 },
-  VolumeUp: isTizen
-    ? { code: "VolumeUp", keyCode: 447 }
-    : { code: "VolumeUp", keyCode: 175 },
-  VolumeDown: isTizen
-    ? { code: "VolumeDown", keyCode: 448 }
-    : { code: "VolumeDown", keyCode: 174 },
-  ToggleMute: isTizen
-    ? { code: "VolumeMute", keyCode: 449 }
-    : { code: "VolumeMute", keyCode: 173 },
-  Stop: isTizen
-    ? { code: "MediaStop", keyCode: 413 }
-    : { code: "Q", keyCode: 81 },
-};
-
-export const ARROW_KEYS = [
-  KEYS.ArrowUp,
-  KEYS.ArrowLeft,
-  KEYS.ArrowDown,
-  KEYS.ArrowRight,
-];

package/appUtils/playerManager/DelayedSeekPlayerWrapper.tsx

@@ -1,180 +0,0 @@
-import { Player } from "./player";
-import { BehaviorSubject } from "rxjs";
-
-export class DelayedSeekPlayerWrapper extends Player {
-  private wrappedPlayer: Player;
-  private delayedSeekPosition: number;
-  private wasPlaying: boolean;
-
-  constructor(props, player: Player) {
-    super(props);
-    this.wrappedPlayer = player;
-    this.delayedSeekPosition = null;
-
-    this.wrappedPlayer.addListener({
-      id: "Master-Wrapper-Listener",
-      listener: this,
-    });
-
-    this.onPlayerSeekComplete = this.onPlayerSeekComplete.bind(this);
-  }
-
-  getOverlayObservable = () => {
-    return this.wrappedPlayer.getOverlayObservable();
-  };
-
-  getEntryObservable = (): BehaviorSubject<ZappEntry | null> => {
-    return this.wrappedPlayer.getEntryObservable();
-  };
-
-  getEntry = (): ZappEntry | null => this.wrappedPlayer.getEntry();
-
-  getListener = (): QuickBrickPlayer.SharedPlayerCallBacks => {
-    return this.wrappedPlayer.getListener();
-  };
-
-  togglePlayPause = () => {
-    this.wrappedPlayer.togglePlayPause();
-  };
-
-  selectTrack = (_track) => this.wrappedPlayer.selectTrack(_track);
-
-  // Implement all default methods by delegating them to wrapped player
-  public seekTo = (position: number) => {
-    this.wrappedPlayer.seekTo(position);
-  };
-
-  public isPlaying = () => {
-    return this.wrappedPlayer.isPlaying();
-  };
-
-  public isPaused = () => {
-    return this.wrappedPlayer.isPaused();
-  };
-
-  public play = () => {
-    this.wrappedPlayer.play();
-  };
-
-  public pause = () => {
-    this.wrappedPlayer.pause();
-  };
-
-  getState = () => {
-    const currentState = this.wrappedPlayer.getState();
-
-    if (this.delayedSeekPosition === null) {
-      return currentState;
-    }
-
-    return {
-      ...currentState,
-      contentPosition: this.delayedSeekPosition,
-      isPaused: false,
-      seekPosition: this.delayedSeekPosition,
-    };
-  };
-
-  forward = (deltaTime: number) => {
-    if (this.delayedSeekPosition !== null) {
-      this.delayedSeekPosition += deltaTime;
-      this.playerState.seekPosition = this.delayedSeekPosition;
-
-      this.onVideoProgress({
-        currentTime: this.playerState.seekPosition,
-        duration: this.getDuration(),
-        seekableDuration: this.playerState.seekableDuration,
-        isLive: this.playerState.isLive,
-      });
-
-      // this.scheduleResumePlayback(DELAYED_SEEK_DELAY, this.delayedSeekPosition);
-
-      return;
-    }
-
-    if (this.playerState.seekPosition == null) {
-      this.playerState.seekPosition = this.playerState.contentPosition;
-    }
-
-    this.playerState.seekPosition += deltaTime;
-
-    this.wrappedPlayer.forward(deltaTime);
-  };
-
-  rewind = (deltaTime: number) => {
-    if (this.delayedSeekPosition !== null) {
-      this.delayedSeekPosition -= deltaTime;
-
-      if (this.delayedSeekPosition < 0) {
-        this.delayedSeekPosition = 0;
-      }
-
-      this.playerState.seekPosition = this.delayedSeekPosition;
-
-      this.onVideoProgress({
-        currentTime: this.playerState.seekPosition,
-        duration: this.getDuration(),
-        seekableDuration: this.playerState.seekableDuration,
-        isLive: this.playerState.isLive,
-      });
-
-      // this.scheduleResumePlayback(DELAYED_SEEK_DELAY, this.delayedSeekPosition);
-
-      return;
-    }
-
-    if (this.playerState.seekPosition == null) {
-      this.playerState.seekPosition = this.playerState.contentPosition;
-    }
-
-    this.playerState.seekPosition -= deltaTime;
-    this.wrappedPlayer.rewind(deltaTime);
-  };
-
-  public getConfig = () => this.wrappedPlayer.getConfig();
-
-  // TODO: replace with enum of supported orientations
-  isFullScreenSupported(): boolean {
-    return this.wrappedPlayer.isFullScreenSupported();
-  }
-
-  public supportsNativeControls = (): boolean =>
-    this.wrappedPlayer.supportsNativeControls();
-
-  public supportNativeCast = (): boolean =>
-    this.wrappedPlayer.supportNativeCast();
-
-  public isInDelayedSeek = () => this.delayedSeekPosition !== null;
-
-  public enterDelayedSeek() {
-    if (this.delayedSeekPosition !== null) {
-      return;
-    }
-
-    if (this.playerState.seekPosition === null) {
-      this.playerState.seekPosition = this.playerState.contentPosition;
-    }
-
-    this.delayedSeekPosition = this.playerState.seekPosition;
-
-    if (!this.isPaused()) {
-      this.wasPlaying = true;
-      this.wrappedPlayer.pause();
-    }
-  }
-
-  public exitDelayedSeek() {
-    if (this.delayedSeekPosition === null) {
-      return;
-    }
-
-    this.wrappedPlayer.seekTo(this.delayedSeekPosition);
-
-    if (this.wasPlaying) {
-      this.wasPlaying = false;
-      this.wrappedPlayer.play();
-    }
-
-    this.delayedSeekPosition = null;
-  }
-}

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;
-};