@applicaster/zapp-react-native-utils 15.0.0-rc.100 → 15.0.0-rc.102

package/appUtils/focusManager/treeDataStructure/Tree/__tests__/Tree.test.js

@@ -373,3 +373,49 @@ describe("addNode", () => {
     checkParents(tree.root);
   });
 });
+
+describe("findInTree", () => {
+  function createNode(id, children) {
+    return {
+      id,
+      children,
+    };
+  }
+
+  it("returns a direct child match from root children", () => {
+    const tree = new Tree(treeLoaded);
+    const direct = createNode("direct-node");
+
+    tree.root.children = [direct];
+
+    expect(tree.findInTree("direct-node")).toEqual(direct);
+  });
+
+  it("returns a nested descendant match", () => {
+    const tree = new Tree(treeLoaded);
+    const nested = createNode("nested-node");
+    const intermediate = createNode("intermediate-node", [nested]);
+    const rootNode = createNode("root-node", [intermediate]);
+
+    tree.root.children = [rootNode];
+
+    expect(tree.findInTree("nested-node")).toEqual(nested);
+  });
+
+  it("returns null when node id does not exist", () => {
+    const tree = new Tree(treeLoaded);
+    const leaf = createNode("leaf-node");
+    const rootNode = createNode("root-node", [leaf]);
+
+    tree.root.children = [rootNode];
+
+    expect(tree.findInTree("missing-node")).toEqual(null);
+  });
+
+  it("returns null when tree has no children", () => {
+    const tree = new Tree(treeLoaded);
+    tree.root.children = null;
+
+    expect(tree.findInTree("any-node")).toEqual(null);
+  });
+});

package/appUtils/focusManager/treeDataStructure/Tree/index.js

@@ -205,31 +205,31 @@ export class Tree {
    * @returns founded node or null
    */
   findInTree(id) {
-    const retVal = null;
-
-    return this.findInArray(id, this.root.children, retVal);
+    return this.findInArray(id, this.root.children);
   }
 
-  findInArray(id, children, retVal) {
-    if (!retVal && children) {
-      retVal = children.find((obj) => obj.id === id);
+  findInArray(id, children) {
+    if (!children) {
+      return null;
+    }
 
-      if (!retVal) {
-        children.forEach((child) => {
-          if (child.children) {
-            retVal = this.findInArray(id, child.children, retVal);
+    const directMatch = children.find((obj) => obj.id === id);
 
-            if (retVal) {
-              return retVal;
-            }
-          }
-        });
-      } else {
-        return retVal;
+    if (directMatch) {
+      return directMatch;
+    }
+
+    for (const child of children) {
+      if (child.children) {
+        const nestedMatch = this.findInArray(id, child.children);
+
+        if (nestedMatch) {
+          return nestedMatch;
+        }
       }
     }
 
-    return retVal;
+    return null;
   }
 
   /**

package/appUtils/playerManager/playerNative.ts

@@ -229,8 +229,9 @@ export class PlayerNative extends Player {
   };
 
   closeNativePlayer = () => {
-    // TODO: Delete does not work
+    // TODO: Delete, does not work (component is null)
     this.currentPlayerComponent()?.closeNativePlayer?.();
+    this.getPlayerModule()?.stopBackgroundPlayback?.();
   };
 
   togglePlayPause = () => {

package/manifestUtils/defaultManifestConfigurations/player.js

@@ -707,22 +707,6 @@ function getPlayerConfiguration({ platform, version }) {
   }
 
   if (isMobile(platform)) {
-    localizations.fields.push(
-      {
-        type: "text_input",
-        label: "Restrict playback on mobile networks alert title",
-        key: "mobile_connection_restricted_alert_title",
-        initial_value: "Restricted Connection Type",
-      },
-      {
-        type: "text_input",
-        label: "Restrict playback on mobile networks alert message",
-        key: "mobile_connection_restricted_alert_message",
-        initial_value:
-          "This content can only be viewed over a Wi-Fi or LAN network.",
-      }
-    );
-
     general.fields.push(
       {
         section: "Default Timestamp Type",

package/package.json

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

package/utils/__tests__/clone.test.ts

@@ -0,0 +1,158 @@
+import { clone } from "../clone";
+
+describe("clone", () => {
+  const originalStructuredClone = global.structuredClone;
+
+  afterEach(() => {
+    // Restore the original structuredClone after each test
+    global.structuredClone = originalStructuredClone;
+  });
+
+  describe("when structuredClone is available", () => {
+    beforeEach(() => {
+      // Mock structuredClone if it's not available
+      if (typeof global.structuredClone === "undefined") {
+        global.structuredClone = jest.fn((value) =>
+          JSON.parse(JSON.stringify(value))
+        );
+      }
+    });
+
+    test("clones primitive values", () => {
+      expect(clone(42)).toBe(42);
+      expect(clone("test")).toBe("test");
+      expect(clone(true)).toBe(true);
+      expect(clone(null)).toBe(null);
+    });
+
+    test("clones simple objects", () => {
+      const original = { a: 1, b: 2 };
+      const cloned = clone(original);
+
+      expect(cloned).toEqual(original);
+      expect(cloned).not.toBe(original);
+    });
+
+    test("clones nested objects", () => {
+      const original = { a: { b: { c: 1 } } };
+      const cloned = clone(original);
+
+      expect(cloned).toEqual(original);
+      expect(cloned).not.toBe(original);
+      expect(cloned.a).not.toBe(original.a);
+      expect(cloned.a.b).not.toBe(original.a.b);
+    });
+
+    test("clones arrays", () => {
+      const original = [1, 2, 3];
+      const cloned = clone(original);
+
+      expect(cloned).toEqual(original);
+      expect(cloned).not.toBe(original);
+    });
+
+    test("clones arrays with nested objects", () => {
+      const original = [{ a: 1 }, { b: 2 }];
+      const cloned = clone(original);
+
+      expect(cloned).toEqual(original);
+      expect(cloned).not.toBe(original);
+      expect(cloned[0]).not.toBe(original[0]);
+      expect(cloned[1]).not.toBe(original[1]);
+    });
+
+    test("does not mutate the original value", () => {
+      const original = { a: 1, b: { c: 2 } };
+      const cloned = clone(original);
+
+      cloned.a = 99;
+      cloned.b.c = 99;
+
+      expect(original.a).toBe(1);
+      expect(original.b.c).toBe(2);
+    });
+  });
+
+  describe("when structuredClone is not available (fallback to cloneDeep)", () => {
+    beforeEach(() => {
+      // Delete structuredClone to force fallback to cloneDeep
+      delete (global as any).structuredClone;
+    });
+
+    test("clones primitive values using cloneDeep", () => {
+      expect(clone(42)).toBe(42);
+      expect(clone("test")).toBe("test");
+      expect(clone(true)).toBe(true);
+      expect(clone(null)).toBe(null);
+    });
+
+    test("clones simple objects using cloneDeep", () => {
+      const original = { a: 1, b: 2 };
+      const cloned = clone(original);
+
+      expect(cloned).toEqual(original);
+      expect(cloned).not.toBe(original);
+    });
+
+    test("clones nested objects using cloneDeep", () => {
+      const original = { a: { b: { c: 1 } } };
+      const cloned = clone(original);
+
+      expect(cloned).toEqual(original);
+      expect(cloned).not.toBe(original);
+      expect(cloned.a).not.toBe(original.a);
+      expect(cloned.a.b).not.toBe(original.a.b);
+    });
+
+    test("clones arrays using cloneDeep", () => {
+      const original = [1, 2, 3];
+      const cloned = clone(original);
+
+      expect(cloned).toEqual(original);
+      expect(cloned).not.toBe(original);
+    });
+
+    test("clones arrays with nested objects using cloneDeep", () => {
+      const original = [{ a: 1 }, { b: 2 }];
+      const cloned = clone(original);
+
+      expect(cloned).toEqual(original);
+      expect(cloned).not.toBe(original);
+      expect(cloned[0]).not.toBe(original[0]);
+      expect(cloned[1]).not.toBe(original[1]);
+    });
+
+    test("does not mutate the original value when using cloneDeep", () => {
+      const original = { a: 1, b: { c: 2 } };
+      const cloned = clone(original);
+
+      cloned.a = 99;
+      cloned.b.c = 99;
+
+      expect(original.a).toBe(1);
+      expect(original.b.c).toBe(2);
+    });
+
+    test("handles complex objects with multiple levels", () => {
+      const original = {
+        name: "test",
+        data: {
+          items: [
+            { id: 1, value: "a" },
+            { id: 2, value: "b" },
+          ],
+          meta: { count: 2 },
+        },
+      };
+
+      const cloned = clone(original);
+
+      expect(cloned).toEqual(original);
+      expect(cloned).not.toBe(original);
+      expect(cloned.data).not.toBe(original.data);
+      expect(cloned.data.items).not.toBe(original.data.items);
+      expect(cloned.data.items[0]).not.toBe(original.data.items[0]);
+      expect(cloned.data.meta).not.toBe(original.data.meta);
+    });
+  });
+});

package/utils/clone.ts

@@ -0,0 +1,7 @@
+import { cloneDeep } from "lodash";
+
+export const clone = (value) => {
+  return typeof structuredClone !== "undefined"
+    ? structuredClone(value) // no support for hermes, fallback to cloneDeep
+    : cloneDeep(value);
+};

package/utils/index.ts

@@ -20,8 +20,9 @@ export { mapAccum } from "./mapAccum";
 
 export { mergeRight } from "./mergeRight";
 
+export { clone } from "./clone";
+
 export {
-  cloneDeep as clone,
   flatten,
   drop,
   size,