@applicaster/zapp-react-native-utils 15.0.0-rc.12 → 15.0.0-rc.120

package/README.md

@@ -245,12 +245,6 @@ const connectionType = useConnectionInfo(true);
 
 `@applicaster/zapp-react-native/reactHooks`
 
-- `useFeedRefresh: ({ reloadData: function, component: { id: boolean | string, rules: {enable_data_refreshing: boolean, refreshing_interval: number} } }) => void` - Hook will call `reloadData` function, in the specified intervals if `enable_data_refreshing` is set to true;
-
-```javascript
-useFeedRefresh({ reloadData, component });
-```
-
 - `useFeedLoader: ({ feedUrl: string, pipesOptions?: { clearCache?: boolean, loadLocalFavourites?: boolean, silentRefresh?: boolean} }) => ({data: ?ApplicasterFeed, loading: boolean, url: string, error: Error,reloadData: (silentRefresh?: boolean) => void, loadNext: () => void})` - Hook will load data to the redux store and return a feed for the provided DSP URL. If the data for the provided url was already loaded, it will return that value
 
 ```javascript

package/actionsExecutor/ActionExecutorContext.tsx

@@ -23,12 +23,9 @@ import {
   EntryResolver,
   resolveObjectValues,
 } from "../appUtils/contextKeysManager/contextResolver";
-import { useNavigation } from "../reactHooks";
+import { useNavigation, useRivers } from "../reactHooks";
 
-import {
-  useContentTypes,
-  usePickFromState,
-} from "@applicaster/zapp-react-native-redux/hooks";
+import { useContentTypes } from "@applicaster/zapp-react-native-redux/hooks";
 import { useSubscriberFor } from "../reactHooks/useSubscriberFor";
 import { APP_EVENTS } from "../appUtils/events";
 import {
@@ -278,7 +275,7 @@ export function withActionExecutor(Component) {
 
   return function ActionExecutorComponent(props: Props) {
     const navigator = useNavigation();
-    const { rivers } = usePickFromState(["rivers"]);
+    const rivers = useRivers();
     const contentTypes = useContentTypes();
 
     const handlers = useMemo(() => {

package/actionsExecutor/feedDecorator.ts

@@ -27,7 +27,7 @@ function makeMultiSelect(feed: ZappFeed, key, decoratedFeed) {
   );
 
   const behavior = {
-    ...feed.extensions?.["behavior"],
+    ...feed.extensions?.behavior,
     select_mode: "multi",
     current_selection: `@{${scope}/${key}}`,
   };
@@ -75,7 +75,7 @@ function makeSingleSelect(feed: ZappFeed, key, decoratedFeed) {
   );
 
   const behavior = {
-    ...feed.extensions?.["behavior"],
+    ...feed.extensions?.behavior,
     select_mode: "single",
     current_selection: `@{${scope}/${key}}`,
   };
@@ -141,11 +141,11 @@ function makeSingleSelect(feed: ZappFeed, key, decoratedFeed) {
 }
 
 export const decorateFeed = (feed: ZappFeed) => {
-  if (!(feed.extensions?.["role"] === "preference_editor")) {
+  if (!(feed.extensions?.role === "preference_editor")) {
     return feed;
   }
 
-  const key = feed.extensions?.["preference_editor_options"]?.["key"];
+  const key = feed.extensions?.preference_editor_options?.key;
 
   if (!key) {
     log_error(
@@ -160,8 +160,8 @@ export const decorateFeed = (feed: ZappFeed) => {
   const decoratedFeed = R.clone(feed);
 
   const isSingleSelect =
-    (feed.extensions?.["preference_editor_options"]?.select_mode ||
-      feed.extensions?.["behavior"]?.select_mode) === "single";
+    (feed.extensions?.preference_editor_options?.select_mode ||
+      feed.extensions?.behavior?.select_mode) === "single";
 
   if (isSingleSelect) {
     return makeSingleSelect(feed, key, decoratedFeed);

package/adsUtils/__tests__/createVMAP.test.ts

@@ -0,0 +1,419 @@
+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 ]]>");
+    });
+  });
+});

package/adsUtils/index.ts

@@ -33,10 +33,10 @@ function convertOffset(offset: any): string {
 }
 
 function createAdBreak(ad: AdMap): string {
-  const offset = ad["offset"];
+  const offset = ad.offset;
   const id = offset.toString();
   const timestamp = convertOffset(offset);
-  const url = ad["ad_url"].toString().trim();
+  const url = ad.ad_url.toString().trim();
 
   return `
     <vmap:AdBreak timeOffset="${timestamp}" breakType="linear" breakId="break-${id}">

package/analyticsUtils/README.md

@@ -388,7 +388,7 @@ export function AnalyticsProvider(props: ComponentWithChildrenProps) {
 
 ```ts
 export function useAnalytics(props: any): any {
-  const { appData } = usePickFromState(["appData"]);
+  const appData = useAppData();
   const getAnalyticsFunctions = React.useContext(AnalyticsContext);
 
   const analyticsFunctions = React.useMemo(

package/analyticsUtils/analyticsMapper.ts

@@ -63,10 +63,14 @@ class StateHolder {
     return value as string;
   }
 
+  public get analyticsCustomPropertiesConsumed(): boolean {
+    return this._cap !== undefined;
+  }
+
   private acp(prefix: string, suffix: string): string | null {
     if (this._cap === undefined) {
-      this._cap = this.pluckedParams[prefix]
-        ? JSON.parse(this.pluckedParams[prefix])
+      this._cap = this.event.params[prefix]
+        ? JSON.parse(this.event.params[prefix])
         : null;
 
       delete this.pluckedParams[prefix];
@@ -254,6 +258,10 @@ export class Mapper {
 
     let params = resultParams.size ? Object.fromEntries(resultParams) : {};
 
+    if (state.analyticsCustomPropertiesConsumed) {
+      delete params[sourceType.analyticsCustomProperties];
+    }
+
     // deal with the remaining params
     if (!isEmptyOrNil(state.pluckedParams)) {
       if (rule.strategy) {