@applicaster/zapp-react-native-utils 15.0.0-rc.99 → 15.1.0-rc.1

package/utils/__tests__/clone.test.ts

@@ -0,0 +1,158 @@
+import { clone } from "../clone";
+
+describe("clone", () => {
+  const originalStructuredClone = global.structuredClone;
+
+  afterEach(() => {
+    // Restore the original structuredClone after each test
+    global.structuredClone = originalStructuredClone;
+  });
+
+  describe("when structuredClone is available", () => {
+    beforeEach(() => {
+      // Mock structuredClone if it's not available
+      if (typeof global.structuredClone === "undefined") {
+        global.structuredClone = jest.fn((value) =>
+          JSON.parse(JSON.stringify(value))
+        );
+      }
+    });
+
+    test("clones primitive values", () => {
+      expect(clone(42)).toBe(42);
+      expect(clone("test")).toBe("test");
+      expect(clone(true)).toBe(true);
+      expect(clone(null)).toBe(null);
+    });
+
+    test("clones simple objects", () => {
+      const original = { a: 1, b: 2 };
+      const cloned = clone(original);
+
+      expect(cloned).toEqual(original);
+      expect(cloned).not.toBe(original);
+    });
+
+    test("clones nested objects", () => {
+      const original = { a: { b: { c: 1 } } };
+      const cloned = clone(original);
+
+      expect(cloned).toEqual(original);
+      expect(cloned).not.toBe(original);
+      expect(cloned.a).not.toBe(original.a);
+      expect(cloned.a.b).not.toBe(original.a.b);
+    });
+
+    test("clones arrays", () => {
+      const original = [1, 2, 3];
+      const cloned = clone(original);
+
+      expect(cloned).toEqual(original);
+      expect(cloned).not.toBe(original);
+    });
+
+    test("clones arrays with nested objects", () => {
+      const original = [{ a: 1 }, { b: 2 }];
+      const cloned = clone(original);
+
+      expect(cloned).toEqual(original);
+      expect(cloned).not.toBe(original);
+      expect(cloned[0]).not.toBe(original[0]);
+      expect(cloned[1]).not.toBe(original[1]);
+    });
+
+    test("does not mutate the original value", () => {
+      const original = { a: 1, b: { c: 2 } };
+      const cloned = clone(original);
+
+      cloned.a = 99;
+      cloned.b.c = 99;
+
+      expect(original.a).toBe(1);
+      expect(original.b.c).toBe(2);
+    });
+  });
+
+  describe("when structuredClone is not available (fallback to cloneDeep)", () => {
+    beforeEach(() => {
+      // Delete structuredClone to force fallback to cloneDeep
+      delete (global as any).structuredClone;
+    });
+
+    test("clones primitive values using cloneDeep", () => {
+      expect(clone(42)).toBe(42);
+      expect(clone("test")).toBe("test");
+      expect(clone(true)).toBe(true);
+      expect(clone(null)).toBe(null);
+    });
+
+    test("clones simple objects using cloneDeep", () => {
+      const original = { a: 1, b: 2 };
+      const cloned = clone(original);
+
+      expect(cloned).toEqual(original);
+      expect(cloned).not.toBe(original);
+    });
+
+    test("clones nested objects using cloneDeep", () => {
+      const original = { a: { b: { c: 1 } } };
+      const cloned = clone(original);
+
+      expect(cloned).toEqual(original);
+      expect(cloned).not.toBe(original);
+      expect(cloned.a).not.toBe(original.a);
+      expect(cloned.a.b).not.toBe(original.a.b);
+    });
+
+    test("clones arrays using cloneDeep", () => {
+      const original = [1, 2, 3];
+      const cloned = clone(original);
+
+      expect(cloned).toEqual(original);
+      expect(cloned).not.toBe(original);
+    });
+
+    test("clones arrays with nested objects using cloneDeep", () => {
+      const original = [{ a: 1 }, { b: 2 }];
+      const cloned = clone(original);
+
+      expect(cloned).toEqual(original);
+      expect(cloned).not.toBe(original);
+      expect(cloned[0]).not.toBe(original[0]);
+      expect(cloned[1]).not.toBe(original[1]);
+    });
+
+    test("does not mutate the original value when using cloneDeep", () => {
+      const original = { a: 1, b: { c: 2 } };
+      const cloned = clone(original);
+
+      cloned.a = 99;
+      cloned.b.c = 99;
+
+      expect(original.a).toBe(1);
+      expect(original.b.c).toBe(2);
+    });
+
+    test("handles complex objects with multiple levels", () => {
+      const original = {
+        name: "test",
+        data: {
+          items: [
+            { id: 1, value: "a" },
+            { id: 2, value: "b" },
+          ],
+          meta: { count: 2 },
+        },
+      };
+
+      const cloned = clone(original);
+
+      expect(cloned).toEqual(original);
+      expect(cloned).not.toBe(original);
+      expect(cloned.data).not.toBe(original.data);
+      expect(cloned.data.items).not.toBe(original.data.items);
+      expect(cloned.data.items[0]).not.toBe(original.data.items[0]);
+      expect(cloned.data.meta).not.toBe(original.data.meta);
+    });
+  });
+});

package/utils/clone.ts

@@ -0,0 +1,7 @@
+import { cloneDeep } from "lodash";
+
+export const clone = (value) => {
+  return typeof structuredClone !== "undefined"
+    ? structuredClone(value) // no support for hermes, fallback to cloneDeep
+    : cloneDeep(value);
+};

package/utils/index.ts

@@ -18,10 +18,9 @@ export { take } from "./take";
 
 export { mapAccum } from "./mapAccum";
 
-export { mergeRight } from "./mergeRight";
+export { clone } from "./clone";
 
 export {
-  cloneDeep as clone,
   flatten,
   drop,
   size,
@@ -38,20 +37,9 @@ export {
   last,
   toLower,
   isEqual as equals,
-  uniq,
   uniqWith,
   flowRight as compose,
   partial,
-  clamp,
   reverse,
-  takeRight,
-  fromPairs,
-  sortBy,
-  merge,
-  values,
-  head,
-  findIndex,
-  set,
   compact,
-  identity,
 } from "lodash";

package/utils/path.ts

@@ -1,8 +1,5 @@
-import { pathOr } from "./pathOr";
+import { get } from "lodash";
 
-export const path = <T = any>(
-  route: (string | number) | (string | number)[],
-  record: any
-) => {
-  return pathOr<T>(undefined, route, record);
+export const path = (route, record) => {
+  return get(record, route, undefined);
 };

package/utils/pathOr.ts

@@ -1,9 +1,5 @@
 import { get } from "lodash";
 
-export const pathOr = <T = any>(
-  defaultValue: T,
-  path: (number | string) | (number | string)[],
-  record: any
-): T => {
+export const pathOr = (defaultValue, path, record) => {
   return get(record, path, defaultValue);
 };

package/zappFrameworkUtils/HookCallback/callbackNavigationAction.ts

@@ -85,7 +85,7 @@ export const getNavigationKeys = (
   const general = (item?.general ?? {}) as General;
 
   const pluginIdentifier =
-    (item as any).identifier ?? item?.type ?? item?.component_type ?? "";
+    (item as any)?.identifier ?? item?.type ?? item?.component_type ?? "";
 
   const legacy =
     legacyMappingKeys[`${pluginIdentifier}.${resultType}`] ??

package/zappFrameworkUtils/HookCallback/hookCallbackManifestExtensions.config.js

@@ -20,7 +20,7 @@ const callbackKeyPrefix = (key, prefix, keySeparator = "_") =>
 
 const extendManifestWithHookCallback = (prefix = null) => ({
   group: true,
-  label: `CallBack Navigation: ${prefix}`,
+  label: prefix ? `Callback Navigation: ${prefix}` : "Callback Navigation",
   folded: true,
   fields: [
     {

package/zappFrameworkUtils/loginPluginUtils.ts

@@ -20,7 +20,7 @@ const isAuthenticationRequired = ({ payload, logs }) => {
 
   if (!payload) {
     log_info(
-      "isAuthenticationRequired: No payload exist, authentication required"
+      "isAuthenticationRequired: No payload exists, authentication required"
     );
 
     return true;

package/adsUtils/__tests__/createVMAP.test.ts

@@ -1,419 +0,0 @@
-import { createVMAP } from "../index";
-
-describe("createVMAP", () => {
-  describe("basic functionality", () => {
-    it("should create VMAP XML with single ad", () => {
-      const ads = [
-        {
-          offset: 0,
-          ad_url: "https://example.com/ad1.xml",
-        },
-      ];
-
-      const result = createVMAP(ads);
-
-      expect(result).toContain(
-        '<vmap:VMAP xmlns:vmap="http://www.iab.net/videosuite/vmap" version="1.0">'
-      );
-
-      expect(result).toContain("</vmap:VMAP>");
-      expect(result).toContain('timeOffset="00:00:00.000"');
-      expect(result).toContain("https://example.com/ad1.xml");
-    });
-
-    it("should create VMAP XML with multiple ads", () => {
-      const ads = [
-        {
-          offset: 0,
-          ad_url: "https://example.com/preroll.xml",
-        },
-        {
-          offset: 300,
-          ad_url: "https://example.com/midroll.xml",
-        },
-        {
-          offset: "postroll",
-          ad_url: "https://example.com/postroll.xml",
-        },
-      ];
-
-      const result = createVMAP(ads);
-
-      expect(result).toContain('timeOffset="00:00:00.000"');
-      expect(result).toContain('timeOffset="00:05:00.000"');
-      expect(result).toContain('timeOffset="end"');
-      expect(result).toContain("https://example.com/preroll.xml");
-      expect(result).toContain("https://example.com/midroll.xml");
-      expect(result).toContain("https://example.com/postroll.xml");
-    });
-
-    it("should create empty VMAP with no ads", () => {
-      const ads: Array<{ [key: string]: any }> = [];
-
-      const result = createVMAP(ads);
-
-      expect(result).toBe(
-        '<vmap:VMAP xmlns:vmap="http://www.iab.net/videosuite/vmap" version="1.0">\n</vmap:VMAP>'
-      );
-    });
-  });
-
-  describe("time offset conversion", () => {
-    it("should convert 0 seconds to 00:00:00.000", () => {
-      const ads = [{ offset: 0, ad_url: "https://example.com/ad.xml" }];
-      const result = createVMAP(ads);
-
-      expect(result).toContain('timeOffset="00:00:00.000"');
-    });
-
-    it("should convert seconds to HH:MM:SS.000 format", () => {
-      const ads = [
-        { offset: 60, ad_url: "https://example.com/ad.xml" }, // 1 minute
-      ];
-
-      const result = createVMAP(ads);
-
-      expect(result).toContain('timeOffset="00:01:00.000"');
-    });
-
-    it("should convert minutes to HH:MM:SS.000 format", () => {
-      const ads = [
-        { offset: 300, ad_url: "https://example.com/ad.xml" }, // 5 minutes
-      ];
-
-      const result = createVMAP(ads);
-
-      expect(result).toContain('timeOffset="00:05:00.000"');
-    });
-
-    it("should convert hours to HH:MM:SS.000 format", () => {
-      const ads = [
-        { offset: 3661, ad_url: "https://example.com/ad.xml" }, // 1:01:01
-      ];
-
-      const result = createVMAP(ads);
-
-      expect(result).toContain('timeOffset="01:01:01.000"');
-    });
-
-    it("should handle large time offsets", () => {
-      const ads = [
-        { offset: 36000, ad_url: "https://example.com/ad.xml" }, // 10 hours
-      ];
-
-      const result = createVMAP(ads);
-
-      expect(result).toContain('timeOffset="10:00:00.000"');
-    });
-
-    it("should convert postroll string to end", () => {
-      const ads = [
-        { offset: "postroll", ad_url: "https://example.com/ad.xml" },
-      ];
-
-      const result = createVMAP(ads);
-
-      expect(result).toContain('timeOffset="end"');
-    });
-
-    it("should convert numeric string to HH:MM:SS.000", () => {
-      const ads = [
-        { offset: "120", ad_url: "https://example.com/ad.xml" }, // 2 minutes
-      ];
-
-      const result = createVMAP(ads);
-
-      expect(result).toContain('timeOffset="00:02:00.000"');
-    });
-
-    it("should keep non-numeric string as-is", () => {
-      const ads = [{ offset: "start", ad_url: "https://example.com/ad.xml" }];
-
-      const result = createVMAP(ads);
-
-      expect(result).toContain('timeOffset="start"');
-    });
-
-    it("should handle fractional seconds", () => {
-      const ads = [{ offset: "90.5", ad_url: "https://example.com/ad.xml" }];
-
-      const result = createVMAP(ads);
-
-      // parseFloat("90.5") = 90.5, seconds = 90.5 % 60 = 30.5
-      // Note: The toHHMMSS function doesn't floor seconds, so fractional seconds appear as-is
-      expect(result).toContain('timeOffset="00:01:30.5.000"');
-    });
-
-    it("should pad single digit hours, minutes, and seconds", () => {
-      const ads = [
-        { offset: 3661, ad_url: "https://example.com/ad.xml" }, // 1:01:01
-      ];
-
-      const result = createVMAP(ads);
-
-      expect(result).toContain('timeOffset="01:01:01.000"');
-    });
-
-    it("should handle offset 0 from various types", () => {
-      const testCases = [
-        { offset: 0, expected: "00:00:00.000" },
-        { offset: "0", expected: "00:00:00.000" },
-        // Note: null and undefined will cause errors when calling offset.toString()
-        // so they are not valid inputs for createVMAP
-      ];
-
-      testCases.forEach(({ offset, expected }) => {
-        const ads = [{ offset, ad_url: "https://example.com/ad.xml" }];
-        const result = createVMAP(ads);
-        expect(result).toContain(`timeOffset="${expected}"`);
-      });
-    });
-  });
-
-  describe("XML structure", () => {
-    it("should include proper VMAP namespace", () => {
-      const ads = [{ offset: 0, ad_url: "https://example.com/ad.xml" }];
-      const result = createVMAP(ads);
-
-      expect(result).toContain(
-        'xmlns:vmap="http://www.iab.net/videosuite/vmap"'
-      );
-
-      expect(result).toContain('version="1.0"');
-    });
-
-    it("should create AdBreak with breakType linear", () => {
-      const ads = [{ offset: 0, ad_url: "https://example.com/ad.xml" }];
-      const result = createVMAP(ads);
-
-      expect(result).toContain('breakType="linear"');
-    });
-
-    it("should create AdBreak with unique breakId based on offset", () => {
-      const ads = [
-        { offset: 0, ad_url: "https://example.com/ad1.xml" },
-        { offset: 300, ad_url: "https://example.com/ad2.xml" },
-      ];
-
-      const result = createVMAP(ads);
-
-      expect(result).toContain('breakId="break-0"');
-      expect(result).toContain('breakId="break-300"');
-    });
-
-    it("should create AdSource with proper attributes", () => {
-      const ads = [{ offset: 0, ad_url: "https://example.com/ad.xml" }];
-      const result = createVMAP(ads);
-
-      expect(result).toContain('allowMultipleAds="true"');
-      expect(result).toContain('followRedirects="true"');
-    });
-
-    it("should use VAST3 template type", () => {
-      const ads = [{ offset: 0, ad_url: "https://example.com/ad.xml" }];
-      const result = createVMAP(ads);
-
-      expect(result).toContain('templateType="vast3"');
-    });
-
-    it("should wrap URL in CDATA", () => {
-      const ads = [{ offset: 0, ad_url: "https://example.com/ad.xml" }];
-      const result = createVMAP(ads);
-
-      expect(result).toContain("<![CDATA[ https://example.com/ad.xml ]]>");
-    });
-
-    it("should create unique ad IDs based on offset", () => {
-      const ads = [
-        { offset: 0, ad_url: "https://example.com/ad1.xml" },
-        { offset: 100, ad_url: "https://example.com/ad2.xml" },
-      ];
-
-      const result = createVMAP(ads);
-
-      expect(result).toContain('id="ad-0-ad-1"');
-      expect(result).toContain('id="ad-100-ad-1"');
-    });
-  });
-
-  describe("URL handling", () => {
-    it("should trim whitespace from URLs", () => {
-      const ads = [{ offset: 0, ad_url: "  https://example.com/ad.xml  " }];
-
-      const result = createVMAP(ads);
-
-      expect(result).toContain("<![CDATA[ https://example.com/ad.xml ]]>");
-    });
-
-    it("should handle URLs with query parameters", () => {
-      const ads = [
-        {
-          offset: 0,
-          ad_url: "https://example.com/ad.xml?param1=value1&param2=value2",
-        },
-      ];
-
-      const result = createVMAP(ads);
-
-      expect(result).toContain(
-        "https://example.com/ad.xml?param1=value1&param2=value2"
-      );
-    });
-
-    it("should handle URLs with special characters", () => {
-      const ads = [
-        {
-          offset: 0,
-          ad_url: "https://example.com/ad.xml?url=https%3A%2F%2Ftest.com",
-        },
-      ];
-
-      const result = createVMAP(ads);
-
-      expect(result).toContain(
-        "https://example.com/ad.xml?url=https%3A%2F%2Ftest.com"
-      );
-    });
-
-    it("should handle URLs with ampersands", () => {
-      const ads = [
-        { offset: 0, ad_url: "https://example.com/ad.xml?a=1&b=2&c=3" },
-      ];
-
-      const result = createVMAP(ads);
-
-      expect(result).toContain(
-        "<![CDATA[ https://example.com/ad.xml?a=1&b=2&c=3 ]]>"
-      );
-    });
-  });
-
-  describe("complex scenarios", () => {
-    it("should create VMAP with preroll, midroll, and postroll", () => {
-      const ads = [
-        { offset: 0, ad_url: "https://example.com/preroll.xml" },
-        { offset: 300, ad_url: "https://example.com/midroll1.xml" },
-        { offset: 600, ad_url: "https://example.com/midroll2.xml" },
-        { offset: "postroll", ad_url: "https://example.com/postroll.xml" },
-      ];
-
-      const result = createVMAP(ads);
-
-      expect(result).toContain('timeOffset="00:00:00.000"');
-      expect(result).toContain('timeOffset="00:05:00.000"');
-      expect(result).toContain('timeOffset="00:10:00.000"');
-      expect(result).toContain('timeOffset="end"');
-    });
-
-    it("should handle ads in any order", () => {
-      const ads = [
-        { offset: "postroll", ad_url: "https://example.com/postroll.xml" },
-        { offset: 0, ad_url: "https://example.com/preroll.xml" },
-        { offset: 300, ad_url: "https://example.com/midroll.xml" },
-      ];
-
-      const result = createVMAP(ads);
-
-      // Should preserve order from input array
-      const postrollIndex = result.indexOf('timeOffset="end"');
-      const prerollIndex = result.indexOf('timeOffset="00:00:00.000"');
-      const midrollIndex = result.indexOf('timeOffset="00:05:00.000"');
-
-      expect(postrollIndex).toBeLessThan(prerollIndex);
-      expect(prerollIndex).toBeLessThan(midrollIndex);
-    });
-
-    it("should handle very long video with multiple ads", () => {
-      const ads = Array.from({ length: 10 }, (_, i) => ({
-        offset: i * 600, // Every 10 minutes
-        ad_url: `https://example.com/ad${i}.xml`,
-      }));
-
-      const result = createVMAP(ads);
-
-      expect(result).toContain('timeOffset="00:00:00.000"'); // 0 min
-      expect(result).toContain('timeOffset="00:10:00.000"'); // 10 min
-      expect(result).toContain('timeOffset="01:30:00.000"'); // 90 min
-    });
-
-    it("should create valid XML structure", () => {
-      const ads = [{ offset: 0, ad_url: "https://example.com/ad.xml" }];
-
-      const result = createVMAP(ads);
-
-      // Check for proper XML nesting
-      expect(result.split("<vmap:VMAP").length - 1).toBe(1);
-      expect(result.split("</vmap:VMAP>").length - 1).toBe(1);
-      expect(result.split("<vmap:AdBreak").length - 1).toBe(1);
-      expect(result.split("</vmap:AdBreak>").length - 1).toBe(1);
-      expect(result.split("<vmap:AdSource").length - 1).toBe(1);
-      expect(result.split("</vmap:AdSource>").length - 1).toBe(1);
-    });
-  });
-
-  describe("edge cases", () => {
-    it("should preserve negative offset in breakId and timeOffset", () => {
-      const ads = [{ offset: -100, ad_url: "https://example.com/ad.xml" }];
-
-      const result = createVMAP(ads);
-
-      expect(result).toContain('breakId="break--100"');
-      expect(result).toContain('timeOffset="-1:-2:-40.000"');
-    });
-
-    it("should handle very large offset", () => {
-      const ads = [{ offset: 999999, ad_url: "https://example.com/ad.xml" }];
-
-      const result = createVMAP(ads);
-
-      expect(result).toContain('timeOffset="277:46:39.000"');
-    });
-
-    it("should handle empty string offset", () => {
-      const ads = [{ offset: "", ad_url: "https://example.com/ad.xml" }];
-
-      const result = createVMAP(ads);
-
-      // Empty string is not a valid number, so it should be kept as-is or converted to 0
-      expect(result).toContain("timeOffset=");
-    });
-
-    it("should handle mixed offset types", () => {
-      const ads = [
-        { offset: 0, ad_url: "https://example.com/ad1.xml" },
-        { offset: "60", ad_url: "https://example.com/ad2.xml" },
-        { offset: 120, ad_url: "https://example.com/ad3.xml" },
-        { offset: "postroll", ad_url: "https://example.com/ad4.xml" },
-      ];
-
-      const result = createVMAP(ads);
-
-      expect(result).toContain('timeOffset="00:00:00.000"');
-      expect(result).toContain('timeOffset="00:01:00.000"');
-      expect(result).toContain('timeOffset="00:02:00.000"');
-      expect(result).toContain('timeOffset="end"');
-    });
-
-    it("should handle ads with same offset", () => {
-      const ads = [
-        { offset: 0, ad_url: "https://example.com/ad1.xml" },
-        { offset: 0, ad_url: "https://example.com/ad2.xml" },
-      ];
-
-      const result = createVMAP(ads);
-
-      // Both should have the same timeOffset but different ad IDs (though ID is also based on offset)
-      const matches = result.match(/timeOffset="00:00:00.000"/g);
-      expect(matches?.length).toBe(2);
-    });
-
-    it("should handle URL with newlines and tabs", () => {
-      const ads = [{ offset: 0, ad_url: "https://example.com/ad.xml\n\t" }];
-
-      const result = createVMAP(ads);
-
-      // trim() should remove the whitespace
-      expect(result).toContain("<![CDATA[ https://example.com/ad.xml ]]>");
-    });
-  });
-});