@applicaster/zapp-react-native-utils 16.0.0-alpha.7343517668 → 16.0.0-alpha.7845362739

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/_internals/index.js

@@ -157,6 +157,10 @@ function generateFieldsFromDefaultsWithoutPrefixedLabel(
 
         if (conditions) {
           generatedField.conditional_fields = conditions.map((condition) => {
+            if (condition.section === null) {
+              return { key: condition.key, condition_value: condition.value };
+            }
+
             const section = condition.section ? `${condition.section}/` : "";
 
             return {
@@ -164,6 +168,8 @@ function generateFieldsFromDefaultsWithoutPrefixedLabel(
               condition_value: condition.value,
             };
           });
+
+          generatedField.rules = "all_conditions";
         }
 
         return generatedField;

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/manifestUtils/fieldUtils/__tests__/fieldUtils.test.js

@@ -1,9 +1,93 @@
 const {
+  parseShorthand,
+  margin,
+  padding,
   withConditional,
   getConditionalKey,
   createConditionalField,
 } = require("..");
 
+describe("parseShorthand", () => {
+  it("1 value → all four sides equal", () => {
+    expect(parseShorthand("8")).toEqual([8, 8, 8, 8]);
+  });
+
+  it("2 values → top/bottom, right/left", () => {
+    expect(parseShorthand("0 20")).toEqual([0, 20, 0, 20]);
+  });
+
+  it("3 values → top, right/left, bottom", () => {
+    expect(parseShorthand("0 0 20")).toEqual([0, 0, 20, 0]);
+  });
+
+  it("4 values → top right bottom left", () => {
+    expect(parseShorthand("1 2 3 4")).toEqual([1, 2, 3, 4]);
+  });
+
+  it("throws on invalid count", () => {
+    expect(() => parseShorthand("1 2 3 4 5")).toThrow();
+  });
+});
+
+describe("margin", () => {
+  it("returns 4 field descriptors with correct suffixes", () => {
+    const fields = margin("margin", { mobile: "0" });
+
+    expect(fields.map((f) => f.suffix)).toEqual([
+      "margin top",
+      "margin right",
+      "margin bottom",
+      "margin left",
+    ]);
+  });
+
+  it("sets type to number_input", () => {
+    margin("margin", { mobile: "0" }).forEach((f) => {
+      expect(f.type).toBe("number_input");
+    });
+  });
+
+  it("expands shorthand per platform", () => {
+    const fields = margin("margin", { mobile: "0 0 20", tv: "0 0 90" });
+    const byKey = Object.fromEntries(fields.map((f) => [f.suffix, f]));
+    expect(byKey["margin top"].initialValue).toEqual({ mobile: 0, tv: 0 });
+    expect(byKey["margin bottom"].initialValue).toEqual({ mobile: 20, tv: 90 });
+    expect(byKey["margin left"].initialValue).toEqual({ mobile: 0, tv: 0 });
+  });
+
+  it("supports a custom suffix prefix", () => {
+    const fields = margin("input margin", { mobile: "4" });
+    expect(fields[0].suffix).toBe("input margin top");
+  });
+});
+
+describe("padding", () => {
+  it("returns 4 field descriptors with correct suffixes", () => {
+    const fields = padding("padding", { mobile: "0" });
+
+    expect(fields.map((f) => f.suffix)).toEqual([
+      "padding top",
+      "padding right",
+      "padding bottom",
+      "padding left",
+    ]);
+  });
+
+  it("expands 2-value shorthand symmetrically", () => {
+    const fields = padding("padding", { mobile: "0 20", tv: "0 124" });
+    const byKey = Object.fromEntries(fields.map((f) => [f.suffix, f]));
+
+    expect(byKey["padding right"].initialValue).toEqual({
+      mobile: 20,
+      tv: 124,
+    });
+
+    expect(byKey["padding left"].initialValue).toEqual({ mobile: 20, tv: 124 });
+    expect(byKey["padding top"].initialValue).toEqual({ mobile: 0, tv: 0 });
+    expect(byKey["padding bottom"].initialValue).toEqual({ mobile: 0, tv: 0 });
+  });
+});
+
 describe("manifestUtils/fieldUtils", () => {
   it("appends conditions and adds all_conditions when there is more than one condition", () => {
     const config = {

package/manifestUtils/fieldUtils/index.js

@@ -1,3 +1,121 @@
+const { ZAPPIFEST_FIELDS } = require("../keys");
+const { toCamelCase } = require("../_internals");
+
+const SIDES = ["top", "right", "bottom", "left"];
+
+/**
+ * Parses a CSS margin/padding shorthand string into [top, right, bottom, left].
+ *
+ * 1 value  → all four sides
+ * 2 values → top/bottom, right/left
+ * 3 values → top, right/left, bottom
+ * 4 values → top, right, bottom, left
+ *
+ * @param {string} str
+ * @returns {[number, number, number, number]}
+ */
+function parseShorthand(str) {
+  const parts = String(str).trim().split(/\s+/).map(Number);
+
+  switch (parts.length) {
+    case 1:
+      return [parts[0], parts[0], parts[0], parts[0]];
+    case 2:
+      return [parts[0], parts[1], parts[0], parts[1]];
+    case 3:
+      return [parts[0], parts[1], parts[2], parts[1]];
+    case 4:
+      return parts;
+    default:
+      throw new Error(
+        `Shorthand expects 1–4 space-separated values, got ${parts.length}: "${str}"`
+      );
+  }
+}
+
+function spacingFields(prefix, initialValues) {
+  const platforms = Object.keys(initialValues);
+
+  const parsed = Object.fromEntries(
+    platforms.map((p) => [p, parseShorthand(initialValues[p])])
+  );
+
+  return SIDES.map((side, i) => ({
+    suffix: `${prefix} ${side}`,
+    type: ZAPPIFEST_FIELDS.number_input,
+    initialValue: Object.fromEntries(platforms.map((p) => [p, parsed[p][i]])),
+  }));
+}
+
+/**
+ * Generates four margin field descriptors (top/right/bottom/left) from a
+ * per-platform CSS shorthand string.
+ *
+ * @param {string} suffix - prefix word for generated field names, e.g. "margin"
+ * @param {Record<string, string>} initialValues - e.g. { mobile: "0 0 20", tv: "0 0 90" }
+ * @returns {object[]}
+ */
+function margin(suffix, initialValues) {
+  return spacingFields(suffix, initialValues);
+}
+
+/**
+ * Generates four padding field descriptors (top/right/bottom/left) from a
+ * per-platform CSS shorthand string.
+ *
+ * @param {string} suffix - prefix word for generated field names, e.g. "padding"
+ * @param {Record<string, string>} initialValues - e.g. { mobile: "0 20", tv: "0 124" }
+ * @returns {object[]}
+ */
+function padding(suffix, initialValues) {
+  return spacingFields(suffix, initialValues);
+}
+
+/**
+ * Returns a flat camelCase defaults object for a spacing shorthand.
+ * e.g. marginDefaults("margin", "0 0 20") → { marginTop: 0, marginRight: 0, marginBottom: 20, marginLeft: 0 }
+ *
+ * @param {string} suffix - e.g. "margin" or "padding"
+ * @param {string} shorthand - CSS-like shorthand string
+ * @returns {Record<string, number>}
+ */
+function spacingDefaults(suffix, shorthand) {
+  const values = parseShorthand(shorthand);
+
+  return Object.fromEntries(
+    SIDES.map((side, i) => [toCamelCase(`${suffix} ${side}`), values[i]])
+  );
+}
+
+function marginDefaults(suffix, shorthand) {
+  return spacingDefaults(suffix, shorthand);
+}
+
+function paddingDefaults(suffix, shorthand) {
+  return spacingDefaults(suffix, shorthand);
+}
+
+/**
+ * Returns four field descriptors (top/right/bottom/left) with only suffix and type — no initialValue.
+ * Used when defaults are stored separately in the subgroup spec.
+ *
+ * @param {string} prefix - e.g. "margin" or "padding"
+ * @returns {object[]}
+ */
+function marginFields(prefix) {
+  return SIDES.map((side) => ({
+    suffix: `${prefix} ${side}`,
+    type: ZAPPIFEST_FIELDS.number_input,
+  }));
+}
+
+function paddingFields(prefix) {
+  return SIDES.map((side) => ({
+    suffix: `${prefix} ${side}`,
+    type: ZAPPIFEST_FIELDS.number_input,
+  }));
+}
+
 /**
  * Appends new conditional_fields from conditions array
  * to config.conditional_fields
@@ -48,6 +166,13 @@ function createConditionalField(key, condition_value, category = "styles") {
 }
 
 module.exports = {
+  parseShorthand,
+  margin,
+  padding,
+  marginDefaults,
+  paddingDefaults,
+  marginFields,
+  paddingFields,
   withConditional,
   getConditionalKey,
   createConditionalField,

package/manifestUtils/keys.js

@@ -43,6 +43,7 @@ const TV_PLATFORMS = [
   "tvos_for_quickbrick",
   "samsung_tv",
   "lg_tv",
+  "vidaa",
   "vizio",
 ];
 
@@ -630,6 +631,14 @@ const MOBILE_ACTION_BUTTON_FIELDS = [
     type: ZAPPIFEST_FIELDS.number_input,
     suffix: "margin left",
   },
+  {
+    type: ZAPPIFEST_FIELDS.number_input,
+    suffix: "horizontal gutter",
+  },
+  {
+    type: ZAPPIFEST_FIELDS.number_input,
+    suffix: "vertical gutter",
+  },
 ];
 
 const TV_MENU_LABEL_FIELDS = [

package/manifestUtils/mobileAction/button/index.js

@@ -129,6 +129,22 @@ function mobileActionButton({ label, description, defaults, isFirstButton }) {
       conditions.push(createConditionalField(labelEnabledKey, true));
     }
 
+    const assetAlignmentKey = keyPrefixGenerator("asset_alignment");
+
+    // horizontal_gutter fields depends on [asset_alignment: left or asset_alignment: right]
+    if (isKeyHasSuffix("horizontal_gutter", key)) {
+      conditions.push(
+        createConditionalField(assetAlignmentKey, ["left", "right"])
+      );
+    }
+
+    // vertical_gutter fields depends on [asset_alignment: above or asset_alignment: below]
+    if (isKeyHasSuffix("vertical_gutter", key)) {
+      conditions.push(
+        createConditionalField(assetAlignmentKey, ["above", "below"])
+      );
+    }
+
     return withConditional(conditions)(field);
   });
 

package/manifestUtils/mobileAction/container/index.js

@@ -49,7 +49,9 @@ function mobileActionButtonsContainer({ label, description, defaults }) {
 
     // over_image_position depends on [positionKey: over_image]
     if (isKeyHasSuffix("over_image_position", key)) {
-      conditions.push(createConditionalField(positionKey, "over_image"));
+      conditions.push(
+        createConditionalField(positionKey, defaults.position[0])
+      );
     }
 
     // horizontal_gutter depends on [stackingKey: horizontal]

package/manifestUtils/mobileAction/groups/defaults.js

@@ -33,7 +33,7 @@ const DEFAULT_MOBILE_ACTION_BUTTON_SHARED_DEFAULTS = {
   assetHeight: 24,
   assetWidth: 24,
   assetMarginTop: 0,
-  assetMarginRight: 6,
+  assetMarginRight: 0,
   assetMarginBottom: 0,
   assetMarginLeft: 0,
   labelEnabled: true,
@@ -50,6 +50,8 @@ const DEFAULT_MOBILE_ACTION_BUTTON_SHARED_DEFAULTS = {
   marginRight: 0,
   marginBottom: 0,
   marginLeft: 0,
+  horizontalGutter: 8,
+  verticalGutter: 8,
 };
 
 const DEFAULT_MOBILE_ACTION_BUTTON_PRESETS = {

package/manifestUtils/platformIsTV.js

@@ -4,6 +4,7 @@ function platformIsTV(platform) {
     "android_tv_for_quickbrick",
     "amazon_fire_tv_for_quickbrick",
     "lg_tv",
+    "vidaa",
     "samsung_tv",
     "web",
     "vizio",

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