jbrowse-plugin-mafviewer 1.4.3 → 1.4.6

package/src/util/fastaUtils.test.ts

@@ -97,3 +97,202 @@ test('gap in assembly1', () => {
   })
   expect(result).toMatchSnapshot()
 })
+
+test('includeInsertions - single insertion in one sample', () => {
+  // Reference seq has a gap (insertion in assembly2)
+  // seq:       AC--GTAC (reference with gap = insertion in aligned seq)
+  // assembly1: AC--GTAC (no insertion, matches reference gap)
+  // assembly2: ACTTGTAC (has TT insertion)
+  const mockFeature = new SimpleFeature({
+    uniqueId: '123',
+    refName: 'abc',
+    start: 100,
+    end: 106, // 6 bp reference (AC GTAC without the gap)
+    seq: 'AC--GTAC',
+    alignments: {
+      assembly1: {
+        chr: 'chr1',
+        start: 100,
+        seq: 'AC--GTAC',
+        strand: 1,
+      },
+      assembly2: {
+        chr: 'chr2',
+        start: 200,
+        seq: 'ACTTGTAC',
+        strand: 1,
+      },
+    },
+  })
+
+  const result = processFeaturesToFasta({
+    features: makeMap([mockFeature]),
+    samples: [{ id: 'assembly1' }, { id: 'assembly2' }],
+    includeInsertions: true,
+    showAllLetters: true,
+    regions: [
+      {
+        refName: 'chr1',
+        start: 100,
+        end: 106,
+        assemblyName: 'assembly1',
+      },
+    ],
+  })
+  // assembly1 should have gaps where the insertion is
+  // assembly2 should have the TT insertion
+  expect(result).toMatchSnapshot()
+})
+
+test('includeInsertions - insertions in multiple samples with different lengths', () => {
+  // Reference has gap, different samples have different insertion lengths
+  // seq:       AC---GTAC (reference with 3-bp gap)
+  // assembly1: AC-T-GTAC (has T insertion, 1 bp)
+  // assembly2: ACTTTGTAC (has TTT insertion, 3 bp)
+  const mockFeature = new SimpleFeature({
+    uniqueId: '123',
+    refName: 'abc',
+    start: 100,
+    end: 106,
+    seq: 'AC---GTAC',
+    alignments: {
+      assembly1: {
+        chr: 'chr1',
+        start: 100,
+        seq: 'AC-T-GTAC',
+        strand: 1,
+      },
+      assembly2: {
+        chr: 'chr2',
+        start: 200,
+        seq: 'ACTTTGTAC',
+        strand: 1,
+      },
+    },
+  })
+
+  const result = processFeaturesToFasta({
+    features: makeMap([mockFeature]),
+    samples: [{ id: 'assembly1' }, { id: 'assembly2' }],
+    includeInsertions: true,
+    showAllLetters: true,
+    regions: [
+      {
+        refName: 'chr1',
+        start: 100,
+        end: 106,
+        assemblyName: 'assembly1',
+      },
+    ],
+  })
+  // assembly1 should have T-- (padded to max insertion length 3)
+  // assembly2 should have TTT
+  expect(result).toMatchSnapshot()
+})
+
+test('includeInsertions - insertions at multiple positions', () => {
+  // Reference has gaps at two positions
+  // seq:       A-CG-TAC
+  // assembly1: ATCGGTAC (T insertion at pos 1, G insertion at pos 4)
+  // assembly2: A-CG-TAC (no insertions)
+  const mockFeature = new SimpleFeature({
+    uniqueId: '123',
+    refName: 'abc',
+    start: 100,
+    end: 106,
+    seq: 'A-CG-TAC',
+    alignments: {
+      assembly1: {
+        chr: 'chr1',
+        start: 100,
+        seq: 'ATCGGTAC',
+        strand: 1,
+      },
+      assembly2: {
+        chr: 'chr2',
+        start: 200,
+        seq: 'A-CG-TAC',
+        strand: 1,
+      },
+    },
+  })
+
+  const result = processFeaturesToFasta({
+    features: makeMap([mockFeature]),
+    samples: [{ id: 'assembly1' }, { id: 'assembly2' }],
+    includeInsertions: true,
+    showAllLetters: true,
+    regions: [
+      {
+        refName: 'chr1',
+        start: 100,
+        end: 106,
+        assemblyName: 'assembly1',
+      },
+    ],
+  })
+  expect(result).toMatchSnapshot()
+})
+
+test('includeInsertions=false ignores insertions', () => {
+  const mockFeature = new SimpleFeature({
+    uniqueId: '123',
+    refName: 'abc',
+    start: 100,
+    end: 106,
+    seq: 'AC--GTAC',
+    alignments: {
+      assembly1: {
+        chr: 'chr1',
+        start: 100,
+        seq: 'AC--GTAC',
+        strand: 1,
+      },
+      assembly2: {
+        chr: 'chr2',
+        start: 200,
+        seq: 'ACTTGTAC',
+        strand: 1,
+      },
+    },
+  })
+
+  const result = processFeaturesToFasta({
+    features: makeMap([mockFeature]),
+    samples: [{ id: 'assembly1' }, { id: 'assembly2' }],
+    includeInsertions: false,
+    showAllLetters: true,
+    regions: [
+      {
+        refName: 'chr1',
+        start: 100,
+        end: 106,
+        assemblyName: 'assembly1',
+      },
+    ],
+  })
+  // Without insertions, both should be 6 characters (no expansion)
+  expect(result[0]).toHaveLength(6)
+  expect(result[1]).toHaveLength(6)
+  expect(result).toMatchSnapshot()
+})
+
+test('includeInsertions with no insertions present', () => {
+  // No gaps in reference = no insertions
+  const result = processFeaturesToFasta({
+    features: makeMap([mockFeature]),
+    samples: [{ id: 'assembly1' }, { id: 'assembly2' }],
+    includeInsertions: true,
+    showAllLetters: true,
+    regions: [
+      {
+        refName: 'chr1',
+        start: 100,
+        end: 105,
+        assemblyName: 'assembly1',
+      },
+    ],
+  })
+  // Should behave same as without includeInsertions since there are none
+  expect(result).toMatchSnapshot()
+})

package/src/util/fastaUtils.ts

@@ -3,6 +3,11 @@ import { Sample } from '../LinearMafDisplay/types'
 import type { AlignmentRecord } from '../LinearMafRenderer/rendering'
 import type { Feature, Region } from '@jbrowse/core/util'
 
+interface InsertionInfo {
+  sequence: string
+  sampleIndex: number
+}
+
 /**
  * Process features into FASTA format
  * @param features - The features to process
@@ -14,90 +19,152 @@ export function processFeaturesToFasta({
   showAllLetters,
   samples,
   features,
+  includeInsertions,
 }: {
   regions: Region[]
   samples: Sample[]
   showAsUpperCase?: boolean
   mismatchRendering?: boolean
   showAllLetters?: boolean
+  includeInsertions?: boolean
   features: Map<string, Feature>
 }) {
   const region = regions[0]!
   const sampleToRowMap = new Map(samples.map((s, i) => [s.id, i]))
   const rlen = region.end - region.start
-  const outputRows = samples.map(() => '-'.repeat(rlen))
+
+  // Use character arrays instead of strings for O(1) mutations
+  const outputRowsArrays = samples.map(() => new Array(rlen).fill('-'))
+
+  // Track insertions at each position if includeInsertions is enabled
+  // Key is the reference position (0-based relative to region), value is array of insertions
+  const insertionsAtPosition = new Map<number, InsertionInfo[]>()
+
   for (const feature of features.values()) {
     const leftCoord = feature.get('start')
     const vals = feature.get('alignments') as Record<string, AlignmentRecord>
     const seq = feature.get('seq')
-    for (const [sample, val] of Object.entries(vals)) {
-      const origAlignment = val.seq
-      const alignment = origAlignment
 
+    for (const [sample, val] of Object.entries(vals)) {
+      const alignment = val.seq
       const row = sampleToRowMap.get(sample)
       if (row === undefined) {
         continue
       }
 
-      // gaps
+      const rowArray = outputRowsArrays[row]!
+
+      // Single-pass processing: handle gaps, matches, mismatches, and collect insertions
       for (let i = 0, o = 0, l = alignment.length; i < l; i++) {
         if (seq[i] !== '-') {
-          if (alignment[i] === '-') {
-            const l = leftCoord + o - region.start
-            if (l >= 0 && l < rlen) {
-              outputRows[row] =
-                outputRows[row]!.slice(0, l) +
-                '-' +
-                outputRows[row]!.slice(l + 1)
+          const c = alignment[i]
+          const pos = leftCoord + o - region.start
+
+          if (pos >= 0 && pos < rlen) {
+            if (c === '-') {
+              // Gap
+              rowArray[pos] = '-'
+            } else if (c !== ' ') {
+              if (showAllLetters) {
+                // Show all letters mode: write character directly
+                rowArray[pos] = c
+              } else if (seq[i] === c) {
+                // Match: use dot notation
+                rowArray[pos] = '.'
+              } else {
+                // Mismatch: write character
+                rowArray[pos] = c
+              }
             }
           }
           o++
-        }
-      }
-
-      if (!showAllLetters) {
-        // matches
-        for (let i = 0, o = 0, l = alignment.length; i < l; i++) {
-          if (seq[i] !== '-') {
+        } else if (includeInsertions) {
+          // This is an insertion (reference has gap)
+          // Collect all consecutive insertion characters
+          let insertionSequence = ''
+          while (i < alignment.length && seq[i] === '-') {
             const c = alignment[i]
-            const l = leftCoord + o - region.start
-            if (l >= 0 && l < rlen) {
-              if (seq[i] === c && c !== '-' && c !== ' ') {
-                outputRows[row] =
-                  outputRows[row]!.slice(0, l) +
-                  '.' +
-                  outputRows[row]!.slice(l + 1)
-              }
-            }
-            o++
+            insertionSequence += c !== '-' && c !== ' ' ? c : '-'
+            i++
           }
-        }
-      }
+          i-- // Back up one since the outer loop will increment
 
-      // mismatches
-      for (let i = 0, o = 0, l = alignment.length; i < l; i++) {
-        const c = alignment[i]
-        if (seq[i] !== '-') {
-          if (c !== '-') {
-            const l = leftCoord + o - region.start
-            if (l >= 0 && l < rlen) {
-              if (seq[i] !== c && c !== ' ') {
-                outputRows[row] =
-                  outputRows[row]!.slice(0, l) +
-                  c +
-                  outputRows[row]!.slice(l + 1)
-              } else if (showAllLetters) {
-                outputRows[row] =
-                  outputRows[row]!.slice(0, l) +
-                  c +
-                  outputRows[row]!.slice(l + 1)
-              }
+          if (insertionSequence.length > 0) {
+            // Position is relative to region start, insertions come after position o-1
+            // (or before position 0 if o is 0)
+            const insertPos = leftCoord + o - region.start
+            if (insertPos >= 0 && insertPos <= rlen) {
+              const existing = insertionsAtPosition.get(insertPos) || []
+              existing.push({ sequence: insertionSequence, sampleIndex: row })
+              insertionsAtPosition.set(insertPos, existing)
             }
           }
-          o++
         }
       }
     }
   }
-  return outputRows
+
+  if (includeInsertions && insertionsAtPosition.size > 0) {
+    return expandWithInsertions(
+      outputRowsArrays,
+      insertionsAtPosition,
+      samples.length,
+    )
+  }
+
+  // Convert character arrays back to strings
+  return outputRowsArrays.map(arr => arr.join(''))
+}
+
+/**
+ * Expand sequences to include insertions
+ * At each position with insertions, find the max insertion length,
+ * then expand all sequences by that amount
+ */
+function expandWithInsertions(
+  outputRowsArrays: string[][],
+  insertionsAtPosition: Map<number, InsertionInfo[]>,
+  numSamples: number,
+) {
+  // Sort insertion positions in descending order so we can insert from right to left
+  // without affecting earlier positions
+  const sortedPositions = [...insertionsAtPosition.keys()].sort((a, b) => b - a)
+
+  for (const pos of sortedPositions) {
+    const insertions = insertionsAtPosition.get(pos)!
+
+    // Find max insertion length at this position
+    let maxLen = 0
+    for (const ins of insertions) {
+      if (ins.sequence.length > maxLen) {
+        maxLen = ins.sequence.length
+      }
+    }
+
+    // Create a map from sample index to insertion sequence
+    const sampleInsertions = new Map<number, string>()
+    for (const ins of insertions) {
+      sampleInsertions.set(ins.sampleIndex, ins.sequence)
+    }
+
+    // Insert characters at this position for each sample
+    for (let sampleIdx = 0; sampleIdx < numSamples; sampleIdx++) {
+      const rowArray = outputRowsArrays[sampleIdx]!
+      const insertionSeq = sampleInsertions.get(sampleIdx)
+
+      if (insertionSeq) {
+        // This sample has an insertion - add it, padded with gaps if needed
+        const paddedInsertion = insertionSeq.padEnd(maxLen, '-')
+        // Insert after position `pos`
+        rowArray.splice(pos, 0, ...paddedInsertion.split(''))
+      } else {
+        // No insertion for this sample - fill with gaps
+        const gaps = new Array(maxLen).fill('-')
+        rowArray.splice(pos, 0, ...gaps)
+      }
+    }
+  }
+
+  // Convert character arrays back to strings
+  return outputRowsArrays.map(arr => arr.join(''))
 }