@applicaster/zapp-react-native-utils 14.0.0-alpha.3552323332 → 14.0.0-alpha.3652810444

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__/equals.test.ts

@@ -0,0 +1,65 @@
+import { equals } from "../equals";
+
+describe("equals", () => {
+  it("returns true for two identical primitive values", () => {
+    expect(equals(5, 5)).toBe(true);
+    expect(equals("hello", "hello")).toBe(true);
+    expect(equals(true, true)).toBe(true);
+  });
+
+  it("returns false for two different primitive values", () => {
+    expect(equals(5, 10)).toBe(false);
+    expect(equals("hello", "world")).toBe(false);
+    expect(equals(true, false)).toBe(false);
+  });
+
+  it("returns true for deeply equal objects", () => {
+    const a = { x: 1, y: { z: 2 } };
+    const b = { x: 1, y: { z: 2 } };
+    expect(equals(a, b)).toBe(true);
+  });
+
+  it("returns false for objects with different values", () => {
+    const a = { x: 1, y: { z: 2 } };
+    const b = { x: 1, y: { z: 3 } };
+    expect(equals(a, b)).toBe(false);
+  });
+
+  it("returns true for arrays with same elements", () => {
+    expect(equals([1, 2, 3], [1, 2, 3])).toBe(true);
+  });
+
+  it("returns false for arrays with different elements", () => {
+    expect(equals([1, 2, 3], [1, 2, 4])).toBe(false);
+  });
+
+  it("returns true for nested arrays/objects", () => {
+    const a = [{ id: 1, data: [1, 2, 3] }];
+    const b = [{ id: 1, data: [1, 2, 3] }];
+    expect(equals(a, b)).toBe(true);
+  });
+
+  it("returns false for arrays with different order", () => {
+    expect(equals([1, 2, 3], [3, 2, 1])).toBe(false);
+  });
+
+  it("handles null and undefined correctly", () => {
+    expect(equals(null, null)).toBe(true);
+    expect(equals(undefined, undefined)).toBe(true);
+    expect(equals(null, undefined)).toBe(false);
+  });
+
+  it("handles dates correctly", () => {
+    const d1 = new Date("2020-01-01");
+    const d2 = new Date("2020-01-01");
+    const d3 = new Date("2021-01-01");
+
+    expect(equals(d1, d2)).toBe(true);
+    expect(equals(d1, d3)).toBe(false);
+  });
+
+  it("handles regex correctly", () => {
+    expect(equals(/abc/, /abc/)).toBe(true);
+    expect(equals(/abc/i, /abc/)).toBe(false);
+  });
+});

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

package/utils/__tests__/max.test.ts

@@ -0,0 +1,36 @@
+import { max } from "../max";
+
+describe("max", () => {
+  describe("for numbers", () => {
+    it("returns the first argument when it is greater", () => {
+      expect(max(10, 5)).toBe(10);
+    });
+
+    it("returns the second argument when it is greater", () => {
+      expect(max(3, 7)).toBe(7);
+    });
+
+    it("returns the same value when both arguments are equal", () => {
+      expect(max(4, 4)).toBe(4);
+    });
+
+    it("works with negative numbers", () => {
+      expect(max(-2, -5)).toBe(-2);
+    });
+
+    it("works when one argument is negative and the other is positive", () => {
+      expect(max(-10, 20)).toBe(20);
+    });
+
+    it("works with zeros", () => {
+      expect(max(0, 0)).toBe(0);
+      expect(max(0, -1)).toBe(0);
+    });
+  });
+
+  describe("for letters", () => {
+    it("returns the second argument when it is greater", () => {
+      expect(max("a", "b")).toBe("b");
+    });
+  });
+});

package/utils/__tests__/omit.test.ts

@@ -0,0 +1,19 @@
+import { omit } from "../omit";
+
+test("example 1", () => {
+  const path = ["a", "b", "c"];
+  const record = { a: 1, b: 2, c: 3 };
+
+  const output = {};
+
+  expect(omit(path, record)).toEqual(output);
+});
+
+test("example 2", () => {
+  const path = ["a", "b"];
+  const record = { a: 1, b: 2, c: 3 };
+
+  const output = { c: 3 };
+
+  expect(omit(path, record)).toEqual(output);
+});

package/utils/__tests__/path.test.ts

@@ -0,0 +1,33 @@
+import { path } from "../path";
+
+test("example 1", () => {
+  const route = ["a", "b", "c"];
+  const xs = { a: { b: { c: 1 } } };
+
+  const output = 1;
+
+  expect(path(route, xs)).toEqual(output);
+});
+
+test("example 2", () => {
+  const route = ["a", "b"];
+  const xs = { a: { b: { c: 1 } } };
+
+  const output = { c: 1 };
+
+  expect(path(route, xs)).toEqual(output);
+});
+
+test("example 3", () => {
+  const route = ["a", "b", "x"];
+  const xs = { a: { b: { c: 1 } } };
+
+  expect(path(route, xs)).toBeUndefined();
+});
+
+test("example 4", () => {
+  const route = ["a", "b", "c"];
+  const xs = undefined;
+
+  expect(path(route, xs)).toBeUndefined();
+});

package/utils/__tests__/pathOr.test.ts

@@ -0,0 +1,37 @@
+import { pathOr } from "../pathOr";
+
+test("example 1", () => {
+  const defaultValue = "defaultValue";
+  const path = ["a", "b", "c"];
+  const xs = { a: { b: { c: 1 } } };
+
+  const output = 1;
+
+  expect(pathOr(defaultValue, path, xs)).toEqual(output);
+});
+
+test("example 2", () => {
+  const defaultValue = "defaultValue";
+  const path = ["a", "b"];
+  const xs = { a: { b: { c: 1 } } };
+
+  const output = { c: 1 };
+
+  expect(pathOr(defaultValue, path, xs)).toEqual(output);
+});
+
+test("example 3", () => {
+  const defaultValue = "defaultValue";
+  const path = ["a", "b", "x"];
+  const xs = { a: { b: { c: 1 } } };
+
+  expect(pathOr(defaultValue, path, xs)).toBe(defaultValue);
+});
+
+test("example 4", () => {
+  const defaultValue = "defaultValue";
+  const path = ["a", "b", "c"];
+  const xs = undefined;
+
+  expect(pathOr(defaultValue, path, xs)).toBe(defaultValue);
+});

package/utils/__tests__/startsWith.test.ts

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

package/utils/__tests__/take.test.ts

@@ -0,0 +1,40 @@
+import { take } from "../take";
+
+describe("take", () => {
+  it("takes n elements from the beginning", () => {
+    expect(take(2, [1, 2, 3])).toEqual([1, 2]);
+  });
+
+  it("returns the whole array if n is larger than length", () => {
+    expect(take(5, [1, 2, 3])).toEqual([1, 2, 3]);
+  });
+
+  it("returns empty array if n is 0", () => {
+    expect(take(0, [1, 2, 3])).toEqual([]);
+  });
+
+  it("returns empty array for empty input array", () => {
+    expect(take(2, [])).toEqual([]);
+  });
+
+  it("returns empty array if n is negative", () => {
+    expect(take(-1, [1, 2, 3])).toEqual([]);
+  });
+
+  it("works with strings in array", () => {
+    expect(take(2, ["a", "b", "c"])).toEqual(["a", "b"]);
+  });
+
+  it("works with objects in array", () => {
+    const arr = [{ id: 1 }, { id: 2 }];
+    expect(take(1, arr)).toEqual([{ id: 1 }]);
+  });
+
+  it("returns empty array if input is not an array", () => {
+    // @ts-expect-error testing non-array input
+    expect(take(2, null)).toEqual([]);
+
+    // @ts-expect-error testing non-array input
+    expect(take(2, undefined)).toEqual([]);
+  });
+});

package/utils/__tests__/toLower.test.ts

@@ -0,0 +1,39 @@
+import { toLower } from "../toLower";
+
+describe("toLower", () => {
+  it("converts mixed case string to lowercase", () => {
+    expect(toLower("--Foo-Bar--")).toBe("--foo-bar--");
+    expect(toLower("fooBar")).toBe("foobar");
+    expect(toLower("__FOO_BAR__")).toBe("__foo_bar__");
+  });
+
+  it("returns the same string if already lowercase", () => {
+    expect(toLower("hello")).toBe("hello");
+  });
+
+  it("converts uppercase string to lowercase", () => {
+    expect(toLower("HELLO")).toBe("hello");
+  });
+
+  it("handles empty string", () => {
+    expect(toLower("")).toBe("");
+  });
+
+  it("converts string with numbers and symbols", () => {
+    expect(toLower("123-ABC-xyz")).toBe("123-abc-xyz");
+  });
+
+  it("handles null and undefined gracefully", () => {
+    // @ts-expect-error testing null input
+    expect(toLower(null)).toBe("");
+    // @ts-expect-error testing undefined input
+    expect(toLower(undefined)).toBe("");
+  });
+
+  it("coerces non-string values to string before lowercasing", () => {
+    // @ts-expect-error testing number input
+    expect(toLower(12345)).toBe("12345");
+    // @ts-expect-error testing boolean input
+    expect(toLower(true)).toBe("true");
+  });
+});

package/utils/endsWith.ts

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

package/utils/equals.ts

@@ -0,0 +1,5 @@
+import { isEqual } from "lodash";
+
+export function equals(a: any, b: any): boolean {
+  return isEqual(a, b);
+}

package/utils/find.ts

@@ -0,0 +1,3 @@
+export const find = (predicate, xs) => {
+  return (xs || []).find((x, index) => predicate(x, index));
+};

package/utils/index.ts

@@ -2,4 +2,40 @@ export { chunk } from "./chunk";
 
 export { times } from "./times";
 
-export { cloneDeep as clone, flatten, drop, size, isNil } from "lodash";
+export { startsWith } from "./startsWith";
+
+export { find } from "./find";
+
+export { pathOr } from "./pathOr";
+
+export { path } from "./path";
+
+export { omit } from "./omit";
+
+export { endsWith } from "./endsWith";
+
+export { max } from "./max";
+
+export { equals } from "./equals";
+
+export { take } from "./take";
+
+export { toLower } from "./toLower";
+
+export {
+  cloneDeep as clone,
+  flatten,
+  drop,
+  size,
+  isNil,
+  isEmpty,
+  get,
+  has,
+  flatMap,
+  difference,
+  pick,
+  map,
+  trim,
+  toString,
+  last,
+} from "lodash";

package/utils/max.ts

@@ -0,0 +1,5 @@
+type Value = number | string;
+
+export function max(a: Value, b: Value): Value {
+  return a > b ? a : b;
+}

package/utils/omit.ts

@@ -0,0 +1,5 @@
+import { omit as Lodash_omit } from "lodash";
+
+export const omit = (path, record) => {
+  return Lodash_omit(record, path);
+};

package/utils/path.ts

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

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/utils/take.ts

@@ -0,0 +1,5 @@
+import { take as Ltake } from "lodash";
+
+export function take<T>(n: number, xs: T[]): T[] {
+  return Ltake(xs, n);
+}

package/utils/toLower.ts

@@ -0,0 +1,5 @@
+import { toLower as L_toLower } from "lodash";
+
+export function toLower(value: Option<string>): string {
+  return L_toLower(value);
+}