@applicaster/zapp-react-native-utils 16.0.0-alpha.1803022420 → 16.0.0-alpha.1832347172

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/bottomSheet/__tests__/scrollContext.test.tsx

@@ -0,0 +1,35 @@
+import React from "react";
+import { Text } from "react-native";
+import { render, screen } from "@testing-library/react-native";
+import { BottomSheetContext, useBottomSheet } from "../index";
+
+const Probe = () => {
+  const ctx = useBottomSheet();
+
+  return <Text testID="probe">{ctx ? "has-context" : "no-context"}</Text>;
+};
+
+describe("useBottomSheet", () => {
+  it("returns null when no provider is present", () => {
+    render(<Probe />);
+    expect(screen.getByTestId("probe")).toHaveTextContent("no-context");
+  });
+
+  it("returns the provided value inside a provider", () => {
+    const value = {
+      scrollRef: React.createRef<any>(),
+      masterDrawerRef: React.createRef<any>(),
+      setBodyDragEnabled: jest.fn(),
+      onDragGestureEvent: jest.fn(),
+      onDragStateChange: jest.fn(),
+    };
+
+    render(
+      <BottomSheetContext.Provider value={value}>
+        <Probe />
+      </BottomSheetContext.Provider>
+    );
+
+    expect(screen.getByTestId("probe")).toHaveTextContent("has-context");
+  });
+});

package/bottomSheet/index.ts

@@ -0,0 +1,17 @@
+import { createContext, useContext, RefObject } from "react";
+
+export type BottomSheetContextValue = {
+  /** The sheet's master TapGestureHandler ref — the scrollable waits for it. */
+  masterDrawerRef: RefObject<any>;
+  /** Header drag-zone wiring: the sheet's pan gesture event handler. */
+  onDragGestureEvent: (...args: any[]) => void;
+  /** Header drag-zone wiring: the sheet's pan state-change handler. */
+  onDragStateChange: (event: { nativeEvent: any }) => void;
+};
+
+export const BottomSheetContext = createContext<BottomSheetContextValue | null>(
+  null
+);
+
+export const useBottomSheet = (): BottomSheetContextValue | null =>
+  useContext(BottomSheetContext);

package/manifestUtils/defaultManifestConfigurations/player.js

@@ -781,21 +781,6 @@ function getPlayerConfiguration({ platform, version }) {
       }
     );
 
-    if (
-      platform.includes("android") ||
-      platform.includes("amazon") ||
-      platform.includes("ios") ||
-      platform.includes("tvos")
-    ) {
-      general.fields.push({
-        key: "user_agent",
-        label: "User agent",
-        initial_value: "",
-        type: "text_input",
-        label_tooltip: "Override default user agent string",
-      });
-    }
-
     if (platform === "android_for_quickbrick") {
       general.fields.push({
         key: "stop_playback_on_task_removal",
@@ -2415,6 +2400,21 @@ function getPlayerConfiguration({ platform, version }) {
     );
   }
 
+  if (
+    platform.includes("android") ||
+    platform.includes("amazon") ||
+    platform.includes("ios") ||
+    platform.includes("tvos")
+  ) {
+    general.fields.push({
+      key: "user_agent",
+      label: "User agent",
+      initial_value: "",
+      type: "text_input",
+      label_tooltip: "Override default user agent string",
+    });
+  }
+
   compact([
     {
       key: "liveCatchUpEnabled",
@@ -3522,13 +3522,13 @@ function getPlayerConfiguration({ platform, version }) {
             label: "Advanced Player Styles",
             type: "text_input",
             multiline: true,
-            initial_value: `.vjs-text-track-cue { 
-            inset: unset !important;
-            top: 94% !important;
+            initial_value: `.vjs-text-track-cue {
+            top: auto !important;
             bottom: 0 !important;
             left: 0 !important;
-            right: 0 !important;
+            right: auto !important;
             width: 100% !important;
+            height: auto !important;
           }`,
             label_tooltip:
               "This field allows you to inject custom CSS styles to override default player styles. The styles will be injected into the document head and can be used to customize the appearance of the player. Leave empty to use only default styles.",

package/numberUtils/__tests__/isMinusZero.test.ts

@@ -0,0 +1,20 @@
+import { isMinusZero } from "..";
+
+describe("isMinusZero", () => {
+  it("return true for minus zero", () => {
+    expect(isMinusZero(-0)).toBe(true);
+  });
+
+  it("return false for positive zero", () => {
+    expect(isMinusZero(0)).toBe(false);
+  });
+
+  it("return false for non-zero numbers", () => {
+    const inputs = [-1, 1, 100, 0.1, -0.1, Infinity, -Infinity];
+    expect.assertions(inputs.length);
+
+    inputs.forEach((input) => {
+      expect(isMinusZero(input)).toBe(false);
+    });
+  });
+});

package/numberUtils/__tests__/isZero.test.ts

@@ -0,0 +1,27 @@
+import { isZero } from "..";
+
+describe("isZero", () => {
+  it("return true for zero and minus zero", () => {
+    expect(isZero(0)).toBe(true);
+    expect(isZero(-0)).toBe(true);
+  });
+
+  it("return false for non-zero numbers", () => {
+    const inputs = [-1, 1, 100, 0.1, -0.1, Infinity, -Infinity, NaN];
+    expect.assertions(inputs.length);
+
+    inputs.forEach((input) => {
+      expect(isZero(input)).toBe(false);
+    });
+  });
+
+  it("return false for non-number values", () => {
+    const inputs = ["0", "-0", null, undefined, "", {}, [], false, true];
+
+    expect.assertions(inputs.length);
+
+    inputs.forEach((input) => {
+      expect(isZero(input)).toBe(false);
+    });
+  });
+});

package/numberUtils/__tests__/requireNumber.test.ts

@@ -0,0 +1,50 @@
+import { requireNumber } from "..";
+
+describe("requireNumber", () => {
+  it("return number if object key holds a number", () => {
+    const inputs = [-1, 1, 100, 0.2];
+    expect.assertions(inputs.length);
+
+    inputs.forEach((input) => {
+      const output = requireNumber({ value: input }, "value");
+      expect(output).toBe(input);
+    });
+  });
+
+  it("return number if object key holds a string as number", () => {
+    const inputs = ["-1", "1", "100", "0.2"];
+    expect.assertions(inputs.length);
+
+    inputs.forEach((input) => {
+      const output = requireNumber({ value: input }, "value");
+      expect(output).toBe(Number(input));
+    });
+  });
+
+  it("return null if object key holds zero", () => {
+    expect(requireNumber({ value: 0 }, "value")).toBeNull();
+    expect(requireNumber({ value: "0" }, "value")).toBeNull();
+  });
+
+  it("return null if object key is missing or not a number", () => {
+    const cases = [
+      [{}, "value"],
+      [{ value: null }, "value"],
+      [{ value: undefined }, "value"],
+      [{ value: NaN }, "value"],
+      [{ value: "" }, "value"],
+      [{ value: "vfdvf" }, "value"],
+      [{ value: {} }, "value"],
+      [{ value: [] }, "value"],
+      [null, "value"],
+      [undefined, "value"],
+    ] as const;
+
+    expect.assertions(cases.length);
+
+    cases.forEach(([obj, key]) => {
+      const output = requireNumber(obj, key);
+      expect(output).toBeNull();
+    });
+  });
+});

package/numberUtils/__tests__/toNumber.test.ts

@@ -21,6 +21,33 @@ describe("toNumber", () => {
     });
   });
 
+  it("return number if input is boxed string as number", () => {
+    const inputs = [
+      new String("-1"),
+      new String("0"),
+      new String("1"),
+      Object("100"),
+      Object("0.2"),
+    ];
+
+    expect.assertions(inputs.length);
+
+    inputs.forEach((input) => {
+      const output = toNumber(input);
+      expect(output).toBe(Number(input));
+    });
+  });
+
+  it("return undefined if input is invalid boxed string", () => {
+    const inputs = [new String("vfdvf"), new String("5n"), Object("")];
+    expect.assertions(inputs.length);
+
+    inputs.forEach((input) => {
+      const output = toNumber(input);
+      expect(output).toBeUndefined();
+    });
+  });
+
   it("return undefined if input is not a number", () => {
     const inputs = [
       "vfdvf",

package/numberUtils/__tests__/toNumberWithDefault.test.ts

@@ -0,0 +1,64 @@
+import { toNumberWithDefault } from "..";
+
+describe("toNumberWithDefault", () => {
+  const DEFAULT = 5;
+
+  it("return number if input is number", () => {
+    const inputs = [-1, 0, 1, 100, 0.2];
+    expect.assertions(inputs.length);
+
+    inputs.forEach((input) => {
+      const output = toNumberWithDefault(DEFAULT, input);
+      expect(output).toBe(input);
+    });
+  });
+
+  it("return number if input is string as number", () => {
+    const inputs = ["-1", "0", "1", "100", "0.2"];
+    expect.assertions(inputs.length);
+
+    inputs.forEach((input) => {
+      const output = toNumberWithDefault(DEFAULT, input);
+      expect(output).toBe(Number(input));
+    });
+  });
+
+  it("return default if input is not a number", () => {
+    const inputs = [
+      "vfdvf",
+      "5n",
+      "-5n",
+      null,
+      undefined,
+      NaN,
+      "",
+      {},
+      { test: 1 },
+      [],
+      [1],
+    ];
+
+    expect.assertions(inputs.length);
+
+    inputs.forEach((input) => {
+      const output = toNumberWithDefault(DEFAULT, input);
+      expect(output).toBe(DEFAULT);
+    });
+  });
+
+  describe("BigInt support", () => {
+    const isBigIntSupported = typeof BigInt !== "undefined";
+
+    if (isBigIntSupported) {
+      it("converts BigInt to number when BigInt is supported", () => {
+        expect(toNumberWithDefault(DEFAULT, BigInt(5))).toBe(5);
+        expect(toNumberWithDefault(DEFAULT, BigInt(0))).toBe(0);
+        expect(toNumberWithDefault(DEFAULT, BigInt(-10))).toBe(-10);
+      });
+    } else {
+      it("skips BigInt tests when BigInt is not supported", () => {
+        expect(typeof BigInt).toBe("undefined");
+      });
+    }
+  });
+});

package/numberUtils/__tests__/toNumberWithDefaultZero.test.ts

@@ -0,0 +1,48 @@
+import { toNumberWithDefaultZero } from "..";
+
+const DEFAULT = 0;
+
+describe("toNumberWithDefaultZero", () => {
+  it("return number if input is number", () => {
+    const inputs = [-1, 0, 1, 100, 0.2];
+    expect.assertions(inputs.length);
+
+    inputs.forEach((input) => {
+      const output = toNumberWithDefaultZero(input);
+      expect(output).toBe(input);
+    });
+  });
+
+  it("return number if input is string as number", () => {
+    const inputs = ["-1", "0", "1", "100", "0.2"];
+    expect.assertions(inputs.length);
+
+    inputs.forEach((input) => {
+      const output = toNumberWithDefaultZero(input);
+      expect(output).toBe(Number(input));
+    });
+  });
+
+  it("return zero if input is not a number", () => {
+    const inputs = [
+      "vfdvf",
+      "5n",
+      "-5n",
+      null,
+      undefined,
+      NaN,
+      "",
+      {},
+      { test: 1 },
+      [],
+      [1],
+    ];
+
+    expect.assertions(inputs.length);
+
+    inputs.forEach((input) => {
+      const output = toNumberWithDefaultZero(input);
+      expect(output).toBe(DEFAULT);
+    });
+  });
+});

package/numberUtils/index.ts

@@ -1,18 +1,37 @@
-import * as R from "ramda";
+import { isNil } from "@applicaster/zapp-react-native-utils/utils";
+
 import { logger } from "@applicaster/zapp-react-native-utils/logger";
 
 const numberUtilsLogger = logger?.addSubsystem("NumberUtils");
 
+/** Matches Ramda isEmpty: "" / [] / {} are empty; numbers and bigints are not. */
+const isEmpty = (value: unknown): boolean => {
+  if (typeof value === "string" || Array.isArray(value)) {
+    return value.length === 0;
+  }
+
+  if (typeof value === "object" && value !== null) {
+    return Object.keys(value).length === 0;
+  }
+
+  return false;
+};
+
 export const toNumber = (value: unknown): number | undefined => {
-  if (R.isNil(value) || R.isEmpty(value)) {
+  if (isNil(value) || isEmpty(value)) {
     return undefined;
   }
 
   // Feature-detect BigInt support to avoid ReferenceError on older runtimes
   const isBigIntSupported = typeof BigInt !== "undefined";
-  const isBigIntValue = isBigIntSupported && R.is(BigInt, value);
-
-  if (R.is(Number, value) || isBigIntValue || R.is(String, value)) {
+  const isBigIntValue = isBigIntSupported && typeof value === "bigint";
+
+  if (
+    typeof value === "number" ||
+    isBigIntValue ||
+    typeof value === "string" ||
+    value instanceof String
+  ) {
     const numberOrNan = Number(value);
 
     return Number.isNaN(numberOrNan) ? undefined : numberOrNan;
@@ -59,7 +78,7 @@ export const toFiniteNumberWithDefault = (
 export const isLikeNumber = (value: unknown): boolean => {
   const possibleNumber = toNumber(value);
 
-  if (R.isNil(possibleNumber)) {
+  if (isNil(possibleNumber)) {
     return false;
   }
 
@@ -76,7 +95,7 @@ export const isMinusZero = (value: number) => {
 export const toPositiveNumber = (value: unknown): number | undefined => {
   const possibleNumber = toNumber(value);
 
-  if (R.isNil(possibleNumber)) {
+  if (isNil(possibleNumber)) {
     return undefined;
   }
 
@@ -97,7 +116,7 @@ export const toPositiveNumberWithDefault = (
 ): number => {
   const possibleNumber = toNumber(value);
 
-  if (R.isNil(possibleNumber)) {
+  if (isNil(possibleNumber)) {
     return defaultValue;
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applicaster/zapp-react-native-utils",
-  "version": "16.0.0-alpha.1803022420",
+  "version": "16.0.0-alpha.1832347172",
   "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-alpha.1803022420",
+    "@applicaster/applicaster-types": "16.0.0-alpha.1832347172",
     "buffer": "^5.2.1",
     "camelize": "^1.0.0",
     "dayjs": "^1.11.10",

package/reactHooks/feed/__tests__/useInflatedUrl.test.tsx

@@ -242,4 +242,29 @@ describe("useGetUrlInflater", () => {
     const url = result.current(source, mapping);
     expect(url).toBe("https://foo.com/shows/A123?q=user%20query");
   });
+
+  it("handles search queries with apostrophes without HTML entity escaping or URL truncation", () => {
+    const source =
+      "https://api.pc-cms.tele.quebec/api/applicaster/v1/mobile/search?q={{q}}";
+
+    const mapping = {
+      q: { source: "search", property: "q" },
+    };
+
+    const searchContext = getSearchContext("L'aventure", mapping);
+
+    const result = getInflatedDataSourceUrl({
+      source,
+      contexts: {
+        search: searchContext,
+      },
+      mapping,
+    });
+
+    expect(result).toBe(
+      "https://api.pc-cms.tele.quebec/api/applicaster/v1/mobile/search?q=L'aventure"
+    );
+
+    expect(result).not.toContain("'");
+  });
 });