@applicaster/zapp-react-native-utils 14.0.0-alpha.3514550494 → 14.0.0-alpha.3652810444

package/focusManager/aux/index.ts

@@ -0,0 +1,167 @@
+import {
+  isNil,
+  startsWith,
+  find,
+  pathOr,
+} from "@applicaster/zapp-react-native-utils/utils";
+
+import {
+  QUICK_BRICK_CONTENT,
+  QUICK_BRICK_NAVBAR,
+  QUICK_BRICK_NAVBAR_SECTIONS,
+} from "@applicaster/quick-brick-core/const";
+
+const isNavBar = (node) => startsWith(QUICK_BRICK_NAVBAR, node?.id);
+const isContent = (node) => startsWith(QUICK_BRICK_CONTENT, node?.id);
+
+// SCREEN_PICKER_SELECTOR_CONTAINER(we assume there is only one SCREEN_PICKER)
+let screenPickerSelectorContainerId;
+
+export const onRegisterScreenPickerSelectorContainer = (id) => {
+  screenPickerSelectorContainerId = id;
+};
+
+export const onUnregisterScreenPickerSelectorContainer = (id) => {
+  // reset screenSelectorId on unregistration
+  if (screenPickerSelectorContainerId === id) {
+    screenPickerSelectorContainerId = undefined;
+  }
+};
+// SCREEN_PICKER_SELECTOR_CONTAINER
+
+// SCREEN_PICKER_CONTENT_CONTAINER(we assume there is only one SCREEN_PICKER)
+let screenPickerContentContainerId;
+
+export const onRegisterScreenPickerContentContainer = (id) => {
+  screenPickerContentContainerId = id;
+};
+
+export const onUnregisterScreenPickerContentContainer = (id) => {
+  // reset screenSelectorId on unregistration
+  if (screenPickerContentContainerId === id) {
+    screenPickerContentContainerId = undefined;
+  }
+};
+
+const isScreenPickerContentContainer = (node) =>
+  screenPickerContentContainerId === node?.id;
+
+// SCREEN_PICKER_CONTENT_CONTAINER
+
+const findSelectedMenuIdInSection = (focusableTree, section) => {
+  const children = pathOr([], ["children"], focusableTree.find(section));
+
+  return find((child) => child.component.current.props.isSelected(), children)
+    ?.id;
+};
+
+export const findSelectedMenuId = (focusableTree) => {
+  const selectedMenuItemIdInLeftSection = findSelectedMenuIdInSection(
+    focusableTree,
+    QUICK_BRICK_NAVBAR_SECTIONS.left
+  );
+
+  if (selectedMenuItemIdInLeftSection) {
+    return selectedMenuItemIdInLeftSection;
+  }
+
+  const selectedMenuItemIdInMenuSection = findSelectedMenuIdInSection(
+    focusableTree,
+    QUICK_BRICK_NAVBAR_SECTIONS.menu
+  );
+
+  if (selectedMenuItemIdInMenuSection) {
+    return selectedMenuItemIdInMenuSection;
+  }
+
+  const selectedMenuItemIdInRightSection = findSelectedMenuIdInSection(
+    focusableTree,
+    QUICK_BRICK_NAVBAR_SECTIONS.right
+  );
+
+  if (selectedMenuItemIdInRightSection) {
+    return selectedMenuItemIdInRightSection;
+  }
+
+  return undefined;
+};
+
+export const findSelectedTabId = (focusableTree, item: ZappEntry): string => {
+  const screenSelectorContainerNode = focusableTree.find(
+    screenPickerSelectorContainerId
+  );
+
+  const selectedTabId = find(
+    (child) => child.component.current.props.isSelected(item.id),
+    screenSelectorContainerNode.children
+  )?.id;
+
+  return selectedTabId;
+};
+
+export const isTabsScreenContentFocused = (focusableTree, id) => {
+  const node = focusableTree.find(id);
+
+  if (isNil(node)) {
+    return false;
+  }
+
+  if (isNavBar(node)) {
+    return false;
+  }
+
+  if (isContent(node)) {
+    return false;
+  }
+
+  if (isScreenPickerContentContainer(node)) {
+    return true;
+  }
+
+  return isTabsScreenContentFocused(focusableTree, node.parentId);
+};
+
+export const isCurrentFocusOnMenu = (focusableTree, id): boolean => {
+  const node = focusableTree.find(id);
+
+  if (isNil(node)) {
+    return false;
+  }
+
+  if (isNavBar(node)) {
+    return true;
+  }
+
+  if (isContent(node)) {
+    return false;
+  }
+
+  return isCurrentFocusOnMenu(focusableTree, node.parentId);
+};
+
+export const isCurrentFocusOnContent = (focusableTree, id) => {
+  const node = focusableTree.find(id);
+
+  if (isNil(node)) {
+    return false;
+  }
+
+  if (isNavBar(node)) {
+    return false;
+  }
+
+  if (isContent(node)) {
+    return true;
+  }
+
+  return isCurrentFocusOnContent(focusableTree, node.parentId);
+};
+
+export const contextWithoutScrolling = (
+  source: FocusManager.FocusContext["source"]
+): FocusManager.FocusContext => {
+  return {
+    source,
+    preserveScroll: true,
+  };
+};

package/focusManager/utils.ts

@@ -4,11 +4,11 @@ import { isNilOrEmpty } from "@applicaster/zapp-react-native-utils/reactUtils/he
 
 export const getFocusableId = (ref) => ref?.current?.props.id;
 
-type Direction = "up" | "down" | "left" | "right";
-
 const normalizeDirection = (direction) => direction.toLowerCase();
 
-const checkDirection = (direction: Direction) => {
+const checkDirection = (
+  direction: FocusManager.Android.FocusNavigationDirections
+) => {
   invariant(!isNilOrEmpty(direction), "direction should not be empty");
 
   invariant(
@@ -17,19 +17,25 @@ const checkDirection = (direction: Direction) => {
   );
 };
 
-export const toFocusDirection = (direction: Direction) => {
+export const toFocusDirection = (
+  direction: FocusManager.Android.FocusNavigationDirections
+) => {
   checkDirection(direction);
 
   return `nextFocus${capitalize(normalizeDirection(direction))}`;
 };
 
-export const isHorizontalDirection = (direction: Direction) => {
+export const isHorizontalDirection = (
+  direction: FocusManager.Android.FocusNavigationDirections
+) => {
   checkDirection(direction);
 
   return ["left", "right"].includes(normalizeDirection(direction));
 };
 
-export const isVerticalDirection = (direction: Direction) => {
+export const isVerticalDirection = (
+  direction: FocusManager.Android.FocusNavigationDirections
+) => {
   checkDirection(direction);
 
   return ["up", "down"].includes(normalizeDirection(direction));

package/manifestUtils/defaultManifestConfigurations/player.js

@@ -208,7 +208,7 @@ function getPlayerConfiguration({ platform, version }) {
       {
         key: "accessibility_forward_label",
         label: "Accessibility forward label",
-        initial_value: "Fast forward button",
+        initial_value: "Forward button",
         label_tooltip: "Label for forward button accessibility",
         type: "text_input",
       },
@@ -292,7 +292,7 @@ function getPlayerConfiguration({ platform, version }) {
       {
         key: "accessibility_back_label",
         label: "Accessibility back label",
-        initial_value: "Exit player button",
+        initial_value: "Back button",
         label_tooltip: "Label for back button accessibility",
         type: "text_input",
       },
@@ -317,20 +317,6 @@ function getPlayerConfiguration({ platform, version }) {
         label_tooltip: "Hint for fullscreen button accessibility",
         type: "text_input",
       },
-      {
-        key: "accessibility_skip_intro_label",
-        label: "Accessibility skip intro label",
-        initial_value: "Skip intro - button",
-        label_tooltip: "Label for skip intro button accessibility",
-        type: "text_input",
-      },
-      {
-        key: "accessibility_skip_intro_hint",
-        label: "Accessibility skip intro hint",
-        initial_value: "Press to skip intro",
-        label_tooltip: "Hint for skip intro button accessibility",
-        type: "text_input",
-      },
     ],
   };
 

package/navigationUtils/index.ts

@@ -42,7 +42,7 @@ export function getNavigationType(
     R.unless(R.isNil, R.prop("navigation_type")),
     R.defaultTo(undefined),
     R.find(R.propEq("category", category))
-  )(navigations);
+  )(navigations || []);
 }
 
 /**

package/package.json

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

package/playerUtils/getPlayerActionButtons.ts

@@ -13,5 +13,5 @@ export const getPlayerActionButtons = (configuration: any) => {
     return [];
   }
 
-  return take(map(buttonsString.split(","), trim), 2);
+  return take(2, map(buttonsString.split(","), trim));
 };

package/reactHooks/feed/useLoadPipesDataDispatch.ts

@@ -30,7 +30,13 @@ export const useLoadPipesDataDispatch = () => {
   return React.useCallback(
     (
       url: string,
-      options = {},
+      options: {
+        callback?: (data: unknown, error?: Error | null | undefined) => void;
+        riverId?: string;
+        clearCache?: boolean;
+        silentRefresh?: boolean;
+        parentFeed?: string;
+      } = {},
       {
         withResolvers = false,
         withScreenRouteMapping = false,

package/screenPickerUtils/index.ts

@@ -5,3 +5,9 @@ export const getPickerSelectorId = (id) => `PickerSelector.${id}`;
 export const SCREEN_PICKER_CONTAINER = "ScreenPickerContainer";
 
 export const getScreenPickerId = (id) => `${SCREEN_PICKER_CONTAINER}.${id}`;
+
+export const getScreenPickerSelectorContainerId = (id) =>
+  `${SCREEN_PICKER_CONTAINER}.${id}-screen-selector`;
+
+export const getScreenPickerContentContainerId = (id) =>
+  `${SCREEN_PICKER_CONTAINER}.${id}-screen-container`;

package/utils/__tests__/endsWith.test.ts

@@ -0,0 +1,30 @@
+import { endsWith } from "../endsWith";
+
+describe("endsWith", () => {
+  it("returns false when str is null", () => {
+    expect(endsWith("a", null)).toBe(false);
+  });
+
+  it("returns false when str is undefined", () => {
+    expect(endsWith("a", undefined)).toBe(false);
+  });
+
+  it("returns true when string ends with target", () => {
+    expect(endsWith("lo", "hello")).toBe(true);
+    expect(endsWith("", "hello")).toBe(true); // empty target always matches
+  });
+
+  it("returns false when string does not end with target", () => {
+    expect(endsWith("yo", "hello")).toBe(false);
+  });
+
+  it("works with single character target", () => {
+    expect(endsWith("o", "hello")).toBe(true);
+    expect(endsWith("x", "hello")).toBe(false);
+  });
+
+  it("is case-sensitive", () => {
+    expect(endsWith("Lo", "hello")).toBe(false);
+    expect(endsWith("lo", "hello")).toBe(true);
+  });
+});

package/utils/__tests__/equals.test.ts

@@ -0,0 +1,65 @@
+import { equals } from "../equals";
+
+describe("equals", () => {
+  it("returns true for two identical primitive values", () => {
+    expect(equals(5, 5)).toBe(true);
+    expect(equals("hello", "hello")).toBe(true);
+    expect(equals(true, true)).toBe(true);
+  });
+
+  it("returns false for two different primitive values", () => {
+    expect(equals(5, 10)).toBe(false);
+    expect(equals("hello", "world")).toBe(false);
+    expect(equals(true, false)).toBe(false);
+  });
+
+  it("returns true for deeply equal objects", () => {
+    const a = { x: 1, y: { z: 2 } };
+    const b = { x: 1, y: { z: 2 } };
+    expect(equals(a, b)).toBe(true);
+  });
+
+  it("returns false for objects with different values", () => {
+    const a = { x: 1, y: { z: 2 } };
+    const b = { x: 1, y: { z: 3 } };
+    expect(equals(a, b)).toBe(false);
+  });
+
+  it("returns true for arrays with same elements", () => {
+    expect(equals([1, 2, 3], [1, 2, 3])).toBe(true);
+  });
+
+  it("returns false for arrays with different elements", () => {
+    expect(equals([1, 2, 3], [1, 2, 4])).toBe(false);
+  });
+
+  it("returns true for nested arrays/objects", () => {
+    const a = [{ id: 1, data: [1, 2, 3] }];
+    const b = [{ id: 1, data: [1, 2, 3] }];
+    expect(equals(a, b)).toBe(true);
+  });
+
+  it("returns false for arrays with different order", () => {
+    expect(equals([1, 2, 3], [3, 2, 1])).toBe(false);
+  });
+
+  it("handles null and undefined correctly", () => {
+    expect(equals(null, null)).toBe(true);
+    expect(equals(undefined, undefined)).toBe(true);
+    expect(equals(null, undefined)).toBe(false);
+  });
+
+  it("handles dates correctly", () => {
+    const d1 = new Date("2020-01-01");
+    const d2 = new Date("2020-01-01");
+    const d3 = new Date("2021-01-01");
+
+    expect(equals(d1, d2)).toBe(true);
+    expect(equals(d1, d3)).toBe(false);
+  });
+
+  it("handles regex correctly", () => {
+    expect(equals(/abc/, /abc/)).toBe(true);
+    expect(equals(/abc/i, /abc/)).toBe(false);
+  });
+});

package/utils/__tests__/max.test.ts

@@ -0,0 +1,36 @@
+import { max } from "../max";
+
+describe("max", () => {
+  describe("for numbers", () => {
+    it("returns the first argument when it is greater", () => {
+      expect(max(10, 5)).toBe(10);
+    });
+
+    it("returns the second argument when it is greater", () => {
+      expect(max(3, 7)).toBe(7);
+    });
+
+    it("returns the same value when both arguments are equal", () => {
+      expect(max(4, 4)).toBe(4);
+    });
+
+    it("works with negative numbers", () => {
+      expect(max(-2, -5)).toBe(-2);
+    });
+
+    it("works when one argument is negative and the other is positive", () => {
+      expect(max(-10, 20)).toBe(20);
+    });
+
+    it("works with zeros", () => {
+      expect(max(0, 0)).toBe(0);
+      expect(max(0, -1)).toBe(0);
+    });
+  });
+
+  describe("for letters", () => {
+    it("returns the second argument when it is greater", () => {
+      expect(max("a", "b")).toBe("b");
+    });
+  });
+});

package/utils/__tests__/omit.test.ts

@@ -0,0 +1,19 @@
+import { omit } from "../omit";
+
+test("example 1", () => {
+  const path = ["a", "b", "c"];
+  const record = { a: 1, b: 2, c: 3 };
+
+  const output = {};
+
+  expect(omit(path, record)).toEqual(output);
+});
+
+test("example 2", () => {
+  const path = ["a", "b"];
+  const record = { a: 1, b: 2, c: 3 };
+
+  const output = { c: 3 };
+
+  expect(omit(path, record)).toEqual(output);
+});

package/utils/__tests__/path.test.ts

@@ -0,0 +1,33 @@
+import { path } from "../path";
+
+test("example 1", () => {
+  const route = ["a", "b", "c"];
+  const xs = { a: { b: { c: 1 } } };
+
+  const output = 1;
+
+  expect(path(route, xs)).toEqual(output);
+});
+
+test("example 2", () => {
+  const route = ["a", "b"];
+  const xs = { a: { b: { c: 1 } } };
+
+  const output = { c: 1 };
+
+  expect(path(route, xs)).toEqual(output);
+});
+
+test("example 3", () => {
+  const route = ["a", "b", "x"];
+  const xs = { a: { b: { c: 1 } } };
+
+  expect(path(route, xs)).toBeUndefined();
+});
+
+test("example 4", () => {
+  const route = ["a", "b", "c"];
+  const xs = undefined;
+
+  expect(path(route, xs)).toBeUndefined();
+});

package/utils/__tests__/take.test.ts

@@ -0,0 +1,40 @@
+import { take } from "../take";
+
+describe("take", () => {
+  it("takes n elements from the beginning", () => {
+    expect(take(2, [1, 2, 3])).toEqual([1, 2]);
+  });
+
+  it("returns the whole array if n is larger than length", () => {
+    expect(take(5, [1, 2, 3])).toEqual([1, 2, 3]);
+  });
+
+  it("returns empty array if n is 0", () => {
+    expect(take(0, [1, 2, 3])).toEqual([]);
+  });
+
+  it("returns empty array for empty input array", () => {
+    expect(take(2, [])).toEqual([]);
+  });
+
+  it("returns empty array if n is negative", () => {
+    expect(take(-1, [1, 2, 3])).toEqual([]);
+  });
+
+  it("works with strings in array", () => {
+    expect(take(2, ["a", "b", "c"])).toEqual(["a", "b"]);
+  });
+
+  it("works with objects in array", () => {
+    const arr = [{ id: 1 }, { id: 2 }];
+    expect(take(1, arr)).toEqual([{ id: 1 }]);
+  });
+
+  it("returns empty array if input is not an array", () => {
+    // @ts-expect-error testing non-array input
+    expect(take(2, null)).toEqual([]);
+
+    // @ts-expect-error testing non-array input
+    expect(take(2, undefined)).toEqual([]);
+  });
+});

package/utils/__tests__/toLower.test.ts

@@ -0,0 +1,39 @@
+import { toLower } from "../toLower";
+
+describe("toLower", () => {
+  it("converts mixed case string to lowercase", () => {
+    expect(toLower("--Foo-Bar--")).toBe("--foo-bar--");
+    expect(toLower("fooBar")).toBe("foobar");
+    expect(toLower("__FOO_BAR__")).toBe("__foo_bar__");
+  });
+
+  it("returns the same string if already lowercase", () => {
+    expect(toLower("hello")).toBe("hello");
+  });
+
+  it("converts uppercase string to lowercase", () => {
+    expect(toLower("HELLO")).toBe("hello");
+  });
+
+  it("handles empty string", () => {
+    expect(toLower("")).toBe("");
+  });
+
+  it("converts string with numbers and symbols", () => {
+    expect(toLower("123-ABC-xyz")).toBe("123-abc-xyz");
+  });
+
+  it("handles null and undefined gracefully", () => {
+    // @ts-expect-error testing null input
+    expect(toLower(null)).toBe("");
+    // @ts-expect-error testing undefined input
+    expect(toLower(undefined)).toBe("");
+  });
+
+  it("coerces non-string values to string before lowercasing", () => {
+    // @ts-expect-error testing number input
+    expect(toLower(12345)).toBe("12345");
+    // @ts-expect-error testing boolean input
+    expect(toLower(true)).toBe("true");
+  });
+});

package/utils/endsWith.ts

@@ -0,0 +1,9 @@
+import { isNil } from "lodash";
+
+export const endsWith = (target, str) => {
+  if (isNil(str)) {
+    return false;
+  }
+
+  return str.endsWith(target);
+};

package/utils/equals.ts

@@ -0,0 +1,5 @@
+import { isEqual } from "lodash";
+
+export function equals(a: any, b: any): boolean {
+  return isEqual(a, b);
+}

package/utils/index.ts

@@ -8,6 +8,20 @@ export { find } from "./find";
 
 export { pathOr } from "./pathOr";
 
+export { path } from "./path";
+
+export { omit } from "./omit";
+
+export { endsWith } from "./endsWith";
+
+export { max } from "./max";
+
+export { equals } from "./equals";
+
+export { take } from "./take";
+
+export { toLower } from "./toLower";
+
 export {
   cloneDeep as clone,
   flatten,
@@ -19,7 +33,6 @@ export {
   has,
   flatMap,
   difference,
-  take,
   pick,
   map,
   trim,

package/utils/max.ts

@@ -0,0 +1,5 @@
+type Value = number | string;
+
+export function max(a: Value, b: Value): Value {
+  return a > b ? a : b;
+}

package/utils/omit.ts

@@ -0,0 +1,5 @@
+import { omit as Lodash_omit } from "lodash";
+
+export const omit = (path, record) => {
+  return Lodash_omit(record, path);
+};

package/utils/path.ts

@@ -0,0 +1,5 @@
+import { get } from "lodash";
+
+export const path = (route, record) => {
+  return get(record, route, undefined);
+};

package/utils/take.ts

@@ -0,0 +1,5 @@
+import { take as Ltake } from "lodash";
+
+export function take<T>(n: number, xs: T[]): T[] {
+  return Ltake(xs, n);
+}

package/utils/toLower.ts

@@ -0,0 +1,5 @@
+import { toLower as L_toLower } from "lodash";
+
+export function toLower(value: Option<string>): string {
+  return L_toLower(value);
+}