@applicaster/zapp-react-native-utils 15.0.0-alpha.3339012525 → 15.0.0-alpha.3512356987

package/analyticsUtils/AnalyticPlayerListener.ts

@@ -35,8 +35,11 @@ export class AnalyticPlayerListener
     this.handleAnalyticEvent(PLAYBACK_EVENT.complete);
   };
 
-  onError = (err: Error) => {
-    this.handleAnalyticEvent(PLAYBACK_EVENT.error, err); // TODO: Check error format
+  onError = (err: QuickBrickPlayer.PlayerErrorI) => {
+    this.handleAnalyticEvent(
+      PLAYBACK_EVENT.error,
+      err.toObject?.() || { message: err.message }
+    );
   };
 
   onPlayerPause = (event) => {

package/appUtils/accessibilityManager/utils.ts

@@ -12,13 +12,44 @@ export function calculateReadingTime(
   minimumPause: number = 500,
   announcementDelay: number = 700
 ): number {
-  const words = text
-    .trim()
+  const trimmed = text.trim();
+
+  // Count words (split on whitespace and punctuation, keep alnum boundaries)
+  const words = trimmed
     .split(/(?<=\d)(?=[a-zA-Z])|(?<=[a-zA-Z])(?=\d)|[^\w\s]+|\s+/)
     .filter(Boolean).length;
 
-  return (
-    Math.max(minimumPause, (words / wordsPerMinute) * 60 * 1000) +
-    announcementDelay
+  // Count spaces - multiple consecutive spaces add extra pause time
+  const spaceMatches: string[] = trimmed.match(/\s+/g) || [];
+
+  const totalSpaces = spaceMatches.reduce(
+    (sum: number, match: string) => sum + match.length,
+    0
   );
+
+  const extraSpaces = Math.max(0, totalSpaces - (words - 1)); // words-1 is normal spacing
+
+  // Heuristic: punctuation increases TTS duration beyond word-based WPM.
+  // Commas typically introduce short pauses, sentence terminators longer ones.
+  const commaCount = (trimmed.match(/,/g) || []).length;
+  const semicolonCount = (trimmed.match(/;/g) || []).length;
+  const colonCount = (trimmed.match(/:/g) || []).length;
+  const dashCount = (trimmed.match(/\u2013|\u2014|-/g) || []).length; // – — -
+  const sentenceEndCount = (trimmed.match(/[.!?](?!\d)/g) || []).length;
+
+  const commaPauseMs = 220; // short prosody pause for ","
+  const midPauseMs = 260; // for ";", ":", dashes
+  const sentenceEndPauseMs = 420; // for ".", "!", "?"
+  const extraSpacePauseMs = 50; // per extra space beyond normal spacing
+
+  const punctuationPause =
+    commaCount * commaPauseMs +
+    (semicolonCount + colonCount + dashCount) * midPauseMs +
+    sentenceEndCount * sentenceEndPauseMs +
+    extraSpaces * extraSpacePauseMs;
+
+  const baseByWordsMs = (words / wordsPerMinute) * 60 * 1000;
+  const estimatedMs = Math.max(minimumPause, baseByWordsMs + punctuationPause);
+
+  return estimatedMs + announcementDelay;
 }

package/appUtils/focusManager/__tests__/__snapshots__/focusManager.test.js.snap

@@ -69,6 +69,7 @@ exports[`focusManagerIOS should be defined 1`] = `
   "getGroupRootById": [Function],
   "getPreferredFocusChild": [Function],
   "invokeHandler": [Function],
+  "isChildOf": [Function],
   "isFocusOn": [Function],
   "isGroupItemFocused": [Function],
   "moveFocus": [Function],

package/appUtils/focusManager/index.ios.ts

@@ -1,12 +1,20 @@
 import { NativeModules } from "react-native";
 import * as R from "ramda";
 
-import { isCurrentFocusOn } from "../focusManagerAux/utils";
+import {
+  isCurrentFocusOn,
+  isChildOf as isChildOfUtils,
+} from "../focusManagerAux/utils";
 import { Tree } from "./treeDataStructure/Tree";
 import { findFocusableNode } from "./treeDataStructure/Utils";
 import { subscriber } from "../../functionUtils";
 import { findChild } from "./utils";
 
+import {
+  emitRegistered,
+  emitUnregistered,
+} from "../focusManagerAux/utils/utils.ios";
+
 const { FocusableManagerModule } = NativeModules;
 
 /**
@@ -180,10 +188,14 @@ export const focusManager = (function () {
   function register({ id, component }) {
     const { isGroup = false } = component;
 
+    emitRegistered(id);
+
     return isGroup ? registerGroup(id, component) : registerItem(id, component);
   }
 
   function unregister(id, { group = false } = {}) {
+    emitUnregistered(id);
+
     group ? unregisterGroup(id) : unregisterItem(id);
   }
 
@@ -400,6 +412,10 @@ export const focusManager = (function () {
     return id && isCurrentFocusOn(id, currentFocusNode);
   }
 
+  function isChildOf(childId, parentId): boolean {
+    return isChildOfUtils(focusableTree, childId, parentId);
+  }
+
   return {
     on,
     invokeHandler,
@@ -422,5 +438,6 @@ export const focusManager = (function () {
     isGroupItemFocused,
     getPreferredFocusChild,
     isFocusOn,
+    isChildOf,
   };
 })();

package/appUtils/focusManagerAux/utils/index.ts

@@ -190,3 +190,21 @@ export const isCurrentFocusOn = (id, node) => {
 
   return isCurrentFocusOn(id, node.parent);
 };
+
+export const isChildOf = (focusableTree, childId, parentId) => {
+  if (isNil(childId) || isNil(parentId)) {
+    return false;
+  }
+
+  const childNode = focusableTree.findInTree(childId);
+
+  if (isNil(childNode)) {
+    return false;
+  }
+
+  if (childNode.parent?.id === parentId) {
+    return true;
+  }
+
+  return isChildOf(focusableTree, childNode.parent?.id, parentId);
+};

package/appUtils/focusManagerAux/utils/utils.ios.ts

@@ -0,0 +1,35 @@
+import { ReplaySubject } from "rxjs";
+import { filter } from "rxjs/operators";
+import { BUTTON_PREFIX } from "@applicaster/zapp-react-native-ui-components/Components/MasterCell/DefaultComponents/tv/TvActionButtons/const";
+import { focusManager } from "@applicaster/zapp-react-native-utils/appUtils/focusManager/index.ios";
+
+type FocusableID = string;
+type RegistrationEvent = {
+  id: FocusableID;
+  registered: boolean;
+};
+
+const isFocusableButton = (id: Option<FocusableID>): boolean =>
+  id && id.includes?.(BUTTON_PREFIX);
+
+const registeredSubject$ = new ReplaySubject<RegistrationEvent>(1);
+
+export const focusableButtonsRegistration$ = (focusableGroupId: string) =>
+  registeredSubject$.pipe(
+    filter(
+      (value) =>
+        value.registered && focusManager.isChildOf(value.id, focusableGroupId)
+    )
+  );
+
+export const emitRegistered = (id: Option<FocusableID>): void => {
+  if (isFocusableButton(id)) {
+    registeredSubject$.next({ id, registered: true });
+  }
+};
+
+export const emitUnregistered = (id: Option<FocusableID>): void => {
+  if (isFocusableButton(id)) {
+    registeredSubject$.next({ id, registered: false });
+  }
+};

package/appUtils/platform/platformUtils.ts

@@ -229,14 +229,14 @@ export class TTSManager {
       try {
         window.webOS.service.request("luna://com.webos.service.tts", {
           method: "speak",
-          onFailure(error: any) {
+          onFailure: (error: any) => {
             log_debug("There was a failure setting up webOS TTS service", {
               error,
             });
 
             this.ttsState$.next(false);
           },
-          onSuccess(response: any) {
+          onSuccess: (response: any) => {
             log_debug("webOS TTS service is configured successfully", {
               response,
             });

package/appUtils/playerManager/conts.ts

@@ -2,6 +2,27 @@ export const userPreferencesNamespace = "user_preferences";
 
 export const skipActionType = "show_skip";
 
+export class PlayerError
+  extends Error
+  implements QuickBrickPlayer.PlayerErrorI
+{
+  description: string;
+
+  constructor(message: string, description: string) {
+    super(message);
+    this.description = description;
+
+    Object.setPrototypeOf(this, PlayerError.prototype);
+  }
+
+  toObject() {
+    return {
+      error: this.message,
+      message: this.description,
+    };
+  }
+}
+
 export enum SharedPlayerCallBacksKeys {
   OnPlayerResume = "onPlayerResume",
   OnPlayerPause = "onPlayerPause",

package/arrayUtils/__tests__/allTruthy.test.ts

@@ -0,0 +1,24 @@
+import { allTruthy } from "..";
+
+describe("allTruthy", () => {
+  it("should return true when all values are true", () => {
+    expect(allTruthy([true, true, true])).toBe(true);
+  });
+
+  it("should return false when at least one value is false", () => {
+    expect(allTruthy([true, false, true])).toBe(false);
+  });
+
+  it("should return false when all values are false", () => {
+    expect(allTruthy([false, false, false])).toBe(false);
+  });
+
+  it("should return false for an empty array", () => {
+    expect(allTruthy([])).toBe(false);
+  });
+
+  it("should handle single-element arrays correctly", () => {
+    expect(allTruthy([true])).toBe(true);
+    expect(allTruthy([false])).toBe(false);
+  });
+});

package/arrayUtils/__tests__/anyThruthy.test.ts

@@ -0,0 +1,24 @@
+import { anyTruthy } from "..";
+
+describe("anyTruthy", () => {
+  it("should return true when at least one value is true", () => {
+    expect(anyTruthy([false, true, false])).toBe(true);
+  });
+
+  it("should return false when all values are false", () => {
+    expect(anyTruthy([false, false, false])).toBe(false);
+  });
+
+  it("should return true when all values are true", () => {
+    expect(anyTruthy([true, true, true])).toBe(true);
+  });
+
+  it("should return false for an empty array", () => {
+    expect(anyTruthy([])).toBe(false);
+  });
+
+  it("should handle single-element arrays correctly", () => {
+    expect(anyTruthy([true])).toBe(true);
+    expect(anyTruthy([false])).toBe(false);
+  });
+});

package/arrayUtils/index.ts

@@ -116,3 +116,8 @@ export const sample = (xs: unknown[]): unknown => {
 
   return xs[index];
 };
+
+export const allTruthy = (xs: boolean[]) =>
+  isFilledArray(xs) && xs.every(Boolean);
+
+export const anyTruthy = (xs: boolean[]) => xs.some(Boolean);

package/cellUtils/index.ts

@@ -9,7 +9,10 @@ import {
 } from "@applicaster/zapp-react-native-utils/stringUtils";
 import { cellUtilsLogger } from "@applicaster/zapp-react-native-utils/cellUtils/logger";
 import { isWeb } from "@applicaster/zapp-react-native-utils/reactUtils";
-import { isNotNil } from "@applicaster/zapp-react-native-utils/reactUtils/helpers";
+import {
+  isNotNil,
+  isNilOrEmpty,
+} from "@applicaster/zapp-react-native-utils/reactUtils/helpers";
 
 import { toNumberWithDefault, toNumberWithDefaultZero } from "../numberUtils";
 
@@ -505,3 +508,39 @@ export const getImageContainerMarginStyles = ({ value }: { value: any }) => {
     marginRight: value("image_margin_right"),
   };
 };
+
+export const withoutNilOrEmpty = (arr: string[]): string[] =>
+  arr.filter((item) => !isNilOrEmpty(item));
+
+export const isTextLabel = (key: string): boolean =>
+  key.includes("text_label_") && key.endsWith("_switch");
+
+export const hasTextLabelsEnabled = (
+  configuration: Record<string, any>
+): boolean => {
+  const textLabelsKeys = Object.keys(configuration).filter(isTextLabel);
+
+  const picked = textLabelsKeys.reduce(
+    (acc, key) => {
+      acc[key] = configuration[key];
+
+      return acc;
+    },
+    {} as Record<string, any>
+  );
+
+  const pickedValues = Object.values(picked);
+
+  // Check if any switch value is truthy (true, "true", "1", etc.)
+  return pickedValues.some((value) => {
+    if (typeof value === "boolean") {
+      return value === true;
+    }
+
+    if (typeof value === "string") {
+      return value !== "" && value.toLowerCase() !== "false";
+    }
+
+    return Boolean(value);
+  });
+};

package/navigationUtils/index.ts

@@ -575,24 +575,27 @@ export function routeIsPlayerScreen(currentRoute) {
   return currentRoute?.includes("/playable");
 }
 
-export const getNavBarProps =
-  (currentRiver: ZappRiver, pathname: string, title: string) => () => {
-    const props = getNavigationPropsV2({
-      currentRiver,
-      title,
-      category: "nav_bar",
-    });
+export const getNavBarProps = (
+  currentRiver: ZappRiver,
+  pathname: string,
+  title: string
+) => {
+  const props = getNavigationPropsV2({
+    currentRiver,
+    title,
+    category: "nav_bar",
+  });
 
-    if (props) {
-      return {
-        ...props,
-        id: pathname,
-        pathname: pathname,
-      };
-    }
+  if (props) {
+    return {
+      ...props,
+      id: pathname,
+      pathname: pathname,
+    };
+  }
 
-    return null;
-  };
+  return null;
+};
 
 export const findMenuPlugin = (
   navigations: ZappNavigation[],

package/package.json

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

package/reactHooks/feed/useBatchLoading.ts

@@ -151,7 +151,13 @@ export const useBatchLoading = (
         }
       }
     });
-  }, [feedUrls, feeds, loadPipesDataDispatcher]);
+  }, [
+    batchComponents,
+    feeds,
+    getUrl,
+    loadPipesDataDispatcher,
+    options.riverId,
+  ]);
 
   React.useEffect(() => {
     runBatchLoading();

package/reactHooks/feed/usePipesCacheReset.ts

@@ -34,7 +34,9 @@ export const usePipesCacheReset = (riverId, riverComponents) => {
             component
           );
 
-          dispatch(clearPipesData(url, { riverId }));
+          if (url) {
+            dispatch(clearPipesData(url, { riverId }));
+          }
         }
       });
     };

package/reactHooks/layout/index.ts

@@ -44,7 +44,7 @@ export function useStatusBarHeight() {
 
   return platformSelect({
     ios: StatusBarHeight,
-    android: StatusBar.currentHeight,
+    android: StatusBar.currentHeight ?? 0,
     default: 0,
   });
 }

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

@@ -16,6 +16,8 @@ export { endsWith } from "./endsWith";
 
 export { take } from "./take";
 
+export { mapAccum } from "./mapAccum";
+
 export {
   cloneDeep as clone,
   flatten,
@@ -34,4 +36,9 @@ export {
   last,
   toLower,
   isEqual as equals,
+  uniq,
+  uniqWith,
+  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/zappFrameworkUtils/HookCallback/callbackNavigationAction.ts

@@ -56,9 +56,23 @@ const legacyMappingKeys = {
     actionType: "logout_completion_action",
     targetScreen: "navigate_to_logout_screen",
   },
+  "quick-brick-storefront": {
+    actionType: "purchase_completion_action",
+    targetScreen: "navigate_to_screen_after_purchase",
+  },
+  "zapp_login_plugin_oauth_tv_2_0.login": {
+    actionType: "login_completion_action",
+    targetScreen: "navigate_to_login_screen",
+  },
+  "zapp_login_plugin_oauth_tv_2_0.logout": {
+    actionType: "logout_completion_action",
+    targetScreen: "navigate_to_logout_screen",
+  },
 };
 
-const NAV_ACTIONS = Object.values(NavigationCallbackOptions) as string[];
+const NAV_ACTIONS = (
+  Object.values(NavigationCallbackOptions) as string[]
+).filter((value) => value !== NavigationCallbackOptions.DEFAULT);
 
 const isNavAction = (v: unknown): v is NavigationCallbackOptions =>
   typeof v === "string" && NAV_ACTIONS.includes(v);