@applicaster/zapp-react-native-utils 14.0.0-alpha.3126393935 → 14.0.0-alpha.3216572828

package/utils/index.ts

@@ -2,6 +2,12 @@ export { chunk } from "./chunk";
 
 export { times } from "./times";
 
+export { startsWith } from "./startsWith";
+
+export { find } from "./find";
+
+export { pathOr } from "./pathOr";
+
 export {
   cloneDeep as clone,
   flatten,
@@ -14,7 +20,9 @@ export {
   flatMap,
   difference,
   take,
+  pick,
   map,
   trim,
   toString,
+  last,
 } from "lodash";

package/utils/pathOr.ts

@@ -0,0 +1,5 @@
+import { get } from "lodash";
+
+export const pathOr = (defaultValue, path, record) => {
+  return get(record, path, defaultValue);
+};

package/utils/startsWith.ts

@@ -0,0 +1,9 @@
+import { isNil } from "lodash";
+
+export const startsWith = (target, str) => {
+  if (isNil(str)) {
+    return false;
+  }
+
+  return str.startsWith(target);
+};

package/actionsExecutor/ScreenActions.ts

@@ -1,163 +0,0 @@
-// 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

@@ -1,110 +0,0 @@
-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

@@ -1,171 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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/reactHooks/navigation/useScreenStateStore.ts

@@ -1,8 +0,0 @@
-import { useRoute } from "./useRoute";
-import { useMemo } from "react";
-
-export const useScreenStateStore = () => {
-  const route = useRoute(false);
-
-  return useMemo(() => route.screenData["screenStateStore"], [route.pathname]);
-};

package/storage/ScreenSingleValueProvider.ts

@@ -1,201 +0,0 @@
-import { BehaviorSubject } from "rxjs";
-import { SingleValueProvider } from "./StorageSingleSelectProvider";
-import { createLogger } from "../logger";
-import { bridgeLogger } from "../../zapp-react-native-bridge/logger";
-
-export const { log_debug, log_error } = createLogger({
-  category: "ScreenSingleValueProvider",
-  subsystem: "zapp-react-native-bridge",
-  parent: bridgeLogger,
-});
-
-export class ScreenSingleValueProvider implements SingleValueProvider {
-  // @ts-ignore
-  private valueSubject: BehaviorSubject<string | null>;
-  private screenStateStoreUnsubscribe: (() => void) | null = null;
-
-  private static providers: Record<
-    string,
-    Record<string, SingleValueProvider>
-  > = {};
-
-  public static getProvider(
-    key: string,
-    screenRoute: string,
-    screenStateStore: ScreenStateStore
-  ): SingleValueProvider {
-    if (!key) {
-      throw new Error("ScreenSingleValueProvider: Key is required");
-    }
-
-    if (!screenRoute) {
-      throw new Error("ScreenSingleValueProvider: Screen route is required");
-    }
-
-    if (!screenStateStore) {
-      throw new Error(
-        "ScreenSingleValueProvider: screen state store is required"
-      );
-    }
-
-    if (!this.providers[screenRoute]) {
-      this.providers[screenRoute] = {};
-    }
-
-    try {
-      if (!this.providers[screenRoute][key]) {
-        this.providers[screenRoute][key] = new ScreenSingleValueProvider(
-          key,
-          screenRoute,
-          screenStateStore
-        );
-      } else {
-        (
-          this.providers[screenRoute][key] as ScreenSingleValueProvider
-        ).updateStore(screenStateStore);
-      }
-    } catch (error) {
-      log_error("Failed to create provider", { key, screenRoute, error });
-      throw error;
-    }
-
-    return this.providers[screenRoute][key];
-  }
-
-  // @ts-ignore
-  private constructor(
-    private key: string,
-    route: string,
-    private screenStateStore: ScreenStateStore
-  ) {
-    if (!key) {
-      throw new Error("ScreenSingleValueProvider: Key is required");
-    }
-
-    if (!screenStateStore) {
-      throw new Error(
-        "ScreenSingleValueProvider: screen state store is required"
-      );
-    }
-
-    this.key = key;
-    this.valueSubject = new BehaviorSubject<string | null>(null);
-
-    this.setupScreenStateSubscription();
-
-    void this.getValueAsync();
-
-    log_debug("ScreenSingleValueProvider: Initializing", { key, route });
-  }
-
-  private updateStore(screenStateStore: ScreenStateStore): void {
-    this.cleanup();
-    this.screenStateStore = screenStateStore;
-    this.setupScreenStateSubscription();
-    void this.getValueAsync();
-  }
-
-  private setupScreenStateSubscription(): void {
-    this.screenStateStoreUnsubscribe = this.screenStateStore.subscribe(
-      (state) => ({
-        value: state.data[this.key],
-        exists: this.key in state.data,
-      }),
-      (current, previous) => {
-        if (!current.exists && previous.exists) {
-          log_debug(
-            `ScreenSingleValueProvider: Key deleted from store: ${this.key}`
-          );
-
-          // TODO: If we need to handle deletion, we can do it here
-        }
-
-        if (current.value !== previous.value) {
-          this.valueSubject.next(current.value || null);
-
-          log_debug(`ScreenSingleValueProvider: Key updated: ${this.key}`, {
-            previous: previous.value,
-            current: current.value,
-          });
-        }
-      }
-    );
-
-    log_debug(
-      `ScreenSingleValueProvider: screen state store subscription setup for key: ${this.key}`
-    );
-  }
-
-  private cleanup(): void {
-    if (this.screenStateStoreUnsubscribe) {
-      this.screenStateStoreUnsubscribe();
-      this.screenStateStoreUnsubscribe = null;
-
-      log_debug(
-        `ScreenSingleValueProvider: Unsubscribed from screen state store for key: ${this.key}`
-      );
-    }
-  }
-
-  clearValue(): Promise<void> {
-    this.screenStateStore.getState().removeValue(this.key);
-    this.valueSubject.next(null);
-
-    log_debug(`clearValue: value cleared for key: ${this.key}`);
-
-    return Promise.resolve();
-  }
-
-  getObservable(): BehaviorSubject<string | null> {
-    return this.valueSubject;
-  }
-
-  getValue(): string | null {
-    return this.valueSubject.value;
-  }
-
-  getValueAsync(): Promise<string | null> {
-    const currentValue = this.screenStateStore.getState().data[this.key];
-    const value = currentValue || null;
-    const selected = this.getValue();
-    const valuesAreEqual = value === selected;
-
-    const bothEmpty =
-      (value === null || value === "") &&
-      (selected === null || selected === "");
-
-    if (!this.valueSubject.closed && !valuesAreEqual && !bothEmpty) {
-      this.valueSubject.next(value);
-    }
-
-    return Promise.resolve(value);
-  }
-
-  setValue(value: string): Promise<void> {
-    this.screenStateStore.getState().setValue(this.key, value);
-    this.valueSubject.next(value);
-
-    log_debug(`setValue: value set for key: ${this.key}`, { value });
-
-    return Promise.resolve();
-  }
-
-  // TODO: remove if not needed
-
-  public static cleanupRoute(screenRoute: string): void {
-    if (this.providers[screenRoute]) {
-      Object.values(this.providers[screenRoute]).forEach((provider) => {
-        (provider as ScreenSingleValueProvider).destroy();
-      });
-
-      delete this.providers[screenRoute];
-    }
-  }
-
-  // TODO: remove if not needed
-
-  public destroy(): void {
-    this.valueSubject.complete();
-    this.cleanup();
-  }
-}