jbrowse-plugin-mafviewer 1.4.5 → 1.4.6

package/src/MafSequenceWidget/baseColors.ts

@@ -0,0 +1,76 @@
+import type { Theme } from '@mui/material'
+
+interface BasePalette {
+  A: { main: string; contrastText: string }
+  C: { main: string; contrastText: string }
+  G: { main: string; contrastText: string }
+  T: { main: string; contrastText: string }
+}
+
+function getBases(theme: Theme): BasePalette | undefined {
+  return (theme.palette as any).bases as BasePalette | undefined
+}
+
+export function getBaseColor(base: string, theme: Theme): string {
+  const bases = getBases(theme)
+  if (!bases) {
+    switch (base.toUpperCase()) {
+      case 'A':
+        return '#6dbf6d'
+      case 'C':
+        return '#6c6cff'
+      case 'G':
+        return '#ffb347'
+      case 'T':
+      case 'U':
+        return '#ff6b6b'
+      default:
+        return theme.palette.grey[500]
+    }
+  }
+
+  switch (base.toUpperCase()) {
+    case 'A':
+      return bases.A.main
+    case 'C':
+      return bases.C.main
+    case 'G':
+      return bases.G.main
+    case 'T':
+    case 'U':
+      return bases.T.main
+    default:
+      return theme.palette.grey[500]
+  }
+}
+
+export function getContrastText(base: string, theme: Theme): string {
+  const bases = getBases(theme)
+  if (!bases) {
+    switch (base.toUpperCase()) {
+      case 'A':
+      case 'C':
+      case 'T':
+      case 'U':
+        return '#fff'
+      case 'G':
+        return '#000'
+      default:
+        return theme.palette.common.white
+    }
+  }
+
+  switch (base.toUpperCase()) {
+    case 'A':
+      return bases.A.contrastText
+    case 'C':
+      return bases.C.contrastText
+    case 'G':
+      return bases.G.contrastText
+    case 'T':
+    case 'U':
+      return bases.T.contrastText
+    default:
+      return theme.palette.common.white
+  }
+}

package/src/MafSequenceWidget/colToGenomePos.test.ts

@@ -0,0 +1,166 @@
+import { describe, expect, test } from 'vitest'
+
+import { buildColToGenomePos, findRefSampleIndex } from './colToGenomePos'
+
+describe('findRefSampleIndex', () => {
+  const samples = [
+    { id: 'mm10', label: 'Mouse' },
+    { id: 'hg38', label: 'Human' },
+    { id: 'panTro6', label: 'Chimp' },
+  ]
+
+  test('returns index of sample matching assemblyName', () => {
+    expect(findRefSampleIndex(samples, 'hg38')).toBe(1)
+    expect(findRefSampleIndex(samples, 'mm10')).toBe(0)
+    expect(findRefSampleIndex(samples, 'panTro6')).toBe(2)
+  })
+
+  test('returns 0 when no match found', () => {
+    expect(findRefSampleIndex(samples, 'galGal6')).toBe(0)
+  })
+
+  test('returns 0 when samples is undefined', () => {
+    expect(findRefSampleIndex(undefined, 'hg38')).toBe(0)
+  })
+
+  test('returns 0 when assemblyName is undefined', () => {
+    expect(findRefSampleIndex(samples, undefined)).toBe(0)
+  })
+
+  test('returns 0 when both are undefined', () => {
+    expect(findRefSampleIndex(undefined, undefined)).toBe(0)
+  })
+
+  test('returns 0 for empty samples array', () => {
+    expect(findRefSampleIndex([], 'hg38')).toBe(0)
+  })
+})
+
+describe('buildColToGenomePos', () => {
+  test('maps non-gap characters to sequential genomic positions', () => {
+    const result = buildColToGenomePos('ACGT', 100)
+    expect(result).toEqual([100, 101, 102, 103])
+  })
+
+  test('maps gaps to undefined', () => {
+    const result = buildColToGenomePos('AC-GT', 100)
+    expect(result).toEqual([100, 101, undefined, 102, 103])
+  })
+
+  test('handles multiple consecutive gaps', () => {
+    const result = buildColToGenomePos('A--G', 100)
+    expect(result).toEqual([100, undefined, undefined, 101])
+  })
+
+  test('handles gaps at start', () => {
+    const result = buildColToGenomePos('--ACG', 100)
+    expect(result).toEqual([undefined, undefined, 100, 101, 102])
+  })
+
+  test('handles gaps at end', () => {
+    const result = buildColToGenomePos('ACG--', 100)
+    expect(result).toEqual([100, 101, 102, undefined, undefined])
+  })
+
+  test('handles all gaps', () => {
+    const result = buildColToGenomePos('----', 100)
+    expect(result).toEqual([undefined, undefined, undefined, undefined])
+  })
+
+  test('handles empty sequence', () => {
+    const result = buildColToGenomePos('', 100)
+    expect(result).toEqual([])
+  })
+
+  test('works with different start positions', () => {
+    const result = buildColToGenomePos('AC-T', 50000)
+    expect(result).toEqual([50000, 50001, undefined, 50002])
+  })
+})
+
+describe('integration: hover highlight with gaps', () => {
+  const samples = [
+    { id: 'mm10', label: 'Mouse' },
+    { id: 'hg38', label: 'Human' },
+    { id: 'panTro6', label: 'Chimp' },
+  ]
+
+  test('gap in non-reference sample does not affect mapping', () => {
+    // Reference is hg38 (index 1)
+    // mm10 (index 0) has a gap, but hg38 does not
+    const sequences = [
+      'A-GT', // mm10 - has gap at position 1
+      'ACGT', // hg38 - no gap (this is the reference)
+      'ACGT', // panTro6
+    ]
+
+    const refIdx = findRefSampleIndex(samples, 'hg38')
+    expect(refIdx).toBe(1)
+
+    const mapping = buildColToGenomePos(sequences[refIdx]!, 100)
+    // All positions should map to genomic coordinates since reference has no gaps
+    expect(mapping).toEqual([100, 101, 102, 103])
+  })
+
+  test('gap in reference sample maps to undefined', () => {
+    // Reference is hg38 (index 1)
+    // hg38 has a gap (insertion in other species)
+    const sequences = [
+      'ACGT', // mm10
+      'A-GT', // hg38 - has gap (this is the reference)
+      'ATGT', // panTro6 - has T where hg38 has gap
+    ]
+
+    const refIdx = findRefSampleIndex(samples, 'hg38')
+    const mapping = buildColToGenomePos(sequences[refIdx]!, 100)
+    // Position 1 should be undefined because reference has gap there
+    expect(mapping).toEqual([100, undefined, 101, 102])
+  })
+
+  test('correctly handles reference as first sample', () => {
+    // Reference is mm10 (index 0)
+    const sequences = [
+      'ACGT', // mm10 - reference
+      'A-GT', // hg38 - has gap
+      'ACGT', // panTro6
+    ]
+
+    const refIdx = findRefSampleIndex(samples, 'mm10')
+    expect(refIdx).toBe(0)
+
+    const mapping = buildColToGenomePos(sequences[refIdx]!, 100)
+    // All positions map because reference (mm10) has no gaps
+    expect(mapping).toEqual([100, 101, 102, 103])
+  })
+
+  test('correctly handles reference as last sample', () => {
+    // Reference is panTro6 (index 2)
+    const sequences = [
+      'A-GT', // mm10 - has gap
+      'A-GT', // hg38 - has gap
+      'ACGT', // panTro6 - no gap (this is the reference)
+    ]
+
+    const refIdx = findRefSampleIndex(samples, 'panTro6')
+    expect(refIdx).toBe(2)
+
+    const mapping = buildColToGenomePos(sequences[refIdx]!, 100)
+    // All positions map because reference (panTro6) has no gaps
+    expect(mapping).toEqual([100, 101, 102, 103])
+  })
+
+  test('falls back to first sample when assembly not found', () => {
+    // Reference is galGal6 which doesn't exist in samples
+    const sequences = [
+      'ACGT', // mm10
+      'A-GT', // hg38
+      'ACGT', // panTro6
+    ]
+
+    const refIdx = findRefSampleIndex(samples, 'galGal6')
+    expect(refIdx).toBe(0) // Falls back to first sample
+
+    const mapping = buildColToGenomePos(sequences[refIdx]!, 100)
+    expect(mapping).toEqual([100, 101, 102, 103])
+  })
+})

package/src/MafSequenceWidget/colToGenomePos.ts

@@ -0,0 +1,40 @@
+import type { Sample } from '../LinearMafDisplay/types'
+
+/**
+ * Find the index of the reference sample (matching the assembly name from the region)
+ * Falls back to 0 if no match is found
+ */
+export function findRefSampleIndex(
+  samples: Sample[] | undefined,
+  assemblyName: string | undefined,
+): number {
+  if (!samples || !assemblyName) {
+    return 0
+  }
+  const idx = samples.findIndex(s => s.id === assemblyName)
+  return idx === -1 ? 0 : idx
+}
+
+/**
+ * Build a mapping from display column index to genomic position.
+ * Only the reference sequence determines genomic positions - gaps in the
+ * reference map to undefined (no genomic position), while gaps in other
+ * samples don't affect the mapping.
+ */
+export function buildColToGenomePos(
+  refSequence: string,
+  regionStart: number,
+): (number | undefined)[] {
+  const mapping: (number | undefined)[] = []
+  let genomePos = regionStart
+
+  for (const char of refSequence) {
+    if (char === '-') {
+      mapping.push(undefined)
+    } else {
+      mapping.push(genomePos)
+      genomePos++
+    }
+  }
+  return mapping
+}

package/src/MafSequenceWidget/configSchema.ts

@@ -0,0 +1,3 @@
+import { ConfigurationSchema } from '@jbrowse/core/configuration'
+
+export const configSchema = ConfigurationSchema('MafSequenceWidget', {})

package/src/MafSequenceWidget/constants.ts

@@ -0,0 +1,4 @@
+export const CHAR_WIDTH = 12
+export const ROW_HEIGHT = 16
+export const FONT = 'bold 12px monospace'
+export const LABEL_PADDING = 10

package/src/MafSequenceWidget/index.ts

@@ -0,0 +1,24 @@
+import { lazy } from 'react'
+
+import WidgetType from '@jbrowse/core/pluggableElementTypes/WidgetType'
+
+import MafSequenceHoverHighlightExtensionF from './MafSequenceHoverHighlightExtension'
+import { configSchema } from './configSchema'
+import { stateModelFactory } from './stateModelFactory'
+
+import type PluginManager from '@jbrowse/core/PluginManager'
+
+export default function MafSequenceWidgetF(pluginManager: PluginManager) {
+  pluginManager.addWidgetType(
+    () =>
+      new WidgetType({
+        name: 'MafSequenceWidget',
+        heading: 'MAF Sequence',
+        configSchema: configSchema,
+        stateModel: stateModelFactory(),
+        ReactComponent: lazy(() => import('./MafSequenceWidget')),
+      }),
+  )
+
+  MafSequenceHoverHighlightExtensionF(pluginManager)
+}

package/src/MafSequenceWidget/stateModelFactory.ts

@@ -0,0 +1,43 @@
+import { types } from '@jbrowse/mobx-state-tree'
+
+import type { Sample } from '../LinearMafDisplay/types'
+import type { AnyConfigurationModel } from '@jbrowse/core/configuration'
+import type { Instance } from '@jbrowse/mobx-state-tree'
+
+export interface HoverHighlight {
+  refName: string
+  start: number
+  end: number
+  assemblyName: string
+}
+
+export function stateModelFactory() {
+  return types
+    .model('MafSequenceWidget', {
+      id: types.identifier,
+      type: types.literal('MafSequenceWidget'),
+      adapterConfig: types.frozen<AnyConfigurationModel | undefined>(undefined),
+      samples: types.frozen<Sample[] | undefined>(undefined),
+      regions: types.frozen<
+        | {
+            refName: string
+            start: number
+            end: number
+            assemblyName: string
+          }[]
+        | undefined
+      >(undefined),
+      connectedViewId: types.maybe(types.string),
+    })
+    .volatile(() => ({
+      hoverHighlight: undefined as HoverHighlight | undefined,
+    }))
+    .actions(self => ({
+      setHoverHighlight(highlight: HoverHighlight | undefined) {
+        self.hoverHighlight = highlight
+      },
+    }))
+}
+
+export type MafSequenceWidgetStateModel = ReturnType<typeof stateModelFactory>
+export type MafSequenceWidgetModel = Instance<MafSequenceWidgetStateModel>

package/src/MafTabixAdapter/MafTabixAdapter.ts

@@ -10,11 +10,15 @@ import {
 } from '@jbrowse/core/util'
 import { openLocation } from '@jbrowse/core/util/io'
 import { ObservableCreate } from '@jbrowse/core/util/rxjs'
-import { getSnapshot } from 'mobx-state-tree'
+import { getSnapshot } from '@jbrowse/mobx-state-tree'
 import { firstValueFrom, toArray } from 'rxjs'
 
 import parseNewick from '../parseNewick'
 import { normalize } from '../util'
+import {
+  parseAssemblyAndChr,
+  selectReferenceSequence,
+} from '../util/parseAssemblyName'
 
 interface OrganismRecord {
   chr: string
@@ -107,53 +111,7 @@ export default class MafTabixAdapter extends BaseFeatureDataAdapter {
               continue
             }
 
-            // Optimized assembly name parsing with simplified logic
-            let assemblyName: string
-            let chr: string
-
-            const firstDotIndex = assemblyAndChr.indexOf('.')
-            if (firstDotIndex === -1) {
-              // No dot found, entire string is assembly name
-              assemblyName = assemblyAndChr
-              chr = ''
-            } else {
-              const secondDotIndex = assemblyAndChr.indexOf(
-                '.',
-                firstDotIndex + 1,
-              )
-              if (secondDotIndex === -1) {
-                // Only one dot: assembly.chr
-                assemblyName = assemblyAndChr.slice(
-                  0,
-                  Math.max(0, firstDotIndex),
-                )
-                chr = assemblyAndChr.slice(Math.max(0, firstDotIndex + 1))
-              } else {
-                // Multiple dots: check if second part is numeric (version number)
-                const secondPart = assemblyAndChr.slice(
-                  firstDotIndex + 1,
-                  secondDotIndex,
-                )
-                const isNumeric =
-                  secondPart.length > 0 && !Number.isNaN(+secondPart)
-
-                if (isNumeric) {
-                  // assembly.version.chr format
-                  assemblyName = assemblyAndChr.slice(
-                    0,
-                    Math.max(0, secondDotIndex),
-                  )
-                  chr = assemblyAndChr.slice(Math.max(0, secondDotIndex + 1))
-                } else {
-                  // assembly.chr.more format
-                  assemblyName = assemblyAndChr.slice(
-                    0,
-                    Math.max(0, firstDotIndex),
-                  )
-                  chr = assemblyAndChr.slice(Math.max(0, firstDotIndex + 1))
-                }
-              }
-            }
+            const { assemblyName, chr } = parseAssemblyAndChr(assemblyAndChr)
 
             if (assemblyName) {
               // Set first assembly name found (only once)
@@ -183,9 +141,12 @@ export default class MafTabixAdapter extends BaseFeatureDataAdapter {
                 name: feature.get('name'),
                 score: feature.get('score'),
                 alignments,
-                seq:
-                  alignments[refAssemblyName || query.assemblyName]?.seq ||
-                  alignments[firstAssemblyNameFound]?.seq,
+                seq: selectReferenceSequence(
+                  alignments,
+                  refAssemblyName,
+                  query.assemblyName,
+                  firstAssemblyNameFound,
+                ),
               },
             }),
           )

package/src/index.ts

@@ -8,6 +8,7 @@ import LinearMafRendererF from './LinearMafRenderer'
 import MafAddTrackWorkflowF from './MafAddTrackWorkflow'
 import MafGetSamplesF from './MafGetSamples'
 import MafGetSequencesF from './MafGetSequences'
+import MafSequenceWidgetF from './MafSequenceWidget'
 import MafTabixAdapterF from './MafTabixAdapter'
 import MafTrackF from './MafTrack'
 
@@ -24,6 +25,7 @@ export default class MafViewerPlugin extends Plugin {
     MafAddTrackWorkflowF(pluginManager)
     MafGetSequencesF(pluginManager)
     MafGetSamplesF(pluginManager)
+    MafSequenceWidgetF(pluginManager)
   }
 
   configure(_pluginManager: PluginManager) {}

package/src/util/__snapshots__/fastaUtils.test.ts.snap

@@ -7,6 +7,41 @@ exports[`gap in assembly1 1`] = `
 ]
 `;
 
+exports[`includeInsertions - insertions at multiple positions 1`] = `
+[
+  "ATCGGTAC",
+  "A-CG-TAC",
+]
+`;
+
+exports[`includeInsertions - insertions in multiple samples with different lengths 1`] = `
+[
+  "AC-T-GTAC",
+  "ACTTTGTAC",
+]
+`;
+
+exports[`includeInsertions - single insertion in one sample 1`] = `
+[
+  "AC--GTAC",
+  "ACTTGTAC",
+]
+`;
+
+exports[`includeInsertions with no insertions present 1`] = `
+[
+  "ACGTA",
+  "AC-TT",
+]
+`;
+
+exports[`includeInsertions=false ignores insertions 1`] = `
+[
+  "ACGTAC",
+  "ACGTAC",
+]
+`;
+
 exports[`no showAllLetters 1`] = `
 [
   ".....",

package/src/util/clipboard.ts

@@ -0,0 +1,35 @@
+export async function copyToClipboard(
+  text: string,
+  onSuccess?: () => void,
+  onError?: (e: unknown) => void,
+) {
+  try {
+    await navigator.clipboard.writeText(text)
+    onSuccess?.()
+  } catch (e) {
+    console.error(e)
+    onError?.(e)
+  }
+}
+
+export function downloadAsFile(
+  content: string,
+  filename: string,
+  onSuccess?: () => void,
+  onError?: (e: unknown) => void,
+) {
+  try {
+    const url = URL.createObjectURL(new Blob([content], { type: 'text/plain' }))
+    const a = document.createElement('a')
+    a.href = url
+    a.download = filename
+    document.body.append(a)
+    a.click()
+    a.remove()
+    URL.revokeObjectURL(url)
+    onSuccess?.()
+  } catch (e) {
+    console.error(e)
+    onError?.(e)
+  }
+}