@applicaster/zapp-react-native-utils 12.0.0-rc.6 → 12.0.0-rc.60

package/functionUtils/__tests__/functionUtils.test.js

@@ -1,14 +1,5 @@
 import * as R from "ramda";
 
-jest.mock("react-native", () => {
-  return {
-    ...jest.requireActual("react-native"),
-    Animating: {
-      timing: jest.fn(() => ({ start: jest.fn() })),
-    },
-  };
-});
-
 const {
   debounce,
   noop,
@@ -88,328 +79,333 @@ function resolveAfterTimeout(func) {
   });
 }
 
-describe("debounce", () => {
-  beforeEach(clearMocks);
-
-  describe("when immediate is false", () => {
+describe("functionUtils", () => {
+  describe("debounce", () => {
     beforeEach(clearMocks);
 
-    it("calls the debounced function only once after the delay", () => {
-      const debounced = debounce({ fn, wait, immediate: false });
-      debounced(...debouncedArgs);
-      debounced(...debouncedArgs);
+    describe("when immediate is false", () => {
+      beforeEach(clearMocks);
 
-      expect(fn).not.toHaveBeenCalled();
+      it("calls the debounced function only once after the delay", () => {
+        const debounced = debounce({ fn, wait, immediate: false });
+        debounced(...debouncedArgs);
+        debounced(...debouncedArgs);
 
-      return resolveAfterTimeout(() => {
-        expect(fn).toHaveBeenCalledTimes(1);
-        expect(fn).toHaveBeenNthCalledWith(1, ...debouncedArgs);
-        expect(fn).not.toHaveBeenCalledTimes(2);
-        expect.assertions(4);
+        expect(fn).not.toHaveBeenCalled();
+
+        return resolveAfterTimeout(() => {
+          expect(fn).toHaveBeenCalledTimes(1);
+          expect(fn).toHaveBeenNthCalledWith(1, ...debouncedArgs);
+          expect(fn).not.toHaveBeenCalledTimes(2);
+          expect.assertions(4);
+        });
       });
     });
-  });
 
-  describe("when immediate is true", () => {
-    beforeEach(clearMocks);
+    describe("when immediate is true", () => {
+      beforeEach(clearMocks);
 
-    it("calls the debounced function only once during the delay", () => {
-      const debounced = debounce({ fn, wait });
-      debounced(...debouncedArgs);
-      debounced(...debouncedArgs);
+      it("calls the debounced function only once during the delay", () => {
+        const debounced = debounce({ fn, wait });
+        debounced(...debouncedArgs);
+        debounced(...debouncedArgs);
 
-      expect(fn).toHaveBeenCalledTimes(1);
-      expect(fn).toHaveBeenNthCalledWith(1, ...debouncedArgs);
+        expect(fn).toHaveBeenCalledTimes(1);
+        expect(fn).toHaveBeenNthCalledWith(1, ...debouncedArgs);
 
-      return resolveAfterTimeout(() => {
-        expect(fn).not.toHaveBeenCalledTimes(2);
-        expect.assertions(3);
+        return resolveAfterTimeout(() => {
+          expect(fn).not.toHaveBeenCalledTimes(2);
+          expect.assertions(3);
+        });
       });
     });
-  });
 
-  describe("when no context is provided", () => {
-    beforeEach(clearMocks);
+    describe("when no context is provided", () => {
+      beforeEach(clearMocks);
 
-    it("invokes the debounce function on the current context", () => {
-      const debounced = debounce({ fn, wait });
-      debounced(...debouncedArgs);
+      it("invokes the debounce function on the current context", () => {
+        const debounced = debounce({ fn, wait });
+        debounced(...debouncedArgs);
 
-      return resolveAfterTimeout(() => {
-        expect(global.debouncedArgs).toEqual(debouncedArgs);
-        expect(context.debouncedArgs).toBeUndefined();
+        return resolveAfterTimeout(() => {
+          expect(global.debouncedArgs).toEqual(debouncedArgs);
+          expect(context.debouncedArgs).toBeUndefined();
+        });
       });
     });
-  });
 
-  describe("when a context is provided", () => {
-    beforeEach(clearMocks);
+    describe("when a context is provided", () => {
+      beforeEach(clearMocks);
 
-    it("invokes the debounce function on the provided context", (done) => {
-      const debounced = debounce({ fn, wait, context });
-      debounced(...debouncedArgs);
+      it("invokes the debounce function on the provided context", (done) => {
+        const debounced = debounce({ fn, wait, context });
+        debounced(...debouncedArgs);
 
-      resolveAfterTimeout(() => {
-        expect(global.debouncedArgs).toBeUndefined();
-        expect(context.debouncedArgs).toEqual(debouncedArgs);
-        done();
+        resolveAfterTimeout(() => {
+          expect(global.debouncedArgs).toBeUndefined();
+          expect(context.debouncedArgs).toEqual(debouncedArgs);
+          done();
+        });
       });
     });
   });
-});
-
-describe("noop", () => {
-  it("does nothing", () => {
-    expect(noop()).toBeUndefined();
-  });
-});
-
-describe("clearObject", () => {
-  it("should clear original object without changing the reference", () => {
-    // arrange
-    const originalObject = {
-      handlers: { a: [1, 2, 3], b: { c: 1, d: 2 }, c: 3 },
-    };
 
-    const objCopy1 = originalObject.handlers;
-    const objCopy2 = originalObject.handlers;
-
-    // act
-    clearObject(originalObject);
-    // assert
-    expect(objCopy1).not.toContain("a");
-    expect(objCopy2).not.toContain("b");
-  });
-});
-
-describe("subscriber", () => {
-  const initialObj = {
-    foo: "bar",
-    method() {
-      return this.foo;
-    },
-  };
-
-  const handler = jest.fn();
-  const handler2 = jest.fn();
-  const event = "some_event";
-  const args = ["foo", { bar: 42 }];
-
-  beforeEach(() => {
-    handler.mockClear();
-    handler2.mockClear();
+  describe("noop", () => {
+    it("does nothing", () => {
+      expect(noop()).toBeUndefined();
+    });
   });
 
-  it("returns the original object with additional methods", () => {
-    const expectedInitialObj = Object.assign({}, initialObj);
-    expect(subscriber(expectedInitialObj)).toMatchSnapshot();
-    expect(expectedInitialObj.handlers).not.toBeUndefined();
+  describe("clearObject", () => {
+    it("should clear original object without changing the reference", () => {
+      // arrange
+      const originalObject = {
+        handlers: { a: [1, 2, 3], b: { c: 1, d: 2 }, c: 3 },
+      };
+
+      const objCopy1 = originalObject.handlers;
+      const objCopy2 = originalObject.handlers;
+
+      // act
+      clearObject(originalObject);
+      // assert
+      expect(objCopy1).not.toContain("a");
+      expect(objCopy2).not.toContain("b");
+    });
   });
 
-  it("can be invoked without args", () => {
-    expect(subscriber()).toMatchSnapshot();
-  });
+  describe("subscriber", () => {
+    const initialObj = {
+      foo: "bar",
+      method() {
+        return this.foo;
+      },
+    };
 
-  describe("on", () => {
-    it("returns the object so handlers can be chained", () => {
-      const subscribable = subscriber();
-      expect(subscribable.on(event, handler)).toEqual(subscribable);
-    });
-  });
+    const handler = jest.fn();
+    const handler2 = jest.fn();
+    const event = "some_event";
+    const args = ["foo", { bar: 42 }];
 
-  describe("invokeHandler", () => {
     beforeEach(() => {
       handler.mockClear();
       handler2.mockClear();
     });
 
-    it("returns the object so handlers invokation can be chained", () => {
-      const subscribable = subscriber();
-      expect(subscribable.invokeHandler(event, ...args)).toEqual(subscribable);
+    it("returns the original object with additional methods", () => {
+      const expectedInitialObj = Object.assign({}, initialObj);
+      expect(subscriber(expectedInitialObj)).toMatchSnapshot();
+      expect(expectedInitialObj.handlers).not.toBeUndefined();
     });
 
-    it("invokes the declared handlers", () => {
-      subscriber()
-        .on(event, handler)
-        .on(event, handler2)
-        .invokeHandler(event, ...args);
-
-      expect(handler).toHaveBeenCalledTimes(1);
-      expect(handler2).toHaveBeenCalledTimes(1);
-
-      expect(handler).toHaveBeenCalledWith(...args, expect.any(Function));
-      expect(handler2).toHaveBeenCalledWith(...args, expect.any(Function));
+    it("can be invoked without args", () => {
+      expect(subscriber()).toMatchSnapshot();
     });
-  });
 
-  describe("dispose", () => {
-    const handlerWithDispose = jest.fn((...handlerArgs) => {
-      const dispose = R.last(handlerArgs);
-      dispose();
+    describe("on", () => {
+      it("returns the object so handlers can be chained", () => {
+        const subscribable = subscriber();
+        expect(subscribable.on(event, handler)).toEqual(subscribable);
+      });
     });
 
-    const handlerWithDisposeAll = jest.fn((...handlerArgs) => {
-      const dispose = R.last(handlerArgs);
-      dispose({ disposeAll: true });
-    });
+    describe("invokeHandler", () => {
+      beforeEach(() => {
+        handler.mockClear();
+        handler2.mockClear();
+      });
 
-    beforeEach(() => {
-      handler.mockClear();
-      handler2.mockClear();
-      handlerWithDispose.mockClear();
-      handlerWithDisposeAll.mockClear();
-    });
+      it("returns the object so handlers invokation can be chained", () => {
+        const subscribable = subscriber();
 
-    it("removes the specific handler", () => {
-      const subscriberObj = subscriber()
-        .on(event, handlerWithDispose)
-        .on(event, handler);
+        expect(subscribable.invokeHandler(event, ...args)).toEqual(
+          subscribable
+        );
+      });
 
-      subscriberObj.invokeHandler(event, ...args);
-      expect(handlerWithDispose).toHaveBeenCalledTimes(1);
-      expect(handler).toHaveBeenCalledTimes(1);
+      it("invokes the declared handlers", () => {
+        subscriber()
+          .on(event, handler)
+          .on(event, handler2)
+          .invokeHandler(event, ...args);
 
-      subscriberObj.invokeHandler(event, ...args);
-      expect(handlerWithDispose).toHaveBeenCalledTimes(1);
-      expect(handler).toHaveBeenCalledTimes(2);
+        expect(handler).toHaveBeenCalledTimes(1);
+        expect(handler2).toHaveBeenCalledTimes(1);
 
-      expect(subscriberObj.handlers[event]).toHaveLength(1);
+        expect(handler).toHaveBeenCalledWith(...args, expect.any(Function));
+        expect(handler2).toHaveBeenCalledWith(...args, expect.any(Function));
+      });
     });
 
-    it("removes all the handlers if the specific option is provided", () => {
-      const subscriberObj = subscriber()
-        .on(event, handlerWithDisposeAll)
-        .on(event, handler);
+    describe("dispose", () => {
+      const handlerWithDispose = jest.fn((...handlerArgs) => {
+        const dispose = R.last(handlerArgs);
+        dispose();
+      });
+
+      const handlerWithDisposeAll = jest.fn((...handlerArgs) => {
+        const dispose = R.last(handlerArgs);
+        dispose({ disposeAll: true });
+      });
 
-      expect(subscriberObj).toMatchObject({
-        invokeHandler: expect.any(Function),
-        removeHandler: expect.any(Function),
-        on: expect.any(Function),
+      beforeEach(() => {
+        handler.mockClear();
+        handler2.mockClear();
+        handlerWithDispose.mockClear();
+        handlerWithDisposeAll.mockClear();
       });
 
-      expect(subscriberObj?.handlers?.[event]).toHaveLength(2);
+      it("removes the specific handler", () => {
+        const subscriberObj = subscriber()
+          .on(event, handlerWithDispose)
+          .on(event, handler);
 
-      subscriberObj.invokeHandler(event, ...args);
+        subscriberObj.invokeHandler(event, ...args);
+        expect(handlerWithDispose).toHaveBeenCalledTimes(1);
+        expect(handler).toHaveBeenCalledTimes(1);
 
-      expect(handlerWithDisposeAll).toHaveBeenCalledTimes(1);
-      expect(handler).toHaveBeenCalledTimes(1);
+        subscriberObj.invokeHandler(event, ...args);
+        expect(handlerWithDispose).toHaveBeenCalledTimes(1);
+        expect(handler).toHaveBeenCalledTimes(2);
 
-      expect(subscriberObj.handlers?.[event]).not.toBeDefined();
+        expect(subscriberObj.handlers[event]).toHaveLength(1);
+      });
 
-      subscriberObj.invokeHandler(event, ...args);
+      it("removes all the handlers if the specific option is provided", () => {
+        const subscriberObj = subscriber()
+          .on(event, handlerWithDisposeAll)
+          .on(event, handler);
 
-      expect(handler).toHaveBeenCalledTimes(1);
-      expect(handlerWithDisposeAll).toHaveBeenCalledTimes(1);
+        expect(subscriberObj).toMatchObject({
+          invokeHandler: expect.any(Function),
+          removeHandler: expect.any(Function),
+          on: expect.any(Function),
+        });
 
-      expect(subscriberObj.handlers?.[event]).not.toBeDefined();
-    });
+        expect(subscriberObj?.handlers?.[event]).toHaveLength(2);
 
-    it("should utilize existing subscriber object", () => {
-      const mockExistingHandler = jest.fn();
+        subscriberObj.invokeHandler(event, ...args);
 
-      const subscriberObjects = Object.create({
-        [event]: {
-          handlers: {
-            [event]: [mockExistingHandler],
-          },
-        },
-      });
+        expect(handlerWithDisposeAll).toHaveBeenCalledTimes(1);
+        expect(handler).toHaveBeenCalledTimes(1);
 
-      const subscriberObj = subscriber(subscriberObjects[event]).on(
-        event,
-        handler
-      );
+        expect(subscriberObj.handlers?.[event]).not.toBeDefined();
 
-      expect(subscriberObj).toMatchObject({
-        invokeHandler: expect.any(Function),
-        removeHandler: expect.any(Function),
-        on: expect.any(Function),
+        subscriberObj.invokeHandler(event, ...args);
+
+        expect(handler).toHaveBeenCalledTimes(1);
+        expect(handlerWithDisposeAll).toHaveBeenCalledTimes(1);
+
+        expect(subscriberObj.handlers?.[event]).not.toBeDefined();
       });
 
-      expect(subscriberObj.handlers[event][0]).toBe(mockExistingHandler);
-      expect(subscriberObj.handlers[event][1]).toBe(handler);
-      expect(subscriberObj?.handlers?.[event]).toHaveLength(2);
+      it("should utilize existing subscriber object", () => {
+        const mockExistingHandler = jest.fn();
+
+        const subscriberObjects = Object.create({
+          [event]: {
+            handlers: {
+              [event]: [mockExistingHandler],
+            },
+          },
+        });
+
+        const subscriberObj = subscriber(subscriberObjects[event]).on(
+          event,
+          handler
+        );
 
-      subscriberObj.invokeHandler(event, ...args);
+        expect(subscriberObj).toMatchObject({
+          invokeHandler: expect.any(Function),
+          removeHandler: expect.any(Function),
+          on: expect.any(Function),
+        });
 
-      expect(handler).toHaveBeenCalledTimes(1);
-      expect(mockExistingHandler).toHaveBeenCalledTimes(1);
+        expect(subscriberObj.handlers[event][0]).toBe(mockExistingHandler);
+        expect(subscriberObj.handlers[event][1]).toBe(handler);
+        expect(subscriberObj?.handlers?.[event]).toHaveLength(2);
 
-      expect(subscriberObj.handlers?.[event]).toBeDefined();
-      expect(subscriberObj.handlers?.[event]).toHaveLength(2);
+        subscriberObj.invokeHandler(event, ...args);
+
+        expect(handler).toHaveBeenCalledTimes(1);
+        expect(mockExistingHandler).toHaveBeenCalledTimes(1);
+
+        expect(subscriberObj.handlers?.[event]).toBeDefined();
+        expect(subscriberObj.handlers?.[event]).toHaveLength(2);
+      });
     });
   });
-});
 
-describe("parseJsonIfNeeded", () => {
-  const data = { foo: "bar" };
-  const json = JSON.stringify(data);
+  describe("parseJsonIfNeeded", () => {
+    const data = { foo: "bar" };
+    const json = JSON.stringify(data);
 
-  describe("when parsing a json", () => {
-    it("returns the object", () => {
-      expect(parseJsonIfNeeded(json)).toEqual(data);
+    describe("when parsing a json", () => {
+      it("returns the object", () => {
+        expect(parseJsonIfNeeded(json)).toEqual(data);
+      });
     });
-  });
 
-  describe("when parsing data that is not a json", () => {
-    it("returns the initial value", () => {
-      expect(parseJsonIfNeeded(data)).toEqual(data);
+    describe("when parsing data that is not a json", () => {
+      it("returns the initial value", () => {
+        expect(parseJsonIfNeeded(data)).toEqual(data);
+      });
     });
   });
-});
-
-describe("isFunction", () => {
-  it("return true if named function is passed", () => {
-    function foo() {
-      return null;
-    }
 
-    const currentResult = isFunction(foo);
-    expect(currentResult).toBe(true);
-  });
+  describe("isFunction", () => {
+    it("return true if named function is passed", () => {
+      function foo() {
+        return null;
+      }
 
-  it("return true if arrow function is passed", () => {
-    const currentResult = isFunction(() => null);
-    expect(currentResult).toBe(true);
-  });
+      const currentResult = isFunction(foo);
+      expect(currentResult).toBe(true);
+    });
 
-  it("return true if anonymous function is passed", () => {
-    const currentResult = isFunction(function () {
-      return null;
+    it("return true if arrow function is passed", () => {
+      const currentResult = isFunction(() => null);
+      expect(currentResult).toBe(true);
     });
 
-    expect(currentResult).toBe(true);
-  });
+    it("return true if anonymous function is passed", () => {
+      const currentResult = isFunction(function () {
+        return null;
+      });
 
-  it("returns false otherwise", () => {
-    expect(isFunction({})).toBe(false);
-    expect(isFunction([])).toBe(false);
-    expect(isFunction(false)).toBe(false);
-    expect(isFunction(null)).toBe(false);
-    expect(isFunction(undefined)).toBe(false);
-    expect(isFunction(0)).toBe(false);
-    expect(isFunction("foo")).toBe(false);
-    expect(isFunction(123)).toBe(false);
-    expect(isFunction(true)).toBe(false);
-  });
-});
+      expect(currentResult).toBe(true);
+    });
 
-describe("extractDataFromProperty", () => {
-  it("returns the value of the path if exists", () => {
-    expect(
-      extractDataFromProperty(VAL.propToExtract, DATA)(MAPPING.showOne)
-    ).toEqual(DATA.extensions.playlistId);
+    it("returns false otherwise", () => {
+      expect(isFunction({})).toBe(false);
+      expect(isFunction([])).toBe(false);
+      expect(isFunction(false)).toBe(false);
+      expect(isFunction(null)).toBe(false);
+      expect(isFunction(undefined)).toBe(false);
+      expect(isFunction(0)).toBe(false);
+      expect(isFunction("foo")).toBe(false);
+      expect(isFunction(123)).toBe(false);
+      expect(isFunction(true)).toBe(false);
+    });
   });
 
-  it("returns null if the path or prop does not exist", () => {
-    expect(
-      extractDataFromProperty(VAL.propToExtract, DATA)(MAPPING.showTwo)
-    ).toBe(null);
-  });
+  describe("extractDataFromProperty", () => {
+    it("returns the value of the path if exists", () => {
+      expect(
+        extractDataFromProperty(VAL.propToExtract, DATA)(MAPPING.showOne)
+      ).toEqual(DATA.extensions.playlistId);
+    });
+
+    it("returns null if the path or prop does not exist", () => {
+      expect(
+        extractDataFromProperty(VAL.propToExtract, DATA)(MAPPING.showTwo)
+      ).toBe(null);
+    });
 
-  it("returns null if the property does not exist on mapped object", () => {
-    expect(
-      extractDataFromProperty(VAL.propToExtract, DATA)(MAPPING.showThree)
-    ).toBe(null);
+    it("returns null if the property does not exist on mapped object", () => {
+      expect(
+        extractDataFromProperty(VAL.propToExtract, DATA)(MAPPING.showThree)
+      ).toBe(null);
+    });
   });
 });

package/headersUtils/index.ts

@@ -28,5 +28,6 @@ export const getAppDataHeaders = (screenId: string) => {
     "x-applicaster-signed-device-info-token": appData.signedDeviceInfoToken,
     "x-applicaster-device-make": appData.deviceMake,
     "x-applicaster-device-model": appData.deviceModel,
+    "x-applicaster-uuid": appData?.uuid,
   };
 };

package/inflatedUrlUtils/index.ts

@@ -1,4 +1,4 @@
-import { last, head, isNil, includes, all, pathOr } from "ramda";
+import { last, head, isNil, includes, pathOr } from "ramda";
 
 const stripBrackets = (path) => {
   const withoutPrepened = last(path.split("{{"));
@@ -13,15 +13,15 @@ const hasValue = (context) => (path) => {
   return !isNil(value);
 };
 
-export const isEnoughDataToInflateString = (context, string): boolean => {
+export const getMissingValues = (context, string): string[] => {
   if (!includes("{{", string)) {
-    return true;
+    return [];
   }
 
   const SEARCH_REGEX = new RegExp(/{{.*?}}/g);
   const paths = string.toString().match(SEARCH_REGEX);
 
-  return all(hasValue(context), paths);
+  return paths.filter((path) => !hasValue(context)(path));
 };
 
 export const isNonInflatedUrl = (url: string): boolean =>

package/localizationUtils/__tests__/localizationUtils.test.ts

@@ -1,3 +1,5 @@
+import * as ReactNative from "react-native";
+
 const mocked_state = {
   remoteConfigurations: { localizations: {} },
   appData: {
@@ -12,19 +14,21 @@ jest.doMock("react-redux", () => ({
   useSelector: jest.fn((fn) => fn(mocked_state)),
 }));
 
-jest.doMock("react-native", () => ({
-  NativeModules: {
-    SettingsManager: {
-      getConstants: jest.fn(() => ({
-        settings: { AppleLanguages: mocked_locale },
-      })),
-    },
-    QuickBrickCommunicationModule: {
-      languageLocale: "en",
-      countryLocale: "US",
-    },
-  },
-}));
+const SettingsManager = {
+  getConstants: jest.fn(() => ({
+    settings: { AppleLanguages: mocked_locale },
+  })),
+};
+
+const QuickBrickCommunicationModule = {
+  languageLocale: "en",
+  countryLocale: "US",
+};
+
+ReactNative.NativeModules.SettingsManager = SettingsManager;
+
+ReactNative.NativeModules.QuickBrickCommunicationModule =
+  QuickBrickCommunicationModule;
 
 const { useIsRTL } = require("../index");