Seed analysis language from project and platform defaults

- analysisLanguage now prefers the active project's first configured language over the platform UI language
- platformLanguage is forwarded to ProjectModals → CreateProjectModal so new projects start with a sensible default in the language field
- makeWebViewState accepts an optional seed map so tests can pre-populate state slots without type assertions
- Clear focusedTokenRef in Interlinearizer when the book changes to prevent stale token references across book switches
- Added tests covering each routing path for analysisLanguage resolution

Author: alex-rawlings-yyc

src/__tests__/components/CreateProjectModal.test.tsx

@@ -54,6 +54,29 @@ describe('CreateProjectModal', () => {
     );
   });
 
+  it('pre-populates the language field from defaultAnalysisLanguage and submits it', async () => {
+    render(
+      <CreateProjectModal
+        projectId={testProjectId}
+        defaultAnalysisLanguage="fr"
+        onClose={() => {}}
+      />,
+    );
+
+    await userEvent.click(screen.getByRole('button', { name: /^create$/i }));
+
+    await waitFor(() =>
+      expect(papi.commands.sendCommand).toHaveBeenCalledWith(
+        'interlinearizer.createProject',
+        testProjectId,
+        ['fr'],
+        undefined,
+        undefined,
+        undefined,
+      ),
+    );
+  });
+
   it('sends the createProject command with entered name and description when submitted', async () => {
     render(<CreateProjectModal projectId={testProjectId} onClose={() => {}} />);
 

src/__tests__/components/InterlinearizerLoader.test.tsx

@@ -104,11 +104,13 @@ jest.mock('../../components/ProjectModals', () => ({
     modal,
     setModal,
     activeProject,
+    defaultAnalysisLanguage,
     useWebViewState,
   }: {
     modal: string;
     setModal: (m: string) => void;
     activeProject: MockProject | undefined;
+    defaultAnalysisLanguage?: string;
     useWebViewState: (
       key: string,
       def: MockProject | undefined,
@@ -117,7 +119,11 @@ jest.mock('../../components/ProjectModals', () => ({
   }) {
     const [, setActiveProject] = useWebViewState('activeProject', undefined);
     return (
-      <div data-testid="project-modals" data-modal={modal}>
+      <div
+        data-testid="project-modals"
+        data-modal={modal}
+        data-default-lang={defaultAnalysisLanguage}
+      >
         {modal === 'select' && (
           <div data-testid="select-modal">
             <button
@@ -428,7 +434,34 @@ describe('InterlinearizerLoader', () => {
     expect(screen.getByTestId('interlinearizer')).toBeInTheDocument();
   });
 
-  it('passes the first interfaceLanguage tag to Interlinearizer as analysisLanguage', () => {
+  it('passes the first analysisLanguages tag from the active project as analysisLanguage', () => {
+    const state = makeWebViewState({ activeProject: STUB_ACTIVE_PROJECT });
+    render(
+      <InterlinearizerLoader
+        projectId={testProjectId}
+        useWebViewScrollGroupScrRef={makeScrollGroupHook()}
+        useWebViewState={state}
+      />,
+    );
+
+    expect(capturedInterlinearizerProps?.analysisLanguage).toBe('en');
+  });
+
+  it('prefers the project analysisLanguage over the platform interface language', () => {
+    mockSettings('simple', ['fr']);
+    const state = makeWebViewState({ activeProject: STUB_ACTIVE_PROJECT });
+    render(
+      <InterlinearizerLoader
+        projectId={testProjectId}
+        useWebViewScrollGroupScrRef={makeScrollGroupHook()}
+        useWebViewState={state}
+      />,
+    );
+
+    expect(capturedInterlinearizerProps?.analysisLanguage).toBe('en');
+  });
+
+  it('falls back to the first interfaceLanguage tag when no project is active', () => {
     mockSettings('simple', ['fr', 'en']);
     render(
       <InterlinearizerLoader
@@ -441,7 +474,20 @@ describe('InterlinearizerLoader', () => {
     expect(capturedInterlinearizerProps?.analysisLanguage).toBe('fr');
   });
 
-  it('passes "und" to Interlinearizer as analysisLanguage when interfaceLanguage is empty', () => {
+  it('passes the platform language to ProjectModals as defaultAnalysisLanguage', () => {
+    mockSettings('simple', ['de']);
+    render(
+      <InterlinearizerLoader
+        projectId={testProjectId}
+        useWebViewScrollGroupScrRef={makeScrollGroupHook()}
+        useWebViewState={makeWebViewState()}
+      />,
+    );
+
+    expect(screen.getByTestId('project-modals')).toHaveAttribute('data-default-lang', 'de');
+  });
+
+  it('falls back to "und" as analysisLanguage when no project is active and interfaceLanguage is empty', () => {
     render(
       <InterlinearizerLoader
         projectId={testProjectId}

src/__tests__/components/ProjectModals.test.tsx

@@ -69,13 +69,15 @@ jest.mock('../../components/SelectInterlinearProjectModal', () => ({
 jest.mock('../../components/CreateProjectModal', () => ({
   __esModule: true,
   CreateProjectModal: ({
+    defaultAnalysisLanguage,
     onClose,
     onProjectCreated,
   }: {
+    defaultAnalysisLanguage?: string;
     onClose: () => void;
     onProjectCreated: (p: InterlinearProjectSummary) => void;
   }) => (
-    <div data-testid="create-modal">
+    <div data-testid="create-modal" data-default-lang={defaultAnalysisLanguage}>
       <button type="button" data-testid="create-close" onClick={onClose}>
         Close
       </button>
@@ -158,6 +160,7 @@ jest.mock('../../components/ProjectMetadataModal', () => ({
 function renderModals(
   overrides: Partial<{
     activeProject: InterlinearProjectSummary | undefined;
+    defaultAnalysisLanguage: string;
     modal: ModalState;
     setModal: (m: ModalState) => void;
     useWebViewState: ReturnType<typeof makeWebViewState>;
@@ -168,6 +171,7 @@ function renderModals(
   render(
     <ProjectModals
       activeProject={overrides.activeProject}
+      defaultAnalysisLanguage={overrides.defaultAnalysisLanguage}
       modal={overrides.modal ?? 'none'}
       projectId="source-proj"
       setModal={setModal}
@@ -249,6 +253,11 @@ describe('ProjectModals', () => {
   });
 
   describe('create modal', () => {
+    it('forwards defaultAnalysisLanguage to CreateProjectModal', () => {
+      renderModals({ modal: 'create', defaultAnalysisLanguage: 'es' });
+      expect(screen.getByTestId('create-modal')).toHaveAttribute('data-default-lang', 'es');
+    });
+
     it('calls setModal with none when create modal is closed without a select source', async () => {
       const { setModal } = renderModals({ modal: 'create' });
       await userEvent.click(screen.getByTestId('create-close'));

src/__tests__/test-helpers.ts

@@ -28,17 +28,21 @@ type StateSlot<T> = { get: () => T; set: (v: T) => void };
  * Returns a `useWebViewState` hook stub that stores values in typed per-key closures so state
  * persists across re-renders within the same test without requiring any type assertions.
  *
+ * @param seed - Optional map of key → initial value. When a key is present in `seed` the slot is
+ *   pre-populated with that value instead of using the hook's `defaultValue` argument.
  * @returns A hook function with the signature `(key, defaultValue) => [value, setter, reset]` where
- *   `value` is the current stored value for `key` (initially `defaultValue`), `setter` updates it,
- *   and `reset` removes the slot so the next call re-initializes from `defaultValue`.
+ *   `value` is the current stored value for `key` (initially `defaultValue` or the seeded value),
+ *   `setter` updates it, and `reset` removes the slot so the next call re-initializes from
+ *   `defaultValue`.
  */
-export function makeWebViewState() {
+export function makeWebViewState(seed: Record<string, unknown> = {}) {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   const slots = new Map<string, StateSlot<any>>();
   return <T>(key: string, defaultValue: T): [T, (v: T) => void, () => void] => {
     let slot: StateSlot<T> | undefined = slots.get(key);
     if (slot === undefined) {
-      let stored = defaultValue;
+      // eslint-disable-next-line no-type-assertion/no-type-assertion
+      let stored: T = Object.hasOwn(seed, key) ? (seed[key] as T) : defaultValue;
       slot = {
         get: () => stored,
         set: (v) => {

src/components/CreateProjectModal.tsx

@@ -25,6 +25,9 @@ const CREATE_PROJECT_MODAL_STRING_KEYS: `%${string}%`[] = [
  *
  * @param props - Component props
  * @param props.projectId - Source project to create the interlinear project for
+ * @param props.defaultAnalysisLanguage - BCP 47 tag pre-populated in the analysis language field;
+ *   caller should pass the platform UI language so the user sees a sensible starting value.
+ *   Defaults to `'und'` when absent.
  * @param props.onClose - Callback invoked when the modal should be dismissed (cancel or submit)
  * @param props.onProjectCreated - Optional callback invoked with the full persisted project after
  *   successful creation, before `onClose` is called.
@@ -33,18 +36,21 @@ const CREATE_PROJECT_MODAL_STRING_KEYS: `%${string}%`[] = [
  */
 export function CreateProjectModal({
   projectId,
+  defaultAnalysisLanguage,
   onClose,
   onProjectCreated,
 }: Readonly<{
   projectId: string;
+  /** BCP 47 tag pre-populated in the analysis language field; defaults to `'und'` when absent. */
+  defaultAnalysisLanguage?: string;
   onClose: () => void;
   onProjectCreated?: (project: InterlinearProjectSummary) => void;
 }>) {
   const [localizedStrings, stringsLoading] = useLocalizedStrings(CREATE_PROJECT_MODAL_STRING_KEYS);
 
   const [name, setName] = useState('');
   const [description, setDescription] = useState('');
-  const [analysisLanguages, setAnalysisLanguages] = useState('und');
+  const [analysisLanguages, setAnalysisLanguages] = useState(defaultAnalysisLanguage ?? 'und');
   const [isSubmitting, setIsSubmitting] = useState(false);
   const isSubmittingRef = useRef(false);
 

src/components/Interlinearizer.tsx

@@ -51,6 +51,12 @@ function InterlinearizerInner({
 }: Omit<InterlinearizerProps, 'initialAnalysis' | 'analysisLanguage' | 'onSaveAnalysis'>) {
   const [focusedTokenRef, setFocusedTokenRef] = useState<string | undefined>(undefined);
 
+  // Clear stale focused token when the book changes so focusedTokenRef never refers to a token
+  // in a different book.
+  useEffect(() => {
+    setFocusedTokenRef(undefined);
+  }, [book]);
+
   /** All word tokens in book order — index into this array is the phrase index. */
   const wordTokens = useMemo(
     () => book.segments.flatMap((seg) => seg.tokens).filter((token) => token.type === 'word'),

src/components/InterlinearizerLoader.tsx

@@ -44,10 +44,28 @@ export default function InterlinearizerLoader({
   const [interfaceMode] = useSetting('platform.interfaceMode', 'simple');
   const [interfaceLanguages] = useSetting('platform.interfaceLanguage', ['und']);
   /* v8 ignore next 3 -- useSetting never returns PlatformError for this key in practice */
-  const analysisLanguage = isPlatformError(interfaceLanguages)
+  const platformLanguage = isPlatformError(interfaceLanguages)
     ? 'und'
     : interfaceLanguages[0] || 'und';
 
+  /**
+   * Persisted snapshot of the active interlinear project — kept in WebView state so it survives tab
+   * restores. The setter lives in {@link ProjectModals}, which writes to the same `'activeProject'`
+   * key; this component reads the value to decide which menu items to show and which analysis
+   * language to use.
+   */
+  const [activeProject] = useWebViewState<InterlinearProjectSummary | undefined>(
+    'activeProject',
+    undefined,
+  );
+
+  /**
+   * BCP 47 tag used for reading and writing gloss values. Prefers the active project's first
+   * configured analysis language; falls back to the platform UI language when no project is
+   * active.
+   */
+  const analysisLanguage = activeProject?.analysisLanguages[0] ?? platformLanguage;
+
   const {
     isLoading: isSettingLoading,
     onChange: handleContinuousScrollChange,
@@ -65,16 +83,6 @@ export default function InterlinearizerLoader({
 
   const [modal, setModal] = useState<ModalState>('none');
 
-  /**
-   * Persisted snapshot of the active interlinear project — kept in WebView state so it survives tab
-   * restores. The setter lives in {@link ProjectModals}, which writes to the same `'activeProject'`
-   * key; this component reads the value to decide which menu items to show.
-   */
-  const [activeProject] = useWebViewState<InterlinearProjectSummary | undefined>(
-    'activeProject',
-    undefined,
-  );
-
   /**
    * Routes top-menu commands to the appropriate modal. `openSelectProjectModal` opens the select
    * modal; `openNewProjectModal` opens the create modal directly; `openProjectInfoModal` opens the
@@ -198,6 +206,7 @@ export default function InterlinearizerLoader({
 
       <ProjectModals
         activeProject={activeProject}
+        defaultAnalysisLanguage={platformLanguage}
         modal={modal}
         projectId={projectId}
         setModal={setModal}

src/components/ProjectModals.tsx

@@ -16,6 +16,8 @@ export type ModalState = 'none' | 'select' | 'create' | 'metadata';
  * @param props - Component props
  * @param props.activeProject - The currently active interlinear project, read from WebView state by
  *   the parent.
+ * @param props.defaultAnalysisLanguage - BCP 47 tag forwarded to {@link CreateProjectModal} as the
+ *   initial value of the analysis language field; should be the platform UI language.
  * @param props.modal - Which modal is currently open
  * @param props.projectId - PAPI project ID passed from the host
  * @param props.setModal - Setter for which modal is open
@@ -25,12 +27,14 @@ export type ModalState = 'none' | 'select' | 'create' | 'metadata';
  */
 export default function ProjectModals({
   activeProject,
+  defaultAnalysisLanguage,
   modal,
   projectId,
   setModal,
   useWebViewState,
 }: Readonly<{
   activeProject: InterlinearProjectSummary | undefined;
+  defaultAnalysisLanguage?: string;
   modal: ModalState;
   projectId: string;
   setModal: (modal: ModalState) => void;
@@ -182,6 +186,7 @@ export default function ProjectModals({
       {modal === 'create' && (
         <CreateProjectModal
           projectId={projectId}
+          defaultAnalysisLanguage={defaultAnalysisLanguage}
           onClose={handleCreateClose}
           onProjectCreated={handleProjectCreated}
         />