@applicaster/zapp-react-native-utils 14.0.0-rc.9 → 14.0.0-rc.91

package/storage/ScreenStateMultiSelectProvider.ts

@@ -0,0 +1,293 @@
+import { MultiSelectProvider } from "./StorageMultiSelectProvider";
+import { BehaviorSubject } from "rxjs";
+import { createLogger } from "../logger";
+import { bridgeLogger } from "../../zapp-react-native-bridge/logger";
+import { useScreenStateStore } from "../reactHooks/navigation/useScreenStateStore";
+
+export const { log_debug, log_error } = createLogger({
+  category: "ScreenMultiSelectProvider",
+  subsystem: "zapp-react-native-bridge",
+  parent: bridgeLogger,
+});
+
+export class ScreenMultiSelectProvider implements MultiSelectProvider {
+  // @ts-ignore
+  private itemSubject: BehaviorSubject<string[] | null>;
+  private screenStateStoreUnsubscribe: (() => void) | null = null;
+
+  private static providers: Record<
+    string,
+    Record<string, MultiSelectProvider>
+  > = {};
+
+  public static getProvider(
+    key: string,
+    screenRoute: string,
+    screenStateStore: ReturnType<typeof useScreenStateStore>
+  ): MultiSelectProvider {
+    if (!key) {
+      throw new Error("ScreenMultiSelectProvider: Key is required");
+    }
+
+    if (!screenRoute) {
+      throw new Error("ScreenMultiSelectProvider: Screen route is required");
+    }
+
+    if (!screenStateStore) {
+      throw new Error(
+        "ScreenMultiSelectProvider: screen state store is required"
+      );
+    }
+
+    if (!this.providers[screenRoute]) {
+      this.providers[screenRoute] = {};
+    }
+
+    try {
+      if (!this.providers[screenRoute][key]) {
+        this.providers[screenRoute][key] = new ScreenMultiSelectProvider(
+          key,
+          screenRoute,
+          screenStateStore
+        );
+      } else {
+        (
+          this.providers[screenRoute][key] as ScreenMultiSelectProvider
+        ).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: ReturnType<typeof useScreenStateStore>
+  ) {
+    if (!key) {
+      throw new Error("ScreenMultiSelectProvider: Key is required");
+    }
+
+    if (!screenStateStore) {
+      throw new Error(
+        "ScreenMultiSelectProvider: screen state store is required"
+      );
+    }
+
+    this.key = key;
+    this.itemSubject = new BehaviorSubject<string[]>([]);
+
+    this.setupScreenStateSubscription();
+
+    void this.getSelectedAsync();
+
+    log_debug("ScreenMultiSelectProvider: Initializing", { key, route });
+  }
+
+  private updateStore(
+    screenStateStore: ReturnType<typeof useScreenStateStore>
+  ): void {
+    if (screenStateStore === this.screenStateStore) {
+      return;
+    }
+
+    this.cleanup();
+    this.screenStateStore = screenStateStore;
+    this.setupScreenStateSubscription();
+    void this.getSelectedAsync();
+  }
+
+  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(
+      //       `ScreenMultiSelectProvider: Key deleted from store: ${this.key}`
+      //     );
+
+      //     // TODO: If we need to handle deletion, we can do it here
+      //   }
+
+      //   if (current.value !== previous.value) {
+      //     const items = this.parseStoredValue(current.value);
+      //     this.itemSubject.next(items);
+
+      //     log_debug(`ScreenMultiSelectProvider: Key updated: ${this.key}`, {
+      //       previous: this.parseStoredValue(previous.value),
+      //       current: items,
+      //     });
+      //   }
+      // }
+    );
+
+    log_debug(
+      `ScreenMultiSelectProvider: screen state store subscription setup for key: ${this.key}`
+    );
+  }
+
+  private parseStoredValue(value: string): string[] {
+    if (!value) return [];
+
+    return typeof value === "string"
+      ? value.split(",").filter((item) => item.length > 0)
+      : [];
+  }
+
+  private formatValueForStorage(items: string[]): string {
+    return items.join(",");
+  }
+
+  private getCurrentItems(): Set<string> {
+    const currentValue = this.screenStateStore.getState().data[this.key];
+    const items = this.parseStoredValue(currentValue);
+
+    return new Set(items);
+  }
+
+  private updateScreenState(items: Set<string>): void {
+    const itemsArray = Array.from(items);
+    const formattedValue = this.formatValueForStorage(itemsArray);
+
+    this.screenStateStore.getState().setValue(this.key, formattedValue);
+    const itemsToUpdate = Array.from(items) || [];
+    this.itemSubject.next(itemsToUpdate);
+  }
+
+  private cleanup(): void {
+    if (this.screenStateStoreUnsubscribe) {
+      this.screenStateStoreUnsubscribe();
+      this.screenStateStoreUnsubscribe = null;
+
+      log_debug(
+        `ScreenMultiSelectProvider: Unsubscribed from screen state store for key: ${this.key}`
+      );
+    }
+  }
+
+  addItem(item: string): Promise<void> {
+    const items = this.getCurrentItems();
+    items.add(item);
+    this.updateScreenState(items);
+
+    log_debug(
+      `addItem: item added: ${item}, current items: [${Array.from(items).join(", ")}]`
+    );
+
+    return Promise.resolve();
+  }
+
+  addItems(itemsToAdd: string[]): Promise<void> {
+    const items = this.getCurrentItems();
+
+    for (const item of itemsToAdd) {
+      items.add(item);
+    }
+
+    this.updateScreenState(items);
+
+    log_debug(
+      `addItems: items added: [${itemsToAdd.join(", ")}], current items: [${Array.from(items).join(", ")}]`
+    );
+
+    return Promise.resolve();
+  }
+
+  public getObservable = (): BehaviorSubject<string[]> => this.itemSubject;
+
+  getSelectedAsync(): Promise<string[]> {
+    const currentValue = this.screenStateStore.getState().data[this.key] || [];
+    const values = this.parseStoredValue(currentValue);
+    const selected = this.getSelectedItems();
+
+    const arraysAreEqual =
+      Array.isArray(values) &&
+      Array.isArray(selected) &&
+      values.length === selected.length &&
+      values.every((val, index) => val === selected[index]);
+
+    const bothEmpty = values.length === 0 && selected.length === 0;
+
+    if (!this.itemSubject.closed && !arraysAreEqual && !bothEmpty) {
+      this.itemSubject.next(values);
+    }
+
+    return Promise.resolve(values);
+  }
+
+  getSelectedItems(): string[] {
+    return this.itemSubject.value || [];
+  }
+
+  removeAllItems(): Promise<void> {
+    this.screenStateStore.getState().removeValue(this.key);
+    this.itemSubject.next([]);
+
+    log_debug(`removeAllItems: all items removed for key: ${this.key}`);
+
+    return Promise.resolve();
+  }
+
+  removeItem(item: string): Promise<void> {
+    const items = this.getCurrentItems();
+    items.delete(item);
+
+    this.updateScreenState(items);
+
+    log_debug(
+      `removeItem: item removed: ${item}, remaining items: ${Array.from(items).join(", ")}`
+    );
+
+    return Promise.resolve();
+  }
+
+  removeItems(itemsToRemove: string[]): Promise<void> {
+    const items = this.getCurrentItems();
+
+    for (const item of itemsToRemove) {
+      items.delete(item);
+    }
+
+    this.updateScreenState(items);
+
+    log_debug(
+      `removeItems: items removed: [${itemsToRemove.join(", ")}], remaining items: [${Array.from(items).join(", ")}]`
+    );
+
+    return Promise.resolve();
+  }
+
+  setSelectedItems(items: string[]): Promise<void> {
+    this.updateScreenState(new Set(items));
+    log_debug(`setSelectedItems: items set to: [${items.join(", ")}]`);
+
+    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 ScreenMultiSelectProvider).destroy();
+      });
+
+      delete this.providers[screenRoute];
+    }
+  }
+
+  // TODO: remove if not needed
+
+  public destroy(): void {
+    this.itemSubject.complete();
+    this.cleanup();
+  }
+}

package/storage/StorageMultiSelectProvider.ts

@@ -0,0 +1,192 @@
+import { bridgeLogger } from "../../zapp-react-native-bridge/logger";
+import { BehaviorSubject } from "rxjs";
+import { Storage } from "@applicaster/zapp-react-native-bridge/ZappStorage/Storage";
+import { localStorage } from "@applicaster/zapp-react-native-bridge/ZappStorage/LocalStorage";
+import { sessionStorage } from "@applicaster/zapp-react-native-bridge/ZappStorage/SessionStorage";
+import { StorageType } from "../appUtils/contextKeysManager/consts";
+import { getNamespaceAndKey } from "../appUtils/contextKeysManager/utils";
+import { createLogger } from "../logger";
+
+export const { log_verbose, log_debug, log_warning, log_info, log_error } =
+  createLogger({
+    category: "StorageMultiSelectProvider",
+    subsystem: "zapp-react-native-bridge",
+    parent: bridgeLogger,
+  });
+
+export interface MultiSelectProvider {
+  getObservable(): BehaviorSubject<string[]>;
+
+  addItem(item: string): Promise<void>;
+
+  addItems(items: string[]): Promise<void>;
+
+  setSelectedItems(items: string[]): Promise<void>;
+
+  removeItem(item: string): Promise<void>;
+
+  removeItems(items: string[]): Promise<void>;
+
+  removeAllItems(): Promise<void>;
+
+  getSelectedItems(): string[];
+
+  getSelectedAsync(): Promise<string[]>;
+}
+
+export class StorageMultiSelectProvider implements MultiSelectProvider {
+  // TODO: Unsubscribe and remove when there is no listeners
+  private static multiSelectProviders: Record<
+    StorageType,
+    Record<string, StorageMultiSelectProvider>
+  > = {
+    [StorageType.local]: {},
+    [StorageType.session]: {},
+    // TODO: not implemented yet
+    [StorageType.secure]: {},
+  };
+
+  public static getProvider(
+    keyNamespace: string,
+    storage: StorageType = StorageType.local
+  ): MultiSelectProvider {
+    if (!this.multiSelectProviders[storage][keyNamespace]) {
+      const storageImpl =
+        storage === StorageType.session ? sessionStorage : localStorage;
+
+      this.multiSelectProviders[storage][keyNamespace] =
+        new StorageMultiSelectProvider(keyNamespace, storageImpl);
+    }
+
+    return this.multiSelectProviders[storage][keyNamespace];
+  }
+
+  private itemSubject: BehaviorSubject<string[] | null>;
+
+  private readonly key: string;
+  private readonly namespace: string;
+
+  private constructor(
+    keyNamespace: string,
+    private storage: Storage
+  ) {
+    const { namespace, key } = getNamespaceAndKey(keyNamespace);
+
+    if (!key) {
+      throw new Error("StorageMultiSelectProvider: Key is required");
+    }
+
+    this.key = key;
+    this.namespace = namespace;
+    this.storage.addListener?.({ key, namespace }, this.reloadItems);
+
+    this.itemSubject = new BehaviorSubject([]);
+
+    void this.getSelectedAsync();
+    log_debug("StorageMultiSelectProvider: Initializing");
+  }
+
+  private reloadItems = async ({ value }: StorageListenerArgs) => {
+    const selectedItems = value ? value.split(",") : [];
+
+    log_debug(
+      `reloadItems: request to reload items for value: ${value}`,
+      selectedItems
+    );
+
+    this.itemSubject.next(selectedItems);
+  };
+
+  public getObservable = (): BehaviorSubject<string[]> => this.itemSubject;
+
+  private async getSetOfCurrentItems() {
+    const currentResult: string = await this.storage.getItem(
+      this.key,
+      this.namespace
+    );
+
+    return new Set(currentResult ? currentResult.split(",") : []);
+  }
+
+  private async updateItemsAndNotifyObservers(currentItems: Set<string>) {
+    const arrayOfItems = Array.from(currentItems);
+    const newValue = arrayOfItems.join(",");
+    await this.storage.setItem(this.key, newValue, this.namespace);
+
+    this.itemSubject.next(arrayOfItems);
+  }
+
+  public addItem = async (item: string): Promise<void> => {
+    const currentItems = await this.getSetOfCurrentItems();
+    currentItems.add(item);
+    log_debug(`addItem: Adding new item: ${item}`);
+
+    await this.updateItemsAndNotifyObservers(currentItems);
+  };
+
+  public addItems = async (items: string[]): Promise<void> => {
+    const currentItems = await this.getSetOfCurrentItems();
+
+    items.forEach((item) => currentItems.add(item));
+
+    log_debug(
+      `addItems: Adding new items: ${items.join(
+        ","
+      )}, current items: ${Array.from(currentItems).join(",")}`
+    );
+
+    await this.updateItemsAndNotifyObservers(currentItems);
+  };
+
+  public removeItem = async (item: string): Promise<void> => {
+    const currentItems = await this.getSetOfCurrentItems();
+    currentItems.delete(item);
+
+    log_debug(
+      `removeItem: Removing item: ${item}, current items: ${Array.from(
+        currentItems
+      ).join(",")}`
+    );
+
+    await this.updateItemsAndNotifyObservers(currentItems);
+  };
+
+  public removeItems = async (items: string[]): Promise<void> => {
+    const currentItems = await this.getSetOfCurrentItems();
+
+    items.forEach((item) => currentItems.delete(item));
+
+    log_debug(
+      `removeItems: Removing items: ${items.join(
+        ","
+      )}, current items: ${Array.from(currentItems).join(",")}`
+    );
+
+    await this.updateItemsAndNotifyObservers(currentItems);
+  };
+
+  public removeAllItems = async (): Promise<void> => {
+    await this.storage.removeItem(this.key, this.namespace);
+    log_debug(`removeAllItems: Removing all items, current items: ${[]}`);
+
+    this.itemSubject.next([]);
+  };
+
+  public getSelectedAsync = async (): Promise<string[]> => {
+    const value = await this.storage.getItem(this.key, this.namespace);
+    const selectedItems = value ? value.split(",") : [];
+    this.itemSubject.next(selectedItems);
+
+    return selectedItems;
+  };
+
+  public getSelectedItems = (): string[] => {
+    return this.itemSubject.getValue();
+  };
+
+  setSelectedItems = async (items: string[]): Promise<void> => {
+    log_debug(`setSelectedItems: Setting selected items: ${items.join(",")}`);
+
+    await this.updateItemsAndNotifyObservers(new Set(items));
+  };
+}

package/storage/StorageSingleSelectProvider.ts

@@ -0,0 +1,108 @@
+import { bridgeLogger } from "../../zapp-react-native-bridge/logger";
+import { BehaviorSubject } from "rxjs";
+import { localStorage } from "@applicaster/zapp-react-native-bridge/ZappStorage/LocalStorage";
+import { getNamespaceAndKey } from "../appUtils/contextKeysManager/utils";
+import { createLogger } from "../logger";
+
+export const { log_verbose, log_debug, log_warning, log_info, log_error } =
+  createLogger({
+    category: "StorageSingleValueProvider",
+    subsystem: "zapp-react-native-bridge",
+    parent: bridgeLogger,
+  });
+
+export interface SingleValueProvider {
+  getObservable(): BehaviorSubject<string | null>;
+
+  setValue(value: string): Promise<void>;
+  getValue(): string | null;
+  getValueAsync(): Promise<string | null>;
+  clearValue(): Promise<void>;
+}
+
+interface StorageListenerArgs {
+  value: string | null;
+}
+
+export class StorageSingleValueProvider implements SingleValueProvider {
+  // Static cache of providers by namespace
+  private static singleValueProviders: Record<
+    string,
+    StorageSingleValueProvider
+  > = {};
+
+  public static getProvider(keyNamespace: string): SingleValueProvider {
+    if (!this.singleValueProviders[keyNamespace]) {
+      this.singleValueProviders[keyNamespace] = new StorageSingleValueProvider(
+        keyNamespace
+      );
+    }
+
+    return this.singleValueProviders[keyNamespace];
+  }
+
+  private valueSubject: BehaviorSubject<string | null>;
+
+  private readonly key: string;
+  private readonly namespace: string;
+
+  private constructor(keyNamespace: string) {
+    const { namespace, key } = getNamespaceAndKey(keyNamespace);
+
+    if (!key) {
+      throw new Error("StorageSingleValueProvider: Key is required");
+    }
+
+    this.key = key;
+    this.namespace = namespace;
+    localStorage.addListener?.({ key, namespace }, this.reloadValue);
+
+    this.valueSubject = new BehaviorSubject<string | null>(null);
+
+    void this.getValueAsync();
+    log_debug("StorageSingleValueProvider: Initializing");
+  }
+
+  private reloadValue = async ({ value }: StorageListenerArgs) => {
+    log_debug(`reloadValue: request to reload value: ${value}`);
+
+    this.valueSubject.next(value);
+  };
+
+  public getObservable = (): BehaviorSubject<string | null> =>
+    this.valueSubject;
+
+  private async updateValueAndNotifyObservers(value: string | null) {
+    if (value === null) {
+      await localStorage.removeItem(this.key, this.namespace);
+    } else {
+      await localStorage.setItem(this.key, value, this.namespace);
+    }
+
+    this.valueSubject.next(value);
+  }
+
+  public setValue = async (value: string): Promise<void> => {
+    log_debug(`setValue: Setting new value: ${value}`);
+
+    await this.updateValueAndNotifyObservers(value);
+  };
+
+  public clearValue = async (): Promise<void> => {
+    await localStorage.removeItem(this.key, this.namespace);
+    log_debug("clearValue: Removing value");
+
+    this.valueSubject.next(null);
+  };
+
+  public getValueAsync = async (): Promise<string | null> => {
+    const value = await localStorage.getItem(this.key, this.namespace);
+    this.valueSubject.next(value);
+
+    return value;
+  };
+
+  public getValue = (): string | null => {
+    return this.valueSubject.getValue();
+  };
+}

package/testUtils/index.tsx

@@ -1,17 +1,16 @@
-import * as R from "ramda";
-
+import { SafeAreaProvider } from "react-native-safe-area-context";
+import { render } from "@testing-library/react-native";
 import React, { PropsWithChildren } from "react";
-import { View } from "react-native";
-
+import configureStore from "redux-mock-store";
 import { Provider } from "react-redux";
+import { View } from "react-native";
 import thunk from "redux-thunk";
-import configureStore from "redux-mock-store";
-import { SafeAreaProvider } from "react-native-safe-area-context";
+import * as R from "ramda";
+
 import { appStore } from "@applicaster/zapp-react-native-redux/AppStore";
 
-import { render } from "@testing-library/react-native";
-import { AnalyticsProvider } from "../analyticsUtils";
 import { ThemeContext } from "../theme";
+import { AnalyticsProvider } from "../analyticsUtils";
 
 export { getByTestId } from "./getByTestId";
 

package/time/BackgroundTimer.ts

@@ -11,15 +11,17 @@ class BackgroundTimer {
     this.uniqueId = 0;
     this.callbacks = {};
 
-    const EventEmitter = platformSelect({
+    const EventEmitter: typeof DeviceEventEmitter | undefined = platformSelect({
       android: DeviceEventEmitter,
-      ios: undefined,
+      android_tv: DeviceEventEmitter,
+      amazon: DeviceEventEmitter, // probably does not exist and uses android_tv
       default: undefined,
     });
 
     EventEmitter?.addListener("BackgroundTimer.timer.fired", (id: number) => {
-      if (this.callbacks[id]) {
-        const callback = this.callbacks[id];
+      const callback = this.callbacks[id];
+
+      if (callback) {
         delete this.callbacks[id];
         callback();
       }

package/utils/__tests__/endsWith.test.ts

@@ -0,0 +1,30 @@
+import { endsWith } from "../endsWith";
+
+describe("endsWith", () => {
+  it("returns false when str is null", () => {
+    expect(endsWith("a", null)).toBe(false);
+  });
+
+  it("returns false when str is undefined", () => {
+    expect(endsWith("a", undefined)).toBe(false);
+  });
+
+  it("returns true when string ends with target", () => {
+    expect(endsWith("lo", "hello")).toBe(true);
+    expect(endsWith("", "hello")).toBe(true); // empty target always matches
+  });
+
+  it("returns false when string does not end with target", () => {
+    expect(endsWith("yo", "hello")).toBe(false);
+  });
+
+  it("works with single character target", () => {
+    expect(endsWith("o", "hello")).toBe(true);
+    expect(endsWith("x", "hello")).toBe(false);
+  });
+
+  it("is case-sensitive", () => {
+    expect(endsWith("Lo", "hello")).toBe(false);
+    expect(endsWith("lo", "hello")).toBe(true);
+  });
+});

package/utils/__tests__/find.test.ts

@@ -0,0 +1,36 @@
+import { find } from "../find";
+
+test("example 1", () => {
+  const predicate = <T>(_: T, index: number): boolean => index === 0;
+  const xs = ["1", "2", "2", "3", "4"];
+
+  expect(find(predicate, xs)).toBe("1");
+});
+
+test("example 2", () => {
+  const predicate = <T>(_: T, index: number): boolean => index === 0;
+  const xs: string[] = [];
+
+  expect(find(predicate, xs)).toBe(undefined);
+});
+
+test("example 3", () => {
+  const predicate = () => false;
+  const xs = ["1", "2", "2", "3"];
+
+  expect(find(predicate, xs)).toBe(undefined);
+});
+
+test("example 4", () => {
+  const predicate = <T>(_: T, index: number): boolean => index === 1;
+  const xs = ["1", "2", "2", "3"];
+
+  expect(find(predicate, xs)).toBe("2");
+});
+
+test("example 5", () => {
+  const predicate = <T>(_: T, index: number): boolean => index === 2;
+  const xs = ["1", "2.1", "2", "3", "2", "4"];
+
+  expect(find(predicate, xs)).toBe("2");
+});