@applicaster/zapp-react-native-bridge 11.0.0-rc.99 → 12.0.0-rc.1

package/OfflineAssets/__tests__/utils.test.ts

@@ -76,9 +76,9 @@ describe("remapAssetPath", () => {
       },
     ];
 
-    const result = {
-      "file://asset.jpg": true,
-      "file://asset.png": true,
+    const result: Record<string, string> = {
+      "http://img.com/asset.jpg": "file://asset.jpg",
+      "http://img.com/asset.png": "file://asset.png",
     };
 
     expect(remapAssetPath(assets, config, result)).toMatchSnapshot();
@@ -97,7 +97,7 @@ describe("collectAssets", () => {
       },
     };
 
-    expect(collectAssets(config, "/nativ/path", "files")).toMatchSnapshot();
+    expect(collectAssets(config, "/nativ/path", "files", [])).toMatchSnapshot();
   });
 });
 

package/OfflineAssets/index.ts

@@ -3,6 +3,7 @@ import * as R from "ramda";
 import md5 from "md5";
 
 import { reducePromises } from "@applicaster/zapp-react-native-utils/arrayUtils";
+import { bridgeLogger } from "../logger";
 
 const { OfflineAssetsBridge } = NativeModules as {
   OfflineAssetsBridge: OfflineAssetsBridgeI;
@@ -57,7 +58,7 @@ function getNativeFileName(nativeRootPath, url, path) {
   const fileNameWithoutQuery = url.split("?")[0];
   const extension = R.compose(R.last, R.split("."))(fileNameWithoutQuery);
 
-  return `${nativeRootPath}/${path}/${md5(fileNameWithoutQuery)}.${extension}`;
+  return `${nativeRootPath}/${path}/${md5(url)}.${extension}`;
 }
 
 function propOrIndex(value) {
@@ -78,21 +79,45 @@ export const fileIsSaved = R.curry((savedFilesResult, { file }) => {
 
 export const remapAssetPath = (
   assets: FilesList,
-  source: {},
-  savedFilesResult?: StoredFilesResult
-) =>
-  R.reduce(
-    (obj, { path, file, url }) =>
-      R.set(
-        R.lensPath(path),
-        fileIsSaved(savedFilesResult, { file }) ? file : url,
-        obj
-      ),
-    source,
-    assets
-  );
+  source: Record<string, any>,
+  localFiles: Record<string, string>
+): Record<string, any> => {
+  return assets.reduce((obj, { path, url }) => {
+    const localFile = localFiles[url];
+
+    if (!localFile) {
+      bridgeLogger.warning({
+        message: `remapAssetPath: Could not replace asset with local file for url: ${url}`,
+        data: { path, obj }});
+
+      return obj;
+    }
+
+    let target = obj;
+
+    // Traverse the path to the appropriate nested object
+    for (let i = 0; i < path.length - 1; i++) {
+      target = target[path[i]] = target[path[i]];
+    }
+
+    if (!target) {
+      bridgeLogger.error({message: `remapAssetPath: Could not find path ${path.join(".")}`, data: obj});
+    } else {
+      // Set the final value
+      target[path[path.length - 1]] = localFile;
+    }
+
+    return obj;
+  }, R.clone(source));
+};
 
 export function collectAssets(object, nativeRootPath, source, path = []) {
+  if (!object) {
+    const message = `collectAssets: object is null or undefined for source: ${source}`;
+    bridgeLogger.error({ message, data: { object, path } });
+    throw new Error(message);
+  }
+
   return Object.entries(object).reduce((assets, [prop, value]) => {
     const propPath = [...path, propOrIndex(prop)];
 

package/PushNotifications/PushTopicManager.ts

@@ -0,0 +1,127 @@
+import { createLogger } from "@applicaster/zapp-react-native-utils/logger";
+import { BehaviorSubject } from "rxjs";
+import { pushBridge } from "./index";
+
+const {
+  registerTags: _registerTags,
+  unregisterTags: _unregisterTags,
+  getRegisteredTags: _getRegisteredTags,
+} = pushBridge;
+
+import { bridgeLogger } from "../logger";
+
+export const { log_verbose, log_debug, log_warning, log_info, log_error } =
+  createLogger({
+    category: "PushTopicManager",
+    subsystem: "zapp-react-native-bridge",
+    parent: bridgeLogger,
+  });
+
+export class PushTopicManager {
+  private registeredTags: string[] | null;
+  private pushTopicSubject: BehaviorSubject<string[] | null>;
+
+  constructor() {
+    void this.prepareTags();
+  }
+
+  getEntryObservable = (): BehaviorSubject<string[]> => {
+    return this.pushTopicSubject;
+  };
+
+  notifyTagsChange = () => {
+    this.pushTopicSubject.next(this.registeredTags);
+  };
+
+  prepareTags = async () => {
+    try {
+      this.pushTopicSubject = new BehaviorSubject(null);
+      this.registeredTags = await _getRegisteredTags();
+
+      log_debug(
+        `prepareTags: Current registered tags: '${this.registeredTags.join(
+          ","
+        )}'`
+      );
+
+      this.notifyTagsChange();
+    } catch (error) {
+      log_error(`prepareTags: Error while preparing tags: ${error.message}`, {
+        error,
+      });
+
+      throw error;
+    }
+  };
+
+  registerTags = async (tags: string[]) => {
+    try {
+      log_debug(
+        `registerTags: Native code will register new tags: '${tags.join(",")}'`
+      );
+
+      await _registerTags(tags);
+
+      this.registeredTags = this.registeredTags.concat(tags);
+
+      log_debug(
+        `registerTags: Tags were successfully registered. New list of existing tags: '${this.registeredTags.join(
+          ","
+        )}'. Notify subscribers`
+      );
+
+      this.notifyTagsChange();
+    } catch (error) {
+      log_error(
+        `registerTags: Error while registering tags: ${error.message}`,
+        { error }
+      );
+
+      throw error;
+    }
+  };
+
+  unregisterTags = async (tags: string[]) => {
+    try {
+      log_debug(
+        `unregisterTags: Native code will unregister new tags: '${tags.join(
+          ","
+        )}'`
+      );
+
+      await _unregisterTags(tags);
+
+      this.registeredTags = this.registeredTags.filter(
+        (tag) => !tags.includes(tag)
+      );
+
+      log_debug(
+        `unregisterTags: Tags were successfully unregistered. New list of existing tags: '${this.registeredTags.join(
+          ","
+        )}'. Notify subscribers`
+      );
+
+      this.notifyTagsChange();
+    } catch (error) {
+      log_error(
+        `unregisterTags: Error while unregistering tags: ${error.message}`,
+        { error }
+      );
+
+      throw error;
+    }
+  };
+
+  getRegisteredTags = () => {
+    return this.registeredTags;
+  };
+
+  private static instance: PushTopicManager;
+  public static getInstance() {
+    if (!PushTopicManager.instance) {
+      PushTopicManager.instance = new PushTopicManager();
+    }
+
+    return PushTopicManager.instance;
+  }
+}

package/PushNotifications/index.ts

@@ -22,7 +22,7 @@ const { PushBridge = defaultPushNotification } = NativeModules as {
 export const pushBridge = {
   /**
    * Register push tags to push notification provider
-   * @param  {String} tags Tags array to reginster
+   * @param  {String} tags Tags array to register
    */
   async registerTags(tags) {
     return PushBridge.registerTags(tags);
@@ -30,7 +30,7 @@ export const pushBridge = {
 
   /**
    * Unregister push tags to push notification provider
-   * @param  {String} tags Tags array to reginster
+   * @param  {String} tags Tags array to register
    */
   async unregisterTags(tags) {
     return PushBridge.unregisterTags(tags);

package/QuickBrick/index.ts

@@ -1,4 +1,3 @@
-// @flow
 import * as R from "ramda";
 import { Platform } from "react-native";
 import uuidv4 from "uuid/v4";

package/ZappStorage/StorageMultiSelectProvider.ts

@@ -0,0 +1,153 @@
+import { createLogger } from "@applicaster/zapp-react-native-utils/logger";
+import { bridgeLogger } from "../logger";
+import { BehaviorSubject } from "rxjs";
+import { localStorage } from "@applicaster/zapp-react-native-bridge/ZappStorage/LocalStorage";
+import { getNamespaceAndKey } from "@applicaster/zapp-react-native-utils/appUtils/contextKeysManager/utils";
+
+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<string, StorageMultiSelectProvider> = {};
+
+  public static getProvider(keyNamespace:string): StorageMultiSelectProvider {
+    if (!this.multiSelectProviders[keyNamespace]) {
+      this.multiSelectProviders[keyNamespace] = new StorageMultiSelectProvider(keyNamespace);
+    }
+
+    return this.multiSelectProviders[keyNamespace];
+  }
+
+  private itemSubject: 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("StorageMultiSelectProvider: Key is required");
+    }
+
+    this.key = key;
+    this.namespace = namespace;
+    localStorage.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 localStorage.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 localStorage.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 localStorage.removeItem(this.key, this.namespace);
+    log_debug(`removeAllItems: Removing all items, current items: ${[]}`);
+
+    this.itemSubject.next([]);
+  }
+
+  public getSelectedAsync = async (): Promise<string[]> => {
+    const value = await localStorage.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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applicaster/zapp-react-native-bridge",
-  "version": "11.0.0-rc.99",
+  "version": "12.0.0-rc.1",
   "description": "Applicaster Zapp React Native modules",
   "main": "index.js",
   "types": "index.d.ts",
@@ -33,7 +33,7 @@
   "homepage": "https://github.com/applicaster/quickbrick#readme",
   "dependencies": {
     "@applicaster/zapp-pipes-dev-kit": "1.4.7",
-    "@applicaster/zapp-react-native-utils": "11.0.0-rc.99",
+    "@applicaster/zapp-react-native-utils": "12.0.0-rc.1",
     "md5": "^2.3.0",
     "uuid": "^3.3.2"
   },