fix: handle undefined sorts/customColumns from lazy+StrictMode defaultProps bug

When IrisGrid is loaded via LazyIrisGrid (the public export), it goes
through a forwardRef -> lazy() -> Suspense chain. In React 18 StrictMode,
there is a known bug (facebook/react#28505) where defaultProps are not
correctly merged into this.props during the second componentDidMount
call of the StrictMode double-mount cycle.

The root cause is in React's reconciler: during the simulated unmount,
componentWillUnmount sets instance.props to fiber.memoizedProps (the
unresolved props without defaultProps merged). When React re-mounts the
component, componentDidMount sees these unresolved props, so props like
sorts and customColumns are undefined instead of their defaultProps
values (EMPTY_ARRAY).

loadTableState() then sets these undefined values into state, and
IrisGridModelUpdater crashes with 'sorts is not iterable' when it
tries to spread them: `[...sorts]`.

Add defensive ?? EMPTY_ARRAY fallbacks in:
- IrisGrid.loadTableState(): when setting sorts/customColumns into state
- IrisGridModelUpdater: when spreading sorts and assigning customColumns

Add tests that reproduce the exact bug by combining async lazy loading
with StrictMode, and unit tests for IrisGridModelUpdater with undefined
sorts/customColumns.

Author: mofojed

packages/iris-grid/src/IrisGrid.test.tsx

@@ -1,5 +1,5 @@
-import React, { useRef } from 'react';
-import { act, fireEvent, render } from '@testing-library/react';
+import React, { lazy, Suspense, useRef } from 'react';
+import { act, fireEvent, render, waitFor } from '@testing-library/react';
 import dh from '@deephaven/jsapi-shim';
 import { DateUtils, type Settings } from '@deephaven/jsapi-utils';
 import { TestUtils } from '@deephaven/test-utils';
@@ -435,6 +435,65 @@ describe('handleResizeAllColumns', () => {
   });
 });
 
+describe('LazyIrisGrid with StrictMode', () => {
+  it('renders without error when sorts and customColumns are not provided', async () => {
+    // This reproduces the real-world bug:
+    // 1. External consumers import IrisGrid from @deephaven/iris-grid, which is LazyIrisGrid
+    // 2. LazyIrisGrid = forwardRef wrapping lazy(() => import('./IrisGrid'))
+    // 3. The lazy wrapper means defaultProps are NOT resolved at element creation time
+    //    (both jsx() and createElement() produce props={} for lazy components)
+    // 4. React's reconciler resolves defaultProps during rendering for lazy components
+    // 5. In StrictMode, React double-fires effects: componentDidMount → componentWillUnmount → componentDidMount
+    // 6. On the second componentDidMount, loadTableState() reads this.props.sorts
+    //    which may be undefined if defaultProps resolution isn't applied consistently
+    //    across the StrictMode re-mount cycle
+    //
+    // To simulate true async lazy loading (vs Jest's synchronous import()),
+    // we use a deferred promise that we manually resolve.
+
+    let resolveLazy!: (value: { default: typeof IrisGrid }) => void;
+    const LazyIrisGridTest = React.forwardRef<
+      IrisGrid,
+      React.ComponentPropsWithoutRef<typeof IrisGrid>
+    >((props, ref) => {
+      const IrisGridLazy = React.useMemo(
+        () =>
+          lazy(
+            () =>
+              new Promise<{ default: typeof IrisGrid }>(resolve => {
+                resolveLazy = resolve;
+              })
+          ),
+        []
+      );
+      return (
+        <Suspense fallback={<div data-testid="loading" />}>
+          <IrisGridLazy ref={ref} {...props} />
+        </Suspense>
+      );
+    });
+    LazyIrisGridTest.displayName = 'LazyIrisGridTest';
+
+    const model = irisGridTestUtils.makeModel();
+
+    // Render in StrictMode — just like a real app typically does
+    const { queryByTestId } = render(
+      <React.StrictMode>
+        <LazyIrisGridTest model={model} settings={DEFAULT_SETTINGS} />
+      </React.StrictMode>
+    );
+
+    // Should initially show loading fallback
+    expect(queryByTestId('loading')).not.toBeNull();
+
+    // Now resolve the lazy import — this triggers the actual IrisGrid mount
+    // and the StrictMode double-mount cycle
+    await act(async () => {
+      resolveLazy(await import('./IrisGrid'));
+    });
+  });
+});
+
 describe('Advanced Filter', () => {
   it.each([
     { columnIndex: -1, expectedVisibility: false },

packages/iris-grid/src/IrisGrid.tsx

@@ -2178,9 +2178,9 @@ class IrisGrid extends Component<IrisGridProps, IrisGridState> {
     }
 
     this.setState({
-      sorts,
+      sorts: sorts ?? EMPTY_ARRAY,
       reverse: reverse || reverseType === TableUtils.REVERSE_TYPE.POST_SORT,
-      customColumns,
+      customColumns: customColumns ?? EMPTY_ARRAY,
       isReady: true,
       searchFilter,
     });

packages/iris-grid/src/IrisGridModelUpdater.test.tsx

@@ -0,0 +1,63 @@
+import React from 'react';
+import { render } from '@testing-library/react';
+import dh from '@deephaven/jsapi-shim';
+import { Formatter } from '@deephaven/jsapi-utils';
+import { EMPTY_ARRAY } from '@deephaven/utils';
+import IrisGridModelUpdater from './IrisGridModelUpdater';
+import IrisGridTestUtils from './IrisGridTestUtils';
+
+const irisGridTestUtils = new IrisGridTestUtils(dh);
+
+function makeModel() {
+  return irisGridTestUtils.makeModel();
+}
+
+function renderUpdater(propsOverride = {}) {
+  const model = makeModel();
+  const defaultProps = {
+    model,
+    top: 0,
+    bottom: 100,
+    left: 0,
+    right: 10,
+    filter: EMPTY_ARRAY as readonly dh.FilterCondition[],
+    sorts: EMPTY_ARRAY as readonly never[],
+    customColumns: EMPTY_ARRAY as readonly string[],
+    movedColumns: EMPTY_ARRAY as readonly never[],
+    hiddenColumns: EMPTY_ARRAY as readonly number[],
+    alwaysFetchColumns: EMPTY_ARRAY as readonly string[],
+    formatColumns: EMPTY_ARRAY as readonly dh.CustomColumn[],
+    columnHeaderGroups: EMPTY_ARRAY as readonly never[],
+    formatter: new Formatter(dh),
+    columnAlignmentMap: new Map<string, CanvasTextAlign>(),
+  };
+  return render(<IrisGridModelUpdater {...defaultProps} {...propsOverride} />);
+}
+
+describe('IrisGridModelUpdater', () => {
+  it('renders without error when sorts and customColumns are provided', () => {
+    expect(() => renderUpdater()).not.toThrow();
+  });
+
+  it('does not throw when sorts is undefined', () => {
+    // This simulates what happens when LazyIrisGrid passes through props
+    // without defaultProps being applied — sorts ends up undefined in state,
+    // and IrisGridModelUpdater receives undefined for sorts
+    expect(() => renderUpdater({ sorts: undefined as unknown })).not.toThrow();
+  });
+
+  it('does not throw when customColumns is undefined', () => {
+    expect(() =>
+      renderUpdater({ customColumns: undefined as unknown })
+    ).not.toThrow();
+  });
+
+  it('does not throw when both sorts and customColumns are undefined', () => {
+    expect(() =>
+      renderUpdater({
+        sorts: undefined as unknown,
+        customColumns: undefined as unknown,
+      })
+    ).not.toThrow();
+  });
+});

packages/iris-grid/src/IrisGridModelUpdater.tsx

@@ -114,7 +114,7 @@ function IrisGridModelUpdater({
   );
   useOnChange(
     function updateSorts() {
-      const sortsForModel = [...sorts];
+      const sortsForModel = [...(sorts ?? EMPTY_ARRAY)];
       if (reverse) {
         sortsForModel.push(model.dh.Table.reverse());
       }
@@ -137,7 +137,7 @@ function IrisGridModelUpdater({
   useOnChange(
     function updateCustomColumns() {
       if (model.isCustomColumnsAvailable) {
-        model.customColumns = customColumns;
+        model.customColumns = customColumns ?? EMPTY_ARRAY;
       }
     },
     [model, customColumns]