@applicaster/zapp-react-native-utils 13.0.0-alpha.1436249127 → 13.0.0-alpha.1486614302

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,30 @@
+### ramda replacement utils
+
+See contribution guide below
+
+## Reference
+
+Prefer non-fp variant as it more performant - if refactoring assumes you need more efforts rewrite ramda sample to lodash and it can be easily replaced with lodash-fp - use lodash-fp.
+
+### Ramda alternatives:
+
+Custom
+- `splitEvery` => `chunk`
+- `times` => `times`
+
+From `lodash`
+- `clone` => `clone`
+- `flatten` => `flatten`
+- `drop` => `drop`
+- `length` => `size`
+
+
+## Contribution
+
+To add new helper function as ramda replacement
+
+1. Search for replacement ( you can use lodash or pure JS solution), arguments should match with Ramda definition (for easier transition).
+2. Add new file if needed, add test, update exports in index file. 2.1. Make sure it's well-typed.
+3. If the function can-be reexported from other 3rd party lib - update index.ts to re-export it.
+4. Make sure README is updated and contains reference for newly added function.
+5. You can use AI's help. Use query like 'lodash & lodash/fp equivalent of Ramda's R.clone function' to get an options you can use.

package/utils/chunk.ts

@@ -0,0 +1,5 @@
+import { chunk as _chunk } from "lodash";
+
+export const chunk = <T>(size: number, array: T[]): T[][] => {
+  return _chunk(array, size);
+};

package/utils/index.ts

@@ -0,0 +1,17 @@
+export { chunk } from "./chunk";
+
+export { times } from "./times";
+
+export { cloneDeep as clone, flatten, drop, size } from "lodash";
+
+export {
+  compose,
+  take,
+  map,
+  split,
+  propOr,
+  trim,
+  mergeRight,
+  prop,
+  identity,
+} from "ramda";

package/utils/times.ts

@@ -0,0 +1,5 @@
+import { times as _times } from "lodash";
+
+export const times = <T>(iteratee: (index: number) => T, n: number) => {
+  return _times(n, iteratee);
+};

package/zappFrameworkUtils/localStorageHelper.ts

@@ -1,6 +1,12 @@
 import { localStorage } from "@applicaster/zapp-react-native-bridge/ZappStorage/LocalStorage";
 import { isNilOrEmpty } from "../reactUtils/helpers";
 import { parseJsonIfNeeded } from "@applicaster/zapp-react-native-utils/functionUtils";
+import {
+  StorageOwnedValues,
+  NamespaceValues,
+  StorageValuesToRemove,
+  StorageValuesToAdd,
+} from "./types";
 
 const defaultOwnedKey = "owned_keys";
 const DEFAULT_NAMESPACE = "applicaster.v2";

package/zappFrameworkUtils/loginPluginUtils.ts

@@ -89,11 +89,15 @@ const runInBackground = async ({
     const shouldPresent = await hookPresentPolicy.shouldPresentScreen();
 
     if (!shouldPresent) {
+      const isRefreshed = await checkUserAuthenticated();
+
       log_info(
-        "runInBackground: Background mode finished, hook plugin will be skipped"
+        `runInBackground: Background mode finished, ${isRefreshed ? "finish hook with completion true" : "refresh failed will presentUI"}`
       );
 
-      await checkUserAuthenticated();
+      isRefreshed
+        ? callback({ success: isRefreshed, payload: item })
+        : presentUI();
 
       return;
     }

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/zappFrameworkUtils/types.ts

@@ -0,0 +1,11 @@
+export type StorageValuesToAdd = Record<string, NamespaceValues>;
+
+export type StorageValuesToRemove = {
+  string?: string[];
+};
+
+export type StorageOwnedValues = {
+  string?: string[];
+};
+
+export type NamespaceValues = Record<string, string>;

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

package/reactUtils/createContext/__tests__/index-no-react.test.js

@@ -1,27 +0,0 @@
-jest.mock("create-react-context", () =>
-  jest.fn(() => ({
-    Consumer: jest.fn(),
-    Provider: jest.fn(),
-  }))
-);
-
-jest.mock("react", () => ({
-  ...jest.requireActual("react"),
-  createContext: undefined,
-}));
-
-const { createContext } = require("../index");
-const createReactContext = require("create-react-context");
-
-describe("when react context api is not defined", () => {
-  it("uses the polyfill", () => {
-    createContext({ foo: "bar" });
-
-    expect(createReactContext).toHaveBeenCalledWith(
-      expect.objectContaining({
-        foo: "bar",
-        setFoo: expect.any(Function),
-      })
-    );
-  });
-});