react-msaview 4.6.0 → 4.8.0

package/src/parsers/ClustalMSA.ts

@@ -1,69 +0,0 @@
-import { parse } from 'clustal-js'
-
-import type { NodeWithIds } from '../types'
-
-export default class ClustalMSA {
-  private MSA: ReturnType<typeof parse>
-
-  constructor(text: string) {
-    this.MSA = parse(text)
-  }
-
-  getMSA() {
-    return this.MSA
-  }
-
-  getRow(name: string): string {
-    return this.MSA.alns.find(aln => aln.id === name)?.seq || ''
-  }
-
-  getWidth() {
-    return this.MSA.alns[0]!.seq.length
-  }
-
-  getRowData() {
-    return undefined
-  }
-
-  getHeader() {
-    return this.MSA.header
-  }
-
-  getNames() {
-    return this.MSA.alns.map(aln => aln.id)
-  }
-
-  getStructures() {
-    return {}
-  }
-
-  get alignmentNames() {
-    return []
-  }
-
-  getTree(): NodeWithIds {
-    return {
-      id: 'root',
-      name: 'root',
-      noTree: true,
-      children: this.getNames()
-        .filter((name): name is string => name !== undefined)
-        .map(name => ({
-          id: name,
-          name,
-          children: [],
-        })),
-    }
-  }
-
-  get seqConsensus() {
-    return this.MSA.consensus
-  }
-  get secondaryStructureConsensus() {
-    return undefined
-  }
-
-  get tracks() {
-    return []
-  }
-}

package/src/parsers/EmfMSA.ts

@@ -1,67 +0,0 @@
-import { parseEmfAln } from 'emf-js'
-
-import type { NodeWithIds } from '../types'
-
-export default class EmfMSA {
-  private MSA: ReturnType<typeof parseEmfAln>
-
-  constructor(text: string) {
-    this.MSA = parseEmfAln(text)
-  }
-
-  getMSA() {
-    return this.MSA
-  }
-
-  getRow(name: string): string {
-    return this.MSA.find(aln => aln.protein === name)?.seq || ''
-  }
-
-  getWidth() {
-    return this.MSA[0]!.seq.length
-  }
-
-  getRowData() {
-    return undefined
-  }
-
-  getHeader() {
-    return ''
-  }
-
-  getNames() {
-    return this.MSA.map(aln => aln.protein)
-  }
-
-  getStructures() {
-    return {}
-  }
-
-  get alignmentNames() {
-    return []
-  }
-
-  getTree(): NodeWithIds {
-    return {
-      id: 'root',
-      name: 'root',
-      noTree: true,
-      children: this.getNames().map(name => ({
-        id: name,
-        name,
-        children: [],
-      })),
-    }
-  }
-
-  get seqConsensus() {
-    return undefined
-  }
-  get secondaryStructureConsensus() {
-    return undefined
-  }
-
-  get tracks() {
-    return []
-  }
-}

package/src/parsers/EmfTree.ts

@@ -1,9 +0,0 @@
-import { parseEmfTree } from 'emf-js'
-
-export default class EmfTree {
-  data: ReturnType<typeof parseEmfTree>
-
-  constructor(text: string) {
-    this.data = parseEmfTree(text)
-  }
-}

package/src/parsers/FastaMSA.ts

@@ -1,82 +0,0 @@
-import type { NodeWithIds } from '../types'
-
-export default class FastaMSA {
-  private MSA: { seqdata: Record<string, string> }
-
-  constructor(text: string) {
-    const seqdata: Record<string, string> = {}
-    for (const entry of text.split('>')) {
-      if (!/\S/.test(entry)) {
-        continue
-      }
-      const newlineIdx = entry.indexOf('\n')
-      if (newlineIdx === -1) {
-        continue
-      }
-      const defLine = entry.slice(0, newlineIdx)
-      const spaceIdx = defLine.indexOf(' ')
-      const id = spaceIdx === -1 ? defLine : defLine.slice(0, spaceIdx)
-      if (id) {
-        seqdata[id] = entry.slice(newlineIdx + 1).replaceAll(/\s/g, '')
-      }
-    }
-    this.MSA = { seqdata }
-  }
-
-  getMSA() {
-    return this.MSA
-  }
-
-  getRowData() {
-    return undefined
-  }
-
-  getNames() {
-    return Object.keys(this.MSA.seqdata)
-  }
-
-  getRow(name: string) {
-    return this.MSA.seqdata[name] || ''
-  }
-
-  getWidth() {
-    const name = Object.keys(this.MSA.seqdata)[0]!
-    return this.getRow(name).length
-  }
-
-  getStructures() {
-    return {}
-  }
-
-  get alignmentNames() {
-    return []
-  }
-
-  getHeader() {
-    return {}
-  }
-
-  getTree(): NodeWithIds {
-    return {
-      id: 'root',
-      name: 'root',
-      noTree: true,
-      children: this.getNames().map(name => ({
-        id: name,
-        children: [],
-        name,
-      })),
-    }
-  }
-
-  get seqConsensus() {
-    return undefined
-  }
-  get secondaryStructureConsensus() {
-    return undefined
-  }
-
-  get tracks() {
-    return []
-  }
-}

package/src/parsers/StockholmMSA.ts

@@ -1,140 +0,0 @@
-import Stockholm from 'stockholm-js'
-
-import parseNewick from '../parseNewick'
-import { generateNodeIds } from '../util'
-
-import type { NodeWithIds } from '../types'
-
-interface StockholmEntry {
-  gf: {
-    DE?: string[]
-    NH?: string[]
-  }
-  gs?: {
-    AC: Record<string, string>
-    DR?: Record<string, string>
-  }
-  gc?: {
-    SS_cons?: string
-    seq_cons?: string
-  }
-  seqdata: Record<string, string>
-}
-
-export default class StockholmMSA {
-  private data: StockholmEntry[]
-  private MSA: StockholmEntry
-
-  constructor(text: string, currentAlignment: number) {
-    const res = Stockholm.parseAll(text)
-    this.data = res
-    this.MSA = res[currentAlignment]
-  }
-
-  getMSA() {
-    return this.MSA
-  }
-
-  getRow(name: string) {
-    return this.MSA.seqdata[name] || ''
-  }
-
-  getWidth() {
-    const name = Object.keys(this.MSA.seqdata)[0]!
-    return this.getRow(name).length
-  }
-
-  get alignmentNames() {
-    return this.data.map((aln, idx) => aln.gf.DE?.[0] || `Alignment ${idx + 1}`)
-  }
-
-  getHeader() {
-    return {
-      General: this.MSA.gf,
-      Accessions: this.MSA.gs?.AC,
-      Dbxref: this.MSA.gs?.DR,
-    }
-  }
-
-  getRowData(rowName: string) {
-    return {
-      name: rowName,
-      accession: this.MSA.gs?.AC[rowName],
-      dbxref: this.MSA.gs?.DR?.[rowName],
-    }
-  }
-
-  getNames() {
-    return Object.keys(this.MSA.seqdata)
-  }
-
-  getSeqCoords() {}
-
-  getStructures() {
-    const pdbRegex = /PDB; +(\S+) +(\S); ([0-9]+)-([0-9]+)/
-    const ent = this.MSA
-    const args = Object.entries(ent.gs?.DR || {})
-      .map(([id, dr]) => [id, pdbRegex.exec(dr)] as const)
-      .filter((item): item is [string, RegExpExecArray] => !!item[1])
-      .map(([id, match]) => {
-        const pdb = match[1]!.toLowerCase()
-        const chain = match[2]!
-        const startPos = +match[3]!
-        const endPos = +match[4]!
-        return { id, pdb, chain, startPos, endPos }
-      })
-
-    const ret = {} as Record<string, Omit<(typeof args)[0], 'id'>[]>
-    for (const entry of args) {
-      const { id, ...rest } = entry
-      if (!ret[id]) {
-        ret[id] = []
-      }
-      ret[id].push(rest)
-    }
-    return ret
-  }
-
-  getTree(): NodeWithIds {
-    const tree = this.MSA.gf.NH?.[0]
-    return tree
-      ? generateNodeIds(parseNewick(tree))
-      : {
-          id: 'root',
-          name: 'root',
-          noTree: true,
-          children: this.getNames().map(name => ({
-            id: name,
-            children: [],
-            name,
-          })),
-        }
-  }
-
-  get seqConsensus() {
-    return this.MSA.gc?.seq_cons
-  }
-  get secondaryStructureConsensus() {
-    return this.MSA.gc?.SS_cons
-  }
-
-  get tracks() {
-    return [
-      {
-        id: 'seqConsensus',
-        name: 'Sequence consensus',
-        data: this.seqConsensus,
-        customColorScheme: {},
-      },
-      {
-        id: 'secondaryStruct',
-        name: 'Secondary-structure',
-        data: this.secondaryStructureConsensus,
-        customColorScheme: {
-          '>': 'pink',
-          '<': 'lightblue',
-        },
-      },
-    ]
-  }
-}

package/src/seqCoordToRowSpecificGlobalCoord.test.ts

@@ -1,53 +0,0 @@
-import { describe, expect, test } from 'vitest'
-
-import { seqCoordToRowSpecificGlobalCoord } from './seqCoordToRowSpecificGlobalCoord'
-
-describe('seqCoordToRowSpecificGlobalCoord', () => {
-  test('converts sequence coordinate to global coordinate with no gaps', () => {
-    const row = 'ATGCATGC'
-    expect(seqCoordToRowSpecificGlobalCoord({ row, position: 3 })).toBe(3)
-    expect(seqCoordToRowSpecificGlobalCoord({ row, position: 0 })).toBe(0)
-    expect(seqCoordToRowSpecificGlobalCoord({ row, position: 8 })).toBe(8)
-  })
-
-  test('converts sequence coordinate to global coordinate with gaps', () => {
-    const row = 'A-TG-CA-TGC'
-    // A(0) -(1) T(2) G(3) -(4) C(5) A(6) -(7) T(8) G(9) C(10)
-    // Sequence positions: A(0) T(1) G(2) C(3) A(4) T(5) G(6) C(7)
-
-    // Position 0 (first A) -> Global index 0
-    expect(seqCoordToRowSpecificGlobalCoord({ row, position: 0 })).toBe(0)
-
-    // Position 1 (T after first gap) -> Global index 2
-    expect(seqCoordToRowSpecificGlobalCoord({ row, position: 1 })).toBe(2)
-
-    // Position 3 (C after second gap) -> Global index 5
-    expect(seqCoordToRowSpecificGlobalCoord({ row, position: 3 })).toBe(5)
-
-    // Position 5 (T after third gap) -> Global index 8
-    expect(seqCoordToRowSpecificGlobalCoord({ row, position: 5 })).toBe(8)
-
-    // Position 8 (end of sequence) -> Global index 11
-    expect(seqCoordToRowSpecificGlobalCoord({ row, position: 8 })).toBe(11)
-  })
-
-  test('handles empty row', () => {
-    expect(seqCoordToRowSpecificGlobalCoord({ row: '', position: 0 })).toBe(0)
-  })
-
-  test('handles row with only gaps', () => {
-    const row = '---..--'
-    expect(seqCoordToRowSpecificGlobalCoord({ row, position: 0 })).toBe(0)
-  })
-
-  test('handles mixed gap characters', () => {
-    const row = 'A-.G-C.'
-    // A(0) -(1) .(2) G(3) -(4) C(5) .(6)
-    // Sequence positions: A(0) G(1) C(2)
-
-    expect(seqCoordToRowSpecificGlobalCoord({ row, position: 0 })).toBe(0)
-    expect(seqCoordToRowSpecificGlobalCoord({ row, position: 1 })).toBe(3)
-    expect(seqCoordToRowSpecificGlobalCoord({ row, position: 2 })).toBe(5)
-    expect(seqCoordToRowSpecificGlobalCoord({ row, position: 3 })).toBe(7)
-  })
-})

package/src/seqCoordToRowSpecificGlobalCoord.ts

@@ -1,25 +0,0 @@
-import { isBlank } from './util'
-
-export function seqCoordToRowSpecificGlobalCoord({
-  row,
-  position,
-}: {
-  row: string
-  position: number
-}) {
-  let k = 0
-  let i = 0
-  // Find the position-th non-gap character
-  while (i < row.length) {
-    if (!isBlank(row[i])) {
-      if (k === position) {
-        return i
-      }
-      k++
-    }
-    i++
-  }
-  // If position is 0 and we didn't find any non-gap character, return 0
-  // Otherwise return i (which is row.length at this point)
-  return position === 0 ? 0 : i
-}