@applicaster/zapp-react-native-utils 16.0.0-alpha.1110044191 → 16.0.0-alpha.1110245265

package/playerUtils/__tests__/contentDataKeys.test.ts

@@ -0,0 +1,297 @@
+import {
+  resolvePlayerContentText,
+  VIDEO_PLAYER_CONTENT_DATA_KEYS,
+  AUDIO_PLAYER_CONTENT_DATA_KEYS,
+  createConfigValueGetter,
+} from "../contentDataKeys";
+
+const entry = {
+  id: "1",
+  type: { value: "audio" },
+  title: "Default Title",
+  summary: "Default Summary",
+  extensions: {
+    episode_name: "Custom Episode",
+    episode_subtitle: "Custom Subtitle",
+    blank: "",
+    show: { name: "Nested Show Name" },
+    genres: ["Drama", "Comedy"],
+    rating: 0,
+    is_featured: true,
+  },
+} as unknown as ZappEntry;
+
+const valueFrom =
+  (config: Record<string, unknown>): GetValue =>
+  (key: string) =>
+    (config[key] ?? null) as never;
+
+const resolveTitle = (config: Record<string, unknown>, target = entry) =>
+  resolvePlayerContentText({
+    entry: target,
+    field: "title",
+    value: valueFrom(config),
+  });
+
+const resolveSubtitle = (config: Record<string, unknown>, target = entry) =>
+  resolvePlayerContentText({
+    entry: target,
+    field: "subtitle",
+    value: valueFrom(config),
+  });
+
+describe("resolvePlayerContentText", () => {
+  describe("backward compatibility", () => {
+    it("returns entry.title when no configuration is stored", () => {
+      expect(resolveTitle({})).toBe("Default Title");
+    });
+
+    it("returns entry.summary when no configuration is stored", () => {
+      expect(resolveSubtitle({})).toBe("Default Summary");
+    });
+
+    it("returns the defaults when the source is explicitly the default option", () => {
+      expect(
+        resolveTitle({
+          title_data_key_source: "title",
+          title_custom_data_key: "extensions.episode_name",
+        })
+      ).toBe("Default Title");
+
+      expect(
+        resolveSubtitle({
+          subtitle_data_key_source: "summary",
+          subtitle_custom_data_key: "extensions.episode_subtitle",
+        })
+      ).toBe("Default Summary");
+    });
+  });
+
+  describe("custom data key", () => {
+    it("resolves a dot path on the entry for the title", () => {
+      expect(
+        resolveTitle({
+          title_data_key_source: "other",
+          title_custom_data_key: "extensions.episode_name",
+        })
+      ).toBe("Custom Episode");
+    });
+
+    it("resolves a dot path on the entry for the subtitle", () => {
+      expect(
+        resolveSubtitle({
+          subtitle_data_key_source: "other",
+          subtitle_custom_data_key: "extensions.episode_subtitle",
+        })
+      ).toBe("Custom Subtitle");
+    });
+
+    it("resolves a nested dot path", () => {
+      expect(
+        resolveTitle({
+          title_data_key_source: "other",
+          title_custom_data_key: "extensions.show.name",
+        })
+      ).toBe("Nested Show Name");
+    });
+
+    it("resolves a top level entry key", () => {
+      expect(
+        resolveTitle({
+          title_data_key_source: "other",
+          title_custom_data_key: "summary",
+        })
+      ).toBe("Default Summary");
+    });
+
+    it("trims surrounding whitespace from the configured key", () => {
+      expect(
+        resolveTitle({
+          title_data_key_source: "other",
+          title_custom_data_key: "  extensions.episode_name  ",
+        })
+      ).toBe("Custom Episode");
+    });
+  });
+
+  describe("fallbacks", () => {
+    it("falls back to the default when the custom key is empty", () => {
+      expect(
+        resolveTitle({
+          title_data_key_source: "other",
+          title_custom_data_key: "",
+        })
+      ).toBe("Default Title");
+    });
+
+    it("falls back to the default when the custom key is whitespace only", () => {
+      expect(
+        resolveTitle({
+          title_data_key_source: "other",
+          title_custom_data_key: "   ",
+        })
+      ).toBe("Default Title");
+    });
+
+    it("falls back to the default when the custom key does not resolve", () => {
+      expect(
+        resolveTitle({
+          title_data_key_source: "other",
+          title_custom_data_key: "extensions.does_not_exist",
+        })
+      ).toBe("Default Title");
+    });
+
+    it("falls back to the default when the custom key resolves to an empty string", () => {
+      expect(
+        resolveTitle({
+          title_data_key_source: "other",
+          title_custom_data_key: "extensions.blank",
+        })
+      ).toBe("Default Title");
+    });
+
+    // The Studio field is free text, so a customer can easily stop one
+    // segment short (`extensions.show` rather than `extensions.show.name`)
+    // or aim the key at a list field. Rendering those would throw
+    // "Objects are not valid as a React child" and red-screen every screen
+    // containing the player.
+    it("falls back to the default when the custom key resolves to an object", () => {
+      expect(
+        resolveTitle({
+          title_data_key_source: "other",
+          title_custom_data_key: "extensions.show",
+        })
+      ).toBe("Default Title");
+    });
+
+    it("falls back to the default when the custom key resolves to an array", () => {
+      expect(
+        resolveSubtitle({
+          subtitle_data_key_source: "other",
+          subtitle_custom_data_key: "extensions.genres",
+        })
+      ).toBe("Default Summary");
+    });
+
+    it("falls back to the default when the custom key resolves to a boolean", () => {
+      expect(
+        resolveTitle({
+          title_data_key_source: "other",
+          title_custom_data_key: "extensions.is_featured",
+        })
+      ).toBe("Default Title");
+    });
+
+    // Numbers are renderable, so the guard above must not swallow them -
+    // including 0, which is falsy but perfectly displayable.
+    it("returns a numeric custom value rather than falling back", () => {
+      expect(
+        resolveTitle({
+          title_data_key_source: "other",
+          title_custom_data_key: "extensions.rating",
+        })
+      ).toBe(0);
+    });
+  });
+
+  describe("missing entry", () => {
+    it("returns undefined without throwing when the entry is undefined", () => {
+      expect(
+        resolvePlayerContentText({
+          entry: undefined,
+          field: "title",
+          value: valueFrom({}),
+        })
+      ).toBeUndefined();
+    });
+
+    it("returns undefined without throwing when a custom key is set", () => {
+      expect(
+        resolvePlayerContentText({
+          entry: undefined,
+          field: "title",
+          value: valueFrom({
+            title_data_key_source: "other",
+            title_custom_data_key: "extensions.episode_name",
+          }),
+        })
+      ).toBeUndefined();
+    });
+  });
+});
+
+describe("custom data key sets", () => {
+  it("reads the TV video keys when given that key set", () => {
+    const value = createConfigValueGetter({
+      video_player_title_data_key_source: "other",
+      video_player_title_custom_data_key: "extensions.episode_name",
+    });
+
+    expect(
+      resolvePlayerContentText({
+        entry,
+        field: "title",
+        value,
+        dataKeys: VIDEO_PLAYER_CONTENT_DATA_KEYS,
+      })
+    ).toBe("Custom Episode");
+  });
+
+  it("reads the TV audio keys when given that key set", () => {
+    const value = createConfigValueGetter({
+      audio_player_summary_data_key_source: "other",
+      audio_player_summary_custom_data_key: "extensions.episode_subtitle",
+    });
+
+    expect(
+      resolvePlayerContentText({
+        entry,
+        field: "subtitle",
+        value,
+        dataKeys: AUDIO_PLAYER_CONTENT_DATA_KEYS,
+      })
+    ).toBe("Custom Subtitle");
+  });
+
+  it("ignores the mobile keys when a TV key set is supplied", () => {
+    const value = createConfigValueGetter({
+      title_data_key_source: "other",
+      title_custom_data_key: "extensions.episode_name",
+    });
+
+    expect(
+      resolvePlayerContentText({
+        entry,
+        field: "title",
+        value,
+        dataKeys: VIDEO_PLAYER_CONTENT_DATA_KEYS,
+      })
+    ).toBe("Default Title");
+  });
+
+  it("defaults to the mobile key set when dataKeys is omitted", () => {
+    const value = createConfigValueGetter({
+      title_data_key_source: "other",
+      title_custom_data_key: "extensions.episode_name",
+    });
+
+    expect(resolvePlayerContentText({ entry, field: "title", value })).toBe(
+      "Custom Episode"
+    );
+  });
+});
+
+describe("createConfigValueGetter", () => {
+  it("returns null for a missing key", () => {
+    expect(createConfigValueGetter({})("anything")).toBeNull();
+  });
+
+  it("returns null for an undefined configuration", () => {
+    expect(createConfigValueGetter(undefined)("anything")).toBeNull();
+  });
+
+  it("returns the stored value", () => {
+    expect(createConfigValueGetter({ a: "b" })("a")).toBe("b");
+  });
+});

package/playerUtils/__tests__/getPlayerActionButtons.test.ts

@@ -1,5 +1,9 @@
-import { getPlayerActionButtons } from "../getPlayerActionButtons";
+import {
+  getPlayerActionButtons,
+  parsePlayerActionIdentifiers,
+} from "../getPlayerActionButtons";
 import { selectActionButtons } from "../../conf/player/selectors";
+import { uiActionsRegistry } from "../../uiActionsRegistrator";
 
 jest.mock("../../conf/player/selectors", () => ({
   selectActionButtons: jest.fn(),
@@ -12,43 +16,126 @@ describe("getPlayerActionButtons", () => {
 
   it("returns an empty array if selectActionButtons returns undefined", () => {
     (selectActionButtons as jest.Mock).mockReturnValue(undefined);
-    const result = getPlayerActionButtons({});
+    const result = getPlayerActionButtons({ configuration: {} });
     expect(result).toEqual([]);
   });
 
   it("returns an empty array if selectActionButtons returns null", () => {
     (selectActionButtons as jest.Mock).mockReturnValue(null);
-    const result = getPlayerActionButtons({});
+    const result = getPlayerActionButtons({ configuration: {} });
     expect(result).toEqual([]);
   });
 
   it("returns an empty array if selectActionButtons returns empty string", () => {
     (selectActionButtons as jest.Mock).mockReturnValue("");
-    const result = getPlayerActionButtons({});
+    const result = getPlayerActionButtons({ configuration: {} });
     expect(result).toEqual([]);
   });
 
   it("returns the first two trimmed action buttons", () => {
     (selectActionButtons as jest.Mock).mockReturnValue(" play , pause , stop ");
-    const result = getPlayerActionButtons({});
+    const result = getPlayerActionButtons({ configuration: {} });
     expect(result).toEqual(["play", "pause"]);
   });
 
   it("returns only one button if only one is present", () => {
     (selectActionButtons as jest.Mock).mockReturnValue(" play ");
-    const result = getPlayerActionButtons({});
+    const result = getPlayerActionButtons({ configuration: {} });
     expect(result).toEqual(["play"]);
   });
 
   it("trims whitespace from button names", () => {
     (selectActionButtons as jest.Mock).mockReturnValue("  play  ,   pause  ");
-    const result = getPlayerActionButtons({});
+    const result = getPlayerActionButtons({ configuration: {} });
     expect(result).toEqual(["play", "pause"]);
   });
 
   it("returns an empty array if selectActionButtons returns only commas", () => {
     (selectActionButtons as jest.Mock).mockReturnValue(" , , ");
-    const result = getPlayerActionButtons({});
+    const result = getPlayerActionButtons({ configuration: {} });
     expect(result).toEqual(["", ""]);
   });
 });
+
+const action = (identifier: string) =>
+  ({ identifier, action: { invokeAction: jest.fn() } }) as any;
+
+describe("getPlayerActionButtons with entry", () => {
+  const entry = {
+    id: "e1",
+    extensions: {
+      entry_action: [
+        { button: { alias: "add_to_playlist" }, actions: [{ type: "test" }] },
+        { button: { alias: "add_to_queue" }, actions: [{ type: "test" }] },
+      ],
+    },
+  };
+
+  beforeEach(() => {
+    jest.spyOn(uiActionsRegistry, "getActions").mockImplementation((name) => {
+      if (name === "entry_actions") {
+        return [action("entry_action_0"), action("entry_action_1")];
+      }
+
+      return [action(name)];
+    });
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it("resolves entry_actions via the registry and keeps plugin identifiers in order", () => {
+    (selectActionButtons as jest.Mock).mockReturnValue(
+      "entry_actions,local_storage_favourites_action,offline-content-button"
+    );
+
+    const result = getPlayerActionButtons({ configuration: {}, entry });
+
+    expect(uiActionsRegistry.getActions).toHaveBeenCalledWith(
+      "entry_actions",
+      entry
+    );
+
+    expect(result.map((item) => item.identifier)).toEqual([
+      "entry_action_0",
+      "entry_action_1",
+      "local_storage_favourites_action",
+      "offline-content-button",
+    ]);
+  });
+
+  it("does not cap the resolved list at two items", () => {
+    (selectActionButtons as jest.Mock).mockReturnValue("a,b,c");
+
+    expect(
+      getPlayerActionButtons({ configuration: {}, entry }).map(
+        (item) => item.identifier
+      )
+    ).toEqual(["a", "b", "c"]);
+  });
+
+  it("excludes the overflow identifier from the resolved list", () => {
+    (selectActionButtons as jest.Mock).mockReturnValue(
+      "open-modal-bottom-sheet-cell-action,local_storage_favourites_action"
+    );
+
+    expect(
+      getPlayerActionButtons({ configuration: {}, entry }).map(
+        (item) => item.identifier
+      )
+    ).toEqual(["local_storage_favourites_action"]);
+  });
+});
+
+describe("parsePlayerActionIdentifiers", () => {
+  it("trims and drops empty tokens", () => {
+    expect(parsePlayerActionIdentifiers(" A , , B , C ")).toEqual([
+      "A",
+      "B",
+      "C",
+    ]);
+
+    expect(parsePlayerActionIdentifiers(null)).toEqual([]);
+  });
+});

package/playerUtils/__tests__/resolveActionIdentifiers.test.ts

@@ -0,0 +1,96 @@
+import {
+  parseActionIdentifiers,
+  resolveActionIdentifiers,
+} from "../resolveActionIdentifiers";
+import { uiActionsRegistry } from "../../uiActionsRegistrator";
+
+const action = (identifier: string) =>
+  ({ identifier, action: { invokeAction: jest.fn() } }) as any;
+
+describe("parseActionIdentifiers", () => {
+  it("parses comma-separated identifiers", () => {
+    expect(parseActionIdentifiers(" a, b , ,c ")).toEqual(["a", "b", "c"]);
+  });
+
+  it("parses identifier arrays", () => {
+    expect(parseActionIdentifiers([" a ", "", "b", "  ", "c"])).toEqual([
+      "a",
+      "b",
+      "c",
+    ]);
+  });
+
+  it("returns empty array for nil config", () => {
+    expect(parseActionIdentifiers(null)).toEqual([]);
+    expect(parseActionIdentifiers(undefined)).toEqual([]);
+  });
+});
+
+describe("resolveActionIdentifiers", () => {
+  const entry = { id: "entry-1" } as any;
+
+  beforeEach(() => {
+    jest
+      .spyOn(uiActionsRegistry, "getActions")
+      .mockImplementation((identifier) => [action(identifier)] as any);
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it("resolves through registry by default", () => {
+    const result = resolveActionIdentifiers({
+      identifiers: "favorites,share",
+      entry,
+    });
+
+    expect(result.map((item) => item.identifier)).toEqual([
+      "favorites",
+      "share",
+    ]);
+
+    expect(uiActionsRegistry.getActions).toHaveBeenCalledWith(
+      "favorites",
+      entry
+    );
+
+    expect(uiActionsRegistry.getActions).toHaveBeenCalledWith("share", entry);
+  });
+
+  it("uses local resolver when provided", () => {
+    const result = resolveActionIdentifiers({
+      identifiers: "entry_actions,favorites",
+      entry,
+      localResolvers: {
+        entry_actions: () => [
+          action("entry_action_0"),
+          action("entry_action_1"),
+        ],
+      },
+    });
+
+    expect(result.map((item) => item.identifier)).toEqual([
+      "entry_action_0",
+      "entry_action_1",
+      "favorites",
+    ]);
+
+    expect(uiActionsRegistry.getActions).toHaveBeenCalledTimes(1);
+
+    expect(uiActionsRegistry.getActions).toHaveBeenCalledWith(
+      "favorites",
+      entry
+    );
+  });
+
+  it("applies includeIdentifier filter before resolving", () => {
+    const result = resolveActionIdentifiers({
+      identifiers: "a,b,c",
+      entry,
+      includeIdentifier: (identifier) => identifier !== "b",
+    });
+
+    expect(result.map((item) => item.identifier)).toEqual(["a", "c"]);
+  });
+});