@applicaster/zapp-react-native-utils 16.0.0-alpha.5652127751 → 16.0.0-alpha.5803191443

package/actionUtils/__tests__/index.test.ts

@@ -0,0 +1,65 @@
+import {
+  resolveAssets,
+  resolveConfiguredAsset,
+} from "@applicaster/zapp-react-native-utils/actionUtils";
+
+describe("actionUtils", () => {
+  describe("resolveConfiguredAsset", () => {
+    it("returns configured asset when value is a non-empty string", () => {
+      expect(resolveConfiguredAsset("configured", "fallback")).toBe(
+        "configured"
+      );
+
+      expect(
+        resolveConfiguredAsset("https://example.com/icon.png", "fallback")
+      ).toBe("https://example.com/icon.png");
+    });
+
+    it("returns fallback when configured asset is empty or undefined", () => {
+      expect(resolveConfiguredAsset("", "fallback")).toBe("fallback");
+      expect(resolveConfiguredAsset(" ", "fallback")).toBe("fallback");
+      expect(resolveConfiguredAsset("   ", "fallback")).toBe("fallback");
+      expect(resolveConfiguredAsset(undefined, "fallback")).toBe("fallback");
+    });
+
+    it("returns fallback for non-string configured asset values", () => {
+      expect(resolveConfiguredAsset(null as any, "fallback")).toBe("fallback");
+      expect(resolveConfiguredAsset(123 as any, "fallback")).toBe("fallback");
+      expect(resolveConfiguredAsset({} as any, "fallback")).toBe("fallback");
+    });
+  });
+
+  describe("resolveAssets", () => {
+    it("returns configured assets when both flavour values are configured", () => {
+      expect(
+        resolveAssets("asset-1", "asset-2", ["default-1", "default-2"])
+      ).toEqual(["asset-1", "asset-2"]);
+    });
+
+    it("falls back to code defaults when configured flavour values are empty", () => {
+      expect(resolveAssets("", undefined, ["default-1", "default-2"])).toEqual([
+        "default-1",
+        "default-2",
+      ]);
+    });
+
+    it("falls back per flavour independently", () => {
+      expect(resolveAssets("", "asset-2", ["default-1", "default-2"])).toEqual([
+        "default-1",
+        "asset-2",
+      ]);
+    });
+
+    it("uses the cell fallback before code defaults", () => {
+      expect(
+        resolveAssets("", undefined, ["default-1", "default-2"], "cell")
+      ).toEqual(["cell", "cell"]);
+    });
+
+    it("preserves configured assets before using the cell fallback", () => {
+      expect(
+        resolveAssets("asset-1", "", ["default-1", "default-2"], "cell")
+      ).toEqual(["asset-1", "cell"]);
+    });
+  });
+});

package/actionUtils/index.ts

@@ -1,7 +1,30 @@
 import { Image } from "react-native";
 import { isTV } from "../reactUtils";
 
+export type Asset = [string, string] | [string];
+
 export const resolveDefaultAssetUri = (source: string | number): string =>
   isTV()
     ? (source as string)
     : Image.resolveAssetSource(source as number)?.uri || "";
+
+const isConfiguredAsset = (asset?: string | null): asset is string =>
+  typeof asset === "string" && asset.trim().length > 0;
+
+export const resolveConfiguredAsset = (
+  configuredAsset: string | undefined,
+  fallbackAsset: string
+): string =>
+  isConfiguredAsset(configuredAsset) ? configuredAsset : fallbackAsset;
+
+/** Resolves assets in the following order: configured asset(can be empty), fallback asset(cell asset, can be empty), default asset */
+export const resolveAssets = <T extends Asset>(
+  flavour1Asset: string | undefined,
+  flavour2Asset: string | undefined,
+  defaultAssets: T,
+  fallbackAssetSrc?: string
+): T =>
+  [
+    resolveConfiguredAsset(flavour1Asset, fallbackAssetSrc || defaultAssets[0]),
+    resolveConfiguredAsset(flavour2Asset, fallbackAssetSrc || defaultAssets[1]),
+  ] as T;

package/appUtils/playerManager/playerFactory.ts

@@ -19,35 +19,52 @@ type PlayerFactoryProps = {
   playerRole: PlayerRole;
 };
 
-interface PlayerControllerConstructor {
+interface PlayerConstructor {
   new (params: any): Player;
 }
 
-type PlayerProtocol = {
-  Component: any;
-  controllerClass: PlayerControllerConstructor;
-};
-
-export const playerFactory = async (
+export const playerFactory = (
   config: PlayerFactoryProps
-): Promise<PlayerFactoryItem | null> => {
-  if (!config?.playerPluginId) return null;
+): PlayerFactoryItem | null => {
+  const IDENTIFIER = config?.playerPluginId;
+
+  if (!IDENTIFIER) {
+    return null;
+  }
 
   const plugins = appStore.get("plugins");
-  if (!plugins) return null;
 
-  const playerPlugin = findPluginByIdentifier(config.playerPluginId, plugins);
-  if (!playerPlugin?.module?.playerProtocol) return null;
+  if (!plugins) {
+    return null;
+  }
+
+  const playerPlugin = findPluginByIdentifier(IDENTIFIER, plugins);
 
-  const playerProtocol: PlayerProtocol | null =
-    await playerPlugin.module.playerProtocol(config.screenConfig, config.entry);
+  if (!playerPlugin?.module?.playerProtocol) {
+    return null;
+  }
+
+  const playerProtocol: PlayerConstructor = playerPlugin.module.playerProtocol(
+    config?.screenConfig,
+    config?.entry
+  );
 
-  if (!playerProtocol?.Component || !playerProtocol.controllerClass) {
+  const playerView = (playerProtocol as any)?.Component || null;
+
+  if (!playerView) {
     return null;
   }
 
+  const Controller = (playerProtocol as any)?.controllerClass || null;
+
+  if (Controller === null) {
+    return null;
+  }
+
+  const controller = new Controller(config);
+
   return {
-    controller: new playerProtocol.controllerClass(config),
-    Component: playerProtocol.Component,
+    controller,
+    Component: playerView,
   };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applicaster/zapp-react-native-utils",
-  "version": "16.0.0-alpha.5652127751",
+  "version": "16.0.0-alpha.5803191443",
   "description": "Applicaster Zapp React Native utilities package",
   "main": "index.js",
   "types": "index.d.ts",
@@ -27,7 +27,7 @@
   },
   "homepage": "https://github.com/applicaster/quickbrick#readme",
   "dependencies": {
-    "@applicaster/applicaster-types": "16.0.0-alpha.5652127751",
+    "@applicaster/applicaster-types": "16.0.0-alpha.5803191443",
     "buffer": "^5.2.1",
     "camelize": "^1.0.0",
     "dayjs": "^1.11.10",

package/appUtils/playerManager/__tests__/playerFactory.test.ts

@@ -1,150 +0,0 @@
-const mockAppStoreGet = jest.fn();
-const mockFindPluginByIdentifier = jest.fn();
-
-jest.mock("@applicaster/zapp-react-native-redux/AppStore", () => ({
-  appStore: { get: (key: string) => mockAppStoreGet(key) },
-}));
-
-jest.mock("@applicaster/zapp-react-native-utils/pluginUtils", () => ({
-  findPluginByIdentifier: (id: string, plugins: any) =>
-    mockFindPluginByIdentifier(id, plugins),
-}));
-
-import { PlayerRole } from "../conts";
-import { playerFactory } from "../playerFactory";
-
-const fakeComponent = () => null;
-
-class FakeController {
-  receivedConfig: any;
-  constructor(config: any) {
-    this.receivedConfig = config;
-  }
-}
-
-const baseConfig = {
-  player: {},
-  playerId: "p1",
-  autoplay: false,
-  entry: { id: "entry-1" } as any,
-  muted: false,
-  playerPluginId: "test-plugin",
-  screenConfig: { foo: "bar" },
-  playerRole: PlayerRole.Cell,
-};
-
-const installPluginWithProtocol = (
-  protocolReturn: any | ((screenConfig: any, entry: any) => any)
-) => {
-  const playerProtocol =
-    typeof protocolReturn === "function"
-      ? protocolReturn
-      : () => protocolReturn;
-
-  mockAppStoreGet.mockImplementation((key: string) =>
-    key === "plugins" ? { "test-plugin": {} } : null
-  );
-
-  mockFindPluginByIdentifier.mockReturnValue({
-    module: { playerProtocol },
-  });
-};
-
-describe("playerFactory", () => {
-  beforeEach(() => {
-    mockAppStoreGet.mockReset();
-    mockFindPluginByIdentifier.mockReset();
-  });
-
-  it("resolves with controller and Component when playerProtocol returns synchronously", async () => {
-    installPluginWithProtocol({
-      Component: fakeComponent,
-      controllerClass: FakeController,
-    });
-
-    const item = await playerFactory(baseConfig);
-
-    expect(item).not.toBeNull();
-    expect(item?.Component).toBe(fakeComponent);
-    expect(item?.controller).toBeInstanceOf(FakeController);
-
-    expect((item?.controller as FakeController).receivedConfig).toBe(
-      baseConfig
-    );
-  });
-
-  it("resolves with controller and Component when playerProtocol returns a Promise (delayed import)", async () => {
-    installPluginWithProtocol(async () => ({
-      Component: fakeComponent,
-      controllerClass: FakeController,
-    }));
-
-    const item = await playerFactory(baseConfig);
-
-    expect(item).not.toBeNull();
-    expect(item?.Component).toBe(fakeComponent);
-    expect(item?.controller).toBeInstanceOf(FakeController);
-  });
-
-  it("passes screenConfig and entry through to playerProtocol", async () => {
-    const playerProtocol = jest.fn(() => ({
-      Component: fakeComponent,
-      controllerClass: FakeController,
-    }));
-
-    mockAppStoreGet.mockImplementation((key: string) =>
-      key === "plugins" ? { "test-plugin": {} } : null
-    );
-
-    mockFindPluginByIdentifier.mockReturnValue({ module: { playerProtocol } });
-
-    await playerFactory(baseConfig);
-
-    expect(playerProtocol).toHaveBeenCalledWith(
-      baseConfig.screenConfig,
-      baseConfig.entry
-    );
-  });
-
-  it("resolves to null when playerPluginId is missing", async () => {
-    expect(
-      await playerFactory({ ...baseConfig, playerPluginId: "" } as any)
-    ).toBeNull();
-  });
-
-  it("resolves to null when appStore has no plugins", async () => {
-    mockAppStoreGet.mockReturnValue(null);
-
-    expect(await playerFactory(baseConfig)).toBeNull();
-  });
-
-  it("resolves to null when the plugin has no playerProtocol", async () => {
-    mockAppStoreGet.mockImplementation((key: string) =>
-      key === "plugins" ? { "test-plugin": {} } : null
-    );
-
-    mockFindPluginByIdentifier.mockReturnValue({ module: {} });
-
-    expect(await playerFactory(baseConfig)).toBeNull();
-  });
-
-  it("resolves to null when playerProtocol returns without a Component", async () => {
-    installPluginWithProtocol({ controllerClass: FakeController });
-
-    expect(await playerFactory(baseConfig)).toBeNull();
-  });
-
-  it("resolves to null when playerProtocol returns without a controllerClass", async () => {
-    installPluginWithProtocol({ Component: fakeComponent });
-
-    expect(await playerFactory(baseConfig)).toBeNull();
-  });
-
-  it("rejects when playerProtocol throws synchronously", async () => {
-    installPluginWithProtocol(() => {
-      throw new Error("boom");
-    });
-
-    await expect(playerFactory(baseConfig)).rejects.toThrow("boom");
-  });
-});