@applicaster/zapp-react-native-utils 13.0.0-rc.14 → 13.0.0-rc.141

package/audioPlayerUtils/__tests__/getBackgroundImage.test.ts

@@ -0,0 +1,72 @@
+import { getBackgroundImage } from "..";
+import { DEFAULT_IMAGE } from "../assets";
+
+describe("getBackgroundImage", () => {
+  const entryBase = {
+    media_group: [
+      {
+        media_item: [
+          { key: "image_key_1", src: "image_src_1" },
+          { key: "image_key_2", src: "image_src_2" },
+        ],
+        type: "image",
+      },
+    ],
+    extensions: {},
+  };
+
+  const pluginConfigBase = {};
+
+  it("returns image from entry.extensions.image_key if present", () => {
+    const entry = {
+      ...entryBase,
+      extensions: { image_key: "image_key_2" },
+    };
+
+    const result = getBackgroundImage({
+      entry,
+      plugin_configuration: pluginConfigBase,
+    });
+
+    expect(result).toBe("image_src_2");
+  });
+
+  it("returns audio_player_background_image from entry.extensions if present and no image_key image", () => {
+    const entry = {
+      ...entryBase,
+      extensions: { audio_player_background_image: "audio_img_ext" },
+    };
+
+    const result = getBackgroundImage({
+      entry,
+      plugin_configuration: pluginConfigBase,
+    });
+
+    expect(result).toBe("audio_img_ext");
+  });
+
+  it("returns image from plugin_configuration.audio_player_image_key if present and not found in entry.extensions", () => {
+    const entry = { ...entryBase };
+    const plugin_configuration = { audio_player_image_key: "image_key_1" };
+    const result = getBackgroundImage({ entry, plugin_configuration });
+    expect(result).toBe("image_src_1");
+  });
+
+  it("returns audio_player_background_image from plugin_configuration if present and not found in entry/extensions", () => {
+    const entry = { ...entryBase };
+
+    const plugin_configuration = {
+      audio_player_background_image: "audio_img_conf",
+    };
+
+    const result = getBackgroundImage({ entry, plugin_configuration });
+    expect(result).toBe("audio_img_conf");
+  });
+
+  it("returns DEFAULT_IMAGE if nothing is found", () => {
+    const entry = { media_group: [], extensions: {} };
+    const plugin_configuration = {};
+    const result = getBackgroundImage({ entry, plugin_configuration });
+    expect(result).toBe(DEFAULT_IMAGE);
+  });
+});

package/audioPlayerUtils/__tests__/getImageFromEntry.test.ts

@@ -0,0 +1,110 @@
+import { getImageFromEntry } from "..";
+
+const entry = {
+  media_group: [
+    {
+      media_item: [
+        {
+          key: "image_base_key",
+          src: "image_base_src",
+        },
+        {
+          key: "thumb_1",
+          src: null,
+        },
+        {
+          key: "thumb_2",
+          src: null,
+        },
+        {
+          key: "thumb_3",
+          src: null,
+        },
+      ],
+      type: "image",
+    },
+  ],
+};
+
+describe("getImageFromEntry", () => {
+  it("returns the src value for existing key", () => {
+    const result = getImageFromEntry({
+      entry,
+      imageKey: "image_base_key",
+    });
+
+    expect(result).toEqual("image_base_src");
+  });
+
+  it("returns undefined for non-existing key", () => {
+    const result = getImageFromEntry({
+      entry,
+      imageKey: "non_existing_key",
+    });
+
+    expect(result).toBeUndefined();
+  });
+
+  it("returns undefined for undefined key", () => {
+    const result = getImageFromEntry({
+      entry,
+      imageKey: undefined,
+    });
+
+    expect(result).toBeUndefined();
+  });
+
+  it("returns undefined for non string src", () => {
+    const entryWithNonStringSrc = {
+      media_group: [
+        {
+          media_item: [
+            {
+              key: "image_base_key",
+              src: 123,
+            },
+            {
+              key: "thumb_1",
+              src: null,
+            },
+          ],
+          type: "image",
+        },
+      ],
+    };
+
+    const result = getImageFromEntry({
+      entry: entryWithNonStringSrc,
+      imageKey: "image_base_key",
+    });
+
+    expect(result).toBeUndefined();
+  });
+
+  it("returns undefined for empty src", () => {
+    const entryWithEmptySrc = {
+      media_group: [
+        {
+          media_item: [
+            {
+              key: "image_base_key",
+              src: "",
+            },
+            {
+              key: "thumb_1",
+              src: null,
+            },
+          ],
+          type: "image",
+        },
+      ],
+    };
+
+    const result = getImageFromEntry({
+      entry: entryWithEmptySrc,
+      imageKey: "image_base_key",
+    });
+
+    expect(result).toBeUndefined();
+  });
+});

package/audioPlayerUtils/assets/index.ts

@@ -0,0 +1,2 @@
+export const DEFAULT_IMAGE =
+  "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAABwgAAAP0CAYAAAC+jGj3AAAxj0lEQVR4AezdIWyd59nH4af9piKXbKAOGXJQpShGJTYacXisSUOxIo1FQZNmBWyaFCXSVBCltHLQpMpGIzYasVFJjUpiVJKgEhuN9Nv9tk7bKI59nnOOfY7/1yW9Ou2aej7PW/bTfT8f3Lp164cGAAAAAAAARPiwAQAAAAAAADEEQgAAAAAAAAgiEAIAAAAAAEAQgRAAAAAAAACCCIQAAAAAAAAQRCAEAAAAAACAIAIhAAAAAAAABBEIAQAAAAAAIIhACAAAAAAAAEEEQgAAAAAAAAgiEAIAAAAAAEAQgRAAAAAAAACCCIQAAAAAAAAQRCAEAAAAAACAIAIhAAAAAAAABBEIAQAAAAAAIIhACAAAAAAAAEEEQgAAAAAAAAgiEAIAAAAAAEAQgRAAAAAAAACCCIQAAAAAAAAQRCAEAAAAAACAIAIhAAAAAAAABBEIAQAAAAAAIIhACAAAAAAAAEEEQgAAAAAAAAgiEAIAAAAAAEAQgRAAAAAAAACCCIQAAAAAAAAQRCAEAAAAAACAIAIhAAAAAAAABBEIAQAAAAAAIIhACAAAAAAAAEEEQgAAAAAAAAgiEAIAAAAAAEAQgRAAAAAAAACCCIQAAAAAAAAQRCAEAAAAAACAIAIhAAAAAAAABBEIAQAAAAAAIIhACAAAAAAAAEEEQgAAAAAAAAgiEAIAAAAAAEAQgRAAAAAAAACCCIQAAAAAAAAQRCAEAAAAAACAIAIhAAAAAAAABBEIAQAAAAAAIIhACAAAAAAAAEEEQgAAAAAAAAgiEAIAAAAAAEAQgRAAAAAAAACCCIQAAAAAAAAQRCAEAAAAAACAIAIhAAAAAAAABBEIAQAAAAAAIIhACAAAAAAAAEEEQgAAAAAAAAgiEAIAAAAAAEAQgRAAAAAAAACCCIQAAAAAAAAQRCAEAAAAAACAIAIhAAAAAAAABBEIAQAAAAAAIIhACAAAAAAAAEEEQgAAAAAAAAgiEAIAAAAAAEAQgRAAAAAAAACCCIQAAAAAAAAQRCAEAAAAAACAIAIhAAAAAAAABBEIAQAAAAAAIIhACAAAAAAAAEEEQgAAAAAAAAgiEAIAAAAAAEAQgRAAAAAAAACCCIQAADQAAAAAcgiEAAAAAAAAEEQgBAAAAAAAgCACIQAAAAAAAAQRCAEAAAAAACCIQAgAAAAAAABBBEIAAAAAAAAIIhACAAAAAABAEIEQAAAAAAAAggiEAAAAAAAAEEQgBAAAAAAAgCACIQAAAAAAAAQRCAEAAAAAACCIQAgAAAAAAABBBEIAAAAAAAAIIhACAAAAAABAEIEQAAAAAAAAggiEAAAAAAAAEEQgBAAAAAAAgCACIQAAAAAAAAQRCAEAAAAAACCIQAgAAAAAAABBBEIAAAAAAAAIIhACAAAAAABAEIEQAAAAAAAAggiEAAAAAAAAEEQgBAAAAAAAgCACIQAAAAAAAAQRCAEAAAAAACCIQAgAAAAAAABBBEIAAAAAAAAIIhACAAAAAABAEIEQAAAAAAAAggiEAAAAAAAAEEQgBAAAAAAAgCACIQAAAAAAAAQRCAEAAAAAACCIQAgAAAAAAABBBEIAAAAAAAAIIhACAAAAAABAEIEQAAAAAAAAggiEAAAAAAAAEEQgBAAAAAAAgCACIQAAAAAAAAQRCAEAAAAAACCIQAgAAAAAAABBBEIAAAAAAAAIIhACAAAAAABAEIEQAAAAAAAAggiEAAAAAAAAEEQgBAAAAAAAgCACIQAAAAAAAAQRCAEAAAAAACCIQAgAAAAAAABBBEIAAAAAAAAIIhACAAAAAABAEIEQAAAAAAAAggiEAAAAAAAAEEQgBAAAAAAAgCACIQAAAAAAAAQRCAEAAAAAACCIQAgAAAAAAABBBEIAAAAAAAAIIhACAAAAAABAEIEQAAAAAAAAggiEAAAAAAAAEEQgBAAAAAAAgCACIQAAAAAAAAQRCAEAAAAAACCIQAgAAAAAAABBBEIAAAAAAAAIIhACAAAAAABAEIEQAAAAAAAAggiEAAAAAAAAEEQgBAAAAAAAgCACIQAAAAAAAAQRCAEAAAAAACCIQAgAAAAAAABBBEIAAAAAAAAIIhACAAAAAABAEIEQAAAAAAAAggiEAAAAAAAAEEQgBAAAAAAAgCACIQAAAAAAAAQRCAEAAAAAACCIQAgAAAAAAABBBEIAAAAAAAAIIhACAAAAAABAEIEQAAAAAAAAggiEAAAAAAAAEEQgBAAAAAAAgCACIQAAAAAAAAQRCAEAAAAAACCIQAgAAAAAAABBBEIAAAAAAAAIIhACAAAAAABAEIEQAAAAAAAAggiEAAAAAAAAEEQgBAAAAAAAgCACIQAAAAAAAAQRCAEAAAAAACCIQAgAAAAAAABBBEIAAAAAAAAIIhACAAAAAABAEIEQAAAAAAAAggiEAAAAAAAAEEQgBAAAAAAAgCACIQAAAAAAAAQRCAEAAAAAACCIQAgAAAAAAABBBEIAAAAAAAAIIhACAAAAAABAEIEQAAAAAAAAggiEAAAAAAAAEEQgBAAAAAAAgCACIQAAAAAAAAQRCAEAAAAAACCIQAgAAAAAAABBBEIAAAAAAAAIIhACAAAAAABAEIEQAAAAAAAAggiEAAAAAAAAEEQgBAAAAAAAgCACIQAAAAAAAAQRCAEAAAAAACCIQAgAAAAAAABBBEIAAAAAAAAIIhACAAAAAABAEIEQAAAAAAAAggiEAAAAAAAAEEQgBAAAAAAAgCACIQAAAAAAAAQRCAEAAAAAACCIQAgAAAAAAABBBEIAAAAAAAAIIhACAAAAAABAEIEQAAAAAAAAggiEAAAAAAAAEEQgBAAAAAAAgCACIQAAAAAAAAQRCAEAAAAAACCIQAgAAAAAAABBBEIAAAAAAAAIIhACAAAAAABAEIEQAAAAAAAAggiEAAAAAAAAEEQgBAAAAAAAgCACIQAAAAAAAAQRCAEAAAAAACCIQAgAAAAAAABBBEIAAAAAAAAIIhACAAAAAABAEIEQAAAAAAAAggiEAAAAAAAAEEQgBAAAAAAAgCACIQAAAAAAAAQRCAEAAAAAACCIQAgAAAAAAABBBEIAAAAAAAAIIhACAAAAAABAEIEQAAAAAAAAggiEAAAAAAAAEEQgBAAAAAAAgCACIQAAAAAAAAQRCAEAAAAAACCIQAgAAAAAAABBBEIAAAAAAAAIIhACAAAAAABAEIEQAAAAAAAAggiEAAAAAAAAEEQgBAAAAAAAgCACIQAAAAAAAAQRCAEAAAAAACCIQAgAAAAAAABBBEIAAAAAAAAIIhACAAAAAABAEIEQAAAAAAAAggiEAAAAAAAAEEQgBAAAAAAAgCACIQAAAAAAAAQRCAEAAAAAACCIQAgAAAAAAABBBEIAAAAAAAAIIhACAAAAAABAEIEQAAAAAAAAggiEAAAAAAAAEEQgBAAAAAAAgCACIQAAAAAAAAQRCAEAAAAAACCIQAgAAAAAAABBBEIAAAAAAAAIIhACAAAAAABAEIEQAAAAAAAAggiEAAAAAAAAEEQgBAAAAAAAgCACIQAAAAAAAAQRCAEAAAAAACCIQAgAAAAAAABBBEIAAAAAAAAIIhACAAAAAABAEIEQAAAAAAAAggiEAAAAAAAAEEQgBAAAAAAAgCACIQAAAAAAAAQRCAEAAAAAACCIQAgAAAAAAABBBEIAAAAAAAAIIhACAAAAAABAEIEQAAAAAAAAggiEAAAAAAAAEEQgBAAAAAAAgCACIQAAAAAAAAQRCAEAAAAAACCIQAgAAAAAAABBBEIAAAAAAAAIIhACAAAAAABAEIEQAAAAAAAAggiEAAAAAAAAEEQgBAAAAAAAgCACIQAAAAAAAAQRCAEAAAAAACCIQAgAAAAAAABBBEIAAAAAAAAIIhACAAAAAABAEIEQAAAAAAAAggiEAAAAAAAAEEQgBAAAAAAAgCACIQAAAAAAAAQRCAEAAAAAACCIQAgAAAAAAABBBEIAAAAAAAAIIhACAAAAAABAEIEQAAAAAAAAggiEAAAAAAAAEEQgBAAAAAAAgCACIQAAAAAAAAQRCAEAAAAAACCIQAgAAAAAAABBBEIAAAAAAAAIIhACAAAAAABAEIEQAAAAAAAAggiEAAAAAAAAEEQgBAAAAAAAgCACIQAAAAAAAAQRCAEAAAAAACCIQAgAAAAAAABBBEIAAAAAAAAIIhACAAAAAABAEIEQAAAAAAAAggiEAAAAAAAAEEQgBAAAAAAAgCACIQAAAAAAAAQRCAEAAAAAACCIQAgAAAAAAABBBEIAAAAAAAAIIhACAAAAAABAEIEQAAAAAAAAggiEAAAAAAAAEEQgBAAAAAAAgCACIQAAAAAAAAQRCAEAAAAAACCIQAgAAAAAAABBBEIAAAAAAAAIIhACAAAAAABAEIEQAAAAAAAAggiEAAAAAAAAEEQgBAAAAAAAgCACIQAAAAAAAAQRCAEAAAAAACCIQAgAAAAAAABBBEIAAAAAAAAIIhACAAAAAABAEIEQAAAAAAAAggiEAAAAAAAAEEQgBAAAAAAAgCACIQAAAAAAAAQRCAEAAAAAACCIQAgAAAAAAABBBEIAAAAAAAAIIhACAAAAAABAEIEQAAAAAAAAggiEAAAAAAAAEEQgBAAAAAAAgCACIQAAAAAAAAQRCAEAAAAAACCIQAgAAAAAAABBBEIAAAAAAAAIIhACAAAAAABAEIEQAAAAAAAAggiEAAAAAAAAEEQgBAAAAAAAgCACIQAAAAAAAAQRCAEAAAAAACCIQAgAAAAAAABBBEIAAAAAAAAIIhACAAAAAABAEIEQAAAAAAAAggiEAAAAAAAAEEQgBAAAAAAAgCACIQAAAAAAAAQRCAEAAAAAACCIQAgAAAAAAABBBEIAAAAAAAAIIhACAAAAAABAEIEQAAAAAAAAggiEAAAAAAAAEEQgBAAAAAAAgCACIQAAAAAAAAQRCAEAAAAAACCIQAgAAAAAAABBBEIAAAAAAAAIIhACAAAAAABAEIEQAAAAAAAAggiEAAAAAAAAEEQgBAAAAAAAgCACIQAAAAAAAAQRCAEAAAAAACCIQAgAAAAAAABBBEIAAAAAAAAIIhACAAAAAABAEIEQAAAAAAAAggiEAAAAAAAAEEQgBAAAAAAAgCACIQAAAAAAAAQRCAEAAAAAACCIQAgAAAAAAABBBEIAAAAAAAAIIhACAAAAAABAEIEQAAAAAAAAggiEAAAAAAAAEEQgBAAAAAAAgCACIQAAAAAAAAQRCAEAAAAAACCIQAgAAAAAAABBBEIAAAAAAAAIIhACAAAAAABAEIEQAAAAAAAAggiEAAAAAAAAEEQgBAAAAAAAgCACIQAAAAAAAAQRCAEAAAAAACCIQAgAAAAAAABBBEIAAAAAAAAIIhACAAAAAABAEIEQAAAAAAAAggiEAAAAAAAAEEQgBAAAAAAAgCACIQAAAAAAAAQRCAEAAAAAACCIQAgAAAAAAABBBEIAAAAAAAAIIhACAAAAAABAEIEQAAAAAAAAggiEAAAAAAAAEEQgBAAAAAAAgCACIQAAAAAAAAQRCAEAAAAAACCIQAgAAAAAAABBBEIAAAAAAAAIIhACAAAAAABAEIEQAAAAAAAAggiEAAAAAAAAEOQ3DQAAgGtncXHxzbOwsDA8N27cOPPPn5yctOPj4+Hz9evXbz7rAQAA4HoRCAEAAOZYhb/bt2+3paWldvPmzeGzouAkHR0dDaHw5cuXw18fHh4OAREAAID59MGtW7d+aAAAAMyFCoIrKytteXl5CIOTjoEXVaGwnv39/TcBEQAAgPkgEAIAAMy4ioJra2ttdXV1iIKzqKYKKxYeHByIhQAAADNOIAQAAJhB8xAFz1KxcHd3d/gUCwEAAGaPQAgAADBDKgZWFKw4WJFw3u3t7bWtrS2hEAAAYIYIhAAAADOgwuDGxsbcTQteVE0Tbm9vDytIAQAAuFoCIQAAwBW67mHwbTVJWBOFNVkIAADA1RAIAQAArkBaGHzb0dFRe/LkyfAJAADA5RIIAQAALtHi4mJ78OBBW1lZabijEAAA4CoIhAAAAJdkfX293bt3ry0sLDR+dnJyMkTCnZ2dBgAAwPQJhAAAAFNWU4Obm5ux60QvqqYIHz58aJoQAABgygRCAACAKTI1OLoXL14ME4UAAABMh0AIAAAwBRUEHz9+PBNTg7XCs57TybzTvy/1e57Gy5p0/OXfX6WDg4P2/Plz04QAAABTIBACAABM2NLS0hAHK7hdpop+h4eH7dWrV+3o6Gh4KrCdxsCLqkBYv3s99V1u3rw5hM7LDodWjgIAAEyHQAgAADBBl7lStMJfTdq9fPly+Jx2SKtYWM/q6uqlBsOaJNzZ2WkAAABMhkAIAAAwIRsbG0McnKaKgru7u0MQrGnBq1SRcG1trS0vL099WtK9hAAAAJMjEAIAAEzA5ubmEMumpWLg9vb28DnqytDLUN/9zp07U71zsaYIa5oQAACA8QiEAAAAY6g1mw8ePJhaHKxpwb29vSufFryomiSsKcqKhdNQk5NPnjyZyUgKAAAwLwRCAACAThUHnz17NtzLN2kVBmut5rTvFZyWaYbCo6Oj9vDhQ5EQAACgk0AIAADQYVpxsCYFa0JuXsPg26YVCkVCAACAfv/3ySef/L0BAAAwkr/97W8TvW+vguCjR4+GqcHrFL3qu9Ra0Pp+N2/eHMLqJPz2t79tv/vd74afDQAAwGgEQgAAgBFN+s7B7e3t9o9//KN999137bqqib+6S/G///1vW15ebpNQ05s3btwQCQEAAEYkEAIAAIxgY2Oj/elPf2qTcDo1+O9//3sIZ9ddfcdaoVpPRcJJTBNWJPzggw+GnwkAAMDFCIQAAAAXtL6+3v785z+3SaigVXfoXeepwbNUGK2pv5r++/3vf9/GVatea5Xpt99+2wAAADifQAgAAHABi4uL7Z///GebhK2trfb06dOIqcGzVND7z3/+M/z1JFaOfvrpp+3rr79u33//fQMAAOD9BEIAAIBzVBx89uzZ2CsxK4p9/vnnbWdnp/GjmqSsc6nA99FHH7Ve9e9+9tlnb+45BAAA4GwfNgAAAN7rwYMHQyQcR0WwWilaAYtfq2BaZ1NnNI56R48fP24AAAC8n0AIAADwHhsbG21lZaWNo+7cu3//fjs6Omq8W51NnVGd1TjqPsK7d+82AAAAziYQAgAAnKEm0u7du9fGUcGrpuPGDV8JJnVWFXXHnfgEAAC4zgRCAACAM9S9g+MQB0d3embjrButuyI3NzcbAAAA7yYQAgAAvMP6+vpYU2gVuB49eiQOdphEJLRqFAAA4GwCIQAAwFsmsVr0+fPn7hwcQ51dneE4rBoFAAB4N4EQAADgLRWWak1lr62trba3t9cYT51hnWWveocPHjxoAAAA/JpACAAA8AtLS0ttbW2t9drf328vXrxoTEad5eHhYeu1srIyrBsFAADgZwIhAADAL2xubrZedXfeF1980Zisce9yrIlQAAAAfiYQAgAA/KQmB2uCsNeTJ0/GClm828nJyXC2vWqC0BQhAADAzwRCAACAn4wzaVZ35Y2zCpP3q7Pd3t5uvUwRAgAA/EwgBAAAaD/eVbe4uNh61NTgzs5OY7rqPsLeCU1ThAAAAD8TCAEAAP5nfX299arpwVqDyXSNu2rUFCEAAMCPBEIAACBeTQ72Tpft7u62vb29xuWoVaO9q1xNEQIAAPxIIAQAAOKNM1lWay+5XONMEdYqWQAAgHQCIQAAEK2mB9fW1lqPmh7svROPfnXmdfY97ty50xYWFhoAAEAygRAAAIg2zspJ04NXp/fsKw72BmEAAIDrQiAEAACi1URZD9ODV2ucKcLV1dUGAACQTCAEAABi1XrR3glC04NXb29vr/Wod27NKAAAkEwgBAAAYq2srLQeh4eHpgdnQL2HenpYMwoAACQTCAEAgFi9qyZ7V1syedvb262HNaMAAEAygRAAAIjUu160Jgd7V1syeTVBeHJy0kZlzSgAAJBMIAQAACItLS21Ht98801jdlQc7J3o7F0xCwAAMO8EQgAAIFLviknTg7Pn4OCg9eiNxAAAAPNOIAQAACL1xKGaVquVlsyW3jWj7iEEAABSCYQAAECcunuuJxBaLzq79vf326jqHkr3EAIAAIkEQgAAIM7t27dbj95Vlkzf0dFR69H73wIAAMA8EwgBAIA4vXfP9UYopq833tYUIQAAQBqBEAAAiHPz5s02qrrjTiCcXa9fv+66h9AEIQAAkEggBAAA4vRMjbl/cPYdHh62UfXEYgAAgHknEAIAAHF6VoyaHpx9r169aqOyYhQAAEgkEAIAAFF6g5BAOPt635FICAAApBEIAQCAKL0xqO64Y7YJhAAAABcjEAIAAFEWFhZaD4Fw9vW+I4EQAABIIxACAABRemLQycnJ8DDbet9TbzQGAACYVwIhAAAQpScGiYPzQyAEAAA4n0AIAABE6YlB1ovOj553ZcUoAACQRiAEAACimBYDAAAgnUAIAABwjuPj48Z8sA4WAADgfAIhAADAOUSn+SHmAgAAnE8gBAAAAAAAgCACIQAAAAAAAAQRCAEAAAAAACCIQAgAAAAAAABBBEIAAAAAAAAIIhACAAAAAABAkN80AAAAui0uLg7PwsLC8JycnLx5jo6OGn1Oz/P0fMvr16/ffJ7+NQAAAKMTCAEAAEZw+/bttry8PHwuLS0NEet9KhLWs7+/3w4ODhrvVudY57m6utpWVlbeRMGznAbY07M9PDxsAAAAXIxACAAAcI6PP/64bWxstLt3754bBN9W0auetbW1IWpVJNza2jIB95MKrRUF63xGOdv6s/Xv1lPvpc6zzvXGjRsNAACA9xMIAQAAzlETbfWMq6JWhbB69vb2okNhTQhubm4OgW+SPw8AAIDzfdgAAAC4dBUJv/rqq2EyMU195y+//HJicRAAAIDRCIQAAABX6N69e0MsO+/OveugvuOzZ8+G7zzqqlYAAAAmRyAEAAC4YnVHYYWz6xwJT7+jqUEAAICrJxACAADMgIqDNUlYIe26SQigAAAA80QgBAAAmBG1dvO6hbTTtaJWigIAAMwOgRAAAGCGnEbC6xDUxEEAAIDZJBACAADMmAprjx8/bvNuY2PDWlEAAIAZJBACAADMoNu3b7e7d++2ebW2tjY8AAAAzB6BEAAAYEbVBN48ruesqcH63QEAAJhNAiEAAMCMqjg4j1OEd+7csVoUAABghv2mAQAA0OXk5KRtb2+3w8PDdnR0NPx9WVpaGp4KZbUqdBzr6+ttZ2fnzc+edRU1J7FatM50f3+/HRwcDN+9nvrZda4rKyttdXVVhAQAAOgkEAIAAIyoYtXW1tYQ7t6lYmE9e3t7QyDc3Nzsjlmnwe2s/69ZU/FunHD3+vXr9uTJkyEQvq3Ovf73er744othunJe17ACAABcJStGAQAARlAB6/79+xcOdhWz6s9XLOxV03LzoqYme+3u7g5n9a44+C71DurP1zsBAADg4gRCAACAC6oQ9fDhw5GDVE2+nTUVdxE1hTgPU3I1Odi7UrXWiT59+nTkVaqn72ReVrACAADMAoEQAADggmqt6DjTao8ePeoOWbW6c9bV/YA96kxrZWiv07WkAAAAXIxACAAAcAE1/TfOmtBScXB7e7v16I1vl6l3enDc8FoODg66JzQBAADSCIQAAAAX0Bv23lb35vVMEdb6zll38+bNNqoKg+OG11MVGgEAADifQAgAAHCOCno1oTapn1X37Y2qJ75dtp6I+fLlyzYpR0dH7iIEAAC4AIEQAADgHBWervrnLSwstFnXEwgnuRa04uC4q0oBAAASCIQAAADnOD4+bpPUM+U2D4Gwx6Qn/iY5kQgAAHBdCYQAAADnsLYSAACA60QgBAAAAAAAgCACIQAAAAAAAAQRCAEAAAAAACCIQAgAAAAAAABBBEIAAAAAAAAIIhACAAAAAABAEIEQAAAAAAAAggiEAAAAAAAAEEQgBAAAAAAAgCACIQAAAAAAAAQRCAEAAAAAACCIQAgAAAAAAABBBEIAAAAAAAAIIhACAACc48aNG22SFhYWGtMx6XcFAABwHQmEAABAlJOTkzaqpaWlNkmLi4ttVK9fv26zrud3nPTZ9vy8nv8mAAAA5plACAAAROmJWDXxd/v27TYpq6urbVTzEAh7QlvPWZyl4mDPdOY8nC0AAMAkCYQAAECU3hg0qUBYP6dngvD4+LjNupcvX7ZR1VlM6mzX19dbj6OjowYAAJBEIAQAAKIcHh62HhWfesLe2x48eNB69P7el6k3tG1sbLRx1btZW1trPQRCAAAgjUAIAABEqTWYvWtGHz9+3MZRIaz3zr15CIS9v2NNEI4bCXvfTcVBdxACAABpBEIAACDO/v5+61Fxb3Nzs/W4c+dOu3fvXutRQXMeptzGiW11Nnfv3m096p30htdvvvmmAQAApBEIAQCAOAcHB61XrbH88ssvL7xutCYPa63oX//619arN2hehe3t7darzmmUScJ6B/UueleLlr29vQYAAJDmg1u3bv3QAAAAwjx79mxYbTmOiksVxN413VdhsO4trHg17t2Ff/zjH7vWol6F+q5fffVVG0d9162trWFl6bu+d7231dXV4WzrnHvVe7t//34DAABIIxACAACRKjJVJJyEWqtZsaliVgWrWnc5bhQ8tbu7254+fdrmySTi66nTtaV1tnWmdbbjRMFfevLkiQlCAAAgkkAIAADEmmTImpZ5mh48VRGvVn/OsjrTOlsAAIBE7iAEAABi1RrLWVbrS+ctDpaa+hvnLsLL8OjRowYAAJBKIAQAAGLVHXezGrIqDL548aLNq/rdZzVunnVvJAAAQAqBEAAAiDarIasm3OruvXlVv3vd8Tdr5j28AgAATIJACAAARKuQ9fDhw5mKhM+fP78WE241oVnfZVbUO653Pc/hFQAAYBL+75NPPvl7AwAACFbBqGLWH/7wh/bRRx+1q1T3Iv7rX/9q18W33347fC4vL7erVO/4L3/5S/vuu+8aAABAOoEQAADgf77//vv29ddft88++6wtLCy0q1Bx8Dquv6z4Wq4qEtbkYMVB9w4CAAD8SCAEAAD4SUXCg4ODtrq6eqmRsKbbPv/887azs9Ouq4qE9T0//fTTS53SPF0ranIQAADgZx/cunXrhwYAAMAbFQfv3bvX1tfX27TVVNujR49m6g7EaVpcXGzPnj0bPqdte3t7mMh05yAAAMCvCYQAAABnWFpaao8fP55KzKpoVStFr/PU4PvcvXt3CLDTONuaVqyzPV1tCgAAwK8JhAAAAOdYW1sbYlYFw3FVGKzJtgqD6ZNtFQfrbO/cuTORUCgMAgAAXIxACAAAcEEVCCtoLS8vjxQLKwTW3Ya7u7vi1RlWVlaGZ9T7H2s16/7+/nC+zhYAAOBiBEIAAIAOFbEqEtZT028ff/zxr/75q1evhnhV0SrlfsFJOT3T+rxx48av/tnx8fFwnqdn635BAACA0QmEAAAAAAAAEOTDBgAAAAAAAMQQCAEAAAAAACCIQAgAAAAAAABBBEIAAAAAAAAIIhACAAAAAABAEIEQAAAAAAAAggiEAAAAAAAAEEQgBAAAAAAAgCACIQAAAAAAAAQRCAEAAAAAACCIQAgAAAAAAABBBEIAAAAAAAAIIhACAAAAAABAEIEQAAAAAAAAggiEAAAAAAAAEEQgBAAAAAAAgCACIQAAAAAAAAQRCAEAAAAAACCIQAgAAAAAAABBBEIAAAAAAAAIIhACAAAAAABAEIEQAAAAAAAAggiEAAAAAAAAEEQgBAAAAAAAgCACIQAAAAAAAAQRCAEAAAAAACCIQAgAAAAAAABBBEIAAAAAAAAIIhACAAAAAABAEIEQAAAAAAAAggiEAAAAAAAAEEQgBAAAAAAAgCACIQAAAAAAAAQRCAEAAAAAACCIQAgAAAAAAABBBEIAAAAAAAAIIhACAAAAAABAEIEQAAAAAAAAggiEAAAAAAAAEEQgBAAAAAAAgCACIQAAAAAAAAQRCAEAAAAAACCIQAgAAAAAAABBBEIAAAAAAAAIIhACAAAAAABAEIEQAAAAAAAAggiEAAAAAAAAEEQgBAAAAAAAgCACIQAAAAAAAAQRCAEAAAAAACCIQAgAAAAAAABBBEIAAAAAAAAIIhACAAAAAABAEIEQAAAAAAAAggiEAAAAAAAAEEQgBAAAAAAAgCACIQAAAAAAAAQRCAEAAAAAACCIQAgAAAAAAABBBEIAAAAAAAAIIhACAAAAAABAEIEQAAAAAAAAggiEAAAAAAAAEEQgBAAAAAAAgCACIQAAAAAAAAQRCAEAAAAAACCIQAgAAAAAAABBBEIAAAAAAAAIIhACAAAAAABAEIEQAAAAAAAAggiEAAAAAAAAEEQgBAAAAAAAgCACIQAAAAAAAAQRCAEAAAAAACCIQAgAAAAAAABBBEIAAAAAAAAIIhACAAAAAABAEIEQAAAAAAAAggiEAAAAAAAAEEQgBAAAAAAAgCACIQAAAAAAAAQRCAEAAAAAACCIQAgAAAAAAABBBEIAAAAAAAAIIhACAAAAAABAEIEQAAAAAAAAggiEAAAAAAAAEEQgBAAAAAAAgCACIQAAAAAAAAQRCAEAAAAAACCIQAgAAAAAAABBBEIAAAAAAAAIIhACAAAAAABAEIEQAAAAAAAAggiEAAAAAAAAEEQgBAAAAAAAgCACIQAAAAAAAAQRCAEAAAAAACCIQAgAAAAAAABBBEIAAAAAAAAIIhACAAAAAABAEIEQAAAAAAAAggiEAAAAAAAAEEQgBAAAAAAAgCACIQAAAAAAAAQRCAEAAAAAACCIQAgAAAAAAABBBEIAAAAAAAAIIhACAAAAAABAEIEQAAAAAAAAggiEAAAAAAAAEEQgBAAAAAAAgCACIQAAAAAAAAQRCAEAAAAAACCIQAgAAAAAAABBBEIAAAAAAAAIIhACAAAAAABAEIEQAAAAAAAAggiEAAAAAAAAEEQgBAAAAAAAgCACIQAAAAAAAAQRCAEAAAAAACCIQAgAAAAAAABBBEIAAAAAAAAIIhACAAAAAABAEIEQAAAAAAAAggiEAAAAAAAAEEQgBAAAAAAAgCACIQAAAAAAAAQRCAEAAAAAACCIQAgAAAAAAABBBEIAAAAAAAAIIhACAAAAAABAEIEQAADg/9uzAwEAAAAAQf7Wg1waAQAAwIggBAAAAAAAgBFBCAAAAAAAACOCEAAAAAAAAEYEIQAAAAAAAIwIQgAAAAAAABgRhAAAAAAAADAiCAEAAAAAAGBEEAIAAAAAAMCIIAQAAAAAAIARQQgAAAAAAAAjghAAAAAAAABGBCEAAAAAAACMCEIAAAAAAAAYEYQAAAAAAAAwIggBAAAAAABgRBACAAAAAADAiCAEAAAAAACAEUEIAAAAAAAAI4IQAAAAAAAARgQhAAAAAAAAjAhCAAAAAAAAGBGEAAAAAAAAMCIIAQAAAAAAYEQQAgAAAAAAwIggBAAAAAAAgBFBCAAAAAAAACOCEAAAAAAAAEYEIQAAAAAAAIwIQgAAAAAAABgRhAAAAAAAADAiCAEAAAAAAGBEEAIAAAAAAMCIIAQAAAAAAIARQQgAAAAAAAAjghAAAAAAAABGBCEAAAAAAACMCEIAAAAAAAAYEYQAAAAAAAAwIggBAAAAAABgRBACAAAAAADAiCAEAAAAAACAEUEIAAAAAAAAI4IQAAAAAAAARgQhAAAAAAAAjAhCAAAAAAAAGBGEAAAAAAAAMCIIAQAAAAAAYEQQAgAAAAAAwIggBAAAAAAAgBFBCAAAAAAAACOCEAAAAAAAAEYEIQAAAAAAAIwIQgAAAAAAABgRhAAAAAAAADAiCAEAAAAAAGBEEAIAAAAAAMCIIAQAAAAAAIARQQgAAAAAAAAjghAAAAAAAABGBCEAAAAAAACMCEIAAAAAAAAYEYQAAAAAAAAwIggBAAAAAABgRBACAAAAAADAiCAEAAAAAACAEUEIAAAAAAAAI4IQAAAAAAAARgQhAAAAAAAAjAhCAAAAAAAAGBGEAAAAAAAAMCIIAQAAAAAAYEQQAgAAAAAAwIggBAAAAAAAgBFBCAAAAAAAACOCEAAAAAAAAEYEIQAAAAAAAIwIQgAAAAAAABgRhAAAAAAAADAiCAEAAAAAAGBEEAIAAAAAAMCIIAQAAAAAAIARQQgAAAAAAAAjghAAAAAAAABGBCEAAAAAAACMCEIAAAAAAAAYEYQAAAAAAAAwIggBAAAAAABgRBACAAAAAADAiCAEAAAAAACAEUEIAAAAAAAAI4IQAAAAAAAARgQhAAAAAAAAjAhCAAAAAAAAGBGEAAAAAAAAMCIIAQAAAAAAYEQQAgAAAAAAwIggBAAAAAAAgBFBCAAAAAAAACOCEAAAAAAAAEYEIQAAAAAAAIwIQgAAAAAAABgRhAAAAAAAADAiCAEAAAAAAGBEEAIAAAAAAMCIIAQAAAAAAIARQQgAAAAAAAAjghAAAAAAAABGBCEAAAAAAACMCEIAAAAAAAAYEYQAAAAAAAAwIggBAAAAAABgRBACAAAAAADAiCAEAAAAAACAEUEIAAAAAAAAI4IQAAAAAAAARgQhAAAAAAAAjAhCAAAAAAAAGBGEAAAAAAAAMCIIAQAAAAAAYEQQAgAAAAAAwIggBAAAAAAAgBFBCAAAAAAAACOCEAAAAAAAAEYEIQAAAAAAAIwIQgAAAAAAABgRhAAAAAAAADAiCAEAAAAAAGBEEAIAAAAAAMCIIAQAAAAAAIARQQgAAAAAAAAjghAAAAAAAABGBCEAAAAAAACMCEIAAAAAAAAYEYQAAAAAAAAwIggBAAAAAABgRBACAAAAAADAiCAEAAAAAACAEUEIAAAAAAAAI4IQAAAAAAAARgQhAAAAAAAAjAhCAAAAAAAAGBGEAAAAAAAAMCIIAQAAAAAAYEQQAgAAAAAAwIggBAAAAAAAgBFBCAAAAAAAACOCEAAAAAAAAEYEIQAAAAAAAIwIQgAAAAAAABgRhAAAAAAAADAiCAEAAAAAAGBEEAIAAAAAAMCIIAQAAAAAAIARQQgAAAAAAAAjghAAAAAAAABGBCEAAAAAAACMCEIAAAAAAAAYEYQAAAAAAAAwIggBAAAAAABgRBACAAAAAADAiCAEAAAAAACAEUEIAAAAAAAAI4IQAAAAAAAARgQhAAAAAAAAjAhCAAAAAAAAGBGEAAAAAAAAMCIIAQAAAAAAYEQQAgAAAAAAwIggBAAAAAAAgBFBCAAAAAAAACOCEAAAAAAAAEYEIQAAAAAAAIwIQgAAAAAAABgRhAAAAAAAADAiCAEAAAAAAGBEEAIAAAAAAMCIIAQAAAAAAIARQQgAAAAAAAAjghAAAAAAAABGBCEAAAAAAACMCEIAAAAAAAAYEYQAAAAAAAAwIggBAAAAAABgRBACAAAAAADAiCAEAAAAAACAEUEIAAAAAAAAI4IQAAAAAAAARgQhAAAAAAAAjAhCAAAAAAAAGBGEAAAAAAAAMCIIAQAAAAAAYEQQAgAAAAAAwIggBAAAAAAAgBFBCAAAAAAAACOCEAAAAAAAAEYEIQAAAAAAAIwIQgAAAAAAABgRhAAAAAAAADAiCAEAAAAAAGBEEAIAAAAAAMCIIAQAAAAAAIARQQgAAAAAAAAjghAAAAAAAABGBCEAAAAAAACMCEIAAAAAAAAYEYQAAAAAAAAwIggBAAAAAABgRBACAAAAAADAiCAEAAAAAACAEUEIAAAAAAAAI4IQAAAAAAAARgQhAAAAAAAAjAhCAAAAAAAAGBGEAAAAAAAAMCIIAQAAAAAAYEQQAgAAAAAAwIggBAAAAAAAgBFBCAAAAAAAACOCEAAAAAAAAEYEIQAAAAAAAIwIQgAAAAAAABgRhAAAAAAAADAiCAEAAAAAAGBEEAIAAAAAAMCIIAQAAAAAAIARQQgAAAAAAAAjghAAAAAAAABGBCEAAAAAAACMCEIAAAAAAAAYEYQAAAAAAAAwIggBAAAAAABgRBACAAAAAADAiCAEAAAAAACAEUEIAAAAAAAAI4IQAAAAAAAARgQhAAAAAAAAjAhCAAAAAAAAGBGEAAAAAAAAMCIIAQAAAAAAYEQQAgAAAAAAwIggBAAAAAAAgBFBCAAAAAAAACOCEAAAAAAAAEYEIQAAAAAAAIwIQgAAAAAAABgRhAAAAAAAADAiCAEAAAAAAGBEEAIAAAAAAMCIIAQAAAAAAIARQQgAAAAAAAAjghAAAAAAAABGBCEAAAAAAACMCEIAAAAAAAAYEYQAAAAAAAAwIggBAAAAAABgRBACAAAAAADAiCAEAAAAAACAEUEIAAAAAAAAI4IQAAAAAAAARgQhAAAAAAAAjAhCAAAAAAAAGBGEAAAAAAAAMCIIAQAAAAAAYEQQAgAAAAAAwIggBAAAAAAAgBFBCAAAAAAAACOCEAAAAAAAAEYEIQAAAAAAAIwIQgAAAAAAABgRhAAAAAAAADAiCAEAAAAAAGBEEAIAAAAAAMCIIAQAAAAAAIARQQgAAAAAAAAjghAAAAAAAABGBCEAAAAAAACMCEIAAAAAAAAYEYQAAAAAAAAwIggBAAAAAABgRBACAAAAAADAiCAEAAAAAACAEUEIAAAAAAAAI4IQAAAAAAAARgQhAAAAAAAAjAhCAAAAAAAAGBGEAAAAAAAAMCIIAQAAAAAAYEQQAgAAAAAAwIggBAAAAAAAgBFBCAAAAAAAACOCEAAAAAAAAEYEIQAAAAAAAIwIQgAAAAAAABgRhAAAAAAAADAiCAEAAAAAAGBEEAIAAAAAAMCIIAQAAAAAAIARQQgAAAAAAAAjghAAAAAAAABGBCEAAAAAAACMCEIAAAAAAAAYEYQAAAAAAAAwIggBAAAAAABgRBACAAAAAADASOotf98aH400AAAAAElFTkSuQmCC";

package/audioPlayerUtils/index.ts

@@ -0,0 +1,242 @@
+import * as React from "react";
+import { get, has } from "@applicaster/zapp-react-native-utils/utils";
+import { useZStore } from "@applicaster/zapp-react-native-utils/reactHooks";
+import { useRoute } from "@applicaster/zapp-react-native-utils/reactHooks/navigation";
+
+import { isNotEmptyString } from "@applicaster/zapp-react-native-utils/stringUtils";
+import { getMediaItems } from "@applicaster/zapp-react-native-utils/configurationUtils";
+
+import { DEFAULT_IMAGE } from "./assets";
+
+export function getImageFromEntry({
+  entry,
+  imageKey,
+}: {
+  entry: ZappEntry;
+  imageKey: Option<string>;
+}): Option<string> {
+  const mediaItems = getMediaItems(entry);
+
+  if (!mediaItems) {
+    return undefined;
+  }
+
+  // Find the media item with the matching key
+  const found = mediaItems.find((item) => item.key === imageKey);
+  const src = found?.src;
+
+  // Special case for react native - uri cannot be an empty string (yellow warning).
+  return isNotEmptyString(src) ? src : undefined;
+}
+
+const getPropertyFromExtensions = (
+  key: string,
+  entry: ZappEntry
+): Option<string> => entry?.extensions?.[key];
+
+const getPropertyFromConfiguration = (
+  key: string,
+  plugin_configuration: Record<string, any>
+) => plugin_configuration?.[key];
+
+type GetBackgroundImageParams = {
+  entry: ZappEntry;
+  plugin_configuration: Record<string, any>;
+};
+
+export const getBackgroundImage = ({
+  entry,
+  plugin_configuration,
+}: GetBackgroundImageParams): string => {
+  // 1) image_key from extensions
+  const imageKeyFromExtensions = getPropertyFromExtensions("image_key", entry);
+
+  const imageFromExtensions = getImageFromEntry({
+    entry,
+    imageKey: imageKeyFromExtensions,
+  });
+
+  if (imageFromExtensions) {
+    return imageFromExtensions;
+  }
+
+  // 2) audio_player_background_image from extensions(KAN case)
+  const audioPlayerBackgroundImageFromExtensions = getPropertyFromExtensions(
+    "audio_player_background_image",
+    entry
+  );
+
+  if (isNotEmptyString(audioPlayerBackgroundImageFromExtensions)) {
+    return audioPlayerBackgroundImageFromExtensions;
+  }
+
+  // 3) image_key from configuration
+  const imageKeyFromConfiguration = getPropertyFromConfiguration(
+    "audio_player_image_key",
+    plugin_configuration
+  );
+
+  const imageFromConfiguration = getImageFromEntry({
+    entry,
+    imageKey: imageKeyFromConfiguration,
+  });
+
+  if (imageFromConfiguration) {
+    return imageFromConfiguration;
+  }
+
+  // 4) audio_player_background_image from configuration
+  const audioPlayerBackgroundImageFromConfiguration =
+    getPropertyFromConfiguration(
+      "audio_player_background_image",
+      plugin_configuration
+    );
+
+  if (isNotEmptyString(audioPlayerBackgroundImageFromConfiguration)) {
+    return audioPlayerBackgroundImageFromConfiguration;
+  }
+
+  // default image
+  return DEFAULT_IMAGE;
+};
+
+type GetArtworkImageParams = {
+  key: string;
+  entry: ZappEntry;
+  plugin_configuration: Record<string, any>;
+};
+
+export const getArtworkImage = ({
+  key,
+  entry,
+  plugin_configuration,
+}: GetArtworkImageParams): string => {
+  // 1) image_key from extensions
+  const imageKeyFromExtensions = getPropertyFromExtensions(key, entry);
+
+  const imageFromExtensions = getImageFromEntry({
+    entry,
+    imageKey: imageKeyFromExtensions,
+  });
+
+  if (imageFromExtensions) {
+    return imageFromExtensions;
+  }
+
+  // 2) image_key from configuration
+  const imageKeyFromConfiguration = getPropertyFromConfiguration(
+    key,
+    plugin_configuration
+  );
+
+  const imageFromConfiguration = getImageFromEntry({
+    entry,
+    imageKey: imageKeyFromConfiguration,
+  });
+
+  if (imageFromConfiguration) {
+    return imageFromConfiguration;
+  }
+
+  // default image
+  return DEFAULT_IMAGE;
+};
+
+const useAdjustedKeyFromScreenData = ({ config, keys }) => {
+  const { screenData } = useRoute();
+
+  const adjustedConfig = { ...config };
+
+  keys.forEach((key) => {
+    const path = ["targetScreen", "styles", key];
+
+    if (has(screenData, path)) {
+      const value = get(screenData, path);
+
+      adjustedConfig[key] = value;
+    }
+  });
+
+  return adjustedConfig;
+};
+
+const AUDIO_PLAYER_ARTWORK_IMAGE_KEY = "audio_player_artwork_image_key";
+
+const audioPlayerArtworkImageKeySelector = (config) =>
+  config?.[AUDIO_PLAYER_ARTWORK_IMAGE_KEY];
+
+export const useArtworkImage = (entry: ZappEntry): string => {
+  const configuration = useZStore("playerConfiguration");
+
+  const audio_player_artwork_image_key_value = configuration(
+    audioPlayerArtworkImageKeySelector
+  );
+
+  const pluginConfiguration = React.useMemo(
+    () => ({
+      audio_player_artwork_image_key: audio_player_artwork_image_key_value,
+    }),
+    [audio_player_artwork_image_key_value]
+  );
+
+  // HACK: for override [key] from screenData, because we treat empty string value as missing key and replace it to initial_value from manifest(which is wrong)
+  const adjustedPluginConfiguration = useAdjustedKeyFromScreenData({
+    keys: [AUDIO_PLAYER_ARTWORK_IMAGE_KEY],
+    config: pluginConfiguration,
+  });
+
+  return React.useMemo(
+    () =>
+      getArtworkImage({
+        key: AUDIO_PLAYER_ARTWORK_IMAGE_KEY,
+        entry,
+        plugin_configuration: adjustedPluginConfiguration,
+      }),
+    []
+  );
+};
+
+const AUDIO_PLAYER_IMAGE_KEY = "audio_player_image_key";
+const AUDIO_PLAYER_BACKGROUND_IMAGE = "audio_player_background_image";
+
+const audioPlayerImageKeySelector = (config) =>
+  config?.[AUDIO_PLAYER_IMAGE_KEY];
+
+const audioPlayerBackgroundImageSelector = (config) =>
+  config?.[AUDIO_PLAYER_BACKGROUND_IMAGE];
+
+export const useBackgroundImage = (entry: ZappEntry): { uri: string } => {
+  const configuration = useZStore("playerConfiguration");
+
+  const audio_player_image_key_value = configuration(
+    audioPlayerImageKeySelector
+  );
+
+  const audio_player_background_image_value = configuration(
+    audioPlayerBackgroundImageSelector
+  );
+
+  const pluginConfiguration = React.useMemo(
+    () => ({
+      audio_player_image_key: audio_player_image_key_value,
+      audio_player_background_image: audio_player_background_image_value,
+    }),
+    [audio_player_image_key_value, audio_player_background_image_value]
+  );
+
+  // HACK: for override [key] from screenData, because we treat empty string value as missing key and replace it to initial_value from manifest(which is wrong)
+  const adjustedPluginConfiguration = useAdjustedKeyFromScreenData({
+    keys: [AUDIO_PLAYER_IMAGE_KEY, AUDIO_PLAYER_BACKGROUND_IMAGE],
+    config: pluginConfiguration,
+  });
+
+  return React.useMemo(
+    () => ({
+      uri: getBackgroundImage({
+        entry,
+        plugin_configuration: adjustedPluginConfiguration,
+      }),
+    }),
+    [entry, adjustedPluginConfiguration]
+  );
+};

package/cellUtils/index.ts

@@ -2,12 +2,16 @@ import * as R from "ramda";
 import dayjs from "dayjs";
 import validateColor from "validate-color";
 
+import { transformColorCode as fixColorHexCode } from "@applicaster/zapp-react-native-utils/transform";
+import {
+  capitalize,
+  isString,
+} from "@applicaster/zapp-react-native-utils/stringUtils";
+import { cellUtilsLogger } from "@applicaster/zapp-react-native-utils/cellUtils/logger";
+import { isWeb } from "@applicaster/zapp-react-native-utils/reactUtils";
+import { isNotNil } from "@applicaster/zapp-react-native-utils/reactUtils/helpers";
+
 import { toNumberWithDefault, toNumberWithDefaultZero } from "../numberUtils";
-import { transformColorCode as fixColorHexCode } from "../transform";
-import { capitalize, isString } from "../stringUtils";
-import { cellUtilsLogger } from "./logger";
-import { isWeb } from "../reactUtils";
-import { isNotNil } from "../reactUtils/helpers";
 
 const CUSTOM_KEY = "other";
 

package/componentsUtils/__tests__/isFirstComponentGallery.test.ts

@@ -0,0 +1,33 @@
+import { isFirstComponentGallery } from "../index";
+
+describe("isFirstComponentGallery", () => {
+  it("should return true if the first component is a gallery", () => {
+    const components = [
+      { component_type: "gallery-qb" },
+      { component_type: "other-component" },
+    ];
+
+    expect(isFirstComponentGallery(components)).toBe(true);
+  });
+
+  it("should return false if the first component is not a gallery", () => {
+    const components = [
+      { component_type: "other-component" },
+      { component_type: "gallery-qb" },
+    ];
+
+    expect(isFirstComponentGallery(components)).toBe(false);
+  });
+
+  it("should return false if the components array is empty", () => {
+    const components = [];
+
+    expect(isFirstComponentGallery(components)).toBe(false);
+  });
+
+  it("should return false if the components array is undefined", () => {
+    const components = undefined;
+
+    expect(isFirstComponentGallery(components)).toBe(false);
+  });
+});

package/componentsUtils/__tests__/isFirstComponentScreenPicker.test.ts

@@ -0,0 +1,33 @@
+import { isFirstComponentScreenPicker } from "..";
+
+describe("isFirstComponentScreenPicker", () => {
+  it("should return true if the first component screen-picker", () => {
+    const items = [{ component_type: "screen-picker-qb-tv" }];
+    expect(isFirstComponentScreenPicker(items)).toBe(true);
+  });
+
+  it("should return false if the first component type is not screen-picker", () => {
+    const items = [{ component_type: "other-component" }];
+    expect(isFirstComponentScreenPicker(items)).toBe(false);
+  });
+
+  it("should return false if the component type is undefined", () => {
+    const items = [{ component_type: undefined }];
+    expect(isFirstComponentScreenPicker(items)).toBe(false);
+  });
+
+  it("should return false if the item is null", () => {
+    const items = null;
+    expect(isFirstComponentScreenPicker(items)).toBe(false);
+  });
+
+  it("should return false if the item is undefined", () => {
+    const items = undefined;
+    expect(isFirstComponentScreenPicker(items)).toBe(false);
+  });
+
+  it("should return false if the item is an empty object", () => {
+    const items = {};
+    expect(isFirstComponentScreenPicker(items)).toBe(false);
+  });
+});

package/componentsUtils/__tests__/isGallery.test.ts

@@ -0,0 +1,33 @@
+import { isGallery } from "..";
+
+describe("isGallery", () => {
+  it("should return true if the component type is 'gallery-qb'", () => {
+    const item = { component_type: "gallery-qb" };
+    expect(isGallery(item)).toBe(true);
+  });
+
+  it("should return false if the component type is not 'gallery-qb'", () => {
+    const item = { component_type: "other-component" };
+    expect(isGallery(item)).toBe(false);
+  });
+
+  it("should return false if the component type is undefined", () => {
+    const item = { component_type: undefined };
+    expect(isGallery(item)).toBe(false);
+  });
+
+  it("should return false if the item is null", () => {
+    const item = null;
+    expect(isGallery(item)).toBe(false);
+  });
+
+  it("should return false if the item is undefined", () => {
+    const item = undefined;
+    expect(isGallery(item)).toBe(false);
+  });
+
+  it("should return false if the item is an empty object", () => {
+    const item = {};
+    expect(isGallery(item)).toBe(false);
+  });
+});

package/componentsUtils/__tests__/isScreenPicker.test.ts

@@ -0,0 +1,33 @@
+import { isScreenPicker } from "..";
+
+describe("isScreenPicker", () => {
+  it("should return true if the component type is 'screen-picker-qb-tv'", () => {
+    const item = { component_type: "screen-picker-qb-tv" };
+    expect(isScreenPicker(item)).toBe(true);
+  });
+
+  it("should return false if the component type is not 'screen-picker-qb-tv'", () => {
+    const item = { component_type: "other-component" };
+    expect(isScreenPicker(item)).toBe(false);
+  });
+
+  it("should return false if the component type is undefined", () => {
+    const item = { component_type: undefined };
+    expect(isScreenPicker(item)).toBe(false);
+  });
+
+  it("should return false if the item is null", () => {
+    const item = null;
+    expect(isScreenPicker(item)).toBe(false);
+  });
+
+  it("should return false if the item is undefined", () => {
+    const item = undefined;
+    expect(isScreenPicker(item)).toBe(false);
+  });
+
+  it("should return false if the item is an empty object", () => {
+    const item = {};
+    expect(isScreenPicker(item)).toBe(false);
+  });
+});

package/componentsUtils/index.ts

@@ -0,0 +1,39 @@
+const GROUP = "group-qb";
+const GROUP_INFO = "group-info-qb";
+const GROUP_INFO_OLD = "group-info";
+const EMPTY_GROUP_COMPONENT = "empty_group_component";
+
+const GALLERY = "gallery-qb";
+
+const SCREEN_PICKER = "screen-picker-qb-tv";
+
+const HORIZONTAL_LIST = "horizontal_list_qb";
+
+export const isGallery = (item): boolean => item?.component_type === GALLERY;
+
+export const isHorizontalList = (item): boolean =>
+  item?.component_type === HORIZONTAL_LIST;
+
+export const isScreenPicker = (item): boolean =>
+  item?.component_type === SCREEN_PICKER;
+
+export const isFirstComponentScreenPicker = (
+  components: ZappUIComponent[]
+): boolean => {
+  return isScreenPicker(components?.[0]);
+};
+
+export const isFirstComponentGallery = (
+  components: ZappUIComponent[]
+): boolean => {
+  return isGallery(components?.[0]);
+};
+
+export const isGroup = (item): boolean => item?.component_type === GROUP;
+
+export const isEmptyGroup = (item): boolean =>
+  item?.component_type === EMPTY_GROUP_COMPONENT;
+
+export const isGroupInfo = (item): boolean =>
+  item?.component_type === GROUP_INFO ||
+  item?.component_type === GROUP_INFO_OLD;