Fix bug where book can be selected for drafting and training without chapter selection

Author: Nateowami

src/SIL.XForge.Scripture/ClientApp/src/app/translate/draft-generation/new-draft/new-draft-logic-handler.spec.ts

@@ -643,6 +643,32 @@ describe('NewDraftLogicHandler', () => {
       expect(env.selectedTrainingSourceBooks['training-source-1-id']).toContain('MAT');
       expect(env.selectedTrainingSourceBooks['training-source-2-id']).not.toContain('MAT');
     });
+
+    it('fully excludes a whole-book draft from training, even chapters the source cannot draft', async () => {
+      // The drafting source has only a couple of chapters of Mark (below the partial-drafting threshold), so Mark
+      // can only be drafted whole. The target has more chapters of Mark translated than the source contains.
+      const env = new TestEnvironment({
+        lastSelectedTranslationScriptureRanges: undefined,
+        previouslySelectedTrainingScriptureRanges: undefined,
+        draftingSourceBooksChapters: 'MRK1-2',
+        targetProjectBooksChapters: 'MRK1-7;LUK1-24',
+        trainingSourcesBooksChapters: {
+          'training-source-1-id': 'MRK1-16;LUK1-24'
+        }
+      });
+      await env.waitForInit();
+
+      // Mark's source has only 2 chapters of content (< 12), so Mark is not eligible for partial drafting. It is
+      // drafted whole, with no chapter selector offered.
+      env.logicHandler.selectDraftingBooks(['MRK']);
+      expect(env.booksOfferedForPartialDrafting).not.toContain('MRK');
+
+      env.logicHandler.setInputMode('training_books');
+
+      // Mark is being drafted as a whole book, so it must not be available for training at all. That includes the
+      // target chapters beyond the source's 2 (MRK3-7), which is what previously leaked through.
+      expect(env.logicHandler.availableTargetTrainingScriptureRange.books.has('MRK')).toBe(false);
+    });
   });
 
   describe('auto-selecting training books on first visit', () => {

src/SIL.XForge.Scripture/ClientApp/src/app/translate/draft-generation/new-draft/new-draft-logic-handler.ts

@@ -699,12 +699,42 @@ export class NewDraftLogicHandler {
     }
   }
 
+  /**
+   * The scripture range to withhold from the training options, so that training data never overlaps what is being
+   * drafted. It is not simply selectedDraftingScriptureRange, which holds only the chapters the source can draft and
+   * is submitted verbatim as the draft request. What counts as "being drafted" for this purpose depends on how the
+   * book was selected:
+   *
+   * - Partial-eligible book: the user was shown a chapter selector, so only the chapters they chose count. Those are
+   *   withheld, and the book's remaining chapters stay available for training (the "draft some, train on the rest" case).
+   * - Whole-book draft: no chapter selector was offered, so the whole book counts as being drafted, including the
+   *   chapters the source cannot draft. The entire book is withheld, so those chapters are not silently offered as
+   *   training data.
+   */
+  private draftingRangeExcludedFromTraining(): VerboseScriptureRange {
+    const excluded = new VerboseScriptureRange();
+    for (const [bookId, draftedChapters] of this.selectedDraftingScriptureRange.books) {
+      if (this.isBookEligibleForPartialDrafting(bookId)) {
+        excluded.books.set(bookId, draftedChapters.clone());
+      } else {
+        // Withhold the whole book. Use its chapters in the target, since the training options are derived from the
+        // target's content; a book with no target content has nothing to withhold.
+        const targetChapters = this.targetProjectScriptureRange.books.get(bookId);
+        if (targetChapters != null) {
+          excluded.books.set(bookId, targetChapters.clone());
+        }
+      }
+    }
+    return excluded;
+  }
+
   private limitAvailableTrainingRangeBasedOnSelectedDraftingRange(): void {
     // Available target training books are the target's content minus what's being drafted, further limited to books
     // that exist in at least one training source: a target book can only be used as training data if a source
     // provides the matching book to pair it with. Books with no such source are recorded
     // (targetTrainingBooksWithoutSource) so the UI can explain why they aren't offered.
-    const targetTrainingRange = this.targetProjectScriptureRange.difference(this.selectedDraftingScriptureRange);
+    const excludedFromTraining = this.draftingRangeExcludedFromTraining();
+    const targetTrainingRange = this.targetProjectScriptureRange.difference(excludedFromTraining);
     const booksInAnyTrainingSource = new Set(Object.values(this.trainingSourceBooks).flat());
 
     const availableTargetTrainingRange = new VerboseScriptureRange();
@@ -718,9 +748,8 @@ export class NewDraftLogicHandler {
     }
     this.availableTargetTrainingScriptureRange = availableTargetTrainingRange;
     this.targetTrainingBooksWithoutSource = booksWithoutSource;
-    this.selectedTargetTrainingScriptureRange = this.selectedTargetTrainingScriptureRange.difference(
-      this.selectedDraftingScriptureRange
-    );
+    this.selectedTargetTrainingScriptureRange =
+      this.selectedTargetTrainingScriptureRange.difference(excludedFromTraining);
 
     // Limit available and selected training source books to not exceed available target training scripture range
     const availableTargetRange = this.availableTargetTrainingScriptureRange;