@applicaster/zapp-react-native-utils 15.1.6-alpha.3988508055 → 16.0.0-alpha.1020865559

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/actionUtils/index.ts

@@ -0,0 +1,7 @@
+import { Image } from "react-native";
+import { isTV } from "../reactUtils";
+
+export const resolveDefaultAssetUri = (source: string | number): string =>
+  isTV()
+    ? (source as string)
+    : Image.resolveAssetSource(source as number)?.uri || "";

package/actionsExecutor/ActionExecutorContext.tsx

@@ -19,11 +19,9 @@ import {
   appRestartAction,
   confirmDialogAction,
   createNavigateToScreenAction,
-  dismissBottomSheetAction,
   localStorageRemoveAction,
   localStorageSetAction,
   localStorageToggleFlagAction,
-  openBottomSheetAction,
   refreshComponentAction,
   screenSetVariableAction,
   screenToggleFlagAction,
@@ -92,8 +90,6 @@ const prepareDefaultActions = (actionExecutor) => {
 
   actionExecutor.registerAction("screenSetVariable", screenSetVariableAction);
   actionExecutor.registerAction("screenToggleFlag", screenToggleFlagAction);
-  actionExecutor.registerAction("openBottomSheet", openBottomSheetAction);
-  actionExecutor.registerAction("dismissBottomSheet", dismissBottomSheetAction);
   actionExecutor.registerAction("showToast", showToastAction);
 };
 

package/actionsExecutor/actions/__tests__/showToast.test.ts

@@ -11,14 +11,13 @@ describe("showToastAction", () => {
     jest.clearAllMocks();
   });
 
-  it("calls postEvent with showToast payload and returns ActionResult.Success", async () => {
+  it("calls postEvent with confirmation source, default timeout, and returns Success", async () => {
     const action = {
       type: "showToast",
       options: {
         id: "toast-1",
         message: "Added to queue",
         extraMessage: "Extra info",
-        timeout: 3000,
       },
     };
 
@@ -32,13 +31,38 @@ describe("showToastAction", () => {
         message: "Added to queue",
         extraMessage: "Extra info",
         style: undefined,
-        timeout: 3000,
+        timeout: 1000,
+        source: "confirmation",
       },
     ]);
 
     expect(result).toBe(ActionResult.Success);
   });
 
+  it("preserves an explicit timeout and style override", async () => {
+    const action = {
+      type: "showToast",
+      options: {
+        message: "Playlist created",
+        timeout: 3000,
+        style: { backgroundColor: "#00FF00" },
+      },
+    };
+
+    await showToastAction(action);
+
+    expect(postEvent).toHaveBeenCalledWith("showToast", [
+      {
+        id: undefined,
+        message: "Playlist created",
+        extraMessage: undefined,
+        style: { backgroundColor: "#00FF00" },
+        timeout: 3000,
+        source: "confirmation",
+      },
+    ]);
+  });
+
   it("handles missing or empty options without throwing", async () => {
     const action = {
       type: "showToast",
@@ -54,7 +78,8 @@ describe("showToastAction", () => {
         message: undefined,
         extraMessage: undefined,
         style: undefined,
-        timeout: undefined,
+        timeout: 1000,
+        source: "confirmation",
       },
     ]);
 

package/actionsExecutor/actions/index.ts

@@ -28,7 +28,3 @@ export { screenToggleFlagAction } from "./screenToggleFlag";
 export { createNavigateToScreenAction } from "./navigateToScreen";
 
 export { showToastAction } from "./showToast";
-
-export { openBottomSheetAction } from "./openBottomSheet";
-
-export { dismissBottomSheetAction } from "./dismissBottomSheet";

package/actionsExecutor/actions/refreshComponent.ts

@@ -14,10 +14,8 @@ const { log_info } = createLogger({
   category: "General",
 });
 
-/**
- * Helper function to prefer component data.source, otherwise direct UIComponentContext parent.
- */
-function getComponentFeedData(component: any) {
+/** Prefer component data.source, otherwise direct UIComponentContext parent. */
+function getComponentFeedData(component) {
   if (component?.data?.source) {
     return component.data;
   }
@@ -29,25 +27,6 @@ function getComponentFeedData(component: any) {
   return null;
 }
 
-/**
- * Helper function to find the parent component in a component tree.
- */
-function findParentComponent(
-  childId: string,
-  parent: ZappRiver | ZappUIComponent
-): ZappRiver | ZappUIComponent | null {
-  for (const child of parent?.ui_components || []) {
-    if (child.id === childId) return parent;
-
-    if (child.ui_components) {
-      const found = findParentComponent(childId, child);
-      if (found) return found;
-    }
-  }
-
-  return null;
-}
-
 /**
  * Refreshes a component's data by reloading its data source.
  * Supports URL inflation with context variables.
@@ -58,11 +37,7 @@ export const refreshComponentAction: ActionHandler = async (
 ): Promise<ActionResult> => {
   const dispatch = appStore.getDispatch();
 
-  const componentData =
-    getComponentFeedData(context?.component) ||
-    (context?.component?.id && context?.screenData
-      ? findParentComponent(context.component.id, context.screenData)?.data
-      : null);
+  const componentData = getComponentFeedData(context?.component);
 
   const source = componentData?.source;
   const mapping = componentData?.mapping;
@@ -74,7 +49,7 @@ export const refreshComponentAction: ActionHandler = async (
       getInflatedDataSourceUrl({
         source,
         contexts: {
-          entry: context?.entryContext || context?.screenEntry,
+          entry: context?.screenEntry,
           screen: context?.screenData,
           search: getSearchContext(null, mapping),
         },
@@ -82,12 +57,6 @@ export const refreshComponentAction: ActionHandler = async (
       }) || source;
   }
 
-  if (!dataSource) {
-    log_info("handleAction: refreshComponent skipped: no dataSource found");
-
-    return ActionResult.Success;
-  }
-
   log_info(`handleAction: refreshComponent for dataSource:${dataSource}`, {
     source,
     inflatedUrl: dataSource,

package/actionsExecutor/actions/showToast.ts

@@ -3,8 +3,58 @@ import { ActionResult } from "../ActionExecutor";
 import { ActionHandler } from "../types";
 import { postEvent } from "../../reactHooks/useSubscriberFor";
 
+export const CONFIRMATION_TOAST_SOURCE = "confirmation";
+
+export const CONFIRMATION_TOAST_DEFAULT_TIMEOUT = 1000;
+
 /**
- * Options for showToast action.
+ * Shows a mobile confirmation toast with Theme defaults from
+ * `Confirmation Toast / Message` in the base theme plugin.
+ *
+ * The action stamps `source: "confirmation"` and defaults `timeout` to 1000 ms.
+ * Callers may override individual style fields; Theme supplies the rest.
+ *
+ * @example From React via ActionExecutorContext
+ * ```tsx
+ * import React, { useContext } from "react";
+ * import { ActionExecutorContext } from "@applicaster/zapp-react-native-utils/actionsExecutor/ActionExecutorContext";
+ *
+ * function QueueButton() {
+ *   const { handleAction } = useContext(ActionExecutorContext);
+ *
+ *   const onPress = () => {
+ *     void handleAction({
+ *       type: "showToast",
+ *       options: { message: "Added to queue" },
+ *     });
+ *   };
+ *
+ *   return <Button onPress={onPress} title="Add to queue" />;
+ * }
+ * ```
+ *
+ * @example From code via the actionExecutor singleton
+ * ```ts
+ * import { actionExecutor } from "@applicaster/zapp-react-native-utils/actionsExecutor/ActionExecutor";
+ *
+ * await actionExecutor.handleAction({
+ *   type: "showToast",
+ *   options: {
+ *     message: "Playlist created",
+ *     style: { backgroundColor: "#00AA55" }, // optional partial override
+ *   },
+ * });
+ * ```
+ *
+ * @example From entry / pipes actions JSON
+ * ```json
+ * {
+ *   "type": "showToast",
+ *   "options": {
+ *     "message": "Item removed from playlist"
+ *   }
+ * }
+ * ```
  */
 export interface ShowToastActionOptions {
   id?: string;
@@ -17,13 +67,16 @@ export interface ShowToastActionOptions {
 export const showToastAction: ActionHandler<ShowToastActionOptions> = async (
   action
 ): Promise<ActionResult> => {
+  const options = action?.options;
+
   postEvent("showToast", [
     {
-      id: action?.options?.id,
-      message: action?.options?.message,
-      extraMessage: action?.options?.extraMessage,
-      style: action?.options?.style,
-      timeout: action?.options?.timeout,
+      id: options?.id,
+      message: options?.message,
+      extraMessage: options?.extraMessage,
+      style: options?.style,
+      timeout: options?.timeout ?? CONFIRMATION_TOAST_DEFAULT_TIMEOUT,
+      source: CONFIRMATION_TOAST_SOURCE,
     },
   ]);
 

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 ]]>");
+    });
+  });
+});