@applicaster/zapp-react-native-utils 16.0.0-rc.46 → 16.0.0-rc.48

package/arrayUtils/__tests__/{anyThruthy.test.ts → anyTruthy.test.ts}

@@ -21,4 +21,12 @@ describe("anyTruthy", () => {
     expect(anyTruthy([true])).toBe(true);
     expect(anyTruthy([false])).toBe(false);
   });
+
+  it("should return true when the first value is true", () => {
+    expect(anyTruthy([true, false, false])).toBe(true);
+  });
+
+  it("should return true when only the last value is true", () => {
+    expect(anyTruthy([false, false, true])).toBe(true);
+  });
 });

package/arrayUtils/__tests__/arrayUtils.test.ts

@@ -28,6 +28,30 @@ describe("shiftArray", () => {
     expect(shiftArray(negativeOffset, array)).toMatchSnapshot();
     expect(shiftArray(2 * negativeOffset, array)).toMatchSnapshot();
   });
+
+  it("returns a new array and does not mutate the original", () => {
+    const original = ["a", "b", "c"];
+    const result = shiftArray(1, original);
+
+    expect(result).toEqual(["b", "c", "a"]);
+    expect(result).not.toBe(original);
+    expect(original).toEqual(["a", "b", "c"]);
+  });
+
+  it("returns an empty array when shifting an empty array", () => {
+    expect(shiftArray(1, [])).toEqual([]);
+    expect(shiftArray(-1, [])).toEqual([]);
+  });
+
+  it("returns the same order for a single-element array", () => {
+    expect(shiftArray(1, [1])).toEqual([1]);
+    expect(shiftArray(-1, [1])).toEqual([1]);
+  });
+
+  it("handles an offset equal to the array length", () => {
+    expect(shiftArray(4, array)).toEqual(array);
+    expect(shiftArray(-4, array)).toEqual(array);
+  });
 });
 
 describe("removeItemFromList", () => {
@@ -58,6 +82,38 @@ describe("removeItemFromList", () => {
       arrayOfObjects
     );
   });
+
+  it("returns the same reference when the item is not found", () => {
+    const list = [1, 2, 3];
+
+    expect(removeItemFromList(4, list)).toBe(list);
+  });
+
+  it("returns a new array when the item is removed", () => {
+    const list = [1, 2, 3];
+    const result = removeItemFromList(2, list);
+
+    expect(result).toEqual([1, 3]);
+    expect(result).not.toBe(list);
+    expect(list).toEqual([1, 2, 3]);
+  });
+
+  it("removes only the first occurrence of a duplicate item", () => {
+    expect(removeItemFromList(2, [1, 2, 2, 3])).toEqual([1, 2, 3]);
+  });
+
+  it("removes the first and last items", () => {
+    expect(removeItemFromList(1, [1, 2, 3])).toEqual([2, 3]);
+    expect(removeItemFromList(3, [1, 2, 3])).toEqual([1, 2]);
+  });
+
+  it("returns an empty list when removing from an empty list", () => {
+    expect(removeItemFromList(1, [])).toEqual([]);
+  });
+
+  it("returns an empty list when removing the only item", () => {
+    expect(removeItemFromList(1, [1])).toEqual([]);
+  });
 });
 
 describe("mapPromises", () => {
@@ -84,145 +140,146 @@ describe("mapPromises", () => {
     values.forEach((value) => {
       expect(promiseFn).toHaveBeenNthCalledWith(value, value, value - 1);
     });
-  });
 
-  describe("removeItemFromList", () => {
-    it("removes an item from a list", () => {
-      const arrayOfPrimitives = [1, 2, 3, 4];
-      expect(removeItemFromList(1, arrayOfPrimitives)).toEqual([2, 3, 4]);
+    expect.assertions(values.length + 1);
+  });
 
-      const arrayOfObjects = [
-        { prop: "value1" },
-        { prop: "value2" },
-        { prop: "value3" },
-      ];
+  it("resolves to an empty array for an empty input", async () => {
+    await expect(mapPromises(promiseFn, [])).resolves.toEqual([]);
+    expect(promiseFn).not.toHaveBeenCalled();
+  });
 
-      expect(removeItemFromList({ prop: "value2" }, arrayOfObjects)).toEqual([
-        { prop: "value1" },
-        { prop: "value3" },
-      ]);
-    });
+  it("rejects when any promise rejects", async () => {
+    const failingFn = jest.fn((num) =>
+      num === 2 ? Promise.reject(new Error("fail")) : Promise.resolve(num)
+    );
 
-    it("leaves the list as is if the item is not found", () => {
-      const arrayOfObjects = [
-        { prop: "value1" },
-        { prop: "value2" },
-        { prop: "value3" },
-      ];
+    await expect(mapPromises(failingFn, [1, 2, 3])).rejects.toThrow("fail");
+  });
+});
 
-      expect(removeItemFromList({ prop: "value4" }, arrayOfObjects)).toEqual(
-        arrayOfObjects
-      );
+describe("reducePromises", () => {
+  const promiseFn = jest.fn((current, previous, index, cb) => {
+    return new Promise((resolve) => {
+      setTimeout(() => {
+        resolve(previous + current);
+        cb?.(index);
+      }, 1);
     });
   });
 
-  describe("mapPromises", () => {
-    const promiseFn = jest.fn((num) => Promise.resolve(num + 1));
+  beforeEach(() => {
+    promiseFn.mockClear();
+  });
 
-    beforeEach(() => {
-      promiseFn.mockClear();
-    });
+  it("is a curried function; and returns the reduced promise values", async () => {
+    const promiseReducer = reducePromises(promiseFn);
 
-    it("is a curried function, and returns an array of resolved values", async () => {
-      const promiseMapper = mapPromises(promiseFn);
-      const values = [1, 2, 3];
+    const initialValue = 0;
+    const values = [1, 2, 3];
+    const sumOfValues = initialValue + values.reduce((a, b) => a + b, 0);
 
-      expect(typeof promiseMapper).toBe("function");
-      await expect(promiseMapper(values)).resolves.toEqual([2, 3, 4]);
-    });
+    expect(typeof promiseReducer).toBe("function");
 
-    it("calls all the promises immediately", () => {
-      const values = [1, 2, 3];
+    await expect(promiseReducer(initialValue, values)).resolves.toEqual(
+      sumOfValues
+    );
+  });
 
-      mapPromises(promiseFn, values);
-      expect(promiseFn).toHaveBeenCalledTimes(values.length);
+  it("calls promises one after the other", (done) => {
+    const values = [1, 2, 3];
+    const previousValues = [0, 1, 3];
+
+    reducePromises(
+      (current, previous, index) =>
+        promiseFn(current, previous, index, (index) => {
+          expect(promiseFn).toHaveBeenCalledTimes(index + 1);
+
+          expect(promiseFn).toHaveBeenNthCalledWith(
+            index + 1,
+            values[index],
+            previousValues[index],
+            index,
+            expect.any(Function)
+          );
+
+          if (index === 2) done();
+        }),
+      0,
+      values
+    );
 
-      values.forEach((value) => {
-        expect(promiseFn).toHaveBeenNthCalledWith(value, value, value - 1);
-      });
+    expect.assertions(values.length * 2);
+  });
 
-      expect.assertions(values.length + 1);
-    });
+  it("returns the initial value for an empty list", async () => {
+    await expect(reducePromises(promiseFn, 10, [])).resolves.toBe(10);
+    expect(promiseFn).not.toHaveBeenCalled();
   });
 
-  describe("reduce promises", () => {
-    const promiseFn = jest.fn((current, previous, index, cb) => {
-      return new Promise((resolve) => {
-        setTimeout(() => {
-          resolve(previous + current);
-          cb?.(index);
-        }, 1);
-      });
-    });
+  it("reduces a single-element list", async () => {
+    await expect(reducePromises(promiseFn, 5, [2])).resolves.toBe(7);
+  });
 
-    beforeEach(() => {
-      promiseFn.mockClear();
+  it("rejects when a promise rejects", async () => {
+    const failingFn = jest.fn(async (current, previous) => {
+      if (current === 2) throw new Error("reduce fail");
+
+      return previous + current;
     });
 
-    it("is a curried function; and returns the reduced promise values", async () => {
-      const promiseReducer = reducePromises(promiseFn);
+    await expect(reducePromises(failingFn, 0, [1, 2, 3])).rejects.toThrow(
+      "reduce fail"
+    );
+  });
+});
+
+describe("mapAndSplit", () => {
+  it("maps over a list of values and split it in chunks", () => {
+    const values = new Array(20).fill(0).map((_, i) => i);
+
+    const alphabet = Array.from(Array(26)).map((_, i) =>
+      String.fromCharCode(i + 65)
+    );
 
-      const initialValue = 0;
-      const values = [1, 2, 3];
-      const sumOfValues = initialValue + values.reduce((a, b) => a + b, 0);
+    const getLetterForInt = (num) => alphabet[num];
+    const chunkSize = 5;
 
-      expect(typeof promiseReducer).toBe("function");
+    const result = mapAndSplit<number, string>(
+      getLetterForInt,
+      chunkSize
+    )(values);
 
-      await expect(promiseReducer(initialValue, values)).resolves.toEqual(
-        sumOfValues
-      );
-    });
+    expect(result.length).toBe(values.length / chunkSize);
 
-    it("calls promises one after the other", (done) => {
-      const values = [1, 2, 3];
-      const previousValues = [0, 1, 3];
-
-      reducePromises(
-        (current, previous, index) =>
-          promiseFn(current, previous, index, (index) => {
-            expect(promiseFn).toHaveBeenCalledTimes(index + 1);
-
-            expect(promiseFn).toHaveBeenNthCalledWith(
-              index + 1,
-              values[index],
-              previousValues[index],
-              index,
-              expect.any(Function)
-            );
-
-            if (index === 2) done();
-          }),
-        0,
-        values
-      );
-
-      expect.assertions(values.length * 2);
+    result.forEach((chunk, chunkIndex) => {
+      chunk.forEach((value, index) => {
+        expect(value).toBe(alphabet[chunkIndex * chunkSize + index]);
+      });
     });
   });
 
-  describe("mapAndSplit", () => {
-    it("maps over a list of values and split it in chunks", () => {
-      const values = new Array(20).fill(0).map((_, i) => i);
+  it("is a curried function", () => {
+    const mapper = (n: number) => n * 2;
+    const splitBy2 = mapAndSplit(mapper, 2);
 
-      const alphabet = Array.from(Array(26)).map((_, i) =>
-        String.fromCharCode(i + 65)
-      );
+    expect(typeof splitBy2).toBe("function");
 
-      const getLetterForInt = (num) => alphabet[num];
-      const chunkSize = 5;
+    expect(splitBy2([1, 2, 3, 4])).toEqual([
+      [2, 4],
+      [6, 8],
+    ]);
+  });
 
-      const result = mapAndSplit<number, string>(
-        getLetterForInt,
-        chunkSize
-      )(values);
+  it("returns an empty list for an empty input", () => {
+    expect(mapAndSplit((n: number) => n, 2)([])).toEqual([]);
+  });
 
-      expect(result.length).toBe(values.length / chunkSize);
+  it("puts remaining items in a final smaller chunk", () => {
+    expect(mapAndSplit((n: number) => n, 2)([1, 2, 3])).toEqual([[1, 2], [3]]);
+  });
 
-      result.forEach((chunk, chunkIndex) => {
-        chunk.forEach((value, index) => {
-          expect(value).toBe(alphabet[chunkIndex * chunkSize + index]);
-        });
-      });
-    });
+  it("returns a single chunk when chunk size exceeds the list length", () => {
+    expect(mapAndSplit((n: number) => n * 10, 10)([1, 2])).toEqual([[10, 20]]);
   });
 });

package/arrayUtils/__tests__/isEmptyArray.test.ts

@@ -60,4 +60,15 @@ describe("isEmptyArray", () => {
 
     expect(isEmptyArray(value)).toBe(false);
   });
+
+  it("array with falsy values is not empty", () => {
+    expect(isEmptyArray([0])).toBe(false);
+    expect(isEmptyArray([false])).toBe(false);
+    expect(isEmptyArray([null])).toBe(false);
+    expect(isEmptyArray([undefined])).toBe(false);
+  });
+
+  it("nested empty array is not empty", () => {
+    expect(isEmptyArray([[]])).toBe(false);
+  });
 });

package/arrayUtils/__tests__/isFilledArray.test.ts

@@ -60,4 +60,16 @@ describe("isFilledArray", () => {
 
     expect(isFilledArray(value)).toBe(false);
   });
+
+  it("array with falsy values is filled", () => {
+    expect(isFilledArray([0])).toBe(true);
+    expect(isFilledArray([false])).toBe(true);
+    expect(isFilledArray([null])).toBe(true);
+    expect(isFilledArray([undefined])).toBe(true);
+    expect(isFilledArray([""])).toBe(true);
+  });
+
+  it("nested empty array is filled", () => {
+    expect(isFilledArray([[]])).toBe(true);
+  });
 });

package/arrayUtils/__tests__/isFirst.test.ts

@@ -0,0 +1,17 @@
+import { isFirst } from "..";
+
+describe("isFirst", () => {
+  it("returns true for index 0", () => {
+    expect(isFirst(0)).toBe(true);
+  });
+
+  it("returns false for positive indexes", () => {
+    expect(isFirst(1)).toBe(false);
+    expect(isFirst(10)).toBe(false);
+  });
+
+  it("returns true for negative indexes", () => {
+    expect(isFirst(-1)).toBe(true);
+    expect(isFirst(-100)).toBe(true);
+  });
+});

package/arrayUtils/__tests__/isIndexInRange.test.ts

@@ -56,4 +56,18 @@ describe("isIndexInRange", () => {
 
     expect(isIndexInRange(index, length)).toBe(false);
   });
+
+  it("single-element list", () => {
+    expect(isIndexInRange(0, 1)).toBe(true);
+    expect(isIndexInRange(1, 1)).toBe(false);
+  });
+
+  it("negative length is out of range", () => {
+    expect(isIndexInRange(0, -1)).toBe(false);
+    expect(isIndexInRange(0, -5)).toBe(false);
+  });
+
+  it("middle index is in range", () => {
+    expect(isIndexInRange(1, 3)).toBe(true);
+  });
 });

package/arrayUtils/__tests__/isLast.test.ts

@@ -0,0 +1,31 @@
+import { isLast } from "..";
+
+describe("isLast", () => {
+  it("returns true for the last index", () => {
+    expect(isLast(2, 3)).toBe(true);
+  });
+
+  it("returns false for indexes before the last", () => {
+    expect(isLast(0, 3)).toBe(false);
+    expect(isLast(1, 3)).toBe(false);
+  });
+
+  it("returns true for indexes at or past the last", () => {
+    expect(isLast(3, 3)).toBe(true);
+    expect(isLast(10, 3)).toBe(true);
+  });
+
+  it("returns true for a single-element list", () => {
+    expect(isLast(0, 1)).toBe(true);
+  });
+
+  it("treats empty length as last for indexes >= -1", () => {
+    expect(isLast(0, 0)).toBe(true);
+    expect(isLast(-1, 0)).toBe(true);
+    expect(isLast(-2, 0)).toBe(false);
+  });
+
+  it("returns false for negative indexes that are before length - 1", () => {
+    expect(isLast(-1, 3)).toBe(false);
+  });
+});

package/arrayUtils/__tests__/makeListOf.test.ts

@@ -0,0 +1,31 @@
+import { makeListOf } from "..";
+
+describe("makeListOf", () => {
+  it("creates a list filled with the given value", () => {
+    expect(makeListOf("x", 3)).toEqual(["x", "x", "x"]);
+    expect(makeListOf(0, 4)).toEqual([0, 0, 0, 0]);
+  });
+
+  it("returns an empty list for size 0", () => {
+    expect(makeListOf("x", 0)).toEqual([]);
+  });
+
+  it("returns a single-element list for size 1", () => {
+    expect(makeListOf(42, 1)).toEqual([42]);
+  });
+
+  it("fills with null, undefined, and objects by reference", () => {
+    expect(makeListOf(null, 2)).toEqual([null, null]);
+    expect(makeListOf(undefined, 2)).toEqual([undefined, undefined]);
+
+    const obj = { a: 1 };
+    const result = makeListOf(obj, 2);
+
+    expect(result).toEqual([obj, obj]);
+    expect(result[0]).toBe(result[1]);
+  });
+
+  it("throws for negative size", () => {
+    expect(() => makeListOf("x", -1)).toThrow(RangeError);
+  });
+});

package/arrayUtils/__tests__/makeListOfIndexes.test.ts

@@ -0,0 +1,20 @@
+import { makeListOfIndexes } from "..";
+
+describe("makeListOfIndexes", () => {
+  it("returns a list of indexes for the given size", () => {
+    expect(makeListOfIndexes(5)).toEqual([0, 1, 2, 3, 4]);
+  });
+
+  it("returns an empty list for size 0", () => {
+    expect(makeListOfIndexes(0)).toEqual([]);
+  });
+
+  it("returns a single-element list for size 1", () => {
+    expect(makeListOfIndexes(1)).toEqual([0]);
+  });
+
+  it("returns an empty list for negative size", () => {
+    expect(makeListOfIndexes(-1)).toEqual([]);
+    expect(makeListOfIndexes(-10)).toEqual([]);
+  });
+});

package/arrayUtils/__tests__/sample.test.ts

@@ -0,0 +1,61 @@
+import { sample } from "..";
+
+declare global {
+  var __DEV__: boolean;
+}
+
+describe("sample", () => {
+  const originalDev = global.__DEV__;
+  const originalRandom = Math.random;
+
+  beforeEach(() => {
+    global.__DEV__ = true;
+  });
+
+  afterEach(() => {
+    global.__DEV__ = originalDev;
+    Math.random = originalRandom;
+  });
+
+  it("returns an item from the list", () => {
+    Math.random = () => 0.5;
+
+    expect(sample(["a", "b", "c"])).toBe("b");
+  });
+
+  it("returns the first item when random is near 0", () => {
+    Math.random = () => 0;
+
+    expect(sample(["a", "b", "c"])).toBe("a");
+  });
+
+  it("returns the last item when random is near 1", () => {
+    Math.random = () => 0.999;
+
+    expect(sample(["a", "b", "c"])).toBe("c");
+  });
+
+  it("returns the only item for a single-element list", () => {
+    Math.random = () => 0.42;
+
+    expect(sample([42])).toBe(42);
+  });
+
+  it("throws when the input is not an array", () => {
+    expect(() => sample("not-an-array" as unknown as unknown[])).toThrow(
+      /input value is not an array/
+    );
+
+    expect(() => sample(null as unknown as unknown[])).toThrow(
+      /input value is not an array/
+    );
+
+    expect(() => sample(undefined as unknown as unknown[])).toThrow(
+      /input value is not an array/
+    );
+  });
+
+  it("throws when the array is empty", () => {
+    expect(() => sample([])).toThrow(/input array is empty/);
+  });
+});

package/arrayUtils/index.ts

@@ -3,17 +3,16 @@ import * as R from "ramda";
 import { invariant } from "@applicaster/zapp-react-native-utils/errorUtils";
 
 /**
- * shifts an array by the given offset. a negative offset will take items
- * from the end of the array and add them at the beginning, while a positive offset
- * will take an item at the beginning and shift it to the end
- * shiftArray(-1, [1,2,3,4]) => [4, 1, 2, 3]
- * shiftArray(1, [1,2,3,4]) => [2, 3, 4, 1]
- * an offset of 0 leaves the array unchanged
- * this function returns a new array and doesn't mutate the original one
- * curried function which can be invoked like offset => array => result
- * @param {Number} offset offset to shift the array
- * @param {Array<T>} array array to shift
- * @returns {Array<T>}
+ * Shifts an array by the given offset and returns a new array (does not mutate).
+ * A positive offset moves items from the head to the tail;
+ * a negative offset moves items from the tail to the head.
+ * An offset of `0` leaves the order unchanged.
+ *
+ * Curried (Ramda): `shiftArray(offset)(array)` or `shiftArray(offset, array)`.
+ *
+ * @example
+ * shiftArray(-1, [1, 2, 3, 4]) // => [4, 1, 2, 3]
+ * shiftArray(1, [1, 2, 3, 4])  // => [2, 3, 4, 1]
  */
 export const shiftArray = R.curry(
   <T extends unknown>(offset: number, array: T[]): T[] => {
@@ -25,10 +24,9 @@ export const shiftArray = R.curry(
 );
 
 /**
- * Tries to remove an item from an array, and returns the array if the item is not found
- * @param {any} item to remove
- * @param {Array<any>} list to remove the item from
- * @returns {Array<any>}
+ * Removes the first item equal to `item` from `list` (Ramda `equals` / deep equality).
+ * If the item is not found, returns the same list reference; otherwise returns a new
+ * array without that element.
  */
 export function removeItemFromList<T extends unknown>(item: T, list: T[]): T[] {
   return R.compose(
@@ -37,6 +35,12 @@ export function removeItemFromList<T extends unknown>(item: T, list: T[]): T[] {
   )(list);
 }
 
+/**
+ * Maps each value to a promise and resolves them all in parallel via `Promise.all`.
+ * The mapper receives `(value, index)`.
+ *
+ * Curried (Ramda): `mapPromises(fn)(values)` or `mapPromises(fn, values)`.
+ */
 export const mapPromises = R.curry(
   <T extends unknown, S extends unknown>(
     fn: (value: T, index?: number) => Promise<S>,
@@ -44,6 +48,10 @@ export const mapPromises = R.curry(
   ): Promise<S[]> => Promise.all(R.addIndex(R.map)(R.nAry(2, fn), values))
 );
 
+/**
+ * Awaits `previousPromise`, then runs `fn(currentValue, previousValue, index)`.
+ * Used internally by `reducePromises` as a Ramda-indexed reducer step.
+ */
 const waitForPromiseAndRun = R.curryN(
   3,
   async <T extends unknown, S extends unknown>(
@@ -58,6 +66,14 @@ const waitForPromiseAndRun = R.curryN(
   }
 );
 
+/**
+ * Reduces a list by applying an async function sequentially.
+ * Each step awaits the previous result, then calls `fn(current, previous, index)`.
+ * An empty list resolves to `initialValue` without calling `fn`.
+ *
+ * Curried (Ramda): `reducePromises(fn)(initialValue)(values)` or
+ * `reducePromises(fn, initialValue, values)`.
+ */
 export const reducePromises = R.curry(
   <T extends unknown, S extends unknown>(
     fn: (current: T, previous: S, index?: number) => Promise<S>,
@@ -71,18 +87,32 @@ export const reducePromises = R.curry(
     )
 );
 
+/**
+ * Returns a function that maps a list with `mapperFn`, then splits the result
+ * into chunks of size `chunks` (`R.splitEvery`).
+ *
+ * Curried (Ramda): `mapAndSplit(mapperFn, chunks)(values)`.
+ */
 export const mapAndSplit = R.curry(
   <T extends unknown, S extends unknown>(
-    mapperFn: (T) => S,
+    mapperFn: (value: T) => S,
     chunks: number
-  ): S[][] => R.compose(R.splitEvery(chunks), R.map(mapperFn))
+  ): ((values: T[]) => S[][]) =>
+    (values: T[]) =>
+      R.splitEvery(chunks, R.map(mapperFn, values))
 );
 
+/** Returns `true` when `index` is at or past the last position (`length - 1`). */
 export const isLast = (index: number, length: number): boolean =>
   index >= length - 1;
 
+/** Returns `true` when `index` is `0` or negative. */
 export const isFirst = (index: number): boolean => index <= 0;
 
+/**
+ * Returns `true` when `index` is a valid zero-based index for a list of the
+ * given `length`. Returns `false` for empty/negative lengths or negative indexes.
+ */
 export const isIndexInRange = (index: number, length: number): boolean => {
   if (length <= 0) return false;
   if (index < 0) return false;
@@ -90,24 +120,29 @@ export const isIndexInRange = (index: number, length: number): boolean => {
   return index + 1 <= length;
 };
 
+/** Builds `[0, 1, ..., size - 1]`. Negative or zero `size` yields `[]`. */
 export const makeListOfIndexes = (size: number): number[] =>
   Array.from({ length: size }, (_, index) => index);
 
+/** Builds an array of the given `size` filled with `value`. */
 export const makeListOf = <T>(value: T, size: number): T[] => {
   return Array(size).fill(value);
 };
 
-/** Checks if a value is a non-empty array */
+/** Checks if a value is a non-empty array. */
 export function isFilledArray(value: unknown): boolean {
   return Array.isArray(value) && value.length > 0;
 }
 
-/** Checks if a value is a empty array */
+/** Checks if a value is an empty array. */
 export function isEmptyArray(value: unknown): boolean {
   return Array.isArray(value) && value.length === 0;
 }
 
-// get random item from the list
+/**
+ * Returns a random item from a non-empty array.
+ * Throws (in development via `invariant`) if the input is not an array or is empty.
+ */
 export const sample = (xs: unknown[]): unknown => {
   invariant(Array.isArray(xs), `input value is not an array: ${xs}`);
   invariant(isFilledArray(xs), `input array is empty: ${xs}`);
@@ -117,7 +152,9 @@ export const sample = (xs: unknown[]): unknown => {
   return xs[index];
 };
 
+/** Returns `true` when `xs` is non-empty and every value is truthy. */
 export const allTruthy = (xs: boolean[]) =>
   isFilledArray(xs) && xs.every(Boolean);
 
+/** Returns `true` when at least one value in `xs` is truthy. */
 export const anyTruthy = (xs: boolean[]) => xs.some(Boolean);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applicaster/zapp-react-native-utils",
-  "version": "16.0.0-rc.46",
+  "version": "16.0.0-rc.48",
   "description": "Applicaster Zapp React Native utilities package",
   "main": "index.js",
   "types": "index.d.ts",
@@ -27,7 +27,7 @@
   },
   "homepage": "https://github.com/applicaster/quickbrick#readme",
   "dependencies": {
-    "@applicaster/applicaster-types": "16.0.0-rc.46",
+    "@applicaster/applicaster-types": "16.0.0-rc.48",
     "buffer": "^5.2.1",
     "camelize": "^1.0.0",
     "dayjs": "^1.11.10",

package/zappFrameworkUtils/__tests__/localStorageHelper.test.ts

@@ -0,0 +1,146 @@
+import {
+  batchSaveOwnedValues,
+  batchRemoveOwnedValues,
+} from "../localStorageHelper";
+import { localStorage } from "@applicaster/zapp-react-native-bridge/ZappStorage/LocalStorage";
+
+// Mock localStorage
+jest.mock(
+  "@applicaster/zapp-react-native-bridge/ZappStorage/LocalStorage",
+  () => ({
+    localStorage: {
+      getItem: jest.fn(),
+      setItem: jest.fn(),
+      removeItem: jest.fn(),
+    },
+  })
+);
+
+describe("localStorageHelper", () => {
+  const ownershipKey = "test_ownership_key";
+  const ownershipNamespace = "test_namespace";
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe("addOwnedKeys via batchSaveOwnedValues", () => {
+    it("should add new keys to existing owned keys", async () => {
+      // Setup existing keys in storage
+      const existingKeys = {
+        namespace1: ["key1"],
+      };
+
+      (localStorage.getItem as jest.Mock).mockResolvedValue(
+        JSON.stringify(existingKeys)
+      );
+
+      const newValues = {
+        namespace1: { key2: "value2" },
+        namespace2: { key3: "value3" },
+      };
+
+      await batchSaveOwnedValues({
+        storageValues: newValues,
+        ownershipKey,
+        ownershipNamespace,
+      });
+
+      // Verify localStorage.setItem was called with correct updated keys
+      // Note: order of keys in array might vary depending on Set implementation, but usually insertion order
+      // However, to be safe, we can parse the argument and check contents
+
+      const lastCall = (localStorage.setItem as jest.Mock).mock.calls.find(
+        (call) => call[0] === ownershipKey
+      );
+
+      expect(lastCall).toBeDefined();
+      const savedData = JSON.parse(lastCall[1]);
+
+      expect(savedData.namespace1).toContain("key1");
+      expect(savedData.namespace1).toContain("key2");
+      expect(savedData.namespace2).toContain("key3");
+    });
+
+    it("should handle empty existing keys", async () => {
+      (localStorage.getItem as jest.Mock).mockResolvedValue(null);
+
+      const newValues = {
+        namespace1: { key1: "value1" },
+      };
+
+      await batchSaveOwnedValues({
+        storageValues: newValues,
+        ownershipKey,
+        ownershipNamespace,
+      });
+
+      const lastCall = (localStorage.setItem as jest.Mock).mock.calls.find(
+        (call) => call[0] === ownershipKey
+      );
+
+      expect(lastCall).toBeDefined();
+      const savedData = JSON.parse(lastCall[1]);
+
+      expect(savedData.namespace1).toEqual(["key1"]);
+    });
+  });
+
+  describe("removeOwnedKeys via batchRemoveOwnedValues", () => {
+    it("should remove keys from owned keys", async () => {
+      const existingKeys = {
+        namespace1: ["key1", "key2"],
+        namespace2: ["key3"],
+      };
+
+      (localStorage.getItem as jest.Mock).mockResolvedValue(
+        JSON.stringify(existingKeys)
+      );
+
+      const keysToRemove = {
+        namespace1: ["key1"],
+      };
+
+      await batchRemoveOwnedValues({
+        storageValues: keysToRemove,
+        ownershipKey,
+        ownershipNamespace,
+      });
+
+      const lastCall = (localStorage.setItem as jest.Mock).mock.calls.find(
+        (call) => call[0] === ownershipKey
+      );
+
+      expect(lastCall).toBeDefined();
+      const savedData = JSON.parse(lastCall[1]);
+
+      expect(savedData.namespace1).toEqual(["key2"]);
+      expect(savedData.namespace2).toEqual(["key3"]);
+    });
+
+    it("should remove namespace if all keys removed", async () => {
+      const existingKeys = {
+        namespace1: ["key1"],
+      };
+
+      (localStorage.getItem as jest.Mock).mockResolvedValue(
+        JSON.stringify(existingKeys)
+      );
+
+      const keysToRemove = {
+        namespace1: ["key1"],
+      };
+
+      await batchRemoveOwnedValues({
+        storageValues: keysToRemove,
+        ownershipKey,
+        ownershipNamespace,
+      });
+
+      expect(localStorage.removeItem).toHaveBeenCalledWith(
+        ownershipKey,
+        ownershipNamespace
+      );
+    });
+  });
+});

package/zappFrameworkUtils/localStorageHelper.ts

@@ -2,10 +2,10 @@ import { localStorage } from "@applicaster/zapp-react-native-bridge/ZappStorage/
 import { isNilOrEmpty } from "../reactUtils/helpers";
 import { parseJsonIfNeeded } from "@applicaster/zapp-react-native-utils/functionUtils";
 import {
-  StorageOwnedValues,
   NamespaceValues,
-  StorageValuesToRemove,
+  StorageOwnedValues,
   StorageValuesToAdd,
+  StorageValuesToRemove,
 } from "./types";
 import { Storage } from "@applicaster/zapp-react-native-bridge/ZappStorage/Storage";
 
@@ -43,10 +43,10 @@ function mapOwnedKeysToAdd(
 ): StorageOwnedValues {
   const mappedData = {};
 
-  Object.keys(storageValues).forEach((namespace: string) => {
+  for (const namespace of Object.keys(storageValues)) {
     const data = storageValues[namespace];
     mappedData[namespace] = Object.keys(data);
-  });
+  }
 
   return mappedData;
 }
@@ -111,12 +111,12 @@ async function addOwnedKeys({
     ownershipNamespace
   );
 
-  Object.keys(newKeys).forEach(async (namespace: string) => {
+  for (const namespace of Object.keys(newKeys)) {
     const newOwnedKeys: string[] = newKeys[namespace];
     const currentKeys = allStoragedOwnedKeys[namespace] || [];
     const combinedSet = new Set([...currentKeys, ...newOwnedKeys]);
     allStoragedOwnedKeys[namespace] = Array.from(combinedSet);
-  });
+  }
 
   const data = JSON.stringify(allStoragedOwnedKeys);
   await localStorage.setItem(ownershipKey, data, ownershipNamespace);
@@ -136,18 +136,14 @@ async function removeOwnedKeys({
     ownershipNamespace
   );
 
-  Object.keys(toRemoveKeys).forEach(async (namespace: string) => {
+  for (const namespace of Object.keys(toRemoveKeys)) {
     const keysToRemove: string[] = toRemoveKeys[namespace] || [];
     const currentKeys: string[] = currentKeysList[namespace] || [];
 
     const storageOwnedSet = new Set(currentKeys);
     const keysToRemoveSet = new Set(keysToRemove);
 
-    function removeAll(originalSet, toBeRemovedSet) {
-      toBeRemovedSet.forEach(Set.prototype.delete, originalSet);
-    }
-
-    removeAll(storageOwnedSet, keysToRemoveSet);
+    keysToRemoveSet.forEach((key) => storageOwnedSet.delete(key));
     const newLoginKeys = Array.from(storageOwnedSet);
 
     if (isNilOrEmpty(newLoginKeys)) {
@@ -155,7 +151,7 @@ async function removeOwnedKeys({
     } else {
       currentKeysList[namespace] = newLoginKeys;
     }
-  });
+  }
 
   if (isNilOrEmpty(currentKeysList)) {
     await localStorage.removeItem(ownershipKey, ownershipNamespace);