@jbrowse/plugin-alignments 2.6.1 → 2.6.3

package/src/BamAdapter/configSchema.ts

@@ -1,65 +0,0 @@
-import { ConfigurationSchema } from '@jbrowse/core/configuration'
-import { types } from 'mobx-state-tree'
-
-/**
- * #config BamAdapter
- * used to configure BAM adapter
- */
-function x() {} // eslint-disable-line @typescript-eslint/no-unused-vars
-
-const configSchema = ConfigurationSchema(
-  'BamAdapter',
-  {
-    /**
-     * #slot
-     */
-    bamLocation: {
-      type: 'fileLocation',
-      defaultValue: { uri: '/path/to/my.bam', locationType: 'UriLocation' },
-    },
-
-    index: ConfigurationSchema('BamIndex', {
-      /**
-       * #slot index.indexType
-       */
-      indexType: {
-        model: types.enumeration('IndexType', ['BAI', 'CSI']),
-        type: 'stringEnum',
-        defaultValue: 'BAI',
-      },
-      /**
-       * #slot index.location
-       */
-      location: {
-        type: 'fileLocation',
-        defaultValue: {
-          uri: '/path/to/my.bam.bai',
-          locationType: 'UriLocation',
-        },
-      },
-    }),
-    /**
-     * #slot
-     */
-    fetchSizeLimit: {
-      type: 'number',
-      description:
-        'size to fetch in bytes over which to display a warning to the user that too much data will be fetched',
-      defaultValue: 5_000_000,
-    },
-    /**
-     * #slot
-     * generally refers to the reference genome assembly's sequence adapter
-     * currently needs to be manually added
-     */
-    sequenceAdapter: {
-      type: 'frozen',
-      description:
-        'sequence data adapter, used to calculate SNPs when BAM reads lacking MD tags',
-      defaultValue: null,
-    },
-  },
-  { explicitlyTyped: true },
-)
-
-export default configSchema

package/src/BamAdapter/index.ts

@@ -1,14 +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(() => {
-    return new AdapterType({
-      name: 'BamAdapter',
-      displayName: 'BAM adapter',
-      configSchema,
-      getAdapterClass: () => import('./BamAdapter').then(r => r.default),
-    })
-  })
-}

package/src/CombinationTest.test.ts

@@ -1,108 +0,0 @@
-import PluginManager from '@jbrowse/core/PluginManager'
-import { toArray } from 'rxjs/operators'
-import { LocalFile } from 'generic-filehandle'
-import { getSubAdapterType } from '@jbrowse/core/data_adapters/dataAdapterCache'
-
-import CramAdapter from './CramAdapter/CramAdapter'
-import BamAdapter from './BamAdapter/BamAdapter'
-import { SequenceAdapter } from './CramAdapter/CramTestAdapters'
-
-import cramConfigSchema from './CramAdapter/configSchema'
-import bamConfigSchema from './BamAdapter/configSchema'
-import { firstValueFrom } from 'rxjs'
-
-const pluginManager = new PluginManager()
-
-const getVolvoxSequenceSubAdapter: getSubAdapterType = async () => {
-  return {
-    dataAdapter: new SequenceAdapter(
-      new LocalFile(require.resolve('../test_data/volvox.fa')),
-    ),
-    sessionIds: new Set(),
-  }
-}
-
-async function getFeats(f1: string, f2: string) {
-  const cramAdapter = new CramAdapter(
-    cramConfigSchema.create({
-      cramLocation: {
-        localPath: require.resolve(f1),
-      },
-      craiLocation: {
-        localPath: require.resolve(f1 + '.crai'),
-      },
-    }),
-    getVolvoxSequenceSubAdapter,
-    pluginManager,
-  )
-
-  const bamAdapter = new BamAdapter(
-    bamConfigSchema.create({
-      bamLocation: {
-        localPath: require.resolve(f2),
-      },
-      index: {
-        location: {
-          localPath: require.resolve(f2 + '.bai'),
-        },
-      },
-    }),
-  )
-  const query = {
-    assemblyName: 'volvox',
-    refName: 'ctgA',
-    start: 1,
-    end: 10200,
-  }
-  const bamFeatures = bamAdapter.getFeatures(query)
-  const cramFeatures = cramAdapter.getFeatures(query)
-  const bamFeaturesArray = await firstValueFrom(bamFeatures.pipe(toArray()))
-  const cramFeaturesArray = await firstValueFrom(cramFeatures.pipe(toArray()))
-  return { bamFeaturesArray, cramFeaturesArray }
-}
-
-type M = { start: number }
-
-async function cigarCheck(f: string) {
-  const { cramFeaturesArray, bamFeaturesArray } = await getFeats(
-    `../test_data/${f}.cram`,
-    `../test_data/${f}.bam`,
-  )
-  const cramMap = Object.fromEntries(
-    cramFeaturesArray.map(f => [f.get('name'), f.get('CIGAR')]),
-  )
-  const bamMap = Object.fromEntries(
-    bamFeaturesArray.map(f => [f.get('name'), f.get('CIGAR')]),
-  )
-  expect(bamMap).toEqual(cramMap)
-}
-
-async function mismatchesCheck(f: string) {
-  const { cramFeaturesArray, bamFeaturesArray } = await getFeats(
-    `../test_data/${f}.cram`,
-    `../test_data/${f}.bam`,
-  )
-  const cramMap = Object.fromEntries(
-    cramFeaturesArray.map(f => [
-      f.get('name'),
-      f.get('mismatches').sort((a: M, b: M) => b.start - a.start),
-    ]),
-  )
-  const bamMap = Object.fromEntries(
-    bamFeaturesArray.map(f => [
-      f.get('name'),
-      f.get('mismatches').sort((a: M, b: M) => b.start - a.start),
-    ]),
-  )
-  expect(bamMap).toEqual(cramMap)
-}
-
-test('match CIGAR across file types', async () => {
-  await cigarCheck('volvox-sorted')
-  await cigarCheck('volvox-long-reads.fastq.sorted')
-}, 20000)
-
-test('mismatches same across file types', async () => {
-  await mismatchesCheck('volvox-sorted')
-  await mismatchesCheck('volvox-long-reads.fastq.sorted')
-}, 20000)

package/src/CramAdapter/CramAdapter.test.ts

@@ -1,85 +0,0 @@
-import { toArray } from 'rxjs/operators'
-import { firstValueFrom } from 'rxjs'
-import { LocalFile } from 'generic-filehandle'
-import PluginManager from '@jbrowse/core/PluginManager'
-import { getSubAdapterType } from '@jbrowse/core/data_adapters/dataAdapterCache'
-import Adapter from './CramAdapter'
-import { SequenceAdapter } from './CramTestAdapters'
-import configSchema from './configSchema'
-
-const pluginManager = new PluginManager()
-
-const getVolvoxSequenceSubAdapter: getSubAdapterType = async () => {
-  return {
-    dataAdapter: new SequenceAdapter(
-      new LocalFile(require.resolve('../../test_data/volvox.fa')),
-    ),
-    sessionIds: new Set(),
-  }
-}
-
-test('adapter can fetch features from volvox-sorted.cram', async () => {
-  const adapter = new Adapter(
-    configSchema.create({
-      cramLocation: {
-        localPath: require.resolve('../../test_data/volvox-sorted.cram'),
-        locationType: 'LocalPathLocation',
-      },
-      craiLocation: {
-        localPath: require.resolve('../../test_data/volvox-sorted.cram.crai'),
-        locationType: 'LocalPathLocation',
-      },
-    }),
-    getVolvoxSequenceSubAdapter,
-    pluginManager,
-  )
-
-  const features = adapter.getFeatures({
-    assemblyName: 'volvox',
-    refName: 'ctgA',
-    start: 0,
-    end: 20000,
-  })
-
-  const featuresArray = await firstValueFrom(features.pipe(toArray()))
-  expect(featuresArray[0].get('refName')).toBe('ctgA')
-  const featuresJsonArray = featuresArray.map(f => f.toJSON())
-  expect(featuresJsonArray.length).toEqual(3809)
-  expect(featuresJsonArray.slice(1000, 1010)).toMatchSnapshot()
-
-  expect(adapter.refIdToName(0)).toBe('ctgA')
-  expect(adapter.refIdToName(1)).toBe(undefined)
-
-  expect(await adapter.hasDataForRefName('ctgA')).toBe(true)
-})
-
-test('test usage of cramSlightlyLazyFeature toJSON (used in the widget)', async () => {
-  const adapter = new Adapter(
-    configSchema.create({
-      cramLocation: {
-        localPath: require.resolve('../../test_data/volvox-sorted.cram'),
-        locationType: 'LocalPathLocation',
-      },
-      craiLocation: {
-        localPath: require.resolve('../../test_data/volvox-sorted.cram.crai'),
-        locationType: 'LocalPathLocation',
-      },
-    }),
-    getVolvoxSequenceSubAdapter,
-    pluginManager,
-  )
-
-  const features = adapter.getFeatures({
-    assemblyName: 'volvox',
-    refName: 'ctgA',
-    start: 0,
-    end: 100,
-  })
-  const featuresArray = await firstValueFrom(features.pipe(toArray()))
-  const f = featuresArray[0].toJSON()
-  expect(f.refName).toBe('ctgA')
-  expect(f.start).toBe(2)
-  expect(f.end).toBe(102)
-  // don't pass the mismatches to the frontend
-  expect(f.mismatches).toEqual(undefined)
-})

package/src/CramAdapter/CramAdapter.ts

@@ -1,323 +0,0 @@
-import { CraiIndex, IndexedCramFile, CramRecord } from '@gmod/cram'
-import {
-  BaseFeatureDataAdapter,
-  BaseOptions,
-  BaseSequenceAdapter,
-} from '@jbrowse/core/data_adapters/BaseAdapter'
-import {
-  checkAbortSignal,
-  Region,
-  Feature,
-  updateStatus,
-} from '@jbrowse/core/util'
-import { openLocation } from '@jbrowse/core/util/io'
-import { ObservableCreate } from '@jbrowse/core/util/rxjs'
-import { toArray } from 'rxjs/operators'
-import { firstValueFrom } from 'rxjs'
-import CramSlightlyLazyFeature from './CramSlightlyLazyFeature'
-
-interface Header {
-  idToName?: string[]
-  nameToId?: Record<string, number>
-  readGroups?: (string | undefined)[]
-}
-
-interface FilterBy {
-  flagInclude: number
-  flagExclude: number
-  tagFilter: { tag: string; value: unknown }
-  readName: string
-}
-
-export default class CramAdapter extends BaseFeatureDataAdapter {
-  samHeader: Header = {}
-
-  private setupP?: Promise<{
-    samHeader: Header
-    cram: IndexedCramFile
-    sequenceAdapter: BaseSequenceAdapter
-  }>
-
-  private configureP?: Promise<{
-    cram: IndexedCramFile
-    sequenceAdapter: BaseSequenceAdapter
-  }>
-
-  // maps a refname to an id
-  private seqIdToRefName: string[] | undefined
-
-  // maps a seqId to original refname, passed specially to render args, to a seqid
-  private seqIdToOriginalRefName: string[] = []
-
-  public async configurePre() {
-    const cramLocation = this.getConf('cramLocation')
-    const craiLocation = this.getConf('craiLocation')
-    if (!cramLocation) {
-      throw new Error('missing cramLocation argument')
-    }
-    if (!craiLocation) {
-      throw new Error('missing craiLocation argument')
-    }
-    const pm = this.pluginManager
-
-    const cram = new IndexedCramFile({
-      cramFilehandle: openLocation(cramLocation, pm),
-      index: new CraiIndex({ filehandle: openLocation(craiLocation, pm) }),
-      seqFetch: (...args) => this.seqFetch(...args),
-      checkSequenceMD5: false,
-      fetchSizeLimit: 200_000_000, // just make this a large size to avoid hitting it
-    })
-
-    if (!this.getSubAdapter) {
-      throw new Error('Error getting subadapter')
-    }
-
-    const seqConf = this.getConf('sequenceAdapter')
-    const subadapter = await this.getSubAdapter(seqConf)
-
-    return {
-      cram,
-      sequenceAdapter: subadapter.dataAdapter as BaseSequenceAdapter,
-    }
-  }
-
-  public async configure() {
-    if (!this.configureP) {
-      this.configureP = this.configurePre().catch(e => {
-        this.configureP = undefined
-        throw e
-      })
-    }
-    return this.configureP
-  }
-
-  async getHeader(opts?: BaseOptions) {
-    const { cram } = await this.configure()
-    return cram.cram.getHeaderText()
-  }
-
-  private async seqFetch(
-    seqId: number,
-    start: number,
-    end: number,
-  ): Promise<string> {
-    start -= 1 // convert from 1-based closed to interbase
-
-    const { sequenceAdapter } = await this.configure()
-    const refName = this.refIdToOriginalName(seqId) || this.refIdToName(seqId)
-    if (!refName) {
-      throw new Error('unknown')
-    }
-
-    const seqChunks = await firstValueFrom(
-      sequenceAdapter
-        .getFeatures({
-          refName,
-          start,
-          end,
-          assemblyName: '',
-        })
-        .pipe(toArray()),
-    )
-
-    const sequence = seqChunks
-      .sort((a, b) => a.get('start') - b.get('start'))
-      .map(chunk => {
-        const chunkStart = chunk.get('start')
-        const chunkEnd = chunk.get('end')
-        const trimStart = Math.max(start - chunkStart, 0)
-        const trimEnd = Math.min(end - chunkStart, chunkEnd - chunkStart)
-        const trimLength = trimEnd - trimStart
-        const chunkSeq = chunk.get('seq') || chunk.get('residues')
-        return chunkSeq.slice(trimStart, trimStart + trimLength)
-      })
-      .join('')
-
-    if (sequence.length !== end - start) {
-      throw new Error(
-        `sequence fetch failed: fetching ${refName}:${(
-          start - 1
-        ).toLocaleString()}-${end.toLocaleString()} returned ${sequence.length.toLocaleString()} bases, but should have returned ${(
-          end - start
-        ).toLocaleString()}`,
-      )
-    }
-    return sequence
-  }
-
-  private async setupPre(opts?: BaseOptions) {
-    const { statusCallback = () => {} } = opts || {}
-    return updateStatus('Downloading index', statusCallback, async () => {
-      const conf = await this.configure()
-      const { cram } = conf
-      const samHeader = await cram.cram.getSamHeader()
-
-      // use the @SQ lines in the header to figure out the
-      // mapping between ref ID numbers and names
-      const idToName: string[] = []
-      const nameToId: Record<string, number> = {}
-      samHeader
-        .filter(l => l.tag === 'SQ')
-        .forEach((sqLine, refId) => {
-          sqLine.data.forEach(item => {
-            if (item.tag === 'SN') {
-              // this is the ref name
-              const refName = item.value
-              nameToId[refName] = refId
-              idToName[refId] = refName
-            }
-          })
-        })
-
-      const readGroups = samHeader
-        .filter(l => l.tag === 'RG')
-        .map(rgLine => rgLine.data.find(item => item.tag === 'ID')?.value)
-
-      const data = { idToName, nameToId, readGroups }
-      this.samHeader = data
-      return { samHeader: data, ...conf }
-    })
-  }
-
-  private async setup(opts?: BaseOptions) {
-    if (!this.setupP) {
-      this.setupP = this.setupPre(opts).catch(e => {
-        this.setupP = undefined
-        throw e
-      })
-    }
-    return this.setupP
-  }
-
-  async getRefNames(opts?: BaseOptions) {
-    const { samHeader } = await this.setup(opts)
-    if (!samHeader.idToName) {
-      throw new Error('CRAM file has no header lines')
-    }
-    return samHeader.idToName
-  }
-
-  // use info from the SAM header if possible, but fall back to using
-  // the ref seq order from when the browser's refseqs were loaded
-  refNameToId(refName: string) {
-    if (this.samHeader.nameToId) {
-      return this.samHeader.nameToId[refName]
-    }
-    if (this.seqIdToRefName) {
-      return this.seqIdToRefName.indexOf(refName)
-    }
-    return undefined
-  }
-
-  // use info from the SAM header if possible, but fall back to using
-  // the ref seq order from when the browser's refseqs were loaded
-  refIdToName(refId: number) {
-    return this.samHeader.idToName?.[refId] || this.seqIdToRefName?.[refId]
-  }
-
-  refIdToOriginalName(refId: number) {
-    return this.seqIdToOriginalRefName[refId]
-  }
-
-  getFeatures(
-    region: Region & { originalRefName?: string },
-    opts?: BaseOptions & {
-      filterBy: FilterBy
-    },
-  ) {
-    const { signal, filterBy, statusCallback = () => {} } = opts || {}
-    const { refName, start, end, originalRefName } = region
-
-    return ObservableCreate<Feature>(async observer => {
-      const { cram } = await this.setup(opts)
-
-      const refId = this.refNameToId(refName)
-      if (refId === undefined) {
-        console.warn('Unknown refName', refName)
-        observer.complete()
-        return
-      }
-
-      if (originalRefName) {
-        this.seqIdToOriginalRefName[refId] = originalRefName
-      }
-      const records = await updateStatus(
-        'Downloading alignments',
-        statusCallback,
-        () => cram.getRecordsForRange(refId, start, end),
-      )
-      checkAbortSignal(signal)
-      await updateStatus('Processing alignments', statusCallback, () => {
-        const {
-          flagInclude = 0,
-          flagExclude = 0,
-          tagFilter,
-          readName,
-        } = filterBy || {}
-
-        for (const record of records) {
-          const flags = record.flags
-          if ((flags & flagInclude) !== flagInclude && !(flags & flagExclude)) {
-            continue
-          }
-
-          if (tagFilter) {
-            const v =
-              tagFilter.tag === 'RG'
-                ? this.samHeader.readGroups?.[record.readGroupId]
-                : record.tags[tagFilter.tag]
-            if (!(v === '*' ? v !== undefined : `${v}` === tagFilter.value)) {
-              continue
-            }
-          }
-
-          if (readName && record.readName !== readName) {
-            continue
-          }
-          observer.next(this.cramRecordToFeature(record))
-        }
-
-        observer.complete()
-      })
-    }, signal)
-  }
-
-  freeResources(/* { region } */): void {}
-
-  cramRecordToFeature(record: CramRecord) {
-    return new CramSlightlyLazyFeature(record, this)
-  }
-
-  // we return the configured fetchSizeLimit, and the bytes for the region
-  async getMultiRegionFeatureDensityStats(
-    regions: Region[],
-    opts?: BaseOptions,
-  ) {
-    const bytes = await this.bytesForRegions(regions, opts)
-    const fetchSizeLimit = this.getConf('fetchSizeLimit')
-    return {
-      bytes,
-      fetchSizeLimit,
-    }
-  }
-
-  /**
-   * get the approximate number of bytes queried from the file for the given
-   * query regions
-   * @param regions - list of query regions
-   */
-  private async bytesForRegions(regions: Region[], _opts?: BaseOptions) {
-    const { cram } = await this.configure()
-    const blockResults = await Promise.all(
-      regions.map(region => {
-        const { refName, start, end } = region
-        const chrId = this.refNameToId(refName)
-        return chrId !== undefined
-          ? cram.index.getEntriesForRange(chrId, start, end)
-          : [{ sliceBytes: 0 }]
-      }),
-    )
-
-    return blockResults.flat().reduce((a, b) => a + b.sliceBytes, 0)
-  }
-}