fix: lens player refresh launch data

README.md

@@ -169,12 +169,13 @@ import { useApplyLens } from "@snap/react-camera-kit";
 useApplyLens("YOUR_LENS_ID", "YOUR_LENS_GROUP_ID");
 ```
 
-| Parameter        | Type                  | Description                          |
-| ---------------- | --------------------- | ------------------------------------ |
-| `lensId`         | `string \| undefined` | Lens ID — pass `undefined` to remove |
-| `lensGroupId`    | `string \| undefined` | Lens Group ID                        |
-| `lensLaunchData` | `LensLaunchData`      | Optional launch parameters           |
-| `lensReadyGuard` | `() => Promise<void>` | Optional async ready guard           |
+| Parameter        | Type                  | Description                                  |
+| ---------------- | --------------------- | -------------------------------------------- |
+| `lensId`         | `string \| undefined` | Lens ID — pass `undefined` to remove         |
+| `lensGroupId`    | `string \| undefined` | Lens Group ID                                |
+| `lensLaunchData` | `LensLaunchData`      | Optional launch parameters                   |
+| `lensReadyGuard` | `() => Promise<void>` | Optional async ready guard                   |
+| `refreshTrigger` | `unknown`             | Reapply with current parameters when changed |
 
 ### useApplySource
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@snap/react-camera-kit",
-  "version": "0.5.1",
+  "version": "0.6.0",
   "description": "React Camera Kit for web applications",
   "type": "module",
   "main": "./dist/cjs/index.js",

src/LensPlayer.test.tsx

@@ -10,37 +10,6 @@ jest.mock("@snap/camera-kit", () => ({
   bootstrapCameraKit: jest.fn(),
 }));
 
-const mockRefreshLens = jest.fn();
-
-// Mock CameraKitProvider
-jest.mock("./CameraKitProvider", () => ({
-  useCameraKit: jest.fn(() => ({
-    cameraKitStatus: "ready" as const,
-    cameraKitError: undefined,
-    liveCanvas: document.createElement("canvas"),
-    captureCanvas: document.createElement("canvas"),
-    source: { status: "none" as const, error: undefined, input: undefined, initializedInput: undefined },
-    lens: {
-      status: "none" as const,
-      error: undefined,
-      lensId: undefined,
-      lensGroupId: undefined,
-      lensLaunchData: undefined,
-      lensReadyGuard: undefined,
-      lens: undefined,
-    },
-    reinitialize: jest.fn(),
-    // Lens manager methods
-    fetchLens: jest.fn(),
-    fetchLenses: jest.fn(),
-    applyLens: jest.fn(),
-    loadAndApplyLens: jest.fn(),
-    removeLens: jest.fn(),
-    refreshLens: mockRefreshLens,
-    lenses: [],
-  })),
-}));
-
 // Mock all the custom hooks
 jest.mock("./useApplySource");
 jest.mock("./useApplyLens");
@@ -100,78 +69,18 @@ describe("LensPlayer", () => {
         />,
       );
 
-      expect(mockUseApplyLens).toHaveBeenCalledWith(lensId, lensGroupId, lensLaunchData, lensReadyGuard);
+      expect(mockUseApplyLens).toHaveBeenCalledWith(lensId, lensGroupId, lensLaunchData, lensReadyGuard, undefined);
     });
 
     it("should call useApplyLens with undefined values when not provided", () => {
       render(<LensPlayer />);
-      expect(mockUseApplyLens).toHaveBeenCalledWith(undefined, undefined, undefined, undefined);
-    });
-  });
-
-  describe("Refresh Trigger", () => {
-    it("should NOT call refreshLens on initial mount even with a defined refreshTrigger value", () => {
-      render(<LensPlayer refreshTrigger={1} />);
-      expect(mockRefreshLens).not.toHaveBeenCalled();
-    });
-
-    it("should NOT call refreshLens when component re-renders but refreshTrigger stays the same", () => {
-      const { rerender } = render(<LensPlayer refreshTrigger={1} lensId="lens-1" />);
-      expect(mockRefreshLens).not.toHaveBeenCalled();
-
-      // Re-render with different props but same refreshTrigger
-      rerender(<LensPlayer refreshTrigger={1} lensId="lens-2" />);
-      expect(mockRefreshLens).not.toHaveBeenCalled();
-
-      // Re-render again with same refreshTrigger
-      rerender(<LensPlayer refreshTrigger={1} lensId="lens-3" />);
-      expect(mockRefreshLens).not.toHaveBeenCalled();
+      expect(mockUseApplyLens).toHaveBeenCalledWith(undefined, undefined, undefined, undefined, undefined);
     });
 
-    it("should call refreshLens when refreshTrigger changes", () => {
-      const { rerender } = render(<LensPlayer refreshTrigger={1} />);
-      expect(mockRefreshLens).not.toHaveBeenCalled();
+    it("should pass refreshTrigger to useApplyLens", () => {
+      render(<LensPlayer lensId="lens-1" lensGroupId="group-1" refreshTrigger={2} />);
 
-      rerender(<LensPlayer refreshTrigger={2} />);
-      expect(mockRefreshLens).toHaveBeenCalledTimes(1);
-
-      rerender(<LensPlayer refreshTrigger={3} />);
-      expect(mockRefreshLens).toHaveBeenCalledTimes(2);
-    });
-
-    it("should not call refreshLens when refreshTrigger is undefined and stays undefined", () => {
-      const { rerender } = render(<LensPlayer />);
-      expect(mockRefreshLens).not.toHaveBeenCalled();
-
-      rerender(<LensPlayer lensId="different" />);
-      expect(mockRefreshLens).not.toHaveBeenCalled();
-    });
-
-    it("should call refreshLens when refreshTrigger changes from undefined to defined", () => {
-      const { rerender } = render(<LensPlayer />);
-      expect(mockRefreshLens).not.toHaveBeenCalled();
-
-      rerender(<LensPlayer refreshTrigger={1} />);
-      expect(mockRefreshLens).toHaveBeenCalledTimes(1);
-    });
-
-    it("should call refreshLens when refreshTrigger changes from defined to undefined", () => {
-      const { rerender } = render(<LensPlayer refreshTrigger={1} />);
-      expect(mockRefreshLens).not.toHaveBeenCalled();
-
-      rerender(<LensPlayer refreshTrigger={undefined} />);
-      expect(mockRefreshLens).toHaveBeenCalledTimes(1);
-    });
-
-    it("should handle different types of refreshTrigger values", () => {
-      const { rerender } = render(<LensPlayer refreshTrigger="trigger1" />);
-      expect(mockRefreshLens).not.toHaveBeenCalled();
-
-      rerender(<LensPlayer refreshTrigger="trigger2" />);
-      expect(mockRefreshLens).toHaveBeenCalledTimes(1);
-
-      rerender(<LensPlayer refreshTrigger={{ key: "value" }} />);
-      expect(mockRefreshLens).toHaveBeenCalledTimes(2);
+      expect(mockUseApplyLens).toHaveBeenCalledWith("lens-1", "group-1", undefined, undefined, 2);
     });
   });
 
@@ -289,10 +198,10 @@ describe("LensPlayer", () => {
   describe("Props Changes", () => {
     it("should handle lensId changes", () => {
       const { rerender } = render(<LensPlayer lensId="lens-1" lensGroupId="group-1" />);
-      expect(mockUseApplyLens).toHaveBeenCalledWith("lens-1", "group-1", undefined, undefined);
+      expect(mockUseApplyLens).toHaveBeenCalledWith("lens-1", "group-1", undefined, undefined, undefined);
 
       rerender(<LensPlayer lensId="lens-2" lensGroupId="group-1" />);
-      expect(mockUseApplyLens).toHaveBeenCalledWith("lens-2", "group-1", undefined, undefined);
+      expect(mockUseApplyLens).toHaveBeenCalledWith("lens-2", "group-1", undefined, undefined, undefined);
     });
 
     it("should handle source changes", () => {
@@ -368,9 +277,8 @@ describe("LensPlayer", () => {
         props.lensGroupId,
         props.lensLaunchData,
         props.lensReadyGuard,
+        props.refreshTrigger,
       );
-      // refreshLens should NOT be called on initial mount
-      expect(mockRefreshLens).not.toHaveBeenCalled();
 
       const canvas = screen.getByTestId("capture-canvas");
       expect(canvas).toHaveClass("test-class");
@@ -388,16 +296,6 @@ describe("LensPlayer", () => {
       expect(screen.queryByTestId("capture-canvas")).not.toBeInTheDocument();
       expect(screen.queryByTestId("live-canvas")).not.toBeInTheDocument();
     });
-
-    it("should handle rapid refreshTrigger changes", () => {
-      const { rerender } = render(<LensPlayer refreshTrigger={0} />);
-
-      for (let i = 1; i <= 5; i++) {
-        rerender(<LensPlayer refreshTrigger={i} />);
-      }
-
-      expect(mockRefreshLens).toHaveBeenCalledTimes(5); // Only actual changes, not initial mount
-    });
   });
 
   describe("Cleanup", () => {

src/LensPlayer.tsx

@@ -1,11 +1,10 @@
-import { ReactNode, useEffect, useRef } from "react";
+import { ReactNode } from "react";
 import { CameraKitSessionEvents, Lens, LensLaunchData, ScreenRegions } from "@snap/camera-kit";
 import { CanvasType, OutputSize, SourceInput } from "./types";
 import { useApplySource } from "./useApplySource";
 import { useApplyLens } from "./useApplyLens";
 import { usePlaybackOptions } from "./usePlaybackOptions";
 import { CaptureCanvas, LiveCanvas } from "./Canvas";
-import { useCameraKit } from "./CameraKitProvider";
 
 /**
  * Props for the LensPlayer component.
@@ -34,8 +33,9 @@ export interface LensPlayerProps {
 
   /**
    * Trigger to refresh the current Lens. When this value changes,
-   * the Lens will be removed and reapplied. Useful for restarting
-   * the Lens experience without moving LensPlayer to another component.
+   * the Lens will be removed and reapplied with the current Lens props.
+   * Useful for restarting the Lens experience without moving LensPlayer
+   * to another component.
    */
   refreshTrigger?: unknown;
 
@@ -140,17 +140,7 @@ export const LensPlayer: React.FC<LensPlayerProps> = ({
 }) => {
   usePlaybackOptions({ fpsLimit, muted, screenRegions, onError });
   useApplySource(source, outputSize);
-  useApplyLens(lensId, lensGroupId, lensLaunchData, lensReadyGuard);
-
-  // Handle refresh trigger - only refresh when the value actually changes (not on mount)
-  const { refreshLens } = useCameraKit();
-  const prevRefreshTrigger = useRef(refreshTrigger);
-  useEffect(() => {
-    if (prevRefreshTrigger.current !== refreshTrigger) {
-      prevRefreshTrigger.current = refreshTrigger;
-      refreshLens();
-    }
-  }, [refreshTrigger, refreshLens]);
+  useApplyLens(lensId, lensGroupId, lensLaunchData, lensReadyGuard, refreshTrigger);
 
   if (children) {
     // If custom children were provided, we wrap them to allow styling at the outer div.

src/useApplyLens.test.ts

@@ -267,6 +267,52 @@ describe("useApplyLens", () => {
       // Should not reapply since stable key is the same
       expect(mockApplyLens).not.toHaveBeenCalled();
     });
+
+    it("should reapply the lens with current launch data when refreshTrigger changes", async () => {
+      const launchData = { launchParams: { hint: "face" } };
+      const { rerender } = renderHook(
+        ({ refreshTrigger }) => useApplyLens("lens-1", "group-1", launchData, undefined, refreshTrigger),
+        { initialProps: { refreshTrigger: 1 } },
+      );
+
+      await waitFor(() => {
+        expect(mockApplyLens).toHaveBeenCalledTimes(1);
+      });
+      mockApplyLens.mockClear();
+
+      rerender({ refreshTrigger: 1 });
+      expect(mockApplyLens).not.toHaveBeenCalled();
+
+      rerender({ refreshTrigger: 2 });
+      await waitFor(() => {
+        expect(mockApplyLens).toHaveBeenCalledWith("lens-1", "group-1", launchData, undefined);
+      });
+    });
+
+    it("should apply updated launch data once when it changes with refreshTrigger", async () => {
+      const { rerender } = renderHook(
+        ({ launchData, refreshTrigger }) => useApplyLens("lens-1", "group-1", launchData, undefined, refreshTrigger),
+        {
+          initialProps: {
+            launchData: { launchParams: { hint: "face" } },
+            refreshTrigger: 1,
+          },
+        },
+      );
+
+      await waitFor(() => {
+        expect(mockApplyLens).toHaveBeenCalledTimes(1);
+      });
+      mockApplyLens.mockClear();
+
+      const updatedLaunchData = { launchParams: { hint: "hand" } };
+      rerender({ launchData: updatedLaunchData, refreshTrigger: 2 });
+
+      await waitFor(() => {
+        expect(mockApplyLens).toHaveBeenCalledTimes(1);
+        expect(mockApplyLens).toHaveBeenCalledWith("lens-1", "group-1", updatedLaunchData, undefined);
+      });
+    });
   });
 
   describe("Cleanup on unmount", () => {
@@ -489,6 +535,35 @@ describe("useApplyLens", () => {
       expect(mockReinitialize).toHaveBeenCalledTimes(1);
     });
 
+    it("reinitializes when refreshTrigger changes while in a LensAbortError", () => {
+      mockUseInternalCameraKit.mockReturnValue(errorContext(abortError));
+
+      const { rerender } = renderHook(
+        ({ refreshTrigger }) => useApplyLens("lens-1", "group-1", undefined, undefined, refreshTrigger),
+        { initialProps: { refreshTrigger: 1 } },
+      );
+
+      expect(mockReinitialize).not.toHaveBeenCalled();
+
+      rerender({ refreshTrigger: 2 });
+
+      expect(mockReinitialize).toHaveBeenCalledTimes(1);
+      expect(mockReportCount).toHaveBeenCalledWith("auto_reinit_on_refresh");
+    });
+
+    it("does NOT reinitialize when refreshTrigger is unchanged", () => {
+      mockUseInternalCameraKit.mockReturnValue(errorContext(abortError));
+
+      const { rerender } = renderHook(
+        ({ refreshTrigger }) => useApplyLens("lens-1", "group-1", undefined, undefined, refreshTrigger),
+        { initialProps: { refreshTrigger: 1 } },
+      );
+
+      rerender({ refreshTrigger: 1 });
+
+      expect(mockReinitialize).not.toHaveBeenCalled();
+    });
+
     it("does NOT reinitialize for a bootstrap-failure error", () => {
       const bootError = Object.assign(new Error("boot failed"), { name: "BootstrapError" });
       mockUseInternalCameraKit.mockReturnValue(errorContext(bootError));