@jbrowse/plugin-variants 2.5.0 → 2.6.2

package/src/VcfFeature/index.test.ts

@@ -1,132 +0,0 @@
-import VcfParser from '@gmod/vcf'
-import VcfFeature from './index'
-
-test('test usage of the VcfFeature', () => {
-  const parser = new VcfParser({
-    header: `#CHROM\tPOS\tID\tREF\tALT\tQUAL\tFILTER\tINFO\tFORMAT\tBAMs/caudaus.sorted.sam`,
-  })
-  const line = `lcl|Scaffald_1\t80465\trs118266897\tR\tA\t29\tPASS\tNS=3;0,14;AF=0.5;DB;112;PG2.1`
-
-  const variant = parser.parseLine(line)
-
-  const f = new VcfFeature({
-    parser,
-    variant,
-    id: 'myuniqueid',
-  })
-  expect(f.id()).toEqual('myuniqueid')
-  expect(f.get('name')).toEqual('rs118266897')
-})
-
-test('try INS feature with END less than start', () => {
-  const parser = new VcfParser({
-    header: `#CHROM\tPOS\tID\tREF\tALT\tQUAL\tFILTER\tINFO\tFORMAT\tBAMs/caudaus.sorted.sam`,
-  })
-  const line = `chr1\t100\trs123\tR\tA\t29\tPASS\tEND=1;SVTYPE=INS`
-
-  const variant = parser.parseLine(line)
-
-  const f = new VcfFeature({
-    parser,
-    variant,
-    id: 'myuniqueid',
-  })
-  expect(f.id()).toEqual('myuniqueid')
-  expect(f.get('start')).toEqual(99)
-  expect(f.get('end')).toEqual(100)
-})
-
-test('try DEL feature with END info field valid', () => {
-  const parser = new VcfParser({
-    header: `#CHROM\tPOS\tID\tREF\tALT\tQUAL\tFILTER\tINFO\tFORMAT\tBAMs/caudaus.sorted.sam`,
-  })
-  const line = `chr1\t100\trs123\tR\t<DEL>\t29\tPASS\tEND=1000;SVTYPE=DEL`
-
-  const variant = parser.parseLine(line)
-
-  const f = new VcfFeature({
-    parser,
-    variant,
-    id: 'myuniqueid',
-  })
-  expect(f.id()).toEqual('myuniqueid')
-  expect(f.get('start')).toEqual(99)
-  expect(f.get('end')).toEqual(1000)
-})
-
-test('multiple SVs', () => {
-  const parser = new VcfParser({
-    header: `#CHROM\tPOS\tID\tREF\tALT\tQUAL\tFILTER\tINFO\tFORMAT\tBAMs/caudaus.sorted.sam`,
-  })
-  const line = `chr1\t100\trs123\tR\t<INVDUP>,<INV>\t29\tPASS\tEND=1000;SVTYPE=DEL`
-
-  const variant = parser.parseLine(line)
-
-  const f = new VcfFeature({
-    parser,
-    variant,
-    id: 'myuniqueid',
-  })
-  expect(f.get('description')).toEqual('<INVDUP>,<INV>')
-})
-test('BND', () => {
-  const parser = new VcfParser({
-    header: `#CHROM\tPOS\tID\tREF\tALT\tQUAL\tFILTER\tINFO\tFORMAT\tBAMs/caudaus.sorted.sam`,
-  })
-  const line = `chr1\t100\trs123\tR\tG[ctgA:34200[\t29\tPASS\tEND=1000;SVTYPE=BND`
-
-  const variant = parser.parseLine(line)
-
-  const f = new VcfFeature({
-    parser,
-    variant,
-    id: 'myuniqueid',
-  })
-  expect(f.get('description')).toEqual('G[ctgA:34200[')
-})
-test('multiple BND', () => {
-  const parser = new VcfParser({
-    header: `#CHROM\tPOS\tID\tREF\tALT\tQUAL\tFILTER\tINFO\tFORMAT\tBAMs/caudaus.sorted.sam`,
-  })
-  const line = `chr1\t100\trs123\tR\tG[ctgA:34200[,G[ctgA:44200[\t29\tPASS\tEND=1000;SVTYPE=BND`
-
-  const variant = parser.parseLine(line)
-
-  const f = new VcfFeature({
-    parser,
-    variant,
-    id: 'myuniqueid',
-  })
-  expect(f.get('description')).toEqual('G[ctgA:34200[,G[ctgA:44200[')
-})
-test('multiple SNV', () => {
-  const parser = new VcfParser({
-    header: `#CHROM\tPOS\tID\tREF\tALT\tQUAL\tFILTER\tINFO\tFORMAT\tBAMs/caudaus.sorted.sam`,
-  })
-  const line = `chr1\t100\trs123\tG\tA,C\t29\tPASS\tHELLO=world`
-
-  const variant = parser.parseLine(line)
-
-  const f = new VcfFeature({
-    parser,
-    variant,
-    id: 'myuniqueid',
-  })
-  expect(f.get('description')).toEqual('SNV G -> A,C')
-})
-
-test('multiple SNV2', () => {
-  const parser = new VcfParser({
-    header: `#CHROM\tPOS\tID\tREF\tALT\tQUAL\tFILTER\tINFO\tFORMAT\tBAMs/caudaus.sorted.sam`,
-  })
-  const line = `chr1\t100\trs123\tG\tAT,<*>\t29\tPASS\tHELLO=world`
-
-  const variant = parser.parseLine(line)
-
-  const f = new VcfFeature({
-    parser,
-    variant,
-    id: 'myuniqueid',
-  })
-  expect(f.get('description')).toEqual('insertion G -> AT,<*>')
-})

package/src/VcfFeature/index.ts

@@ -1,104 +0,0 @@
-import { Feature } from '@jbrowse/core/util'
-import VCF from '@gmod/vcf'
-
-// locals
-import { getSOTermAndDescription } from './util'
-
-/* eslint-disable no-underscore-dangle */
-
-interface Samples {
-  [key: string]: {
-    [key: string]: { values: string[] | number[] | null }
-  }
-}
-
-interface FeatureData {
-  [key: string]: unknown
-  refName: string
-  start: number
-  end: number
-  description?: string
-  type?: string
-  name?: string
-  aliases?: string[]
-  samples?: Samples
-}
-
-export default class VCFFeature implements Feature {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  private variant: any
-
-  private parser: VCF
-
-  private data: FeatureData
-
-  private _id: string
-
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  constructor(args: { variant: any; parser: VCF; id: string }) {
-    this.variant = args.variant
-    this.parser = args.parser
-    this.data = this.dataFromVariant(this.variant)
-    this._id = args.id
-  }
-
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  get(field: string): any {
-    return field === 'samples'
-      ? this.variant.SAMPLES
-      : this.data[field] || this.variant[field]
-  }
-
-  set() {}
-
-  parent() {
-    return undefined
-  }
-
-  children() {
-    return undefined
-  }
-
-  tags() {
-    return [...Object.keys(this.data), ...Object.keys(this.variant), 'samples']
-  }
-
-  id() {
-    return this._id
-  }
-
-  dataFromVariant(variant: {
-    REF: string
-    POS: number
-    ALT: string[]
-    CHROM: string
-    INFO: any // eslint-disable-line @typescript-eslint/no-explicit-any
-    ID: string[]
-  }): FeatureData {
-    const { REF, ALT, POS, CHROM, INFO, ID } = variant
-    const start = POS - 1
-    const [type, description] = getSOTermAndDescription(REF, ALT, this.parser)
-    const isTRA = ALT?.some(f => f === '<TRA>')
-    const isSymbolic = ALT?.some(f => f.includes('<'))
-
-    return {
-      refName: CHROM,
-      start,
-      end: isSymbolic && INFO.END && !isTRA ? +INFO.END[0] : start + REF.length,
-      description,
-      type,
-      name: ID?.join(','),
-      aliases: ID && ID.length > 1 ? variant.ID.slice(1) : undefined,
-    }
-  }
-
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  toJSON(): any {
-    return {
-      uniqueId: this._id,
-      ...this.variant,
-      ...this.data,
-      samples: this.variant.SAMPLES,
-    }
-  }
-}

package/src/VcfFeature/util.ts

@@ -1,138 +0,0 @@
-import VCF, { parseBreakend } from '@gmod/vcf'
-
-const altTypeToSO: { [key: string]: string | undefined } = {
-  DEL: 'deletion',
-  INS: 'insertion',
-  DUP: 'duplication',
-  INV: 'inversion',
-  INVDUP: 'inverted duplication',
-  CNV: 'copy_number_variation',
-  TRA: 'translocation',
-  'DUP:TANDEM': 'tandem_duplication',
-  NON_REF: 'sequence_variant',
-  '*': 'sequence_variant',
-}
-
-/**
- * Get a sequence ontology (SO) term that describes the variant type
- */
-export function getSOTermAndDescription(
-  ref: string,
-  alt: string[],
-  parser: VCF,
-): string[] {
-  // it's just a remark if there are no alternate alleles
-  if (!alt || alt.length === 0) {
-    return ['remark', 'no alternative alleles']
-  }
-
-  const soTerms = new Set<string>()
-  let descriptions = new Set<string>()
-  alt.forEach(a => {
-    let [soTerm, description] = getSOAndDescFromAltDefs(ref, a, parser)
-    if (!soTerm) {
-      ;[soTerm, description] = getSOAndDescByExamination(ref, a)
-    }
-    if (soTerm && description) {
-      soTerms.add(soTerm)
-      descriptions.add(description)
-    }
-  })
-
-  // Combine descriptions like ["SNV G -> A", "SNV G -> T"] to ["SNV G -> A,T"]
-  if (descriptions.size > 1) {
-    const descs = [...descriptions]
-    const prefixes = new Set(
-      descs.map(desc => {
-        const prefix = desc.split('->')
-        return prefix[1] ? prefix[0] : desc
-      }),
-    )
-
-    descriptions = new Set(
-      [...prefixes].map(prefix => {
-        const suffixes = descs
-          .map(desc => {
-            const pref = desc.split('-> ')
-            return pref[1] && pref[0] === prefix ? pref[1] : ''
-          })
-          .filter(f => !!f)
-
-        return suffixes.length ? prefix + '-> ' + suffixes.join(',') : prefix
-      }),
-    )
-  }
-  if (soTerms.size) {
-    return [[...soTerms].join(','), [...descriptions].join(',')]
-  }
-  return []
-}
-
-export function getSOAndDescFromAltDefs(
-  ref: string,
-  alt: string,
-  parser: VCF,
-): string[] {
-  if (typeof alt === 'string' && !alt.startsWith('<')) {
-    return []
-  }
-
-  // look for a definition with an SO type for this
-  let soTerm = altTypeToSO[alt]
-  // if no SO term but ALT is in metadata, assume sequence_variant
-  if (!soTerm && parser.getMetadata('ALT', alt)) {
-    soTerm = 'sequence_variant'
-  }
-  if (soTerm) {
-    return [soTerm, alt]
-  }
-
-  // try to look for a definition for a parent term if we can
-  const modAlt = alt.split(':')
-  if (modAlt.length > 1) {
-    return getSOAndDescFromAltDefs(
-      ref,
-      `<${modAlt.slice(0, -1).join(':')}>`,
-      parser,
-    )
-  }
-
-  // no parent
-  return []
-}
-
-// note: term SNV is used instead of SNP because SO definition of SNP says
-// abundance must be at least 1% in population, and can't be sure we meet
-// that
-export function getSOAndDescByExamination(ref: string, alt: string) {
-  const bnd = parseBreakend(alt)
-  if (bnd) {
-    return ['breakend', alt]
-  } else if (ref.length === 1 && alt.length === 1) {
-    return ['SNV', makeDescriptionString('SNV', ref, alt)]
-  } else if (alt === '<INS>') {
-    return ['insertion', alt]
-  } else if (alt === '<DEL>') {
-    return ['deletion', alt]
-  } else if (alt === '<INV>') {
-    return ['deletion', alt]
-  } else if (alt === '<TRA>') {
-    return ['translocation', alt]
-  } else if (alt.includes('<')) {
-    return ['sv', alt]
-  } else if (ref.length === alt.length) {
-    return ref.split('').reverse().join('') === alt
-      ? ['inversion', makeDescriptionString('inversion', ref, alt)]
-      : ['substitution', makeDescriptionString('substitution', ref, alt)]
-  } else if (ref.length <= alt.length) {
-    return ['insertion', makeDescriptionString('insertion', ref, alt)]
-  } else if (ref.length > alt.length) {
-    return ['deletion', makeDescriptionString('deletion', ref, alt)]
-  }
-
-  return ['indel', makeDescriptionString('indel', ref, alt)]
-}
-
-function makeDescriptionString(soTerm: string, ref: string, alt: string) {
-  return `${soTerm} ${ref} -> ${alt}`
-}

package/src/VcfTabixAdapter/VcfTabixAdapter.test.ts

@@ -1,69 +0,0 @@
-import { toArray } from 'rxjs/operators'
-import { firstValueFrom } from 'rxjs'
-import Adapter from './VcfTabixAdapter'
-import configSchema from './configSchema'
-
-test('adapter can fetch variants from volvox.vcf.gz', async () => {
-  const adapter = new Adapter(
-    configSchema.create({
-      vcfGzLocation: {
-        localPath: require.resolve('./test_data/volvox.filtered.vcf.gz'),
-        locationType: 'LocalPathLocation',
-      },
-      index: {
-        indexType: 'TBI',
-        location: {
-          localPath: require.resolve('./test_data/volvox.filtered.vcf.gz.tbi'),
-          locationType: 'LocalPathLocation',
-        },
-      },
-    }),
-  )
-
-  const csiAdapter = new Adapter(
-    configSchema.create({
-      vcfGzLocation: {
-        localPath: require.resolve('./test_data/volvox.filtered.vcf.gz'),
-        locationType: 'LocalPathLocation',
-      },
-      index: {
-        indexType: 'CSI',
-        location: {
-          localPath: require.resolve('./test_data/volvox.filtered.vcf.gz.csi'),
-          locationType: 'LocalPathLocation',
-        },
-      },
-    }),
-  )
-
-  const csiFeatures = csiAdapter.getFeatures({
-    refName: 'ctgA',
-    start: 0,
-    end: 20000,
-  })
-
-  const names = await adapter.getRefNames()
-  const csiNames = await csiAdapter.getRefNames()
-  expect(names).toEqual(csiNames)
-  expect(names).toMatchSnapshot()
-
-  const feat = adapter.getFeatures({
-    refName: 'ctgA',
-    start: 0,
-    end: 20000,
-  })
-
-  const featArray = await firstValueFrom(feat.pipe(toArray()))
-  const csiFeaturesArray = await firstValueFrom(csiFeatures.pipe(toArray()))
-  expect(featArray.slice(0, 5)).toMatchSnapshot()
-  expect(csiFeaturesArray.slice(0, 5)).toEqual(featArray.slice(0, 5))
-
-  const featNonExist = adapter.getFeatures({
-    refName: 'ctgC',
-    start: 0,
-    end: 20000,
-  })
-
-  const featArrayNonExist = await firstValueFrom(featNonExist.pipe(toArray()))
-  expect(featArrayNonExist).toEqual([])
-})

package/src/VcfTabixAdapter/VcfTabixAdapter.ts

@@ -1,90 +0,0 @@
-import {
-  BaseFeatureDataAdapter,
-  BaseOptions,
-} from '@jbrowse/core/data_adapters/BaseAdapter'
-import { NoAssemblyRegion } from '@jbrowse/core/util/types'
-import { openLocation } from '@jbrowse/core/util/io'
-import { ObservableCreate } from '@jbrowse/core/util/rxjs'
-import { Feature } from '@jbrowse/core/util'
-import { TabixIndexedFile } from '@gmod/tabix'
-import VcfParser from '@gmod/vcf'
-
-// local
-import VcfFeature from '../VcfFeature'
-
-export default class extends BaseFeatureDataAdapter {
-  private configured?: Promise<{
-    vcf: TabixIndexedFile
-    parser: VcfParser
-  }>
-
-  private async configurePre() {
-    const pm = this.pluginManager
-    const vcfGzLocation = this.getConf('vcfGzLocation')
-    const location = this.getConf(['index', 'location'])
-    const indexType = this.getConf(['index', 'indexType'])
-
-    const filehandle = openLocation(vcfGzLocation, pm)
-    const isCSI = indexType === 'CSI'
-    const vcf = new TabixIndexedFile({
-      filehandle,
-      csiFilehandle: isCSI ? openLocation(location, pm) : undefined,
-      tbiFilehandle: !isCSI ? openLocation(location, pm) : undefined,
-      chunkCacheSize: 50 * 2 ** 20,
-      chunkSizeLimit: 1000000000,
-    })
-
-    const header = await vcf.getHeader()
-    return {
-      vcf,
-      parser: new VcfParser({ header }),
-    }
-  }
-
-  protected async configure() {
-    if (!this.configured) {
-      this.configured = this.configurePre().catch(e => {
-        this.configured = undefined
-        throw e
-      })
-    }
-    return this.configured
-  }
-
-  public async getRefNames(opts: BaseOptions = {}) {
-    const { vcf } = await this.configure()
-    return vcf.getReferenceSequenceNames(opts)
-  }
-
-  async getHeader() {
-    const { vcf } = await this.configure()
-    return vcf.getHeader()
-  }
-
-  async getMetadata() {
-    const { parser } = await this.configure()
-    return parser.getMetadata()
-  }
-
-  public getFeatures(query: NoAssemblyRegion, opts: BaseOptions = {}) {
-    return ObservableCreate<Feature>(async observer => {
-      const { refName, start, end } = query
-      const { vcf, parser } = await this.configure()
-      await vcf.getLines(refName, start, end, {
-        lineCallback: (line, fileOffset) => {
-          observer.next(
-            new VcfFeature({
-              variant: parser.parseLine(line),
-              parser,
-              id: `${this.id}-vcf-${fileOffset}`,
-            }),
-          )
-        },
-        ...opts,
-      })
-      observer.complete()
-    }, opts.signal)
-  }
-
-  public freeResources(/* { region } */): void {}
-}