@applicaster/zapp-react-native-utils 14.0.0-alpha.8583696651 → 14.0.0-alpha.9203091422

package/actionsExecutor/ActionExecutorContext.tsx

@@ -16,7 +16,6 @@ import { QUICK_BRICK_EVENTS } from "@applicaster/zapp-react-native-bridge/QuickB
 import { showConfirmationDialog } from "../alertUtils";
 import { createCloudEvent, sendCloudEvent } from "../cloudEventsUtils";
 import { createLogger } from "../logger";
-import { StorageMultiSelectProvider } from "@applicaster/zapp-react-native-bridge/ZappStorage/StorageMultiSelectProvider";
 import { ACTIVE_LAYOUT_ID_STORAGE_KEY } from "@applicaster/quick-brick-core/App/remoteContextReloader/consts";
 import { appStore } from "@applicaster/zapp-react-native-redux/AppStore";
 import { loadPipesData } from "@applicaster/zapp-react-native-redux/ZappPipes";
@@ -25,15 +24,19 @@ import {
   resolveObjectValues,
 } from "../appUtils/contextKeysManager/contextResolver";
 import { useNavigation } from "../reactHooks";
-import { get } from "../utils";
 
 import {
   useContentTypes,
   usePickFromState,
 } from "@applicaster/zapp-react-native-redux/hooks";
-import { TOGGLE_FLAG_MAX_ITEMS_REACHED_EVENT } from "./consts";
-import { postEvent, useSubscriberFor } from "../reactHooks/useSubscriberFor";
+import { useSubscriberFor } from "../reactHooks/useSubscriberFor";
 import { APP_EVENTS } from "../appUtils/events";
+import {
+  localStorageToggleFlag,
+  sessionStorageToggleFlag,
+} from "./StorageActions";
+
+import { screenSetVariable, screenToggleFlag } from "./ScreenActions";
 
 export const { log_error, log_info, log_debug } = createLogger({
   subsystem: "ActionExecutorContext",
@@ -82,19 +85,6 @@ function findParentComponent(
   return null;
 }
 
-// send all data just in case (like for message string formatting)
-// Type is not exported for now
-type MaxTagsReachedEvent = {
-  selectedItems: string[];
-  maxItems: number;
-  tag: string;
-  keyNamespace: string;
-};
-
-async function onMaxTagsReached(data: MaxTagsReachedEvent) {
-  postEvent(TOGGLE_FLAG_MAX_ITEMS_REACHED_EVENT, [data]);
-}
-
 const prepareDefaultActions = (actionExecutor) => {
   actionExecutor.registerAction("localStorageSet", async (action) => {
     const namespaces = action.options.content;
@@ -178,10 +168,15 @@ const prepareDefaultActions = (actionExecutor) => {
 
       const entry = context?.entry || {};
       const entryResolver = new EntryResolver(entry);
+      const screenData = context?.screenStateStore.getState().data || {};
+      const screenResolver = new EntryResolver(screenData || {});
 
       const data =
         options?.data && options.inflateData
-          ? await resolveObjectValues(options.data, { entry: entryResolver })
+          ? await resolveObjectValues(options.data, {
+              entry: entryResolver,
+              screen: screenResolver,
+            })
           : options?.data || entry;
 
       const cloudEvent = await createCloudEvent({
@@ -216,80 +211,62 @@ const prepareDefaultActions = (actionExecutor) => {
   });
 
   actionExecutor.registerAction(
-    "localStorageToggleFlag",
+    "sessionStorageToggleFlag",
     async (
       action: ActionType,
       context?: Record<string, any>
     ): Promise<ActionResult> => {
-      if (!context) {
-        log_error(
-          "handleAction: localStorageToggleFlag action missing context"
-        );
-
-        return ActionResult.Error;
-      }
-
-      const entry = context?.entry as ZappEntry;
-
-      if (!entry) {
-        log_error(
-          "handleAction: localStorageToggleFlag action missing entry. Entry is required to get the tag."
-        );
-
-        return ActionResult.Error;
-      }
-
-      const tag = action.options?.selector
-        ? get(entry, action.options.selector)
-        : (entry.extensions?.tag ?? entry.id);
-
-      const keyNamespace = action.options?.key;
-
-      if (keyNamespace && tag) {
-        const multiSelectProvider =
-          StorageMultiSelectProvider.getProvider(keyNamespace);
-
-        const selectedItems = await multiSelectProvider.getSelectedAsync();
-        const isTagInSelectedItems = selectedItems.includes(tag);
-
-        log_info(
-          `handleAction: localStorageToggleFlag event will ${
-            isTagInSelectedItems ? "remove" : "add"
-          } tag: ${tag} for keyNamespace: ${keyNamespace}, current selectedItems: ${selectedItems}`
-        );
-
-        if (selectedItems.includes(tag)) {
-          await multiSelectProvider.removeItem(tag);
-        } else {
-          const maxItems = action.options?.max_items;
-
-          if (maxItems && selectedItems.length >= maxItems) {
-            log_info(
-              `handleAction: localStorageToggleFlag event reached max items limit: ${maxItems}, cannot add tag: ${tag}`
-            );
+      return await sessionStorageToggleFlag(context, action);
+    }
+  );
 
-            await onMaxTagsReached({
-              selectedItems,
-              maxItems,
-              tag,
-              keyNamespace,
-            });
+  actionExecutor.registerAction(
+    "localStorageToggleFlag",
+    async (
+      action: ActionType,
+      context?: Record<string, any>
+    ): Promise<ActionResult> => {
+      return await localStorageToggleFlag(context, action);
+    }
+  );
 
-            return ActionResult.Cancel;
-          }
+  actionExecutor.registerAction(
+    "screenSetVariable",
+    async (
+      action: ActionType,
+      context?: Record<string, any>
+    ): Promise<ActionResult> => {
+      const route = context?.screenRoute;
+      const screenStateStore = context?.screenStateStore;
+
+      await screenSetVariable(
+        route,
+        screenStateStore,
+        { entry: context?.entry, options: action.options },
+        action
+      );
 
-          await multiSelectProvider.addItem(tag);
-        }
-      } else {
-        log_error(
-          "handleAction: localStorageToggleFlag event missing keyNamespace or tag",
-          { keyNamespace, tag }
-        );
+      return Promise.resolve(ActionResult.Success);
+    }
+  );
 
-        return ActionResult.Error;
-      }
+  actionExecutor.registerAction(
+    "screenToggleFlag",
+    async (
+      action: ActionType,
+      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
+      );
 
-      return ActionResult.Success;
+      return Promise.resolve(ActionResult.Success);
     }
   );
 };

package/actionsExecutor/ScreenActions.ts

@@ -0,0 +1,163 @@
+// import { localStorage } from "@applicaster/zapp-react-native-bridge/ZappStorage/LocalStorage";
+
+import { log_error, log_info } from "./ActionExecutorContext";
+import { ActionResult } from "./ActionExecutor";
+import { get } from "lodash";
+
+import { onMaxTagsReached } from "./StorageActions";
+import { ScreenMultiSelectProvider } from "../storage/ScreenStateMultiSelectProvider";
+import { ScreenSingleValueProvider } from "../storage/ScreenSingleValueProvider";
+
+export const screenSetVariable = async (
+  screenRoute: string,
+  screenStateStore: ScreenStateStore,
+  context: Record<string, any>,
+  action: ActionType
+): Promise<ActionResult> => {
+  if (!context) {
+    log_error("handleAction: screenSetVariable action missing context");
+
+    return ActionResult.Error;
+  }
+
+  const entry = context?.entry as ZappEntry;
+
+  if (!entry) {
+    log_error(
+      "handleAction: screenSetVariable action missing entry. Entry is required to get the value."
+    );
+
+    return ActionResult.Error;
+  }
+
+  const tag = action.options?.selector
+    ? get(entry, action.options.selector)
+    : (entry.extensions?.tag ?? entry.id);
+
+  const keyNamespace = action.options?.key;
+
+  if (!keyNamespace) {
+    log_error("handleAction: screenSetVariable action missing key namespace", {
+      keyNamespace,
+    });
+
+    return ActionResult.Error;
+  }
+
+  if (!tag) {
+    log_error(
+      "handleAction: screenSetVariable action could not determine tag",
+      { selector: action.options?.selector, value: action.options?.value }
+    );
+
+    return ActionResult.Error;
+  }
+
+  try {
+    const singleValueProvider = ScreenSingleValueProvider.getProvider(
+      keyNamespace,
+      screenRoute,
+      screenStateStore
+    );
+
+    const currentValue = await singleValueProvider.getValueAsync();
+
+    log_info(
+      `handleAction: screenSetVariable setting value: ${tag} for keyNamespace: ${keyNamespace}, previous value: ${currentValue}`
+    );
+
+    await singleValueProvider.setValue(String(tag));
+
+    log_info(
+      `handleAction: screenSetVariable successfully set value: ${tag} for keyNamespace: ${keyNamespace}`
+    );
+
+    return ActionResult.Success;
+  } catch (error) {
+    log_error("handleAction: screenSetVariable failed to set value", {
+      keyNamespace,
+      tag,
+      error,
+    });
+
+    return ActionResult.Error;
+  }
+};
+
+export const screenToggleFlag = async (
+  screenRoute: string,
+  screenStateStore: ScreenStateStore,
+  context: Record<string, any>,
+  action: ActionType
+) => {
+  if (!context) {
+    log_error("handleAction: screenToggleFlag action missing context");
+
+    return ActionResult.Error;
+  }
+
+  const entry = context?.entry as ZappEntry;
+
+  if (!entry) {
+    log_error(
+      "handleAction: screenToggleFlag action missing entry. Entry is required to get the tag."
+    );
+
+    return ActionResult.Error;
+  }
+
+  const tag = action.options?.selector
+    ? get(entry, action.options.selector)
+    : (entry.extensions?.tag ?? entry.id);
+
+  const keyNamespace = action.options?.key;
+
+  if (keyNamespace && tag) {
+    const multiSelectProvider = ScreenMultiSelectProvider.getProvider(
+      keyNamespace,
+      screenRoute,
+      screenStateStore
+    );
+
+    const selectedItems = await multiSelectProvider.getSelectedAsync();
+    const isTagInSelectedItems = selectedItems.includes(tag);
+
+    log_info(
+      `handleAction: screenToggleFlag event will ${
+        isTagInSelectedItems ? "remove" : "add"
+      } tag: ${tag} for keyNamespace: ${keyNamespace}, current selectedItems: ${selectedItems}`
+    );
+
+    if (selectedItems.includes(tag)) {
+      await multiSelectProvider.removeItem(tag);
+    } else {
+      const maxItems = action.options?.max_items;
+
+      if (maxItems && selectedItems.length >= maxItems) {
+        log_info(
+          `handleAction: screenToggleFlag event reached max items limit: ${maxItems}, cannot add tag: ${tag}`
+        );
+
+        await onMaxTagsReached({
+          selectedItems,
+          maxItems,
+          tag,
+          keyNamespace,
+        });
+
+        return ActionResult.Cancel;
+      }
+
+      await multiSelectProvider.addItem(tag);
+    }
+  } else {
+    log_error(
+      "handleAction: screenToggleFlag event missing keyNamespace or tag",
+      { keyNamespace, tag }
+    );
+
+    return ActionResult.Error;
+  }
+
+  return ActionResult.Success;
+};

package/actionsExecutor/StorageActions.ts

@@ -0,0 +1,110 @@
+import { ActionResult } from "./ActionExecutor";
+import { get } from "lodash";
+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";
+import { StorageType } from "../appUtils/contextKeysManager/consts";
+
+// send all data just in case (like for message string formatting)
+// Type is not exported for now
+type MaxTagsReachedEvent = {
+  selectedItems: string[];
+  maxItems: number;
+  tag: string;
+  keyNamespace: string;
+};
+
+export async function onMaxTagsReached(data: MaxTagsReachedEvent) {
+  postEvent(TOGGLE_FLAG_MAX_ITEMS_REACHED_EVENT, [data]);
+}
+
+export async function storageToggleFlag(
+  context: Record<string, any>,
+  action: ActionType,
+  storageType: StorageType
+) {
+  if (!context) {
+    log_error("handleAction: localStorageToggleFlag action missing context");
+
+    return ActionResult.Error;
+  }
+
+  const entry = context?.entry as ZappEntry;
+
+  if (!entry) {
+    log_error(
+      "handleAction: localStorageToggleFlag action missing entry. Entry is required to get the tag."
+    );
+
+    return ActionResult.Error;
+  }
+
+  const tag = action.options?.selector
+    ? get(entry, action.options.selector)
+    : (entry.extensions?.tag ?? entry.id);
+
+  const keyNamespace = action.options?.key;
+
+  if (keyNamespace && tag) {
+    const multiSelectProvider = StorageMultiSelectProvider.getProvider(
+      keyNamespace,
+      storageType
+    );
+
+    const selectedItems = await multiSelectProvider.getSelectedAsync();
+    const isTagInSelectedItems = selectedItems.includes(tag);
+
+    log_info(
+      `handleAction: localStorageToggleFlag event will ${
+        isTagInSelectedItems ? "remove" : "add"
+      } tag: ${tag} for keyNamespace: ${keyNamespace}, current selectedItems: ${selectedItems}`
+    );
+
+    if (selectedItems.includes(tag)) {
+      await multiSelectProvider.removeItem(tag);
+    } else {
+      const maxItems = action.options?.max_items;
+
+      if (maxItems && selectedItems.length >= maxItems) {
+        log_info(
+          `handleAction: localStorageToggleFlag event reached max items limit: ${maxItems}, cannot add tag: ${tag}`
+        );
+
+        await onMaxTagsReached({
+          selectedItems,
+          maxItems,
+          tag,
+          keyNamespace,
+        });
+
+        return ActionResult.Cancel;
+      }
+
+      await multiSelectProvider.addItem(tag);
+    }
+  } else {
+    log_error(
+      "handleAction: localStorageToggleFlag event missing keyNamespace or tag",
+      { keyNamespace, tag }
+    );
+
+    return ActionResult.Error;
+  }
+
+  return ActionResult.Success;
+}
+
+export async function sessionStorageToggleFlag(
+  context: Record<string, any>,
+  action: ActionType
+) {
+  return storageToggleFlag(context, action, StorageType.session);
+}
+
+export async function localStorageToggleFlag(
+  context: Record<string, any>,
+  action: ActionType
+) {
+  return storageToggleFlag(context, action, StorageType.local);
+}

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,
+        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/analyticsUtils/AnalyticsEvents/helper.ts

@@ -9,7 +9,7 @@ import {
 } from "../events";
 import { isEmptyOrNil } from "../../cellUtils";
 import { get } from "lodash";
-import { StorageMultiSelectProvider } from "@applicaster/zapp-react-native-bridge/ZappStorage/StorageMultiSelectProvider";
+import { StorageMultiSelectProvider } from "@applicaster/zapp-react-native-utils/storage/StorageMultiSelectProvider";
 
 export enum OfflineItemState {
   notExist = "NOT_EXISTS",

package/appUtils/contextKeysManager/contextResolver.ts

@@ -1,10 +1,11 @@
 import { ContextKeysManager } from "./index";
 import * as R from "ramda";
 
-interface IResolver {
+export interface IResolver {
   resolve: (string) => Promise<string | number | object>;
 }
 
+// TODO: Rename to ObjectKeyResolver or similar
 export class EntryResolver implements IResolver {
   entry: ZappEntry;
 
@@ -21,6 +22,18 @@ export class EntryResolver implements IResolver {
   }
 }
 
+// TODO: Move to proper place
+
+export class ScreenStateResolver implements IResolver {
+  constructor(private screenStateStore: ScreenStateStore) {}
+
+  async resolve(key: string) {
+    const screenState = this.screenStateStore.getState().data;
+
+    return screenState?.[key];
+  }
+}
+
 export class ContextResolver implements IResolver {
   resolve = async (compositeKey: string) =>
     ContextKeysManager.instance.getKey(compositeKey);