test(geometry): cover the nested-mutation case in a component

The deep copy added in 57b2827 was guarded by a single unit test, so a
review reasonably suggested dropping it. Checking through the components
shows it is load-bearing: mutating an `icons` entry in place and changing
another option in the same render sends only the other option without it,
and the icon change is lost.

Mutating in place with no other change is a different matter, since
`useMemoized` masks it before the hook runs. The doc comment and the unit
test name both implied that case worked, so both now say what is actually
guaranteed.

Author: samithahansaka

src/components/__tests__/polyline.test.tsx

@@ -74,6 +74,33 @@ test('polyline should have a click listener', () => {
   );
 });
 
+test('polyline should send a nested option mutated in place', () => {
+  const path = [
+    {lat: 1, lng: 2},
+    {lat: 3, lng: 4}
+  ];
+  const icons = [{offset: '50%'}];
+
+  const {rerender} = render(
+    <Polyline path={path} icons={icons as never} strokeColor="#ff0000" />
+  );
+
+  const polyline = mockInstances.get(google.maps.Polyline)[0];
+  (polyline.setOptions as jest.Mock).mockClear();
+
+  // mutating in place keeps the same reference, so a shallow copy of the
+  // tracked options would compare the array against itself and drop the change
+  icons[0].offset = '75%';
+
+  rerender(
+    <Polyline path={path} icons={icons as never} strokeColor="#00ff00" />
+  );
+
+  const [sent] = (polyline.setOptions as jest.Mock).mock.calls[0];
+  expect(Object.keys(sent).sort()).toEqual(['icons', 'strokeColor']);
+  expect(sent.icons).toEqual([{offset: '75%'}]);
+});
+
 test('polyline should only send the options that changed', () => {
   const path = [
     {lat: 1, lng: 2},

src/libraries/__tests__/get-changed-options.test.ts

@@ -77,7 +77,7 @@ describe('getChangedOptions', () => {
 });
 
 describe('snapshotOptions', () => {
-  test('copies nested values so later mutation is visible', () => {
+  test('does not alias nested values from the source object', () => {
     const icons = [{offset: '50%'}];
     const tracked = snapshotOptions({icons});
 

src/libraries/get-changed-options.ts

@@ -61,13 +61,16 @@ export function getChangedOptions<T extends object>(
 }
 
 /**
- * Copies an options object deeply enough that a later comparison sees changes
- * made in place.
+ * Copies an options object deeply enough that nested values are not aliased by
+ * the caller's.
  *
- * A shallow copy aliases nested values, so mutating something like a polyline's
- * `icons` array and re-rendering compares the array against itself and reports
- * no change. Plain objects and arrays are copied; anything else, including maps
- * API instances, is kept by reference.
+ * A shallow copy shares nested values with the props, so an `icons` array
+ * mutated in place is compared against itself and reported unchanged. That only
+ * matters once some other option also changes, since `useMemoized` otherwise
+ * masks an in-place mutation before the hook runs at all.
+ *
+ * Plain objects and arrays are copied; anything else, including maps API
+ * instances, is kept by reference.
  *
  * @internal
  */