@applicaster/zapp-react-native-utils 13.0.0-alpha.7120331332 → 13.0.0-alpha.7192404241

package/logger/const.ts

@@ -1,6 +1,3 @@
-/* eslint-disable unused-imports/no-unused-vars */
-import * as R from "ramda";
-
 enum XRayLogLevel {
   verbose = 0,
   debug = 1,
@@ -11,51 +8,9 @@ enum XRayLogLevel {
   off = 100,
 }
 
-enum ToastLogLevel {
-  off = "off",
-  verbose = "verbose",
-  debug = "debug",
-  info = "info",
-  warning = "warning",
-  error = "error",
-}
-
-const toastLevelToLogLevel = (toastLogLevel: ToastLogLevel): XRayLogLevel => {
-  if (R.isNil(toastLogLevel)) {
-    return XRayLogLevel.off;
-  }
-
-  switch (toastLogLevel) {
-    case ToastLogLevel.verbose:
-      return XRayLogLevel.verbose;
-    case ToastLogLevel.debug:
-      return XRayLogLevel.debug;
-    case ToastLogLevel.info:
-      return XRayLogLevel.info;
-    case ToastLogLevel.error:
-      return XRayLogLevel.error;
-    default:
-      return XRayLogLevel.off;
-  }
-};
-
-const PLUGIN_IDENTIFIER = "xray_logging_plugin";
-
-const wrapInObject = (obj, name) => {};
-
-const applyConditions = (wrappedObj) => {};
-
-const sanitizeEventPayload = () => {};
+const wrapInObject = (_ctx: unknown, _key: string) => {};
 
-const __isRunningRepoTests = () => {};
-
-const isWeb = () => {};
-
-const isDOMApp = () => {};
-
-const isBrowser = () => {};
-
-const eventAllowed = () => {};
+const applyConditions = (_fn: unknown) => {};
 
 /**
  * This is the mocked version of XRayLogger
@@ -90,34 +45,21 @@ export default class XRayLogger {
     );
   };
 
-  log = (event: string | XRayEventData) => {
-    const logEvent = typeof event === "string" ? { message: event } : event;
-  };
+  log = (_event) => {};
 
-  debug = (event: string | XRayEventData) => {
-    const logEvent = typeof event === "string" ? { message: event } : event;
-  };
+  debug = (_event) => {};
 
-  info = (event: string | XRayEventData) => {
-    const logEvent = typeof event === "string" ? { message: event } : event;
-  };
+  info = (_event) => {};
 
-  warning = (event: string | XRayEventData) => {
-    const logEvent = typeof event === "string" ? { message: event } : event;
-  };
+  warning = (_event) => {};
 
-  warn = (event: string | XRayEventData) => {
+  warn = (_event) => {
     this.warning(event);
   };
 
-  error = (event: Error | XRayEventData) => {
-    const logEvent: XRayEventData =
-      event instanceof Error
-        ? { exception: event as Error, message: event.message }
-        : (event as XRayEventData);
-  };
+  error = (_event) => {};
 
-  sendEvent = (event, eventData) => {};
+  sendEvent = (_event, _eventData) => {};
 
   // To be used by QuickBrick Hook events
   sendAudienceEvent = (event, eventData = null) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applicaster/zapp-react-native-utils",
-  "version": "13.0.0-alpha.7120331332",
+  "version": "13.0.0-alpha.7192404241",
   "description": "Applicaster Zapp React Native utilities package",
   "main": "index.js",
   "types": "index.d.ts",
@@ -28,7 +28,7 @@
   },
   "homepage": "https://github.com/applicaster/quickbrick#readme",
   "dependencies": {
-    "@applicaster/applicaster-types": "13.0.0-alpha.7120331332",
+    "@applicaster/applicaster-types": "13.0.0-alpha.7192404241",
     "buffer": "^5.2.1",
     "camelize": "^1.0.0",
     "create-react-context": "^0.2.3",
@@ -44,6 +44,7 @@
     "immer": "*",
     "react": "17.0.2",
     "react-native": "0.68.6",
+    "uglify-js": "*",
     "validate-color": "*",
     "zustand": "*"
   },

package/reactHooks/cell-click/__tests__/index.test.js

@@ -25,6 +25,11 @@ jest.mock("@applicaster/zapp-react-native-utils/analyticsUtils/", () => ({
   }),
 }));
 
+jest.mock("@applicaster/zapp-react-native-utils/reactHooks/screen", () => ({
+  useTargetScreenData: jest.fn(() => ({})),
+  useCurrentScreenData: jest.fn(() => ({})),
+}));
+
 jest.mock("@applicaster/zapp-react-native-ui-components/Contexts", () => ({
   ...jest.requireActual(
     "@applicaster/zapp-react-native-ui-components/Contexts"

package/reactHooks/cell-click/index.ts

@@ -16,6 +16,7 @@ import { ActionExecutorContext } from "@applicaster/zapp-react-native-utils/acti
 import { isFunction, noop } from "../../functionUtils";
 import { useSendAnalyticsOnPress } from "../analytics";
 import { logOnPress, warnEmptyContentType } from "./helpers";
+import { useCurrentScreenData } from "../screen";
 
 /**
  * If onCellTap is defined execute the function and
@@ -44,6 +45,7 @@ export const useCellClick = ({
 
   const onCellTap: Option<Function> = React.useContext(CellTapContext);
   const actionExecutor = React.useContext(ActionExecutorContext);
+  const screenData = useCurrentScreenData();
 
   const cellSelectable = toBooleanWithDefaultTrue(
     component?.rules?.component_cells_selectable
@@ -78,7 +80,10 @@ export const useCellClick = ({
       logOnPress(selectedItem, pathname, component, onCellTap);
 
       if (selectedItem) {
-        await actionExecutor?.handleEntryActions(selectedItem);
+        await actionExecutor?.handleEntryActions(selectedItem, {
+          component,
+          screenData,
+        });
       }
 
       if (selectedItem?.type?.value === "action") {
@@ -111,6 +116,7 @@ export const useCellClick = ({
       pathname,
       push,
       sendAnalyticsOnPress,
+      screenData,
     ]
   );
 

package/reactHooks/feed/useFeedLoader.tsx

@@ -87,7 +87,7 @@ export const useFeedLoader = ({
         );
       }
     }
-  }, [callableFeedUrl, currentFeed?.data]);
+  }, [callableFeedUrl, currentFeed?.data?.next]);
 
   useEffect(() => {
     if (

package/reactHooks/player/TVSeekControlller/ISeekController.ts

@@ -0,0 +1,32 @@
+import { MAX_SEEK_TIME, SEEK_TYPE, SKIP_TIME_BASE } from "../const";
+
+export interface ISeekControllerDelegate {
+  handleDelayedSeek(offset: number): void;
+  handleSeek(offset: number): void;
+  handleSeekComplete(): void;
+  handlePlayerPause(): void;
+}
+
+export interface ISeekController {
+  title: string;
+  onStartSeek(seekType: SEEK_TYPE): void;
+  onSeekEnd(): void;
+  reset(): void;
+}
+
+export class SeekIncrementalBaseStrategy {
+  private skipMultiplier = 1;
+
+  getSkipTime = () =>
+    Math.min(MAX_SEEK_TIME, SKIP_TIME_BASE * this.skipMultiplier);
+
+  increment = () => {
+    this.skipMultiplier++;
+  };
+
+  getSkipMultiplier = () => this.skipMultiplier;
+
+  reset = () => {
+    this.skipMultiplier = 1;
+  };
+}

package/reactHooks/player/TVSeekControlller/LongPressSeekController.ts

@@ -0,0 +1,71 @@
+import {
+  ISeekController,
+  ISeekControllerDelegate,
+  SeekIncrementalBaseStrategy,
+} from "./ISeekController";
+import { SEEK_TYPE } from "../const";
+import { log_debug, log_error, log_verbose } from "./TVSeekController";
+import { interval, Subscription } from "rxjs";
+import { tap } from "rxjs/operators";
+
+interface LongPressConfig {
+  TIMER_INTERVAL_MS: number;
+}
+
+export class LongPressSeekController implements ISeekController {
+  private subscription: Subscription | null = null;
+  readonly title = "LongPressSeek";
+  constructor(
+    private seekControllerDelegate: ISeekControllerDelegate,
+    private seekIncrementalStrategy: SeekIncrementalBaseStrategy,
+    private config: LongPressConfig
+  ) {}
+
+  onStartSeek(seekType: SEEK_TYPE) {
+    this.cleanUpSubscription();
+
+    log_debug(`${this.title}: start long press seek type: ${seekType}.`);
+
+    this.seekControllerDelegate.handlePlayerPause();
+
+    this.subscription = interval(this.config.TIMER_INTERVAL_MS)
+      .pipe(
+        tap(() => {
+          this.seekControllerDelegate.handleDelayedSeek(
+            this.seekIncrementalStrategy.getSkipTime()
+          );
+
+          log_debug(
+            `${
+              this.title
+            }: handle delayed seek type: ${seekType} - multiplier: ${this.seekIncrementalStrategy.getSkipMultiplier()}, currentSkipAmount: ${this.seekIncrementalStrategy.getSkipTime()}.`
+          );
+
+          this.seekIncrementalStrategy.increment();
+        })
+      )
+      .subscribe({
+        complete: () =>
+          log_verbose(`${this.title}: Long press subscription complete`),
+        error: (err) =>
+          log_error(`${this.title}: Long press subscription error`, err),
+      });
+  }
+
+  onSeekEnd() {
+    this.cleanUpSubscription();
+    this.seekControllerDelegate.handleSeekComplete();
+  }
+
+  reset() {
+    this.seekIncrementalStrategy.reset();
+    this.cleanUpSubscription();
+  }
+
+  private cleanUpSubscription() {
+    if (this.subscription) {
+      this.subscription.unsubscribe();
+      this.subscription = null;
+    }
+  }
+}

package/reactHooks/player/TVSeekControlller/TVSeekController.ts

@@ -0,0 +1,258 @@
+import { BehaviorSubject } from "rxjs";
+import { TapSeekController } from "./TapSeekController";
+import { LongPressSeekController } from "./LongPressSeekController";
+import { SEEK_TYPE } from "../const";
+import { createLogger } from "../../../logger";
+import { Player } from "../../../appUtils/playerManager/player";
+import { SeekKeyHandlerListener } from "../../../appUtils/keyInputHandler/KeyInputHandler";
+import {
+  ISeekController,
+  ISeekControllerDelegate,
+  SeekIncrementalBaseStrategy,
+} from "./ISeekController";
+
+export const { log_warning, log_debug, log_info, log_error, log_verbose } =
+  createLogger({
+    category: "General",
+    subsystem: "TVSeekController",
+  });
+
+export enum SEEK_STRATEGY {
+  TAP_SEEK = "TAP_SEEK",
+  AUTO_SEEK = "AUTO_SEEK",
+}
+
+const CONFIG_TAP_SEEK = {
+  CLICKS_BEFORE_PAUSE: 0,
+};
+
+const CONFIG_LONG_PRESS = {
+  TIMER_INTERVAL_MS: 200,
+};
+
+const LONG_PRESS_THRESHOLD = 500;
+const SEEK_END_TIMEOUT_DURATION = 700;
+// prettier-ignore
+
+export class TVSeekController
+  implements SeekKeyHandlerListener, ISeekControllerDelegate {
+  public delayedSeekPosition: number | null = null;
+  private readonly playerController: Player;
+  private delayedSeekProgressSubject = new BehaviorSubject<number | null>(null);
+  isPlayerInitiallyPaused: null | boolean = null;
+  currentSeekType: SEEK_TYPE | null = null;
+
+  private currentSeekController: ISeekController;
+  private readonly tapSeekController: TapSeekController;
+  private readonly longPressSeekController: LongPressSeekController;
+  private longPressThresholdTimeout: any | null = null;
+  private seekEndTimeout: any | null = null;
+
+  constructor(playerController: Player) {
+    this.playerController = playerController;
+
+    this.tapSeekController = new TapSeekController(
+      this,
+      new SeekIncrementalBaseStrategy(),
+      CONFIG_TAP_SEEK
+    );
+
+    this.longPressSeekController = new LongPressSeekController(
+      this,
+      new SeekIncrementalBaseStrategy(),
+      CONFIG_LONG_PRESS
+    );
+
+    this.currentSeekController = this.tapSeekController;
+  }
+
+  getDelayedSeekProgressObservable = () => {
+    return this.delayedSeekProgressSubject;
+  };
+
+  setStrategy = (seekStrategy: SEEK_STRATEGY) => {
+    switch (seekStrategy) {
+      case SEEK_STRATEGY.TAP_SEEK:
+        this.currentSeekController = this.tapSeekController;
+        log_debug("TVSeekController: setStrategy - TAP_SEEK");
+
+        break;
+      case SEEK_STRATEGY.AUTO_SEEK:
+        this.currentSeekController = this.longPressSeekController;
+        log_debug("TVSeekController: setStrategy - AUTO_SEEK");
+
+        break;
+      default:
+    }
+  };
+
+  handleStartSeek = (seekType: SEEK_TYPE) => {
+    this.currentSeekType = seekType;
+
+    if (this.isPlayerInitiallyPaused === null) {
+      this.isPlayerInitiallyPaused = this.playerController.isPaused();
+    }
+
+    this.clearLongPressThresholdTimeout();
+    this.clearSeekCompleteTimeout();
+    this.setStrategy(SEEK_STRATEGY.TAP_SEEK);
+    this.currentSeekController.onStartSeek(seekType);
+
+    this.longPressThresholdTimeout = setTimeout(() => {
+      this.setStrategy(SEEK_STRATEGY.AUTO_SEEK);
+      this.currentSeekController.onStartSeek(seekType);
+    }, LONG_PRESS_THRESHOLD);
+  };
+
+  onForwardPress = (): boolean => {
+    this.handleStartSeek(SEEK_TYPE.FORWARD);
+
+    return true;
+  };
+
+  onRewindPress = (): boolean => {
+    this.handleStartSeek(SEEK_TYPE.REWIND);
+
+    return true;
+  };
+
+  onSeekEnd = () => {
+    this.clearLongPressThresholdTimeout();
+    this.currentSeekController.onSeekEnd();
+  };
+
+  onRewindPressOut = () => {
+    this.onSeekEnd();
+  };
+
+  onForwardPressOut = () => {
+    this.onSeekEnd();
+  };
+
+  onVideoProgress = (position: number) => {
+    if (this.delayedSeekPosition !== null) {
+      return;
+    }
+
+    this.delayedSeekProgressSubject.next(position);
+  };
+
+  handleDelayedSeek = (offset: number = 0) => {
+    this.handlePlayerPause();
+
+    const currentPos =
+      this.delayedSeekPosition === null
+        ? this.playerController.getPosition()
+        : this.delayedSeekPosition;
+
+    let targetPos = currentPos;
+
+    if (this.currentSeekType === SEEK_TYPE.FORWARD) {
+      targetPos = Math.min(
+        currentPos + offset,
+        this.playerController.getSeekableDuration()
+      );
+    } else if (this.currentSeekType === SEEK_TYPE.REWIND) {
+      targetPos = Math.max(0, currentPos - offset);
+    } else {
+      log_warning(
+        `TVSeekController: handleDelayedSeek - invalid seek type: ${this.currentSeekType}`
+      );
+    }
+
+    log_debug(
+      `TVSeekController: handleDelayedSeek - targetPos: ${targetPos}, skipTime: ${offset}`
+    );
+
+    const prevValue = this.delayedSeekProgressSubject.getValue();
+
+    if (prevValue !== null) {
+      const delta = Math.abs(prevValue - targetPos);
+
+      if (delta < 1) {
+        return;
+      }
+    }
+
+    this.delayedSeekPosition = targetPos;
+    this.delayedSeekProgressSubject.next(targetPos);
+  };
+
+  handleSeekTo = (newPosition: number) => {
+    this.playerController.seekTo(newPosition);
+
+    if (!this.isPlayerInitiallyPaused) {
+      this.playerController.play();
+    }
+  };
+
+  handleSeek = (offset: number) => {
+    this.playerController[this.currentSeekType](offset);
+
+    if (!this.isPlayerInitiallyPaused) {
+      this.playerController.play();
+    }
+  };
+
+  handleSeekComplete = () => {
+    this.clearSeekCompleteTimeout();
+
+    this.seekEndTimeout = setTimeout(() => {
+      if (this.delayedSeekPosition !== null) {
+        this.handleSeekTo(this.delayedSeekPosition);
+      }
+
+      log_debug(
+        `handleSeekComplete: Seek finished, type: ${this.currentSeekController.title}, seekPosition: ${this.delayedSeekPosition}. Reset all states and seek position.`
+      );
+
+      this.resetAll();
+    }, SEEK_END_TIMEOUT_DURATION);
+  };
+
+  isSeeking = (): boolean => {
+    return this.delayedSeekPosition !== null;
+  };
+
+  handlePlayerPause = () => {
+    if (this.playerController.isPaused()) {
+      return;
+    }
+
+    this.playerController.pause();
+  };
+
+  clearSeekCompleteTimeout = () => {
+    if (this.seekEndTimeout === null) {
+      return;
+    }
+
+    clearTimeout(this.seekEndTimeout);
+    this.seekEndTimeout = null;
+  };
+
+  clearLongPressThresholdTimeout = () => {
+    if (this.longPressThresholdTimeout === null) {
+      return;
+    }
+
+    clearTimeout(this.longPressThresholdTimeout);
+    this.longPressThresholdTimeout = null;
+  };
+
+  resetAll() {
+    log_debug("TVSeekController: Reset all states");
+    this.currentSeekType = null;
+
+    this.delayedSeekPosition = null;
+    this.isPlayerInitiallyPaused = null;
+
+    this.clearSeekCompleteTimeout();
+    this.clearLongPressThresholdTimeout();
+
+    this.tapSeekController.reset();
+    this.longPressSeekController.reset();
+
+    this.setStrategy(SEEK_STRATEGY.TAP_SEEK);
+  }
+}

package/reactHooks/player/TVSeekControlller/TapSeekController.ts

@@ -0,0 +1,53 @@
+import {
+  ISeekController,
+  ISeekControllerDelegate,
+  SeekIncrementalBaseStrategy,
+} from "./ISeekController";
+import { SEEK_TYPE } from "../const";
+import { log_debug } from "./TVSeekController";
+
+interface TapPressConfig {
+  CLICKS_BEFORE_PAUSE: number;
+}
+
+export class TapSeekController implements ISeekController {
+  readonly title = "TapSeek";
+  constructor(
+    private seekControllerDelegate: ISeekControllerDelegate,
+    private seekIncrementalStrategy: SeekIncrementalBaseStrategy,
+    private config: TapPressConfig
+  ) {}
+
+  onStartSeek = (seekType: SEEK_TYPE) => {
+    log_debug(`${this.title}: start tap seek type: ${seekType}.`);
+
+    const skipTime = this.seekIncrementalStrategy.getSkipTime();
+    const seekMultiplier = this.seekIncrementalStrategy.getSkipMultiplier();
+
+    if (seekMultiplier > this.config.CLICKS_BEFORE_PAUSE) {
+      log_debug(
+        `${this.title}: handle delayed seek type:${seekType} - skipTime: ${skipTime}, seekMultiplier: ${seekMultiplier}.`
+      );
+
+      this.seekControllerDelegate.handleDelayedSeek(skipTime);
+    } else {
+      log_debug(
+        `${this.title}: handle seek type:${seekType} - skipTime: ${skipTime}.`
+      );
+
+      this.seekControllerDelegate.handleSeek(skipTime);
+    }
+
+    this.seekIncrementalStrategy.increment();
+  };
+
+  onSeekEnd = () => {
+    this.seekControllerDelegate.handleSeekComplete();
+  };
+
+  reset = () => {
+    log_debug("{this.title}: Reset states");
+
+    this.seekIncrementalStrategy.reset();
+  };
+}

package/reactHooks/player/const.ts

@@ -1,9 +1,5 @@
 export const SKIP_TIME_BASE = 10;
 
-export const ON_PRESS_RESET_DURATION = 2000;
-
-export const ON_HOLD_INTERVAL = 500;
-
 export const MAX_SEEK_TIME = 600;
 
 export enum SEEK_TYPE {

package/reactHooks/player/index.ts

@@ -1,7 +1 @@
 export { useLanguageData } from "./useLanguageData";
-
-export { useAutoSeek } from "./useAutoSeek";
-
-export { useTapSeek } from "./useTapSeek";
-
-export { useSeek, withUseSeek } from "./useSeek";

package/time/Timer.ts

@@ -4,7 +4,7 @@ export class Timer {
   private timeoutId: NodeJS.Timeout | null;
 
   constructor(private callback: () => void, private duration: number) {
-    this.remaining = duration;
+    this.remaining = this.duration;
     this.timeoutId = null;
   }
 

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",
 }