@applicaster/zapp-react-native-ui-components 15.0.0-alpha.3514407021 → 15.0.0-alpha.3515180215

package/Components/MasterCell/DefaultComponents/tv/TvActionButtons/utils/__tests__/getPluginIdentifier.test.ts

@@ -3,7 +3,7 @@ import { getPluginIdentifier } from "..";
 describe("getPluginIdentifier", () => {
   const prefix = "tv_buttons";
 
-  it("get first plugin identifier", () => {
+  it("returns the first valid plugin identifier", () => {
     const configuration = {
       tv_buttons_button_1_other: "value",
       tv_buttons_button_1_assign_action:
@@ -13,13 +13,12 @@ describe("getPluginIdentifier", () => {
     };
 
     const index = 0;
-
     const result = getPluginIdentifier(configuration, prefix, index);
 
     expect(result).toEqual(configuration.tv_buttons_button_1_assign_action);
   });
 
-  it("get second plugin identifier", () => {
+  it("returns the second valid plugin identifier", () => {
     const configuration = {
       tv_buttons_button_1_other: "value_1",
       tv_buttons_button_1_assign_action:
@@ -30,24 +29,124 @@ describe("getPluginIdentifier", () => {
     };
 
     const index = 1;
-
     const result = getPluginIdentifier(configuration, prefix, index);
 
     expect(result).toEqual(configuration.tv_buttons_button_2_assign_action);
   });
 
-  it("get undefined if no assign_actions at all", () => {
+  it("returns undefined when there are no assign_action keys", () => {
     const configuration = {};
+    const index = 0;
+
+    const result = getPluginIdentifier(configuration, prefix, index);
+
+    expect(result).toBeUndefined();
+  });
+
+  it("skips undefined values and returns the correct plugin identifier", () => {
+    const configuration = {
+      tv_buttons_button_1_assign_action: "tv_buttons_button_1_assign_action",
+      tv_buttons_button_2_assign_action: undefined,
+      tv_buttons_button_3_assign_action: "tv_buttons_button_3_assign_action",
+    };
+
+    const index = 1;
+    const result = getPluginIdentifier(configuration, prefix, index);
+
+    expect(result).toEqual(configuration.tv_buttons_button_3_assign_action);
+  });
+
+  it("handles missing intermediate keys and returns the correct plugin identifier", () => {
+    const configuration = {
+      tv_buttons_button_1_assign_action: "tv_buttons_button_1_assign_action",
+      tv_buttons_button_3_assign_action: "tv_buttons_button_3_assign_action",
+    };
+
+    const index = 1;
+    const result = getPluginIdentifier(configuration, prefix, index);
+
+    expect(result).toEqual(configuration.tv_buttons_button_3_assign_action);
+  });
+
+  it("skips empty string values and returns the first non-empty assign_action", () => {
+    const configuration = {
+      tv_buttons_button_1_assign_action: "",
+      tv_buttons_button_2_assign_action: "tv_buttons_button_2_assign_action",
+    };
 
     const index = 0;
+    const result = getPluginIdentifier(configuration, prefix, index);
+
+    expect(result).toEqual(configuration.tv_buttons_button_2_assign_action);
+  });
+
+  it("returns undefined for negative index", () => {
+    const configuration = {
+      tv_buttons_button_1_assign_action: "a",
+      tv_buttons_button_2_assign_action: "b",
+    };
 
+    const index = -1;
     const result = getPluginIdentifier(configuration, prefix, index);
 
     expect(result).toBeUndefined();
   });
+
+  it("returns undefined for out-of-bounds index", () => {
+    const configuration = {
+      tv_buttons_button_1_assign_action: "a",
+      tv_buttons_button_2_assign_action: "b",
+    };
+
+    const index = 5;
+    const result = getPluginIdentifier(configuration, prefix, index);
+
+    expect(result).toBeUndefined();
+  });
+
+  it("ignores keys with wrong prefix or format", () => {
+    const configuration = {
+      tv_buttons_button_1_assign_action: "a",
+      tv_buttons_wrongprefix_2_assign_action: "b",
+      tv_buttons_button_x_assign_action: "c",
+    };
+
+    const index = 1;
+    const result = getPluginIdentifier(configuration, prefix, index);
+
+    expect(result).toBeUndefined();
+  });
+
+  it("returns undefined if all assign_actions are null or empty", () => {
+    const configuration = {
+      tv_buttons_button_1_assign_action: null,
+      tv_buttons_button_2_assign_action: undefined,
+      tv_buttons_button_3_assign_action: "",
+    };
+
+    const index = 0;
+    const result = getPluginIdentifier(configuration, prefix, index);
+
+    expect(result).toBeUndefined();
+  });
+
+  it("handles non-string values correctly", () => {
+    const configuration = {
+      tv_buttons_button_1_assign_action: 123,
+      tv_buttons_button_2_assign_action: true,
+      tv_buttons_button_3_assign_action: { nested: "value" },
+    };
+
+    expect(getPluginIdentifier(configuration, prefix, 0)).toEqual(123);
+    expect(getPluginIdentifier(configuration, prefix, 1)).toEqual(true);
+
+    expect(getPluginIdentifier(configuration, prefix, 2)).toEqual({
+      nested: "value",
+    });
+  });
 });
 
-describe("getPluginIdentifier - when configuration has same values for different keys", () => {
+describe("getPluginIdentifier - when configuration has duplicate values", () => {
   const prefix = "tv_buttons";
 
   const configuration = {
@@ -55,17 +154,15 @@ describe("getPluginIdentifier - when configuration has same values for different
     tv_buttons_button_2_assign_action: "navigation_action",
   };
 
-  it("get first plugin identifier", () => {
+  it("returns the first plugin identifier when values are identical", () => {
     const index = 0;
-
     const result = getPluginIdentifier(configuration, prefix, index);
 
     expect(result).toEqual(configuration.tv_buttons_button_1_assign_action);
   });
 
-  it("get second plugin identifier", () => {
+  it("returns the second plugin identifier when values are identical", () => {
     const index = 1;
-
     const result = getPluginIdentifier(configuration, prefix, index);
 
     expect(result).toEqual(configuration.tv_buttons_button_2_assign_action);

package/Components/MasterCell/DefaultComponents/tv/TvActionButtons/utils/index.ts

@@ -1,7 +1,7 @@
 import * as R from "ramda";
+import memoizee from "memoizee";
 
 import { isWeb } from "@applicaster/zapp-react-native-utils/reactUtils";
-import { isNotNil } from "@applicaster/zapp-react-native-utils/reactUtils/helpers";
 
 export const getButtonsCount = (
   configuration: Record<string, unknown>,
@@ -21,23 +21,29 @@ export const getPluginIdentifier = (
   configuration: Record<string, unknown>,
   prefix: string,
   index: number
-): string => {
-  const match = `${prefix}_button_\\d_assign_action`;
-  const re = new RegExp(match);
-
-  const rejectNils = R.compose(R.path([index]), R.filter(isNotNil));
-
-  return rejectNils(
-    R.toPairs(configuration)
-      .filter(([key]) => R.startsWith(`${prefix}_button`, key))
-      .map(([key, value]) => {
-        const matched = key.match(re);
+): string | undefined => {
+  const re = new RegExp(`${prefix}_button_\\d_assign_action`);
+  let count = 0;
+
+  for (const [key, value] of Object.entries(configuration)) {
+    if (
+      key.startsWith(`${prefix}_button`) &&
+      re.test(key) &&
+      value != null &&
+      value !== ""
+    ) {
+      if (count === index) return value as string;
+      count++;
+    }
+  }
 
-        return matched ? value : undefined;
-      })
-  );
+  return undefined;
 };
 
+export const memoizedGetPluginIdentifier = memoizee(getPluginIdentifier, {
+  primitive: true,
+});
+
 type Label = {
   name: string;
 };

package/Components/MasterCell/index.tsx

@@ -103,6 +103,8 @@ export function masterCellBuilder({
         wrapperRef,
         cellUUID,
         skipButtons,
+        hasFocusableInside,
+        entry: item,
       })
     );
 

package/Components/MasterCell/utils/__tests__/resolveColor.test.js

@@ -32,14 +32,16 @@ describe("resolveColor", () => {
       color: "invalid_path",
     };
 
-    expect(resolveColor(entry, style)).toEqual(style);
+    expect(resolveColor(entry, style)).toEqual({
+      color: undefined,
+    });
 
     expect(loggerSpy).toHaveBeenCalledWith(
       expect.objectContaining({
         message: "Cannot resolve property invalid_path from the entry.",
         data: {
+          colorFromProp: "invalid_path",
           configurationValue: "invalid_path",
-          entry,
         },
       })
     );
@@ -102,7 +104,9 @@ describe("resolveColor", () => {
       color: "not.exist.path",
     };
 
-    expect(resolveColor(entry, style)).toEqual(style);
+    expect(resolveColor(entry, style)).toEqual({
+      color: undefined,
+    });
   });
 
   it("not modify style with empty path", () => {
@@ -112,4 +116,79 @@ describe("resolveColor", () => {
 
     expect(resolveColor(entry, style)).toEqual(style);
   });
+
+  describe("memoization", () => {
+    beforeEach(() => {
+      // Clear memoization cache before each test
+      resolveColor.clear && resolveColor.clear();
+    });
+
+    it("hits cache with same entry and style references", () => {
+      const style = { color: "extensions.color" };
+
+      const result1 = resolveColor(entry, style);
+      const result2 = resolveColor(entry, style);
+
+      expect(result1).toBe(result2); // Same object reference
+    });
+
+    it("hits cache with new references but equal entry/style values", () => {
+      const entryClone = {
+        extensions: {
+          color: "red",
+          green_color: "green",
+        },
+      };
+
+      const style = { color: "extensions.color" };
+      const styleClone = { color: "extensions.color" };
+
+      const result1 = resolveColor(entry, style);
+      const result2 = resolveColor(entryClone, styleClone);
+
+      expect(result1).toBe(result2);
+    });
+
+    it("misses cache when entry is new object", () => {
+      const entry2 = { extensions: { color: "blue" } }; // Same values, different object
+      const style = { color: "extensions.color" };
+
+      const result1 = resolveColor(entry, style);
+      const result2 = resolveColor(entry2, style);
+
+      expect(result1).not.toBe(result2); // Different object references
+    });
+
+    it("misses cache when entry property changes", () => {
+      const myEntry = {
+        extensions: {
+          color: "red",
+          green_color: "green",
+        },
+      };
+
+      const style = { color: "extensions.color" };
+
+      const result1 = resolveColor(myEntry, style);
+
+      myEntry.extensions.color = "blue"; // Change property
+      const result2 = resolveColor(myEntry, style);
+
+      expect(result1).toEqual({ color: "red" });
+      expect(result2).toEqual({ color: "blue" });
+      expect(result1).not.toBe(result2);
+    });
+
+    it("misses cache when style changes", () => {
+      const style1 = { color: "extensions.color" };
+      const style2 = { backgroundColor: "extensions.color" };
+
+      const result1 = resolveColor(entry, style1);
+      const result2 = resolveColor(entry, style2);
+
+      expect(result1).toEqual({ color: "red" });
+      expect(result2).toEqual({ backgroundColor: "red" });
+      expect(result1).not.toBe(result2);
+    });
+  });
 });

package/Components/MasterCell/utils/index.ts

@@ -7,9 +7,12 @@ import { useActions } from "@applicaster/zapp-react-native-utils/reactHooks/acti
 import { masterCellLogger } from "../logger";
 import { getCellState } from "../../Cell/utils";
 import { getColorFromData } from "@applicaster/zapp-react-native-utils/cellUtils";
+import { get } from "@applicaster/zapp-react-native-utils/utils";
 import { isCellSelected, useBehaviorUpdate } from "./behaviorProvider";
 import { useRoute } from "@applicaster/zapp-react-native-utils/reactHooks";
 import { useScreenStateStore } from "@applicaster/zapp-react-native-utils/reactHooks/navigation/useScreenStateStore";
+import memoizee from "memoizee";
+import stringify from "fast-json-stable-stringify";
 
 const hasElementSpecificViewType = (viewType) => (element) => {
   if (R.isNil(element)) {
@@ -24,21 +27,21 @@ const hasElementSpecificViewType = (viewType) => (element) => {
   return hasElementsSpecificViewType(viewType)(element.elements);
 };
 
-const logWarning = R.curry(
-  (colorValueFromCellStyle, style, entry, colorValueFromEntry) => {
-    if (R.isNil(colorValueFromEntry)) {
-      masterCellLogger.warn({
-        message: `Cannot resolve property ${colorValueFromCellStyle} from the entry.`,
-        data: {
-          configurationValue: colorValueFromCellStyle,
-          entry,
-        },
-      });
-    }
-
-    return style;
+const logWarning = (
+  colorValueFromCellStyle,
+  colorFromProp,
+  colorValueFromEntry
+) => {
+  if (R.isNil(colorValueFromEntry)) {
+    masterCellLogger.warn({
+      message: `Cannot resolve property ${colorValueFromCellStyle} from the entry.`,
+      data: {
+        configurationValue: colorValueFromCellStyle,
+        colorFromProp,
+      },
+    });
   }
-);
+};
 
 export const hasElementsSpecificViewType = (viewType) => (elements) => {
   if (R.isNil(elements) || R.isEmpty(elements)) {
@@ -48,14 +51,22 @@ export const hasElementsSpecificViewType = (viewType) => (elements) => {
   return R.any(hasElementSpecificViewType(viewType))(elements);
 };
 
-function resolveColorForProp(entry, style, colorProp) {
-  const colorFromProp = style[colorProp];
-  const nestedEntryValue = R.path(colorFromProp.split("."), entry);
+function resolveColorForProp(entry: any, colorFromProp: string | undefined) {
+  if (!colorFromProp) {
+    return undefined;
+  }
+
+  const nestedEntryValue: string | undefined = get(
+    entry,
+    colorFromProp.split(".")
+  );
 
   const color = colorFromProp.replace(".00", "").replace(".0", ""); // https://github.com/dreamyguy/validate-color/issues/44
 
   if (nestedEntryValue === undefined && !validateColor(color)) {
-    logWarning(colorFromProp, style, entry, nestedEntryValue);
+    logWarning(colorFromProp, colorFromProp, nestedEntryValue);
+
+    return undefined;
   }
 
   const colorValue = getColorFromData({
@@ -64,27 +75,46 @@ function resolveColorForProp(entry, style, colorProp) {
   });
 
   if (!colorValue) {
-    logWarning(colorProp, style, entry, colorValue);
+    logWarning(colorFromProp, colorFromProp, nestedEntryValue);
 
-    return style;
+    return undefined;
   }
 
-  return { ...style, [colorProp]: colorValue };
+  return colorValue;
 }
 
-export function resolveColor(entry, style) {
-  if (style === null || style === undefined) {
-    return style;
-  }
-
-  // TODO can be optimized to remove 3 O(n) loops
+const getColorKeys = memoizee((style) => {
   const styleKeys = Object.keys(style);
   const colorKeys = styleKeys.filter((key) => /color/i.test(key));
 
-  return colorKeys.reduce((acc, value) => {
-    return { ...style, ...resolveColorForProp(entry, acc, value) };
-  }, style);
-}
+  return colorKeys;
+});
+
+export const resolveColor = memoizee(
+  (entry, style) => {
+    if (style === null || style === undefined) {
+      return style;
+    }
+
+    return getColorKeys(style).reduce(
+      (acc, value) => {
+        if (acc[value] && typeof acc[value] === "string") {
+          const colorStyle = resolveColorForProp(entry, acc[value]);
+
+          acc[value] = colorStyle;
+        }
+
+        return acc;
+      },
+      { ...style }
+    );
+  },
+  {
+    normalizer: (args) => {
+      return [stringify(args[0]), stringify(args[1])].join("|");
+    },
+  }
+);
 
 export function isVideoPreviewEnabled({
   enable_video_preview = false,

package/Components/MeasurmentsPortal/MeasurementsPortal.tsx

@@ -1,8 +1,12 @@
-/* eslint react/prop-types: off */
-
-import React from "react";
+import React, {
+  memo,
+  PropsWithChildren,
+  useCallback,
+  useMemo,
+  useRef,
+  useState,
+} from "react";
 import { View, StyleSheet } from "react-native";
-import * as R from "ramda";
 import { v4 } from "uuid";
 
 type Props = {
@@ -46,93 +50,104 @@ type MeasurementPortalContextType = {
 const MeasurementPortalContext =
   React.createContext<null | MeasurementPortalContextType>(null);
 
-const MeasurementsPortalContextProvider = ({ children }) => {
-  const Component = React.useRef(View);
-  const [measuringInProgress, setMeasuringInProgress] = React.useState(false);
-
-  const measureComponentCallback = React.useRef(null);
-  const componentProps = React.useRef(null);
-  const onLoadFinishedIsCalled = React.useRef(null);
-
-  const setComponent = (comp) => {
-    Component.current = comp;
-  };
-
-  const setMeasureComponentCallback = (cb) => {
-    measureComponentCallback.current = cb;
-  };
-
-  const finalize = ({ width, height }) => {
-    measureComponentCallback?.current?.({
-      width,
-      height,
-      index: componentProps.current.index,
-    });
-
-    setMeasureComponentCallback(null);
-    setMeasuringInProgress(false);
-    onLoadFinishedIsCalled.current = false;
-  };
-
-  const setComponentProps = (props) => {
-    const handleOnLoadFinish = (...args) => {
-      const error = R.path([0, "error"], args);
-
-      if (isError(error)) {
-        finalize({ width: 0, height: 0 });
-      } else {
-        onLoadFinishedIsCalled.current = true;
-        props.onLoadFinished(...args);
-      }
-    };
-
-    componentProps.current = {
-      ...props,
-      onLoadFinished: handleOnLoadFinish,
-    };
-  };
-
-  const measureComponent = React.useCallback(async (comp, props) => {
-    return new Promise((resolve) => {
-      setMeasureComponentCallback(resolve);
-      setMeasuringInProgress(true);
-
-      setComponentProps(props);
-      setComponent(comp);
-    });
-  }, []);
-
-  const onLayout = ({
-    nativeEvent: {
-      layout: { width, height },
-    },
-  }) => {
-    if (measureComponentCallback.current && onLoadFinishedIsCalled.current) {
-      finalize({
+const MeasurementsPortalContextProvider = memo(
+  ({ children }: PropsWithChildren) => {
+    const Component = useRef(View);
+    const [measuringInProgress, setMeasuringInProgress] = useState(false);
+
+    const measureComponentCallback = useRef(null);
+    const componentProps = useRef(null);
+    const onLoadFinishedIsCalled = useRef(null);
+
+    const setComponent = useCallback((comp) => {
+      Component.current = comp;
+    }, []);
+
+    const setMeasureComponentCallback = useCallback((cb) => {
+      measureComponentCallback.current = cb;
+    }, []);
+
+    const finalize = useCallback(({ width, height }) => {
+      measureComponentCallback?.current?.({
         width,
         height,
+        index: componentProps.current.index,
       });
-    }
-  };
 
-  return (
-    <>
-      <MeasurementsPortal
-        Component={Component.current}
-        componentProps={componentProps.current}
-        onLayout={onLayout}
-      />
-      <MeasurementPortalContext.Provider
-        value={{
-          measureComponent,
-          measuringInProgress,
-        }}
-      >
-        {children}
-      </MeasurementPortalContext.Provider>
-    </>
-  );
-};
+      setMeasureComponentCallback(null);
+      setMeasuringInProgress(false);
+      onLoadFinishedIsCalled.current = false;
+    }, []);
+
+    const setComponentProps = useCallback((props) => {
+      const handleOnLoadFinish = (...args) => {
+        const error = args[0]?.error;
+
+        if (isError(error)) {
+          finalize({ width: 0, height: 0 });
+        } else {
+          onLoadFinishedIsCalled.current = true;
+          props.onLoadFinished(...args);
+        }
+      };
+
+      componentProps.current = {
+        ...props,
+        onLoadFinished: handleOnLoadFinish,
+      };
+    }, []);
+
+    const measureComponent = useCallback(async (comp, props) => {
+      return new Promise((resolve) => {
+        setMeasureComponentCallback(resolve);
+        setMeasuringInProgress(true);
+
+        setComponentProps(props);
+        setComponent(comp);
+      });
+    }, []);
+
+    const onLayout = useCallback(
+      ({
+        nativeEvent: {
+          layout: { width, height },
+        },
+      }) => {
+        if (
+          measureComponentCallback.current &&
+          onLoadFinishedIsCalled.current
+        ) {
+          finalize({
+            width,
+            height,
+          });
+        }
+      },
+      []
+    );
+
+    const contextValue = useMemo(
+      () => ({
+        measureComponent,
+        measuringInProgress,
+      }),
+      [measuringInProgress]
+    );
+
+    return (
+      <>
+        <MeasurementsPortal
+          Component={Component.current}
+          componentProps={componentProps.current}
+          onLayout={onLayout}
+        />
+        <MeasurementPortalContext.Provider value={contextValue}>
+          {children}
+        </MeasurementPortalContext.Provider>
+      </>
+    );
+  }
+);
 
 export {
   MeasurementsPortal,