@applicaster/zapp-react-native-utils 14.0.0-alpha.1054425138 → 14.0.0-alpha.1216545755

package/actionsExecutor/ActionExecutorContext.tsx

@@ -36,7 +36,6 @@ import {
   sessionStorageToggleFlag,
 } from "./StorageActions";
 
-import { ScreenSingleValueProvider } from "@applicaster/zapp-react-native-bridge/ZappStorage/ScreenSingleValueProvider";
 import { screenSetVariable, screenToggleFlag } from "./ScreenActions";
 
 export const { log_error, log_info, log_debug } = createLogger({
@@ -169,8 +168,7 @@ const prepareDefaultActions = (actionExecutor) => {
 
       const entry = context?.entry || {};
       const entryResolver = new EntryResolver(entry);
-      const route = context.screenRoute;
-      const screenData = ScreenSingleValueProvider.getState(route) as any;
+      const screenData = context?.screenStateStore.getState().data || {};
       const screenResolver = new EntryResolver(screenData || {});
 
       const data =
@@ -253,9 +251,11 @@ const prepareDefaultActions = (actionExecutor) => {
       context?: Record<string, any>
     ): Promise<ActionResult> => {
       const screenRoute = context?.screenRoute;
+      const screenStateStore = context?.screenStateStore;
 
       await screenToggleFlag(
         screenRoute,
+        screenStateStore,
         { entry: context?.entry, options: action.options },
         action
       );

package/actionsExecutor/ScreenActions.ts

@@ -4,8 +4,8 @@ import { log_error, log_info } from "./ActionExecutorContext";
 import { ActionResult } from "./ActionExecutor";
 import { get } from "lodash";
 
-import { ScreenMultiSelectProvider } from "@applicaster/zapp-react-native-bridge/ZappStorage/ScreenStateMultiSelectProvider";
 import { onMaxTagsReached } from "./StorageActions";
+import { ScreenMultiSelectProvider } from "../storage/ScreenStateMultiSelectProvider";
 
 export const screenSetVariable = (
   _screenRoute: string,
@@ -15,11 +15,12 @@ export const screenSetVariable = (
 
 export const screenToggleFlag = async (
   screenRoute: string,
+  screenStateStore: ScreenStateStore,
   context: Record<string, any>,
   action: ActionType
 ) => {
   if (!context) {
-    log_error("handleAction: localStorageToggleFlag action missing context");
+    log_error("handleAction: screenToggleFlag action missing context");
 
     return ActionResult.Error;
   }
@@ -28,7 +29,7 @@ export const screenToggleFlag = async (
 
   if (!entry) {
     log_error(
-      "handleAction: localStorageToggleFlag action missing entry. Entry is required to get the tag."
+      "handleAction: screenToggleFlag action missing entry. Entry is required to get the tag."
     );
 
     return ActionResult.Error;
@@ -43,7 +44,8 @@ export const screenToggleFlag = async (
   if (keyNamespace && tag) {
     const multiSelectProvider = ScreenMultiSelectProvider.getProvider(
       keyNamespace,
-      screenRoute
+      screenRoute,
+      screenStateStore
     );
 
     const selectedItems = await multiSelectProvider.getSelectedAsync();

package/actionsExecutor/StorageActions.ts

@@ -1,6 +1,6 @@
 import { ActionResult } from "./ActionExecutor";
 import { get } from "lodash";
-import { StorageMultiSelectProvider } from "@applicaster/zapp-react-native-bridge/ZappStorage/StorageMultiSelectProvider";
+import { StorageMultiSelectProvider } from "@applicaster/zapp-react-native-utils/storage/StorageMultiSelectProvider";
 import { log_error, log_info } from "./ActionExecutorContext";
 import { postEvent } from "../reactHooks/useSubscriberFor";
 import { TOGGLE_FLAG_MAX_ITEMS_REACHED_EVENT } from "./consts";

package/actionsExecutor/feedDecorator.ts

@@ -0,0 +1,171 @@
+import * as R from "ramda";
+import { getNamespaceAndKey } from "../appUtils/contextKeysManager/utils";
+import { createLogger } from "../logger";
+
+const { log_error, log_verbose } = createLogger({
+  subsystem: "FeedDecorator",
+  category: "General",
+});
+
+function getScope(scope) {
+  if (scope === "screen") {
+    return scope;
+  } else if (!scope || scope === "ctx") {
+    return "ctx";
+  } else {
+    log_verbose(
+      `decorateFeed: Unsupported scope "${scope}" provided in preference_editor_options. Defaulting to "ctx".`
+    );
+
+    return "ctx";
+  }
+}
+
+function makeMultiSelect(feed: ZappFeed, key, decoratedFeed) {
+  const scope = getScope(
+    decoratedFeed.extensions?.preference_editor_options?.scope
+  );
+
+  const behavior = {
+    ...feed.extensions?.["behavior"],
+    select_mode: "multi",
+    current_selection: `@{${scope}/${key}}`,
+  };
+
+  if (!feed.extensions) {
+    decoratedFeed.extensions = {
+      behavior,
+    };
+  } else {
+    decoratedFeed.extensions.behavior = behavior;
+  }
+
+  const actionType =
+    decoratedFeed.extensions?.preference_editor_options?.scope === "screen"
+      ? "screenToggleFlag"
+      : decoratedFeed.extensions?.preference_editor_options?.scope === "session"
+        ? "sessionStorageToggleFlag"
+        : "localStorageToggleFlag";
+
+  decoratedFeed.entry?.forEach((entry: ZappEntry) => {
+    entry.type.value = "action";
+    entry.id = entry.extensions?.tag || entry.id;
+
+    entry.extensions = {
+      ...(entry.extensions || {}),
+      tap_actions: {
+        actions: [
+          {
+            type: actionType,
+            options: {
+              key,
+            },
+          },
+        ],
+      },
+    };
+  });
+
+  return decoratedFeed;
+}
+
+function makeSingleSelect(feed: ZappFeed, key, decoratedFeed) {
+  const scope = getScope(
+    decoratedFeed.extensions?.preference_editor_options?.scope
+  );
+
+  const behavior = {
+    ...feed.extensions?.["behavior"],
+    select_mode: "single",
+    current_selection: `@{${scope}/${key}}`,
+  };
+
+  if (!feed.extensions) {
+    decoratedFeed.extensions = {
+      behavior,
+    };
+  } else {
+    decoratedFeed.extensions.behavior = behavior;
+  }
+
+  const localStorageProducer = (entry: ZappFeed) => {
+    entry.id = entry.extensions?.tag || entry.id;
+    const { key: keyName, namespace } = getNamespaceAndKey(key);
+
+    const action =
+      decoratedFeed.extensions?.preference_editor_options?.scope === "session"
+        ? "sessionStorageSet"
+        : "localStorageSet";
+
+    return {
+      type: action,
+      options: {
+        content: {
+          [namespace]: {
+            [keyName]: entry.id,
+          },
+        },
+      },
+    };
+  };
+
+  const screenStateProducer = (entry: ZappFeed) => {
+    entry.id = entry.extensions?.tag || entry.id;
+
+    return {
+      type: "screenSetVariable",
+      options: {
+        key: `@{screen/${key}}`,
+        value: entry.id,
+      },
+    };
+  };
+
+  const producer =
+    decoratedFeed.extensions?.preference_editor_options?.scope === "screen"
+      ? screenStateProducer
+      : localStorageProducer;
+
+  decoratedFeed.entry?.forEach((entry: ZappEntry) => {
+    entry.type.value = "action";
+
+    entry.extensions = {
+      ...(entry.extensions || {}),
+      tap_actions: {
+        actions: [producer(entry)],
+      },
+    };
+  });
+
+  return decoratedFeed;
+}
+
+export const decorateFeed = (feed: ZappFeed) => {
+  if (!(feed.extensions?.["role"] === "preference_editor")) {
+    return feed;
+  }
+
+  const key = feed.extensions?.["preference_editor_options"]?.["key"];
+
+  if (!key) {
+    log_error(
+      `decorateFeed: No 'key' provided in feed titled "${feed.title}" with id "${feed.id}" in preference_editor_options. The preference_editor role requires a key for local storage.`
+    );
+
+    throw new Error(
+      "decorateFeed: No 'key' provided in feed preference_editor_options"
+    );
+  }
+
+  const decoratedFeed = R.clone(feed);
+
+  const isSingleSelect =
+    (feed.extensions?.["preference_editor_options"]?.select_mode ||
+      feed.extensions?.["behavior"]?.select_mode) === "single";
+
+  if (isSingleSelect) {
+    return makeSingleSelect(feed, key, decoratedFeed);
+  } else {
+    return makeMultiSelect(feed, key, decoratedFeed);
+  }
+};

package/actionsExecutor/screenResolver.ts

@@ -0,0 +1,11 @@
+import { useMemo } from "react";
+import { ScreenStateResolver } from "../appUtils/contextKeysManager/contextResolver";
+import { useScreenStateStore } from "../reactHooks/navigation/useScreenStateStore";
+
+export const useScreenResolvers = () => {
+  const screenStateStore = useScreenStateStore();
+
+  return useMemo(() => {
+    return { screen: new ScreenStateResolver(screenStateStore) };
+  }, [screenStateStore]);
+};

package/appUtils/accessibilityManager/index.ts

@@ -3,6 +3,7 @@ import { accessibilityManagerLogger as logger } from "./logger";
 import { TTSManager } from "../platform/platformUtils";
 import { BUTTON_ACCESSIBILITY_KEYS } from "./const";
 import { AccessibilityRole } from "react-native";
+import _ from "lodash";
 
 export class AccessibilityManager {
   private static _instance: AccessibilityManager | null = null;
@@ -135,7 +136,9 @@ export class AccessibilityManager {
     });
   }
 
-  public getButtonAccessibilityProps(buttonName: string): AccessibilityProps {
+  public getButtonAccessibilityProps(name: string): AccessibilityProps {
+    const buttonName = _.toString(name);
+
     const buttonConfig = BUTTON_ACCESSIBILITY_KEYS[buttonName];
 
     if (!buttonConfig) {

package/appUtils/contextKeysManager/contextResolver.ts

@@ -1,6 +1,5 @@
 import { ContextKeysManager } from "./index";
 import * as R from "ramda";
-import { screenStates } from "@applicaster/zapp-react-native-bridge/ZappStorage/ScreenSingleValueProvider";
 
 export interface IResolver {
   resolve: (string) => Promise<string | number | object>;
@@ -26,10 +25,10 @@ export class EntryResolver implements IResolver {
 // TODO: Move to proper place
 
 export class ScreenStateResolver implements IResolver {
-  constructor(private route: string) {}
+  constructor(private screenStateStore: ScreenStateStore) {}
 
   async resolve(key: string) {
-    const screenState = screenStates[this.route];
+    const screenState = this.screenStateStore.getState().data;
 
     return screenState?.[key];
   }

package/arrayUtils/__tests__/isEmptyArray.test.ts

@@ -0,0 +1,63 @@
+import { isEmptyArray } from "..";
+
+describe("isEmptyArray", () => {
+  it("non-empty array is not empty", () => {
+    const value = [1, 2, 3];
+
+    expect(isEmptyArray(value)).toBe(false);
+  });
+
+  it("empty array is empty", () => {
+    const value = [];
+
+    expect(isEmptyArray(value)).toBe(true);
+  });
+
+  it("number is not array", () => {
+    const value = 123;
+
+    expect(isEmptyArray(value)).toBe(false);
+  });
+
+  it("string is not array", () => {
+    const value = "vfnjdk";
+
+    expect(isEmptyArray(value)).toBe(false);
+  });
+
+  it("empty string is not array", () => {
+    const value = "";
+
+    expect(isEmptyArray(value)).toBe(false);
+  });
+
+  it("NaN is not array", () => {
+    const value = NaN;
+
+    expect(isEmptyArray(value)).toBe(false);
+  });
+
+  it("object is not array", () => {
+    const value = { test: 1 };
+
+    expect(isEmptyArray(value)).toBe(false);
+  });
+
+  it("empty object is not array", () => {
+    const value = {};
+
+    expect(isEmptyArray(value)).toBe(false);
+  });
+
+  it("undefined is not array", () => {
+    const value = undefined;
+
+    expect(isEmptyArray(value)).toBe(false);
+  });
+
+  it("null is not array", () => {
+    const value = null;
+
+    expect(isEmptyArray(value)).toBe(false);
+  });
+});

package/arrayUtils/__tests__/isFilledArray.test.ts

@@ -32,7 +32,7 @@ describe("isFilledArray", () => {
   });
 
   it("NaN is not array", () => {
-    const value = "";
+    const value = NaN;
 
     expect(isFilledArray(value)).toBe(false);
   });

package/arrayUtils/index.ts

@@ -99,12 +99,17 @@ export const makeListOf = (value: unknown, size: number): number[] => {
 
 /** Checks if a value is a non-empty array */
 export function isFilledArray(value: unknown): boolean {
-  return R.is(Array, value) && R.length(value) > 0;
+  return Array.isArray(value) && value.length > 0;
+}
+
+/** Checks if a value is a empty array */
+export function isEmptyArray(value: unknown): boolean {
+  return Array.isArray(value) && value.length === 0;
 }
 
 // get random item from the list
 export const sample = (xs: unknown[]): unknown => {
-  invariant(R.is(Array, xs), `input value is not a array: ${xs}`);
+  invariant(Array.isArray(xs), `input value is not an array: ${xs}`);
   invariant(isFilledArray(xs), `input array is empty: ${xs}`);
 
   const index = Math.floor(Math.random() * xs.length);

package/audioPlayerUtils/__tests__/getArtworkImage.test.ts

@@ -0,0 +1,144 @@
+import { getArtworkImage } from "..";
+import { DEFAULT_IMAGE } from "../assets";
+
+describe("getArtworkImage", () => {
+  const entryWithImage = {
+    media_group: [
+      {
+        type: "image",
+        media_item: [
+          { key: "artwork_key", src: "image_from_entry" },
+          { key: "other_key", src: "other_image" },
+        ],
+      },
+    ],
+    extensions: {
+      artwork_key: "artwork_key",
+    },
+  };
+
+  const entryWithoutImage = {
+    media_group: [
+      {
+        type: "image",
+        media_item: [{ key: "other_key", src: "other_image" }],
+      },
+    ],
+    extensions: {
+      artwork_key: "artwork_key",
+    },
+  };
+
+  const pluginConfigWithImage = {
+    artwork_key: "plugin_artwork_key",
+  };
+
+  it("returns image from entry extensions key", () => {
+    const result = getArtworkImage({
+      key: "artwork_key",
+      entry: entryWithImage,
+      plugin_configuration: {},
+    });
+
+    expect(result).toBe("image_from_entry");
+  });
+
+  it("returns image from plugin configuration key if not in entry", () => {
+    const entryNoMatch = {
+      ...entryWithoutImage,
+      extensions: { artwork_key: "not_found_key" },
+    };
+
+    const pluginConfig = {
+      artwork_key: "plugin_artwork_key",
+    };
+
+    const entryWithPluginImage = {
+      ...entryNoMatch,
+      media_group: [
+        {
+          type: "image",
+          media_item: [{ key: "plugin_artwork_key", src: "image_from_plugin" }],
+        },
+      ],
+    };
+
+    const result = getArtworkImage({
+      key: "artwork_key",
+      entry: entryWithPluginImage,
+      plugin_configuration: pluginConfig,
+    });
+
+    expect(result).toBe("image_from_plugin");
+  });
+
+  it("returns DEFAULT_IMAGE if neither entry nor plugin configuration has image", () => {
+    const entryNoImage = {
+      media_group: [
+        {
+          type: "image",
+          media_item: [{ key: "other_key", src: "other_image" }],
+        },
+      ],
+      extensions: { artwork_key: "not_found_key" },
+    };
+
+    const pluginConfig = { artwork_key: "not_found_key" };
+
+    const result = getArtworkImage({
+      key: "artwork_key",
+      entry: entryNoImage,
+      plugin_configuration: pluginConfig,
+    });
+
+    expect(result).toBe(DEFAULT_IMAGE);
+  });
+
+  it("handles undefined key gracefully", () => {
+    const result = getArtworkImage({
+      key: undefined,
+      entry: entryWithImage,
+      plugin_configuration: pluginConfigWithImage,
+    });
+
+    expect(result).toBe(DEFAULT_IMAGE);
+  });
+
+  it("handles missing entry or plugin_configuration gracefully", () => {
+    const result = getArtworkImage({
+      key: "artwork_key",
+      entry: undefined,
+      plugin_configuration: undefined,
+    });
+
+    expect(result).toBe(DEFAULT_IMAGE);
+  });
+
+  it("handles empty media_group", () => {
+    const entryEmptyMedia = {
+      media_group: [],
+      extensions: { artwork_key: "artwork_key" },
+    };
+
+    const result = getArtworkImage({
+      key: "artwork_key",
+      entry: entryEmptyMedia,
+      plugin_configuration: pluginConfigWithImage,
+    });
+
+    expect(result).toBe(DEFAULT_IMAGE);
+  });
+
+  it("handles missing extensions/config keys", () => {
+    const entryNoExt = { media_group: [], extensions: {} };
+    const pluginConfig = {};
+
+    const result = getArtworkImage({
+      key: "artwork_key",
+      entry: entryNoExt,
+      plugin_configuration: pluginConfig,
+    });
+
+    expect(result).toBe(DEFAULT_IMAGE);
+  });
+});

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