@jbrowse/plugin-bed 2.5.0 → 2.6.2

package/src/BedpeAdapter/BedpeAdapter.ts

@@ -1,202 +0,0 @@
-import {
-  BaseFeatureDataAdapter,
-  BaseOptions,
-} from '@jbrowse/core/data_adapters/BaseAdapter'
-import { openLocation } from '@jbrowse/core/util/io'
-import { ObservableCreate } from '@jbrowse/core/util/rxjs'
-import { Region, Feature, SimpleFeature } from '@jbrowse/core/util'
-import IntervalTree from '@flatten-js/interval-tree'
-import { unzip } from '@gmod/bgzf-filehandle'
-
-function isGzip(buf: Buffer) {
-  return buf[0] === 31 && buf[1] === 139 && buf[2] === 8
-}
-
-export function featureData(
-  line: string,
-  uniqueId: string,
-  flip: boolean,
-  names?: string[],
-) {
-  const l = line.split('\t')
-  const ref1 = l[flip ? 3 : 0]
-  const start1 = +l[flip ? 4 : 1]
-  const end1 = +l[flip ? 5 : 2]
-  const ref2 = +l[!flip ? 3 : 0]
-  const start2 = +l[!flip ? 4 : 1]
-  const end2 = +l[!flip ? 5 : 2]
-  const name = l[6]
-  const score = +l[7]
-  const strand1 = parseStrand(l[8])
-  const strand2 = parseStrand(l[9])
-  const extra = l.slice(9)
-  const rest = names
-    ? Object.fromEntries(names.slice(9).map((n, idx) => [n, extra[idx]]))
-    : extra
-
-  return new SimpleFeature({
-    start: start1,
-    end: end1,
-    refName: ref1,
-    strand: strand1,
-    name,
-    ...rest,
-    score,
-    uniqueId,
-    mate: { refName: ref2, start: start2, end: end2, strand: strand2 },
-  })
-}
-
-function parseStrand(strand: string) {
-  if (strand === '+') {
-    return 1
-  } else if (strand === '-') {
-    return -1
-  } else if (strand === '.') {
-    return 0
-  } else {
-    return undefined
-  }
-}
-
-export default class BedpeAdapter extends BaseFeatureDataAdapter {
-  protected bedpeFeatures?: Promise<{
-    header: string
-    feats1: Record<string, string[]>
-    feats2: Record<string, string[]>
-    columnNames: string[]
-  }>
-
-  protected intervalTrees: {
-    [key: string]: Promise<IntervalTree | undefined> | undefined
-  } = {}
-
-  public static capabilities = ['getFeatures', 'getRefNames']
-
-  private async loadDataP(opts: BaseOptions = {}) {
-    const pm = this.pluginManager
-    const bedLoc = this.getConf('bedpeLocation')
-    const buf = await openLocation(bedLoc, pm).readFile(opts)
-    const buffer = isGzip(buf) ? await unzip(buf) : buf
-    // 512MB  max chrome string length is 512MB
-    if (buffer.length > 536_870_888) {
-      throw new Error('Data exceeds maximum string length (512MB)')
-    }
-    const data = new TextDecoder('utf8', { fatal: true }).decode(buffer)
-    const lines = data.split(/\n|\r\n|\r/).filter(f => !!f)
-    const headerLines = []
-    let i = 0
-    for (; i < lines.length && lines[i].startsWith('#'); i++) {
-      headerLines.push(lines[i])
-    }
-    const header = headerLines.join('\n')
-    const feats1 = {} as Record<string, string[]>
-    const feats2 = {} as Record<string, string[]>
-    for (; i < lines.length; i++) {
-      const line = lines[i]
-      const cols = line.split('\t')
-      const r1 = cols[0]
-      const r2 = cols[3]
-      if (!feats1[r1]) {
-        feats1[r1] = []
-      }
-      if (!feats2[r2]) {
-        feats2[r2] = []
-      }
-      feats1[r1].push(line)
-      feats2[r2].push(line)
-    }
-    const columnNames = this.getConf('columnNames')
-
-    return {
-      header,
-      feats1,
-      feats2,
-      columnNames,
-    }
-  }
-
-  private async loadData(opts: BaseOptions = {}) {
-    if (!this.bedpeFeatures) {
-      this.bedpeFeatures = this.loadDataP(opts).catch(e => {
-        this.bedpeFeatures = undefined
-        throw e
-      })
-    }
-
-    return this.bedpeFeatures
-  }
-
-  public async getRefNames(opts: BaseOptions = {}) {
-    const { feats1, feats2 } = await this.loadData(opts)
-    return [...new Set([...Object.keys(feats1), ...Object.keys(feats2)])]
-  }
-
-  async getHeader(opts: BaseOptions = {}) {
-    const { header } = await this.loadData(opts)
-    return header
-  }
-
-  async getNames() {
-    const { header, columnNames } = await this.loadData()
-    if (columnNames.length) {
-      return columnNames
-    }
-    const defs = header.split(/\n|\r\n|\r/).filter(f => !!f)
-    const defline = defs[defs.length - 1]
-    return defline?.includes('\t')
-      ? defline
-          .slice(1)
-          .split('\t')
-          .map(field => field.trim())
-      : undefined
-  }
-
-  private async loadFeatureTreeP(refName: string) {
-    const { feats1, feats2 } = await this.loadData()
-    const lines1 = feats1[refName]
-    const lines2 = feats2[refName]
-    const names = await this.getNames()
-
-    const intervalTree = new IntervalTree()
-    const ret1 = lines1?.map((f, i) => {
-      const uniqueId = `${this.id}-${refName}-${i}`
-      return featureData(f, uniqueId, false, names)
-    })
-    const ret2 = lines2?.map((f, i) => {
-      const uniqueId = `${this.id}-${refName}-${i}`
-      return featureData(f, uniqueId, true, names)
-    })
-
-    for (const obj of ret1) {
-      intervalTree.insert([obj.get('start'), obj.get('end')], obj)
-    }
-
-    for (const obj of ret2) {
-      intervalTree.insert([obj.get('start'), obj.get('end')], obj)
-    }
-
-    return intervalTree
-  }
-
-  private async loadFeatureTree(refName: string) {
-    if (!this.intervalTrees[refName]) {
-      this.intervalTrees[refName] = this.loadFeatureTreeP(refName).catch(e => {
-        this.intervalTrees[refName] = undefined
-        throw e
-      })
-    }
-    return this.intervalTrees[refName]
-  }
-
-  public getFeatures(query: Region, opts: BaseOptions = {}) {
-    return ObservableCreate<Feature>(async observer => {
-      const { start, end, refName } = query
-      const intervalTree = await this.loadFeatureTree(refName)
-      intervalTree?.search([start, end]).forEach(f => observer.next(f))
-      observer.complete()
-    }, opts.signal)
-  }
-
-  public freeResources(): void {}
-}

package/src/BedpeAdapter/configSchema.ts

@@ -1,34 +0,0 @@
-import { ConfigurationSchema } from '@jbrowse/core/configuration'
-
-/**
- * #config BedpeAdapter
- * intended for SVs in a single assembly
- */
-function x() {} // eslint-disable-line @typescript-eslint/no-unused-vars
-
-const BedpeAdapter = ConfigurationSchema(
-  'BedpeAdapter',
-  {
-    /**
-     * #slot
-     * can be plaintext or gzipped, not indexed so loaded into memory on startup
-     */
-    bedpeLocation: {
-      type: 'fileLocation',
-      defaultValue: {
-        uri: '/path/to/my.bedpe.gz',
-        locationType: 'UriLocation',
-      },
-    },
-    /**
-     * #slot
-     */
-    columnNames: {
-      type: 'stringArray',
-      description: 'List of column names',
-      defaultValue: [],
-    },
-  },
-  { explicitlyTyped: true },
-)
-export default BedpeAdapter

package/src/BedpeAdapter/index.ts

@@ -1,16 +0,0 @@
-import PluginManager from '@jbrowse/core/PluginManager'
-import AdapterType from '@jbrowse/core/pluggableElementTypes/AdapterType'
-
-import configSchema from './configSchema'
-
-export default (pluginManager: PluginManager) => {
-  pluginManager.addAdapterType(
-    () =>
-      new AdapterType({
-        name: 'BedpeAdapter',
-        displayName: 'BEDPE adapter',
-        configSchema,
-        getAdapterClass: () => import('./BedpeAdapter').then(r => r.default),
-      }),
-  )
-}

package/src/BigBedAdapter/BigBedAdapter.test.ts

@@ -1,28 +0,0 @@
-import { toArray } from 'rxjs/operators'
-import { firstValueFrom } from 'rxjs'
-import BigBedAdapter from './BigBedAdapter'
-import configSchema from './configSchema'
-
-test('adapter can fetch features from volvox.bb', async () => {
-  const adapter = new BigBedAdapter(
-    configSchema.create({
-      bigBedLocation: {
-        localPath: require.resolve('./test_data/volvox.bb'),
-        locationType: 'LocalPathLocation',
-      },
-    }),
-  )
-
-  const features = adapter.getFeatures({
-    assemblyName: 'volvox',
-    refName: 'ctgA',
-    start: 0,
-    end: 20000,
-  })
-  expect(await adapter.hasDataForRefName('ctgA')).toBe(true)
-  expect(await adapter.hasDataForRefName('ctgB')).toBe(false)
-
-  const featuresArray = await firstValueFrom(features.pipe(toArray()))
-  const featuresJsonArray = featuresArray.map(f => f.toJSON())
-  expect(featuresJsonArray).toMatchSnapshot()
-})

package/src/BigBedAdapter/BigBedAdapter.ts

@@ -1,130 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { BigBed } from '@gmod/bbi'
-import BED from '@gmod/bed'
-import {
-  BaseFeatureDataAdapter,
-  BaseOptions,
-} from '@jbrowse/core/data_adapters/BaseAdapter'
-import { Region } from '@jbrowse/core/util/types'
-import { openLocation } from '@jbrowse/core/util/io'
-import { ObservableCreate } from '@jbrowse/core/util/rxjs'
-import SimpleFeature, { Feature } from '@jbrowse/core/util/simpleFeature'
-import { map, mergeAll } from 'rxjs/operators'
-import { readConfObject } from '@jbrowse/core/configuration'
-import { ucscProcessedTranscript } from '../util'
-
-function isUCSC(f: Feature) {
-  return f.get('thickStart') && f.get('blockCount') && f.get('strand') !== 0
-}
-
-export default class BigBedAdapter extends BaseFeatureDataAdapter {
-  private cached?: Promise<{ bigbed: BigBed; header: any; parser: BED }>
-
-  public async configurePre(opts?: BaseOptions) {
-    const bigbed = new BigBed({
-      filehandle: openLocation(
-        readConfObject(this.config, 'bigBedLocation'),
-        this.pluginManager,
-      ),
-    })
-    const header = await bigbed.getHeader(opts)
-    const parser = new BED({ autoSql: header.autoSql })
-    return { bigbed, header, parser }
-  }
-
-  public async configure(opts?: BaseOptions) {
-    if (!this.cached) {
-      this.cached = this.configurePre(opts).catch(e => {
-        this.cached = undefined
-        throw e
-      })
-    }
-    return this.cached
-  }
-
-  public async getRefNames(opts?: BaseOptions) {
-    const { header } = await this.configure(opts)
-    return Object.keys(header.refsByName)
-  }
-
-  async getHeader(opts?: BaseOptions) {
-    const { parser, header } = await this.configure(opts)
-    const { version, fileType } = header
-    const { fields, ...rest } = parser.autoSql
-    return {
-      version,
-      fileType,
-      autoSql: { ...rest },
-      fields: Object.fromEntries(
-        fields.map(({ name, comment }) => [name, comment]),
-      ),
-    }
-  }
-
-  public getFeatures(region: Region, opts: BaseOptions = {}) {
-    const { refName, start, end } = region
-    const { signal } = opts
-    return ObservableCreate<Feature>(async observer => {
-      try {
-        const { parser, bigbed } = await this.configure(opts)
-        const ob = await bigbed.getFeatureStream(refName, start, end, {
-          signal,
-          basesPerSpan: end - start,
-        })
-        ob.pipe(
-          mergeAll(),
-          map(r => {
-            const data = parser.parseLine(
-              `${refName}\t${r.start}\t${r.end}\t${r.rest}`,
-              {
-                uniqueId: r.uniqueId as string,
-              },
-            )
-
-            const { blockCount, blockSizes, blockStarts, chromStarts } = data
-            if (blockCount) {
-              const starts = chromStarts || blockStarts || []
-              const sizes = blockSizes
-              const blocksOffset = r.start
-              data.subfeatures = []
-
-              for (let b = 0; b < blockCount; b += 1) {
-                const bmin = (starts[b] || 0) + blocksOffset
-                const bmax = bmin + (sizes[b] || 0)
-                data.subfeatures.push({
-                  uniqueId: `${r.uniqueId}-${b}`,
-                  start: bmin,
-                  end: bmax,
-                  type: 'block',
-                })
-              }
-            }
-            if (r.uniqueId === undefined) {
-              throw new Error('invalid bbi feature')
-            }
-            const { chromStart, chromEnd, chrom, ...rest } = data
-
-            const f = new SimpleFeature({
-              id: `${this.id}-${r.uniqueId}`,
-              data: {
-                ...rest,
-                start: r.start,
-                end: r.end,
-                refName,
-              },
-            })
-
-            // collection of heuristics for suggesting that this feature
-            // should be converted to a gene, CNV bigbed has many gene like
-            // features including thickStart and blockCount but no strand
-            return isUCSC(f) ? ucscProcessedTranscript(f) : f
-          }),
-        ).subscribe(observer)
-      } catch (e) {
-        observer.error(e)
-      }
-    }, opts.signal)
-  }
-
-  public freeResources(): void {}
-}

package/src/BigBedAdapter/__snapshots__/BigBedAdapter.test.ts.snap

@@ -1,254 +0,0 @@
-// Jest Snapshot v1, https://goo.gl/fbAQLP
-
-exports[`adapter can fetch features from volvox.bb 1`] = `
-[
-  {
-    "end": 9000,
-    "geneBioType": "-",
-    "geneId": "EDEN",
-    "geneName": "EDEN",
-    "method": "-",
-    "name": "EDEN.1",
-    "refName": "ctgA",
-    "reserved": "0,0,0",
-    "score": 1000,
-    "start": 1049,
-    "strand": 1,
-    "subfeatures": [
-      {
-        "end": 1200,
-        "parentId": "test-bb-358912",
-        "start": 1049,
-        "strand": 1,
-        "type": "five_prime_UTR",
-        "uniqueId": "test-bb-358912-0",
-      },
-      {
-        "end": 1500,
-        "parentId": "test-bb-358912",
-        "start": 1200,
-        "strand": 1,
-        "type": "CDS",
-        "uniqueId": "test-bb-358912-1",
-      },
-      {
-        "end": 3902,
-        "parentId": "test-bb-358912",
-        "start": 2999,
-        "strand": 1,
-        "type": "CDS",
-        "uniqueId": "test-bb-358912-2",
-      },
-      {
-        "end": 5500,
-        "parentId": "test-bb-358912",
-        "start": 4999,
-        "strand": 1,
-        "type": "CDS",
-        "uniqueId": "test-bb-358912-3",
-      },
-      {
-        "end": 7608,
-        "parentId": "test-bb-358912",
-        "start": 6999,
-        "strand": 1,
-        "type": "CDS",
-        "uniqueId": "test-bb-358912-4",
-      },
-      {
-        "end": 9000,
-        "parentId": "test-bb-358912",
-        "start": 7608,
-        "strand": 1,
-        "type": "three_prime_UTR",
-        "uniqueId": "test-bb-358912-5",
-      },
-    ],
-    "tags": "-",
-    "type": "mRNA",
-    "uniqueId": "test-bb-358912",
-  },
-  {
-    "end": 9000,
-    "geneBioType": "-",
-    "geneId": "EDEN",
-    "geneName": "EDEN",
-    "method": "-",
-    "name": "EDEN.2",
-    "refName": "ctgA",
-    "reserved": "0,0,0",
-    "score": 1000,
-    "start": 1049,
-    "strand": 1,
-    "subfeatures": [
-      {
-        "end": 1200,
-        "parentId": "test-bb-359006",
-        "start": 1049,
-        "strand": 1,
-        "type": "five_prime_UTR",
-        "uniqueId": "test-bb-359006-0",
-      },
-      {
-        "end": 1500,
-        "parentId": "test-bb-359006",
-        "start": 1200,
-        "strand": 1,
-        "type": "CDS",
-        "uniqueId": "test-bb-359006-1",
-      },
-      {
-        "end": 5500,
-        "parentId": "test-bb-359006",
-        "start": 4999,
-        "strand": 1,
-        "type": "CDS",
-        "uniqueId": "test-bb-359006-2",
-      },
-      {
-        "end": 7608,
-        "parentId": "test-bb-359006",
-        "start": 6999,
-        "strand": 1,
-        "type": "CDS",
-        "uniqueId": "test-bb-359006-3",
-      },
-      {
-        "end": 9000,
-        "parentId": "test-bb-359006",
-        "start": 7608,
-        "strand": 1,
-        "type": "three_prime_UTR",
-        "uniqueId": "test-bb-359006-4",
-      },
-    ],
-    "tags": "-",
-    "type": "mRNA",
-    "uniqueId": "test-bb-359006",
-  },
-  {
-    "end": 9000,
-    "geneBioType": "-",
-    "geneId": "EDEN",
-    "geneName": "EDEN",
-    "method": "-",
-    "name": "EDEN.3",
-    "refName": "ctgA",
-    "reserved": "0,0,0",
-    "score": 1000,
-    "start": 1299,
-    "strand": 1,
-    "subfeatures": [
-      {
-        "end": 1500,
-        "parentId": "test-bb-359091",
-        "start": 1299,
-        "strand": 1,
-        "type": "five_prime_UTR",
-        "uniqueId": "test-bb-359091-0",
-      },
-      {
-        "end": 3300,
-        "parentId": "test-bb-359091",
-        "start": 2999,
-        "strand": 1,
-        "type": "five_prime_UTR",
-        "uniqueId": "test-bb-359091-1",
-      },
-      {
-        "end": 3902,
-        "parentId": "test-bb-359091",
-        "start": 3300,
-        "strand": 1,
-        "type": "CDS",
-        "uniqueId": "test-bb-359091-2",
-      },
-      {
-        "end": 5500,
-        "parentId": "test-bb-359091",
-        "start": 4999,
-        "strand": 1,
-        "type": "CDS",
-        "uniqueId": "test-bb-359091-3",
-      },
-      {
-        "end": 7600,
-        "parentId": "test-bb-359091",
-        "start": 6999,
-        "strand": 1,
-        "type": "CDS",
-        "uniqueId": "test-bb-359091-4",
-      },
-      {
-        "end": 9000,
-        "parentId": "test-bb-359091",
-        "start": 7600,
-        "strand": 1,
-        "type": "three_prime_UTR",
-        "uniqueId": "test-bb-359091-5",
-      },
-    ],
-    "tags": "-",
-    "type": "mRNA",
-    "uniqueId": "test-bb-359091",
-  },
-  {
-    "end": 23000,
-    "geneBioType": "-",
-    "geneId": "rna-Apple3",
-    "geneName": "rna-Apple3",
-    "method": "-",
-    "name": "rna-Apple3",
-    "refName": "ctgA",
-    "reserved": "0,0,0",
-    "score": 1000,
-    "start": 17399,
-    "strand": 1,
-    "subfeatures": [
-      {
-        "end": 17999,
-        "parentId": "test-bb-359185",
-        "start": 17399,
-        "strand": 1,
-        "type": "five_prime_UTR",
-        "uniqueId": "test-bb-359185-0",
-      },
-      {
-        "end": 18800,
-        "parentId": "test-bb-359185",
-        "start": 17999,
-        "strand": 1,
-        "type": "CDS",
-        "uniqueId": "test-bb-359185-1",
-      },
-      {
-        "end": 19500,
-        "parentId": "test-bb-359185",
-        "start": 18999,
-        "strand": 1,
-        "type": "CDS",
-        "uniqueId": "test-bb-359185-2",
-      },
-      {
-        "end": 21200,
-        "parentId": "test-bb-359185",
-        "start": 20999,
-        "strand": 1,
-        "type": "CDS",
-        "uniqueId": "test-bb-359185-3",
-      },
-      {
-        "end": 23000,
-        "parentId": "test-bb-359185",
-        "start": 21200,
-        "strand": 1,
-        "type": "three_prime_UTR",
-        "uniqueId": "test-bb-359185-4",
-      },
-    ],
-    "tags": "-",
-    "type": "mRNA",
-    "uniqueId": "test-bb-359185",
-  },
-]
-`;

package/src/BigBedAdapter/configSchema.ts

@@ -1,22 +0,0 @@
-import { ConfigurationSchema } from '@jbrowse/core/configuration'
-
-/**
- * #config BigBedAdapter
- */
-function x() {} // eslint-disable-line @typescript-eslint/no-unused-vars
-
-const BigBedAdapter = ConfigurationSchema(
-  'BigBedAdapter',
-  {
-    /**
-     * #slot
-     */
-    bigBedLocation: {
-      type: 'fileLocation',
-      defaultValue: { uri: '/path/to/my.bb', locationType: 'UriLocation' },
-    },
-  },
-  { explicitlyTyped: true },
-)
-
-export default BigBedAdapter

package/src/BigBedAdapter/index.ts

@@ -1,16 +0,0 @@
-import PluginManager from '@jbrowse/core/PluginManager'
-import AdapterType from '@jbrowse/core/pluggableElementTypes/AdapterType'
-
-import configSchema from './configSchema'
-
-export default (pluginManager: PluginManager) => {
-  pluginManager.addAdapterType(
-    () =>
-      new AdapterType({
-        name: 'BigBedAdapter',
-        displayName: 'BigBed adapter',
-        configSchema,
-        getAdapterClass: () => import('./BigBedAdapter').then(r => r.default),
-      }),
-  )
-}