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

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

@@ -0,0 +1,115 @@
+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({ legacyFakeTimers: true });
+
+const rewind = jest.fn();
+const forward = jest.fn();
+
+jest
+  .spyOn(playerManager, "getInstanceController")
+  .mockReturnValue({ 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

@@ -0,0 +1,94 @@
+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/state/useRefWithInitialValue.ts

@@ -0,0 +1,14 @@
+import React from "react";
+
+/**
+ * returns a ref with an initial value that is lazily evaluated once
+ * */
+export const useRefWithInitialValue = <T>(initialValueGetter: () => T) => {
+  const ref = React.useRef<T>(null);
+
+  if (ref.current === null) {
+    ref.current = initialValueGetter();
+  }
+
+  return ref;
+};

package/reactHooks/state/useStateFromSubscribe.ts

@@ -0,0 +1,23 @@
+import { useEffect, useState } from "react";
+import type { Subject } from "rxjs";
+
+export const useStateFromSubscribe = <T, U>(
+  subject: Subject<T>,
+  onUpdate: (
+    observerValue: T,
+    next: React.Dispatch<React.SetStateAction<U>>
+  ) => void,
+  initialValue: U
+) => {
+  const [state, setState] = useState<U>(initialValue);
+
+  useEffect(() => {
+    const subscription = subject.subscribe((observer) =>
+      onUpdate(observer, setState)
+    );
+
+    return () => subscription.unsubscribe();
+  }, [subject]);
+
+  return state;
+};

package/reactHooks/usePluginConfiguration.ts

@@ -91,7 +91,7 @@ export function useLayoutConfiguration<
   S extends unknown,
   G extends unknown,
   R extends unknown,
-  L extends unknown
+  L extends unknown,
 >(layoutData, manifest, options: Options = {}) {
   const keys = options.keys || [
     "assets",

package/reactHooks/useSubscriberFor.ts

@@ -4,9 +4,10 @@ import { subscriber } from "@applicaster/zapp-react-native-utils/functionUtils";
 const subscriberObjects = Object.create({});
 
 interface UseSubscriberFor {
-  (eventName: string, handler?: (...args: unknown[]) => void): (
-    ...args: unknown[]
-  ) => ReturnType<typeof subscriber>;
+  (
+    eventName: string,
+    handler?: (...args: unknown[]) => void
+  ): (...args: unknown[]) => ReturnType<typeof subscriber>;
 }
 
 /**

package/reactUtils/__tests__/__snapshots__/reactUtilsHelpers.test.js.snap

@@ -1,6 +1,6 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
-exports[`addLifeCycleMethods attaches the lifecycle method to the component 1`] = `
+exports[`reactUtils helpers addLifeCycleMethods attaches the lifecycle method to the component 1`] = `
 <View>
   <Text>
     I'm a class component
@@ -8,7 +8,7 @@ exports[`addLifeCycleMethods attaches the lifecycle method to the component 1`]
 </View>
 `;
 
-exports[`attachMethodToPrototype attaches a lifecycle method to the component's prototype 1`] = `
+exports[`reactUtils helpers attachMethodToPrototype attaches a lifecycle method to the component's prototype 1`] = `
 <View>
   <Text>
     I'm a class component
@@ -16,6 +16,18 @@ exports[`attachMethodToPrototype attaches a lifecycle method to the component's
 </View>
 `;
 
-exports[`attachMethodToPrototype preserves any existing lifecycle method 1`] = `<StatelessComponent />`;
+exports[`reactUtils helpers attachMethodToPrototype preserves any existing lifecycle method 1`] = `
+<View>
+  <Text>
+    I'm a stateless component
+  </Text>
+</View>
+`;
 
-exports[`wrapInClass wraps the stateless component in a class 1`] = `<StatelessComponent />`;
+exports[`reactUtils helpers wrapInClass wraps the stateless component in a class 1`] = `
+<View>
+  <Text>
+    I'm a stateless component
+  </Text>
+</View>
+`;

package/reactUtils/__tests__/reactUtils.test.js

@@ -1,4 +1,3 @@
-jest.mock("create-react-ref/lib/createRef", () => jest.fn());
 import * as React from "react";
 import * as helpers from "../helpers";
 
@@ -8,13 +7,7 @@ import {
   componentDidMount,
 } from "./fixtures";
 
-const {
-  attachLifeCycleMethods,
-  createReactRef,
-  mergeChildrenProps,
-} = require("../index");
-
-const createRef = require("create-react-ref/lib/createRef");
+import { attachLifeCycleMethods, mergeChildrenProps } from "..";
 
 describe("attachLifeCycleMethods", () => {
   let addLifeCycleMethodsSpy;
@@ -48,35 +41,6 @@ describe("attachLifeCycleMethods", () => {
   });
 });
 
-describe("createReactRef", () => {
-  it("calls the React.createRef function if it exists", () => {
-    jest.resetModules();
-
-    jest.doMock("react", () => ({
-      ...jest.requireActual("react"),
-      createRef: jest.fn(),
-    }));
-
-    const React = require("react");
-
-    createReactRef();
-    expect(React.createRef).toHaveBeenCalled();
-    expect(createRef).not.toHaveBeenCalled();
-  });
-
-  it("calls the polyfill if React.createRef doesn't exist", () => {
-    jest.resetModules();
-
-    jest.doMock("react", () => ({
-      ...jest.requireActual("react"),
-      createRef: undefined,
-    }));
-
-    createReactRef();
-    expect(createRef).toHaveBeenCalled();
-  });
-});
-
 describe("mergeChildrenProps", () => {
   it("returns the cloned children with the merged props", () => {
     const Egg = () => React.createElement("Egg");

package/reactUtils/__tests__/reactUtilsHelpers.test.js

@@ -1,6 +1,5 @@
 import * as React from "react";
-import { shallow } from "enzyme";
-import { shallowToJson } from "enzyme-to-json";
+import { render } from "@testing-library/react-native";
 
 import {
   isClassComponent,
@@ -20,98 +19,100 @@ import {
 } from "./fixtures";
 
 describe("reactUtils helpers", () => {
-  it("should have isNilOrEmpty", () => {
-    expect(isNilOrEmpty).toBeDefined();
-    expect(isNilOrEmpty(null)).toBeTruthy();
-    expect(isNilOrEmpty(undefined)).toBeTruthy();
-    expect(isNilOrEmpty("")).toBeTruthy();
-    expect(isNilOrEmpty([])).toBeTruthy();
+  describe("isNilOrEmpty", () => {
+    it("should return correct output", () => {
+      expect(isNilOrEmpty).toBeDefined();
+      expect(isNilOrEmpty(null)).toBeTruthy();
+      expect(isNilOrEmpty(undefined)).toBeTruthy();
+      expect(isNilOrEmpty("")).toBeTruthy();
+      expect(isNilOrEmpty([])).toBeTruthy();
+    });
   });
-});
 
-describe("isClassComponent", () => {
-  it("returns true if the component is a class component", () => {
-    expect(isClassComponent(ClassComponent)).toBe(true);
-  });
+  describe("isClassComponent", () => {
+    it("returns true if the component is a class component", () => {
+      expect(isClassComponent(ClassComponent)).toBe(true);
+    });
 
-  it("returns false otherwise", () => {
-    expect(isClassComponent(StatelessComponent)).toBe(false);
+    it("returns false otherwise", () => {
+      expect(isClassComponent(StatelessComponent)).toBe(false);
+    });
   });
-});
 
-describe("attachMethodToPrototype", () => {
-  const initialWrapper = shallow(<ClassComponent />);
+  describe("attachMethodToPrototype", () => {
+    const initialWrapper = render(<ClassComponent />);
 
-  expect(initialWrapper.instance()).not.toHaveProperty(
-    COMPONENT_DID_MOUNT_METHOD
-  );
-
-  afterEach(() => {
-    componentDidMount.mockClear();
-  });
-
-  it("attaches a lifecycle method to the component's prototype", () => {
-    const NewComponent = attachMethodToPrototype(ClassComponent)(
-      componentDidMount,
+    expect(initialWrapper.toJSON()).not.toHaveProperty(
       COMPONENT_DID_MOUNT_METHOD
     );
 
-    const wrapper = shallow(<NewComponent />);
+    afterEach(() => {
+      componentDidMount.mockClear();
+    });
 
-    expect(shallowToJson(wrapper)).toMatchSnapshot();
-    expect(wrapper.instance()).toHaveProperty(COMPONENT_DID_MOUNT_METHOD);
-    expect(componentDidMount).toHaveBeenCalled();
-  });
+    it("attaches a lifecycle method to the component's prototype", () => {
+      const NewComponent = attachMethodToPrototype(ClassComponent)(
+        componentDidMount,
+        COMPONENT_DID_MOUNT_METHOD
+      );
 
-  it("preserves any existing lifecycle method", () => {
-    const NewComponent = attachMethodToPrototype(ComponentWithLifeCycle)(
-      componentDidMount,
-      COMPONENT_DID_MOUNT_METHOD
-    );
+      const wrapper = render(<NewComponent />);
 
-    expect(componentDidMount).not.toHaveBeenCalled();
+      expect(wrapper.toJSON(wrapper)).toMatchSnapshot();
+      expect(new NewComponent()).toHaveProperty(COMPONENT_DID_MOUNT_METHOD);
+      expect(componentDidMount).toHaveBeenCalled();
+    });
 
-    const wrapper = shallow(<NewComponent />);
+    it("preserves any existing lifecycle method", () => {
+      const NewComponent = attachMethodToPrototype(ComponentWithLifeCycle)(
+        componentDidMount,
+        COMPONENT_DID_MOUNT_METHOD
+      );
 
-    expect(shallowToJson(wrapper)).toMatchSnapshot();
-    expect(componentDidMount).toHaveBeenCalled();
-    expect(existingMethod).toHaveBeenCalled();
-  });
-});
+      expect(componentDidMount).not.toHaveBeenCalled();
 
-describe("wrapInClass", () => {
-  let NewComponent;
-  let wrapper;
+      const wrapper = render(<NewComponent />);
 
-  beforeEach(() => {
-    NewComponent = wrapInClass(StatelessComponent);
-    wrapper = shallow(<NewComponent />);
+      expect(wrapper.toJSON()).toMatchSnapshot();
+      expect(componentDidMount).toHaveBeenCalled();
+      expect(existingMethod).toHaveBeenCalled();
+    });
   });
 
-  it("wraps the stateless component in a class", () => {
-    expect(isClassComponent(NewComponent)).toBe(true);
-    expect(shallowToJson(wrapper)).toMatchSnapshot();
-  });
-});
+  describe("wrapInClass", () => {
+    let NewComponent;
+    let wrapper;
 
-describe("addLifeCycleMethods", () => {
-  let NewComponent;
-  let wrapper;
+    beforeEach(() => {
+      NewComponent = wrapInClass(StatelessComponent);
+      wrapper = render(<NewComponent />);
+    });
 
-  beforeEach(() => {
-    NewComponent = addLifeCycleMethods({ componentDidMount })(ClassComponent);
-    wrapper = shallow(<NewComponent />);
+    it("wraps the stateless component in a class", () => {
+      expect(isClassComponent(NewComponent)).toBe(true);
+      expect(wrapper.toJSON()).toMatchSnapshot();
+    });
   });
 
-  afterEach(() => {
-    componentDidMount.mockClear();
-  });
+  describe("addLifeCycleMethods", () => {
+    let NewComponent;
+    let wrapper;
 
-  it("attaches the lifecycle method to the component", () => {
-    expect(shallowToJson(wrapper)).toMatchSnapshot();
-  });
+    beforeEach(() => {
+      NewComponent = addLifeCycleMethods({ componentDidMount })(ClassComponent);
+      wrapper = render(<NewComponent />);
+    });
+
+    afterEach(() => {
+      componentDidMount.mockClear();
+    });
+
+    it("attaches the lifecycle method to the component", () => {
+      expect(wrapper.toJSON()).toMatchSnapshot();
+    });
 
-  it("adds the lifecycle method to the component", () => {
-    expect(componentDidMount).toHaveBeenCalled();
+    it("adds the lifecycle method to the component", () => {
+      expect(componentDidMount).toHaveBeenCalled();
+    });
   });
 });

package/reactUtils/createContext/__tests__/__snapshots__/helpers.test.js.snap

@@ -1,106 +1,40 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
-exports[`createContextSetters when no state validator is provided calls setState when the setters are called, no matter what the value is 1`] = `
-Object {
+exports[`helpers createContextSetters when no state validator is provided calls setState when the setters are called, no matter what the value is 1`] = `
+{
   "bar": "bar",
   "foo": "foo",
 }
 `;
 
-exports[`createContextSetters when no state validator is provided calls setState when the setters are called, no matter what the value is 2`] = `
-Object {
-  "bar": "bar",
-  "foo": "invalid foo",
-}
-`;
-
-exports[`createContextSetters when no state validator is provided calls setState when the setters are called, no matter what the value is 3`] = `
-Object {
-  "bar": "invalid bar",
-  "foo": "invalid foo",
-}
-`;
-
-exports[`createContextSetters when no state validator is provided calls setState when the setters are called, no matter what the value is 4`] = `
-Array [
-  Array [
-    [Function],
-  ],
-  Array [
-    [Function],
-  ],
-]
-`;
-
-exports[`createContextSetters when state validator is provided calls setState when the setters are called & the validator passes 1`] = `
-Object {
+exports[`helpers createContextSetters when no state validator is provided calls setState when the setters are called, no matter what the value is 2`] = `
+{
   "bar": "bar",
   "foo": "foo",
 }
 `;
 
-exports[`createContextSetters when state validator is provided calls setState when the setters are called & the validator passes 2`] = `
-Object {
+exports[`helpers createContextSetters when no state validator is provided calls setState when the setters are called, no matter what the value is 3`] = `
+{
   "bar": "bar",
-  "foo": "new foo",
-}
-`;
-
-exports[`createContextSetters when state validator is provided calls setState when the setters are called & the validator passes 3`] = `
-Object {
-  "bar": "new bar",
-  "foo": "new foo",
+  "foo": "foo",
 }
 `;
 
-exports[`createContextSetters when state validator is provided calls setState when the setters are called & the validator passes 4`] = `
-Array [
-  Array [
+exports[`helpers createContextSetters when no state validator is provided calls setState when the setters are called, no matter what the value is 4`] = `
+[
+  [
     [Function],
   ],
-  Array [
+  [
     [Function],
   ],
 ]
 `;
 
-exports[`createContextSetters when state validator is provided skips the update if the new value is the same as the previous one 1`] = `
-Object {
+exports[`helpers createContextSetters when state validator is provided skips the update if the new value is the same as the previous one 1`] = `
+{
   "bar": "bar",
   "foo": "new foo",
 }
 `;
-
-exports[`createContextSetters when state validator is provided skips the update if the state validator doesn't pass 1`] = `
-Object {
-  "bar": "bar",
-  "foo": "foo",
-}
-`;
-
-exports[`createContextSetters when state validator is provided skips the update if the state validator doesn't pass 2`] = `
-Object {
-  "bar": "bar",
-  "foo": "foo",
-}
-`;
-
-exports[`createContextSetters when state validator is provided skips the update if the state validator doesn't pass 3`] = `
-Object {
-  "bar": "bar",
-  "foo": "foo",
-}
-`;
-
-exports[`createContextSetters when state validator is provided skips the update if the state validator doesn't pass 4`] = `
-Array [
-  Array [
-    "trying to invoke setFoo with invalid foo - but it was rejected by the state validator
-          skipping context update",
-  ],
-  Array [
-    "trying to invoke setBar with invalid bar - but it was rejected by the state validator
-          skipping context update",
-  ],
-]
-`;

package/reactUtils/createContext/__tests__/__snapshots__/{index.test.js.snap → index.test.ts.snap}

@@ -1,10 +1,10 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
 exports[`createContext - when React has the new context API returns the components and the decorators 1`] = `
-Object {
+{
   "Consumer": [MockFunction],
   "Provider": [MockFunction],
-  "ReactContext": Object {
+  "ReactContext": {
     "Consumer": [MockFunction],
     "Provider": [MockFunction],
   },