@applicaster/zapp-react-native-utils 13.0.0-rc.12 → 13.0.0-rc.121

package/appUtils/HooksManager/types.ts

@@ -0,0 +1,119 @@
+import { SubscriberObj } from "../../functionUtils";
+import { HOOKS_EVENTS } from "./constants";
+
+export interface HookConfiguration {}
+
+/* existing Hook Plugn props: sample */
+
+/*
+interface _HookModulePlugin {
+  Component:
+    | React.FC<HookPluginProps>
+    | React.Component<HookPluginProps, any>
+    | React.ReactNode;
+  ModalContainer?: React.FC<ModalProps> | React.Component<ModalProps, any>;
+  skipHook?: (payload: ZappRiver | ZappEntry) => boolean;
+  presentFullScreen: boolean;
+  showNavBar?: boolean;
+  isFlowBlocker: (() => boolean) | boolean; // narrow this
+  hasPlayerHook?: boolean;
+  name: string;
+  runInBackground?: (
+    item: HookPluginProps["payload"],
+    callback: hookCallback,
+    hookPlugin: HookScreenData,
+    presentUI: (payload?: HookPluginProps["payload"]) => void
+  ) => any;
+}
+*/
+
+//* Derived from usage */
+export interface HookModule {
+  ModalContainer?: React.ComponentType<any>;
+  Component: React.ComponentType<any>;
+  presentFullScreen: boolean;
+  run?: (
+    arg0: unknown,
+    callback: () => void,
+    configuration: HookConfiguration
+  ) => void; // not sure about optional parameter
+  hasPlayerHook?: boolean;
+  configuration?: HookConfiguration;
+  isFlowBlocker: () => boolean;
+  skipHook?: (payload?: ZappRiver | ZappEntry) => boolean;
+  runInBackground?: (
+    arg0: unknown,
+    callback: () => void,
+    hookPlugin: Hook,
+    presentUI: (payload?: HookPluginProps["payload"]) => void
+  ) => void;
+  name: string;
+  showNavBar?: boolean; // unsure
+}
+
+export type HookManagerArgs = {
+  rivers: Record<string, ZappRiver>;
+  plugins: ZappPlugin[];
+  targetScreen: ZappRiver;
+  startUpHooksData?: {
+    startUpHooks?: unknown[] | "in_process";
+    setStartUpHooks?: (arg0: string) => void;
+  };
+};
+
+export interface HookManager {
+  subscriber: SubscriberObj;
+  presentScreenHook: (
+    hook: Hook,
+    payload: unknown,
+    callback: (...any) => void
+  ) => void;
+  executeHook: (
+    hook: Hook,
+    payload: unknown,
+    callback: (...any) => void
+  ) => void;
+  handleHooks: (payload: unknown) => void;
+  runInBackground: (
+    hook: Hook,
+    payload: unknown,
+    callback: (...any) => void,
+    presentUI: (payload?: HookPluginProps["payload"]) => void
+  ) => void;
+}
+
+export type HookIniObj = {
+  hook: HookModule & {
+    module: HookModule;
+    general: unknown;
+    screen_id?: string;
+    identifier?: string;
+    weight?: number | string;
+  };
+  hooks: Hook<any>[];
+  manager: HookManager;
+};
+
+export interface Hook<T extends HookModule = HookModule> {
+  manager: HookManager;
+  lastHook: boolean;
+  state: number;
+  module: T;
+  screen_id: string;
+  identifier: string;
+  configuration: T["configuration"];
+  setStateAndNotify(
+    event: (typeof HOOKS_EVENTS)[keyof typeof HOOKS_EVENTS],
+    opts: {
+      error?: typeof Error;
+      route?: string;
+      hookPlugin: Hook<T>;
+      payload: unknown;
+    }
+  );
+  general?: {
+    transition_type: (typeof HOOKS_EVENTS)[keyof typeof HOOKS_EVENTS];
+    allow_screen_plugin_presentation: boolean;
+    is_flow_blocker: boolean;
+  };
+}

package/appUtils/RiverFocusManager/index.js

@@ -26,7 +26,7 @@ export const riverFocusManager = (function () {
   /**
    * Retrieve screen focus data by id
    *
-   * @param {String}  screenFocusableGroupId Id that was used to save screen data.
+   * @param {{screenFocusableGroupId: string}} screenFocusableGroupId Unique Id of the screen from layout.json
    *
    */
   function screenFocusableData({ screenFocusableGroupId }) {
@@ -36,8 +36,9 @@ export const riverFocusManager = (function () {
   /**
    * Clear screen data for specific screen
    *
-   * @param {String}  screenId Unique Id of the screen from layout.json
-   * @param {boolean} isInsideContainer If this screen a screen picker child
+   * @param {{ screenId: string, isInsideContainer: boolean }}
+   * screenId Unique Id of the screen from layout.json
+   * isInsideContainer If this screen a screen picker child
    *
    */
   function clearScreenData({ screenId, isInsideContainer }) {
@@ -60,9 +61,13 @@ export const riverFocusManager = (function () {
   /**
    * Focus on selected items
    *
-   * @param {String}  screenFocusableGroupId Top group id that was saved as screenn
-   * @param {String} screenFocusedOnItem focusable item to focus
-   * @param {object} history navigator history object
+   * @param {{
+   * screenFocusableGroupId: string,
+   * screenFocusedOnItem: () => void,
+   * previousAction: QuickBrickNavigationActionType,
+   * isDeepLink: boolean }} object contains data for focus
+   * - `screenFocusedOnItem` focusable item to focus
+   * - `previousActionhistory` navigator history object
    *
    */
   function focusOnSelectedItem({
@@ -115,15 +120,15 @@ export const riverFocusManager = (function () {
 
   /**
    * Create unique key that will be used for save focused group data inside specific screen
-   *
-   * @param {String}  screenId Unique Id of the screen from layout.json
-   * @param {boolean} isInsideContainer If this screen a screen picker child
+   * @param {{ screenId: string, isInsideContainer: boolean }}
+   * screenId Unique Id of the screen from layout.json
+   * isInsideContainer If this screen a screen picker child
    *
    */
   function screenFocusableGroupId({ screenId, isInsideContainer }) {
-    return R.isNil(isInsideContainer)
-      ? `RiverFocusableGroup-${screenId}`
-      : `RiverFocusableGroup-${screenId}-isInsideContainer`;
+    return `RiverFocusableGroup-${screenId}${
+      R.isNil(isInsideContainer) ? "" : "-isInsideContainer"
+    }`;
   }
 
   return {

package/appUtils/__tests__/__snapshots__/localizationsHelper.test.ts.snap

@@ -0,0 +1,151 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`toDayJSLocaleMap [af] returns a valid dayjs locale 1`] = `"af"`;
+
+exports[`toDayJSLocaleMap [ar] returns a valid dayjs locale 1`] = `"ar"`;
+
+exports[`toDayJSLocaleMap [bg] returns a valid dayjs locale 1`] = `"bg"`;
+
+exports[`toDayJSLocaleMap [bn] returns a valid dayjs locale 1`] = `"bn"`;
+
+exports[`toDayJSLocaleMap [bo] returns a valid dayjs locale 1`] = `"bo"`;
+
+exports[`toDayJSLocaleMap [ca] returns a valid dayjs locale 1`] = `"ca"`;
+
+exports[`toDayJSLocaleMap [cs] returns a valid dayjs locale 1`] = `"cs"`;
+
+exports[`toDayJSLocaleMap [da] returns a valid dayjs locale 1`] = `"da"`;
+
+exports[`toDayJSLocaleMap [de] returns a valid dayjs locale 1`] = `"de"`;
+
+exports[`toDayJSLocaleMap [el] returns a valid dayjs locale 1`] = `"el"`;
+
+exports[`toDayJSLocaleMap [en] returns a valid dayjs locale 1`] = `"en"`;
+
+exports[`toDayJSLocaleMap [en-GB] returns a valid dayjs locale 1`] = `"en-gb"`;
+
+exports[`toDayJSLocaleMap [en-UK] returns a valid dayjs locale 1`] = `"en-gb"`;
+
+exports[`toDayJSLocaleMap [es] returns a valid dayjs locale 1`] = `"es"`;
+
+exports[`toDayJSLocaleMap [es-LA] returns a valid dayjs locale 1`] = `"es"`;
+
+exports[`toDayJSLocaleMap [es-MX] returns a valid dayjs locale 1`] = `"es-mx"`;
+
+exports[`toDayJSLocaleMap [es-US] returns a valid dayjs locale 1`] = `"es-us"`;
+
+exports[`toDayJSLocaleMap [et] returns a valid dayjs locale 1`] = `"et"`;
+
+exports[`toDayJSLocaleMap [eu] returns a valid dayjs locale 1`] = `"eu"`;
+
+exports[`toDayJSLocaleMap [fa] returns a valid dayjs locale 1`] = `"fa"`;
+
+exports[`toDayJSLocaleMap [fi] returns a valid dayjs locale 1`] = `"fi"`;
+
+exports[`toDayJSLocaleMap [fj] returns a valid dayjs locale 1`] = `"en"`;
+
+exports[`toDayJSLocaleMap [fr] returns a valid dayjs locale 1`] = `"fr"`;
+
+exports[`toDayJSLocaleMap [ga] returns a valid dayjs locale 1`] = `"ga"`;
+
+exports[`toDayJSLocaleMap [gu] returns a valid dayjs locale 1`] = `"gu"`;
+
+exports[`toDayJSLocaleMap [he] returns a valid dayjs locale 1`] = `"he"`;
+
+exports[`toDayJSLocaleMap [hi] returns a valid dayjs locale 1`] = `"hi"`;
+
+exports[`toDayJSLocaleMap [hr] returns a valid dayjs locale 1`] = `"hr"`;
+
+exports[`toDayJSLocaleMap [hu] returns a valid dayjs locale 1`] = `"hu"`;
+
+exports[`toDayJSLocaleMap [hy] returns a valid dayjs locale 1`] = `"hy-am"`;
+
+exports[`toDayJSLocaleMap [id] returns a valid dayjs locale 1`] = `"id"`;
+
+exports[`toDayJSLocaleMap [is] returns a valid dayjs locale 1`] = `"is"`;
+
+exports[`toDayJSLocaleMap [it] returns a valid dayjs locale 1`] = `"it"`;
+
+exports[`toDayJSLocaleMap [ja] returns a valid dayjs locale 1`] = `"ja"`;
+
+exports[`toDayJSLocaleMap [ka] returns a valid dayjs locale 1`] = `"ka"`;
+
+exports[`toDayJSLocaleMap [km] returns a valid dayjs locale 1`] = `"km"`;
+
+exports[`toDayJSLocaleMap [ko] returns a valid dayjs locale 1`] = `"ko"`;
+
+exports[`toDayJSLocaleMap [la] returns a valid dayjs locale 1`] = `"en"`;
+
+exports[`toDayJSLocaleMap [lt] returns a valid dayjs locale 1`] = `"lt"`;
+
+exports[`toDayJSLocaleMap [lv] returns a valid dayjs locale 1`] = `"lv"`;
+
+exports[`toDayJSLocaleMap [mi] returns a valid dayjs locale 1`] = `"mi"`;
+
+exports[`toDayJSLocaleMap [mk] returns a valid dayjs locale 1`] = `"mk"`;
+
+exports[`toDayJSLocaleMap [ml] returns a valid dayjs locale 1`] = `"ml"`;
+
+exports[`toDayJSLocaleMap [mn] returns a valid dayjs locale 1`] = `"mn"`;
+
+exports[`toDayJSLocaleMap [mr] returns a valid dayjs locale 1`] = `"mr"`;
+
+exports[`toDayJSLocaleMap [ms] returns a valid dayjs locale 1`] = `"ms"`;
+
+exports[`toDayJSLocaleMap [mt] returns a valid dayjs locale 1`] = `"mt"`;
+
+exports[`toDayJSLocaleMap [ne] returns a valid dayjs locale 1`] = `"ne"`;
+
+exports[`toDayJSLocaleMap [nl] returns a valid dayjs locale 1`] = `"nl"`;
+
+exports[`toDayJSLocaleMap [no] returns a valid dayjs locale 1`] = `"en"`;
+
+exports[`toDayJSLocaleMap [pa] returns a valid dayjs locale 1`] = `"pa-in"`;
+
+exports[`toDayJSLocaleMap [pl] returns a valid dayjs locale 1`] = `"pl"`;
+
+exports[`toDayJSLocaleMap [pt] returns a valid dayjs locale 1`] = `"pt"`;
+
+exports[`toDayJSLocaleMap [pt-BR] returns a valid dayjs locale 1`] = `"pt-br"`;
+
+exports[`toDayJSLocaleMap [qu] returns a valid dayjs locale 1`] = `"en"`;
+
+exports[`toDayJSLocaleMap [ro] returns a valid dayjs locale 1`] = `"ro"`;
+
+exports[`toDayJSLocaleMap [ru] returns a valid dayjs locale 1`] = `"ru"`;
+
+exports[`toDayJSLocaleMap [sk] returns a valid dayjs locale 1`] = `"sk"`;
+
+exports[`toDayJSLocaleMap [sl] returns a valid dayjs locale 1`] = `"sl"`;
+
+exports[`toDayJSLocaleMap [sm] returns a valid dayjs locale 1`] = `"en"`;
+
+exports[`toDayJSLocaleMap [sq] returns a valid dayjs locale 1`] = `"sq"`;
+
+exports[`toDayJSLocaleMap [sr] returns a valid dayjs locale 1`] = `"sr"`;
+
+exports[`toDayJSLocaleMap [sv] returns a valid dayjs locale 1`] = `"sv"`;
+
+exports[`toDayJSLocaleMap [sw] returns a valid dayjs locale 1`] = `"sw"`;
+
+exports[`toDayJSLocaleMap [ta] returns a valid dayjs locale 1`] = `"ta"`;
+
+exports[`toDayJSLocaleMap [te] returns a valid dayjs locale 1`] = `"te"`;
+
+exports[`toDayJSLocaleMap [th] returns a valid dayjs locale 1`] = `"th"`;
+
+exports[`toDayJSLocaleMap [to] returns a valid dayjs locale 1`] = `"en"`;
+
+exports[`toDayJSLocaleMap [tr] returns a valid dayjs locale 1`] = `"tr"`;
+
+exports[`toDayJSLocaleMap [tt] returns a valid dayjs locale 1`] = `"en"`;
+
+exports[`toDayJSLocaleMap [uk] returns a valid dayjs locale 1`] = `"uk"`;
+
+exports[`toDayJSLocaleMap [ur] returns a valid dayjs locale 1`] = `"ur"`;
+
+exports[`toDayJSLocaleMap [uz] returns a valid dayjs locale 1`] = `"uz"`;
+
+exports[`toDayJSLocaleMap [vi] returns a valid dayjs locale 1`] = `"vi"`;
+
+exports[`toDayJSLocaleMap [zh] returns a valid dayjs locale 1`] = `"zh"`;

package/appUtils/__tests__/allZappLocales.ts

@@ -0,0 +1,79 @@
+export default [
+  // common locales from https://rubygems.org/gems/language_list
+  "en",
+  "fr",
+  "de",
+  "nl",
+  "ru",
+  "es",
+  "he",
+  "hy",
+  "sq",
+  "af",
+  "ar",
+  "eu",
+  "bn",
+  "bg",
+  "zh",
+  "cs",
+  "km",
+  "ca",
+  "hr",
+  "da",
+  "et",
+  "fj",
+  "fi",
+  "gu",
+  "ka",
+  "hu",
+  "hi",
+  "it",
+  "is",
+  "id",
+  "ga",
+  "ja",
+  "ko",
+  "la",
+  "lv",
+  "lt",
+  "ms",
+  "mi",
+  "mn",
+  "mt",
+  "mk",
+  "el",
+  "mr",
+  "ml",
+  "ne",
+  "no",
+  "pa",
+  "pl",
+  "pt",
+  "fa",
+  "qu",
+  "ro",
+  "sk",
+  "sm",
+  "sr",
+  "sw",
+  "sv",
+  "sl",
+  "to",
+  "tr",
+  "th",
+  "te",
+  "bo",
+  "tt",
+  "ta",
+  "uk",
+  "ur",
+  "uz",
+  "vi",
+  // Extra locales https://github.com/applicaster/zapp/blob/5604794f15cfd270ae494b0db85e542de4cebfaa/config/additional_languages.yml
+  "en-UK",
+  "en-GB",
+  "es-LA",
+  "pt-BR",
+  "es-MX",
+  "es-US",
+];

package/appUtils/__tests__/{localizationsHelper.test.js → localizationsHelper.test.ts}

@@ -8,6 +8,7 @@ const {
   getLocale,
   getLanguageCode,
   getCountryCode,
+  toDayJSLocaleMap,
 } = require("../localizationsHelper");
 
 describe("getLocale", () => {
@@ -69,3 +70,13 @@ describe("getCountryCode", () => {
     expect(currentValue).toEqual(expectedValue);
   });
 });
+
+describe("toDayJSLocaleMap", () => {
+  const allZappLocales: string[] = require("./allZappLocales").default;
+
+  it.each(allZappLocales)("[%s] returns a valid dayjs locale", (locale) => {
+    const dayJSLocale = toDayJSLocaleMap(locale);
+    expect(dayJSLocale).toBeDefined();
+    expect(dayJSLocale).toMatchSnapshot();
+  });
+});

package/appUtils/accessibilityManager/index.ts

@@ -6,6 +6,9 @@ import { AccessibilityRole } from "react-native";
 
 export class AccessibilityManager {
   private static _instance: AccessibilityManager | null = null;
+  private headingTimeout: NodeJS.Timeout | null = null;
+  private WORDS_PER_MINUTE = 160;
+  private MINIMUM_PAUSE = 500;
   private state$ = new BehaviorSubject<AccessibilityState>({
     screenReaderEnabled: false,
     reduceMotionEnabled: false,
@@ -20,6 +23,7 @@ export class AccessibilityManager {
 
   private ttsManager = TTSManager.getInstance();
   private localizations: { [key: string]: string } = {};
+  private headingQueue: string[] = [];
 
   private constructor() {}
 
@@ -52,6 +56,28 @@ export class AccessibilityManager {
     return this.state$.asObservable();
   }
 
+  /** Calculates the reading time for a given text
+   * This method is a bit of a hack because we don't have a callback, or promise from VIZIO API
+   * @param text - The text to calculate the reading time for
+   * @returns The reading time in milliseconds
+   */
+  private calculateReadingTime(text: string): number {
+    const words = text.trim().split(/\s+/).length;
+
+    return Math.max(
+      this.MINIMUM_PAUSE,
+      (words / this.WORDS_PER_MINUTE) * 60 * 1000
+    );
+  }
+
+  /**
+   * Adds a heading to the queue, headings will be read before the next text
+   * Each heading will be read once and removed from the queue
+   */
+  public addHeading(heading: string) {
+    this.headingQueue.push(heading);
+  }
+
   /**
    * text you want to be read, if you want to use localized text pass keyOfLocalizedText instead
    * keyOfLocalizedText is the key to the localized text
@@ -85,7 +111,22 @@ export class AccessibilityManager {
       textToRead = localizedMessage;
     }
 
-    this.ttsManager && this.ttsManager.readText(textToRead);
+    if (this.headingQueue.length > 0) {
+      const heading = this.headingQueue.shift()!;
+      this.ttsManager?.readText(heading);
+
+      if (this.headingTimeout) {
+        clearTimeout(this.headingTimeout);
+      }
+
+      const pauseTime = this.calculateReadingTime(heading);
+
+      this.headingTimeout = setTimeout(() => {
+        this.ttsManager?.readText(textToRead);
+      }, pauseTime);
+    } else {
+      this.ttsManager?.readText(textToRead);
+    }
 
     this.announcements$.next({
       message: textToRead,

package/appUtils/contextKeysManager/contextResolver.ts

@@ -0,0 +1,66 @@
+import { ContextKeysManager } from "./index";
+import * as R from "ramda";
+
+interface IResolver {
+  resolve: (string) => Promise<string | number | object>;
+}
+
+export class EntryResolver implements IResolver {
+  entry: ZappEntry;
+
+  constructor(entry: ZappEntry) {
+    this.entry = entry;
+  }
+
+  async resolve(key: string) {
+    if (!key || key.length === 0) {
+      return this.entry;
+    }
+
+    return R.view(R.lensPath(key.split(".")), this.entry);
+  }
+}
+
+export class ContextResolver implements IResolver {
+  resolve = async (compositeKey: string) =>
+    ContextKeysManager.instance.getKey(compositeKey);
+}
+
+export const resolveObjectValues = async (
+  data: Record<string, any>,
+  resolvers: Record<string, IResolver> = null
+) => {
+  const entries = Object.entries(data);
+
+  const exResolvers = { ctx: new ContextResolver(), ...resolvers };
+
+  const resolvedEntries = await Promise.all(
+    entries.map(async ([key, value]) => {
+      if (typeof value !== "string") {
+        return [key, value];
+      }
+
+      if (!value.startsWith("@")) {
+        return [key, value];
+      }
+
+      const regex = /@{([^/]+)\/([^}]*)}/;
+
+      const match = (value as string).match(regex);
+
+      if (match) {
+        const contextResolverName = match[1];
+        const compositeKey = match[2];
+
+        const resolver = exResolvers[contextResolverName] || exResolvers.ctx;
+        const resolvedValue = await resolver.resolve(compositeKey);
+
+        return [key, resolvedValue];
+      }
+
+      return [key, value];
+    })
+  );
+
+  return Object.fromEntries(resolvedEntries);
+};

package/appUtils/contextKeysManager/index.ts

@@ -16,12 +16,12 @@ import {
 
 export { StorageLevel };
 
-type KeyNameObj = {
+export type KeyNameObj = {
   namespace: string;
   key: string;
 };
 
-type KeyName = string | KeyNameObj;
+export type KeyName = string | KeyNameObj;
 
 type ParsedKeyAndNamespace = {
   namespace?: string;

package/appUtils/contextKeysManager/utils/index.ts

@@ -1,10 +1,11 @@
 import * as R from "ramda";
 import { DEFAULT_NAMESPACE } from "../consts";
+import { KeyName, KeyNameObj } from "../index";
 
 const lastDotRegex = /\.([^.]+)$/;
 const splitByLastDot = R.compose(R.init, R.split(lastDotRegex));
 
-export function getNamespaceAndKey(namespacedKey) {
+export function getNamespaceAndKey(namespacedKey: KeyName): KeyNameObj {
   if (typeof namespacedKey !== "string") return namespacedKey;
 
   const namespacedKeyProps = namespacedKey.includes(".")

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

@@ -1,14 +1,15 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
 exports[`focusManager should be defined 1`] = `
-Object {
+{
   "blur": [Function],
   "disableFocus": [Function],
   "enableFocus": [Function],
+  "findPreferredFocusChild": [Function],
   "focusableTree": Tree {
     "loadingCounter": 0,
-    "root": Object {
-      "children": Array [],
+    "root": {
+      "children": [],
       "component": null,
       "id": "root",
       "lastFocusedItem": null,
@@ -28,6 +29,7 @@ Object {
   "moveFocus": [Function],
   "on": [Function],
   "press": [Function],
+  "pressIn": [Function],
   "pressOut": [Function],
   "recoverFocus": [Function],
   "register": [Function],
@@ -39,12 +41,12 @@ Object {
 `;
 
 exports[`focusManagerIOS should be defined 1`] = `
-Object {
+{
   "focus": [Function],
   "focusableTree": Tree {
     "loadingCounter": 0,
-    "root": Object {
-      "children": Array [],
+    "root": {
+      "children": [],
       "component": null,
       "id": "root",
       "lastFocusedItem": null,
@@ -59,6 +61,7 @@ Object {
   "getCurrentGroup": [Function],
   "getGroupById": [Function],
   "getGroupRootById": [Function],
+  "getPreferredFocusChild": [Function],
   "invokeHandler": [Function],
   "isGroupItemFocused": [Function],
   "moveFocus": [Function],

package/appUtils/focusManager/index.ios.ts

@@ -1,8 +1,10 @@
 import { NativeModules } from "react-native";
 import * as R from "ramda";
+
 import { Tree } from "./treeDataStructure/Tree";
 import { findFocusableNode } from "./treeDataStructure/Utils";
 import { subscriber } from "../../functionUtils";
+import { findChild } from "./utils";
 
 const { FocusableManagerModule } = NativeModules;
 
@@ -52,10 +54,7 @@ export const focusManager = (function () {
     const node = focusableTree.findInTree(groupId);
 
     if (node?.children?.length > 0) {
-      const preferredFocus = R.compose(
-        R.find(R.pathEq(["component", "props", "preferredFocus"], true)),
-        R.prop("children")
-      )(node);
+      const preferredFocus = findChild(true, node);
 
       if (preferredFocus?.component?.isGroup) {
         return getPreferredFocusInGroup({ groupId: preferredFocus?.id });
@@ -382,6 +381,16 @@ export const focusManager = (function () {
     forceFocusOnItem({ focusableItem, callback });
   }
 
+  function getPreferredFocusChild(id) {
+    const node = focusableTree.findInTree(id);
+
+    if (node?.children?.length > 0) {
+      return findChild(true, node) || findChild(false, node);
+    }
+
+    return node;
+  }
+
   return {
     on,
     invokeHandler,
@@ -402,5 +411,6 @@ export const focusManager = (function () {
     getCurrentGroup,
     getGroupRootById,
     isGroupItemFocused,
+    getPreferredFocusChild,
   };
 })();