@applicaster/zapp-react-native-utils 14.0.0-alpha.1101330035 → 14.0.0-alpha.1152359078

package/storage/ScreenSingleValueProvider.ts

@@ -2,6 +2,7 @@ import { BehaviorSubject } from "rxjs";
 import { SingleValueProvider } from "./StorageSingleSelectProvider";
 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: "ScreenSingleValueProvider",
@@ -22,7 +23,7 @@ export class ScreenSingleValueProvider implements SingleValueProvider {
   public static getProvider(
     key: string,
     screenRoute: string,
-    screenStateStore: ScreenStateStore
+    screenStateStore: ReturnType<typeof useScreenStateStore>
   ): SingleValueProvider {
     if (!key) {
       throw new Error("ScreenSingleValueProvider: Key is required");
@@ -66,7 +67,7 @@ export class ScreenSingleValueProvider implements SingleValueProvider {
   private constructor(
     private key: string,
     route: string,
-    private screenStateStore: ScreenStateStore
+    private screenStateStore: ReturnType<typeof useScreenStateStore>
   ) {
     if (!key) {
       throw new Error("ScreenSingleValueProvider: Key is required");
@@ -88,7 +89,9 @@ export class ScreenSingleValueProvider implements SingleValueProvider {
     log_debug("ScreenSingleValueProvider: Initializing", { key, route });
   }
 
-  private updateStore(screenStateStore: ScreenStateStore): void {
+  private updateStore(
+    screenStateStore: ReturnType<typeof useScreenStateStore>
+  ): void {
     this.cleanup();
     this.screenStateStore = screenStateStore;
     this.setupScreenStateSubscription();
@@ -100,25 +103,25 @@ export class ScreenSingleValueProvider implements SingleValueProvider {
       (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,
-          });
-        }
-      }
+      })
+      // (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(

package/storage/ScreenStateMultiSelectProvider.ts

@@ -2,6 +2,7 @@ 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",
@@ -22,7 +23,7 @@ export class ScreenMultiSelectProvider implements MultiSelectProvider {
   public static getProvider(
     key: string,
     screenRoute: string,
-    screenStateStore: ScreenStateStore
+    screenStateStore: ReturnType<typeof useScreenStateStore>
   ): MultiSelectProvider {
     if (!key) {
       throw new Error("ScreenMultiSelectProvider: Key is required");
@@ -66,7 +67,7 @@ export class ScreenMultiSelectProvider implements MultiSelectProvider {
   private constructor(
     private key: string,
     route: string,
-    private screenStateStore: ScreenStateStore
+    private screenStateStore: ReturnType<typeof useScreenStateStore>
   ) {
     if (!key) {
       throw new Error("ScreenMultiSelectProvider: Key is required");
@@ -88,7 +89,9 @@ export class ScreenMultiSelectProvider implements MultiSelectProvider {
     log_debug("ScreenMultiSelectProvider: Initializing", { key, route });
   }
 
-  private updateStore(screenStateStore: ScreenStateStore): void {
+  private updateStore(
+    screenStateStore: ReturnType<typeof useScreenStateStore>
+  ): void {
     if (screenStateStore === this.screenStateStore) {
       return;
     }
@@ -104,26 +107,26 @@ export class ScreenMultiSelectProvider implements MultiSelectProvider {
       (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,
-          });
-        }
-      }
+      })
+      // (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(

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,7 +11,7 @@ class BackgroundTimer {
     this.uniqueId = 0;
     this.callbacks = {};
 
-    const EventEmitter = platformSelect({
+    const EventEmitter: typeof DeviceEventEmitter | undefined = platformSelect({
       android: DeviceEventEmitter,
       android_tv: DeviceEventEmitter,
       amazon: DeviceEventEmitter, // probably does not exist and uses android_tv

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

package/utils/__tests__/mapAccum.test.ts

@@ -0,0 +1,73 @@
+import { mapAccum } from "../mapAccum";
+
+describe("mapAccum", () => {
+  it("using standard ramda test", () => {
+    const digits = ["1", "2", "3", "4"];
+    const appender = (a, b) => [a + b, a + b];
+
+    const [acc, result] = mapAccum(appender, 0, digits); //= > ['01234', ['01', '012', '0123', '01234']]
+    expect(acc).toBe("01234");
+    expect(result).toEqual(["01", "012", "0123", "01234"]);
+  });
+
+  it("maps and accumulates over an array", () => {
+    const fn = (acc, x) => [acc + x, x * 2];
+    const [acc, result] = mapAccum(fn, 0, [1, 2, 3]);
+
+    expect(acc).toBe(6); // final accumulator (0 + 1 + 2 + 3)
+    expect(result).toEqual([2, 4, 6]); // mapped values (acc + x*2 at each step)
+  });
+
+  it("returns initial accumulator for empty array", () => {
+    const fn = (acc, x) => [acc + x, acc * x];
+    const [acc, result] = mapAccum(fn, 10, []);
+
+    expect(acc).toBe(10);
+    expect(result).toEqual([]);
+  });
+
+  it("accumulates strings correctly", () => {
+    const fn = (acc, x) => [acc + x, acc + x];
+    const [acc, result] = mapAccum(fn, "A", ["B", "C", "D"]);
+
+    expect(acc).toBe("ABCD");
+    expect(result).toEqual(["AB", "ABC", "ABCD"]);
+  });
+
+  it("works with objects as accumulator", () => {
+    const fn = (acc, x) => {
+      const newAcc = { sum: acc.sum + x };
+
+      return [newAcc, newAcc.sum];
+    };
+
+    const [acc, result] = mapAccum(fn, { sum: 0 }, [1, 2, 3]);
+
+    expect(acc).toEqual({ sum: 6 });
+    expect(result).toEqual([1, 3, 6]);
+  });
+
+  it("is curried", () => {
+    const fn = (acc, x) => [acc + x, x * 2];
+    const mapWithFn = mapAccum(fn);
+    const withInit = mapWithFn(2);
+    const [acc, result] = withInit([1, 2, 3]);
+
+    expect(acc).toBe(8);
+    expect(result).toEqual([2, 4, 6]);
+  });
+
+  it("does not mutate the original array", () => {
+    const arr = [1, 2, 3];
+    mapAccum((acc, x) => [acc + x, acc + x], 0, arr);
+    expect(arr).toEqual([1, 2, 3]);
+  });
+
+  it("handles mixed types in accumulator and result", () => {
+    const fn = (acc, x) => [acc + x.length, acc + "-" + x];
+    const [acc, result] = mapAccum(fn, 0, ["a", "bb", "ccc"]);
+
+    expect(acc).toBe(6);
+    expect(result).toEqual(["0-a", "1-bb", "3-ccc"]);
+  });
+});

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/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/find.ts

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

package/utils/index.ts

@@ -2,6 +2,22 @@ export { chunk } from "./chunk";
 
 export { times } from "./times";
 
+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 { take } from "./take";
+
+export { mapAccum } from "./mapAccum";
+
 export {
   cloneDeep as clone,
   flatten,
@@ -13,8 +29,14 @@ export {
   has,
   flatMap,
   difference,
-  take,
+  pick,
   map,
   trim,
   toString,
+  last,
+  toLower,
+  isEqual as equals,
+  flowRight as compose,
+  partial,
+  reverse,
 } from "lodash";

package/utils/mapAccum.ts

@@ -0,0 +1,23 @@
+import { curry } from "lodash";
+
+/**
+ * A native reimplementation of Ramda's mapAccum.
+ *
+ * @template A, B, C
+ * @param {(acc: A, value: B) => [A, C]} fn - Function returning [newAcc, mappedValue]
+ * @param {A} acc - Initial accumulator
+ * @param {B[]} list - List to process
+ * @returns {[A, C[]]} - Tuple of [final accumulator, mapped array]
+ */
+export const mapAccum = curry((fn, acc, list) => {
+  const result = [];
+  let currentAcc = acc;
+
+  for (let i = 0; i < list.length; i++) {
+    const [nextAcc, mapped] = fn(currentAcc, list[i]);
+    currentAcc = nextAcc;
+    result.push(mapped);
+  }
+
+  return [currentAcc, result];
+});

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