jbrowse-plugin-mafviewer 1.4.5 → 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,12 +19,14 @@ 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]!
@@ -29,6 +36,10 @@ export function processFeaturesToFasta({
   // 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>
@@ -43,7 +54,7 @@ export function processFeaturesToFasta({
 
       const rowArray = outputRowsArrays[row]!
 
-      // Single-pass processing: handle gaps, matches, and mismatches together
+      // 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] !== '-') {
           const c = alignment[i]
@@ -67,11 +78,93 @@ export function processFeaturesToFasta({
             }
           }
           o++
+        } 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]
+            insertionSequence += c !== '-' && c !== ' ' ? c : '-'
+            i++
+          }
+          i-- // Back up one since the outer loop will increment
+
+          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)
+            }
+          }
         }
       }
     }
   }
 
+  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(''))
 }

package/src/util/parseAssemblyName.test.ts

@@ -0,0 +1,350 @@
+import { describe, expect, test } from 'vitest'
+
+import {
+  parseAssemblyAndChr,
+  parseAssemblyAndChrSimple,
+  selectReferenceSequence,
+} from './parseAssemblyName'
+
+describe('parseAssemblyAndChr (MafTabix format)', () => {
+  test('no dot - entire string is assembly name', () => {
+    const result = parseAssemblyAndChr('hg38')
+    expect(result).toEqual({
+      assemblyName: 'hg38',
+      chr: '',
+    })
+  })
+
+  test('single dot - simple assembly.chr format', () => {
+    const result = parseAssemblyAndChr('hg38.chr1')
+    expect(result).toEqual({
+      assemblyName: 'hg38',
+      chr: 'chr1',
+    })
+  })
+
+  test('single dot - assembly.refName format with non-chr name', () => {
+    const result = parseAssemblyAndChr('mm10.scaffold_1')
+    expect(result).toEqual({
+      assemblyName: 'mm10',
+      chr: 'scaffold_1',
+    })
+  })
+
+  test('two dots with numeric version - assembly.version.chr format', () => {
+    const result = parseAssemblyAndChr('hg38.1.chr1')
+    expect(result).toEqual({
+      assemblyName: 'hg38.1',
+      chr: 'chr1',
+    })
+  })
+
+  test('two dots with multi-digit numeric version', () => {
+    const result = parseAssemblyAndChr('GRCh38.123.chrX')
+    expect(result).toEqual({
+      assemblyName: 'GRCh38.123',
+      chr: 'chrX',
+    })
+  })
+
+  test('two dots with non-numeric middle - assembly.chr.more format', () => {
+    const result = parseAssemblyAndChr('mm10.chr1.random')
+    expect(result).toEqual({
+      assemblyName: 'mm10',
+      chr: 'chr1.random',
+    })
+  })
+
+  test('two dots with non-numeric middle - chr_Un type naming', () => {
+    const result = parseAssemblyAndChr('hg38.chrUn_gl000220')
+    expect(result).toEqual({
+      assemblyName: 'hg38',
+      chr: 'chrUn_gl000220',
+    })
+  })
+
+  test('three dots with numeric version - assembly.version.chr.more format', () => {
+    const result = parseAssemblyAndChr('GRCh38.1.chr1.random')
+    expect(result).toEqual({
+      assemblyName: 'GRCh38.1',
+      chr: 'chr1.random',
+    })
+  })
+
+  test('empty string', () => {
+    const result = parseAssemblyAndChr('')
+    expect(result).toEqual({
+      assemblyName: '',
+      chr: '',
+    })
+  })
+
+  test('just a dot', () => {
+    const result = parseAssemblyAndChr('.')
+    expect(result).toEqual({
+      assemblyName: '',
+      chr: '',
+    })
+  })
+
+  test('leading dot', () => {
+    const result = parseAssemblyAndChr('.chr1')
+    expect(result).toEqual({
+      assemblyName: '',
+      chr: 'chr1',
+    })
+  })
+
+  test('trailing dot', () => {
+    const result = parseAssemblyAndChr('hg38.')
+    expect(result).toEqual({
+      assemblyName: 'hg38',
+      chr: '',
+    })
+  })
+
+  test('real world example - UCSC style', () => {
+    const result = parseAssemblyAndChr('hg19.chr6_ssto_hap7')
+    expect(result).toEqual({
+      assemblyName: 'hg19',
+      chr: 'chr6_ssto_hap7',
+    })
+  })
+
+  test('real world example - Ensembl style with numeric', () => {
+    const result = parseAssemblyAndChr('GRCh37.1.1')
+    expect(result).toEqual({
+      assemblyName: 'GRCh37.1',
+      chr: '1',
+    })
+  })
+})
+
+describe('parseAssemblyAndChrSimple (BigMaf format)', () => {
+  test('no dot - entire string is assembly name', () => {
+    const result = parseAssemblyAndChrSimple('hg38')
+    expect(result).toEqual({
+      assemblyName: 'hg38',
+      chr: '',
+    })
+  })
+
+  test('single dot - simple org.chr format', () => {
+    const result = parseAssemblyAndChrSimple('hg38.chr1')
+    expect(result).toEqual({
+      assemblyName: 'hg38',
+      chr: 'chr1',
+    })
+  })
+
+  test('multiple dots - only splits on first dot', () => {
+    const result = parseAssemblyAndChrSimple('mm10.chr1.random')
+    expect(result).toEqual({
+      assemblyName: 'mm10',
+      chr: 'chr1.random',
+    })
+  })
+
+  test('empty string', () => {
+    const result = parseAssemblyAndChrSimple('')
+    expect(result).toEqual({
+      assemblyName: '',
+      chr: '',
+    })
+  })
+})
+
+describe('selectReferenceSequence', () => {
+  const alignments = {
+    hg38: { seq: 'ACGTACGT' },
+    mm10: { seq: 'TGCATGCA' },
+    panTro6: { seq: 'GGGGGGGG' },
+  }
+
+  test('uses refAssemblyName when provided and exists', () => {
+    const result = selectReferenceSequence(
+      alignments,
+      'mm10',
+      'hg38',
+      'panTro6',
+    )
+    expect(result).toBe('TGCATGCA')
+  })
+
+  test('falls back to queryAssemblyName when refAssemblyName is empty', () => {
+    const result = selectReferenceSequence(alignments, '', 'hg38', 'panTro6')
+    expect(result).toBe('ACGTACGT')
+  })
+
+  test('falls back to queryAssemblyName when refAssemblyName is undefined', () => {
+    const result = selectReferenceSequence(
+      alignments,
+      undefined,
+      'hg38',
+      'panTro6',
+    )
+    expect(result).toBe('ACGTACGT')
+  })
+
+  test('falls back to firstAssemblyNameFound when queryAssemblyName does not match', () => {
+    const result = selectReferenceSequence(
+      alignments,
+      undefined,
+      'galGal6', // not in alignments
+      'hg38',
+    )
+    expect(result).toBe('ACGTACGT')
+  })
+
+  test('falls back to firstAssemblyNameFound when both config values are empty', () => {
+    const result = selectReferenceSequence(alignments, '', '', 'panTro6')
+    expect(result).toBe('GGGGGGGG')
+  })
+
+  test('returns undefined when refAssemblyName does not exist in alignments', () => {
+    const result = selectReferenceSequence(
+      alignments,
+      'nonexistent',
+      undefined,
+      undefined,
+    )
+    expect(result).toBeUndefined()
+  })
+
+  test('returns undefined when no matches and all params undefined', () => {
+    const result = selectReferenceSequence(
+      alignments,
+      undefined,
+      undefined,
+      undefined,
+    )
+    expect(result).toBeUndefined()
+  })
+
+  test('returns undefined for empty alignments object', () => {
+    const result = selectReferenceSequence({}, 'hg38', 'mm10', 'panTro6')
+    expect(result).toBeUndefined()
+  })
+
+  test('skips refAssemblyName when it does not exist and uses queryAssemblyName', () => {
+    const result = selectReferenceSequence(
+      alignments,
+      'galGal6', // not in alignments
+      'hg38',
+      'panTro6',
+    )
+    expect(result).toBe('ACGTACGT')
+  })
+
+  test('skips both refAssemblyName and queryAssemblyName when neither exists', () => {
+    const result = selectReferenceSequence(
+      alignments,
+      'galGal6', // not in alignments
+      'rn6', // not in alignments
+      'mm10',
+    )
+    expect(result).toBe('TGCATGCA')
+  })
+})
+
+describe('assembly name lookup integration scenarios', () => {
+  test('refAssemblyName config takes precedence over query.assemblyName', () => {
+    const alignments = {
+      hg38: { seq: 'REFERENCE_SEQ' },
+      mm10: { seq: 'QUERY_SEQ' },
+    }
+    const result = selectReferenceSequence(alignments, 'hg38', 'mm10', 'mm10')
+    expect(result).toBe('REFERENCE_SEQ')
+  })
+
+  test('query.assemblyName works when refAssemblyName not configured', () => {
+    const alignments = {
+      hg38: { seq: 'QUERY_SEQ' },
+      mm10: { seq: 'OTHER_SEQ' },
+    }
+    const result = selectReferenceSequence(alignments, '', 'hg38', 'mm10')
+    expect(result).toBe('QUERY_SEQ')
+  })
+
+  test('firstAssemblyNameFound is used as last resort fallback', () => {
+    const alignments = {
+      panTro6: { seq: 'FIRST_FOUND' },
+      mm10: { seq: 'OTHER_SEQ' },
+    }
+    // When query assemblyName does not match any alignment
+    const result = selectReferenceSequence(alignments, '', 'hg38', 'panTro6')
+    expect(result).toBe('FIRST_FOUND')
+  })
+})
+
+describe('real-world MAF format parsing', () => {
+  test('ce10.chrI from UCSC 7-way alignment', () => {
+    const result = parseAssemblyAndChr('ce10.chrI')
+    expect(result).toEqual({
+      assemblyName: 'ce10',
+      chr: 'chrI',
+    })
+  })
+
+  test('caePb3.Scfld02_18 scaffold format', () => {
+    const result = parseAssemblyAndChr('caePb3.Scfld02_18')
+    expect(result).toEqual({
+      assemblyName: 'caePb3',
+      chr: 'Scfld02_18',
+    })
+  })
+
+  test('caeRem4.Crem_Contig16 contig format', () => {
+    const result = parseAssemblyAndChr('caeRem4.Crem_Contig16')
+    expect(result).toEqual({
+      assemblyName: 'caeRem4',
+      chr: 'Crem_Contig16',
+    })
+  })
+
+  test('cb4.chrI C. briggsae format', () => {
+    const result = parseAssemblyAndChr('cb4.chrI')
+    expect(result).toEqual({
+      assemblyName: 'cb4',
+      chr: 'chrI',
+    })
+  })
+
+  test('multiple assemblies from same MAF block produce correct lookup', () => {
+    const alignments = {
+      ce10: { seq: 'TCTTTTAGTATTTGTAA' },
+      caePb3: { seq: 'tcTTTTCGC-TTTATAA' },
+    }
+
+    // When querying with ce10 assembly
+    expect(selectReferenceSequence(alignments, '', 'ce10', 'ce10')).toBe(
+      'TCTTTTAGTATTTGTAA',
+    )
+
+    // When refAssemblyName is configured to override
+    expect(selectReferenceSequence(alignments, 'caePb3', 'ce10', 'ce10')).toBe(
+      'tcTTTTCGC-TTTATAA',
+    )
+  })
+})
+
+describe('refName renaming compatibility', () => {
+  test('parseAssemblyAndChr extracts chr correctly for refName alias matching', () => {
+    // When a file uses "chrI" but assembly has alias "I" -> "chrI"
+    // The chr portion extracted here should match what renameRegionsIfNeeded expects
+    const { chr } = parseAssemblyAndChr('ce10.chrI')
+    expect(chr).toBe('chrI')
+  })
+
+  test('parseAssemblyAndChrSimple extracts chr correctly for refName alias matching', () => {
+    const { chr } = parseAssemblyAndChrSimple('ce10.chrI')
+    expect(chr).toBe('chrI')
+  })
+
+  test('assembly name is isolated from chr for assembly-based lookups', () => {
+    // The assembly name (e.g., "ce10") is used to look up reference sequence
+    // It should not include the chr portion
+    const { assemblyName } = parseAssemblyAndChr('ce10.chrI')
+    expect(assemblyName).toBe('ce10')
+  })
+})