jbrowse-plugin-mafviewer 1.3.2 → 1.4.0

package/src/MafAddTrackWorkflow/AddTrackWorkflow.tsx

@@ -37,10 +37,7 @@ const useStyles = makeStyles()(theme => ({
   },
 }))
 
-type AdapterTypeOptions =
-  | 'BigMafAdapter'
-  | 'MafTabixAdapter'
-  | 'BgzipTaffyAdapter'
+type AdapterTypeOptions = 'BigMafAdapter' | 'MafTabixAdapter'
 type IndexTypeOptions = 'TBI' | 'CSI'
 
 export default function MultiMAFWidget({ model }: { model: AddTrackModel }) {
@@ -89,7 +86,8 @@ export default function MultiMAFWidget({ model }: { model: AddTrackModel }) {
               setLoc(arg)
             }}
           />
-        ) : fileTypeChoice === 'MafTabixAdapter' ? (
+        ) : // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        fileTypeChoice === 'MafTabixAdapter' ? (
           <>
             <FormControl>
               <FormLabel>Index type</FormLabel>
@@ -212,7 +210,8 @@ export default function MultiMAFWidget({ model }: { model: AddTrackModel }) {
                         samples: sampleNames,
                         nhLocation: nhLoc,
                       }
-                    : fileTypeChoice === 'MafTabixAdapter'
+                    : // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+                      fileTypeChoice === 'MafTabixAdapter'
                       ? {
                           type: fileTypeChoice,
                           bedGzLocation: loc,

package/src/index.ts

@@ -2,7 +2,6 @@ import Plugin from '@jbrowse/core/Plugin'
 import PluginManager from '@jbrowse/core/PluginManager'
 
 import { version } from '../package.json'
-import BgzipTaffyAdapterF from './BgzipTaffyAdapter'
 import BigMafAdapterF from './BigMafAdapter'
 import LinearMafDisplayF from './LinearMafDisplay'
 import LinearMafRendererF from './LinearMafRenderer'
@@ -22,7 +21,6 @@ export default class MafViewerPlugin extends Plugin {
     LinearMafDisplayF(pluginManager)
     LinearMafRendererF(pluginManager)
     MafTabixAdapterF(pluginManager)
-    BgzipTaffyAdapterF(pluginManager)
     MafAddTrackWorkflowF(pluginManager)
     MafGetSequencesF(pluginManager)
     MafGetSamplesF(pluginManager)

package/src/BgzipTaffyAdapter/BgzipTaffyAdapter.ts

@@ -1,307 +0,0 @@
-import { unzip } from '@gmod/bgzf-filehandle'
-import {
-  BaseFeatureDataAdapter,
-  BaseOptions,
-} from '@jbrowse/core/data_adapters/BaseAdapter'
-import {
-  Feature,
-  Region,
-  SimpleFeature,
-  updateStatus,
-} from '@jbrowse/core/util'
-import QuickLRU from '@jbrowse/core/util/QuickLRU'
-import { openLocation } from '@jbrowse/core/util/io'
-import { ObservableCreate } from '@jbrowse/core/util/rxjs'
-import AbortablePromiseCache from 'abortable-promise-cache'
-import Long from 'long'
-
-import VirtualOffset from './virtualOffset'
-import parseNewick from '../parseNewick'
-import { normalize } from '../util'
-import { parseRowInstructions } from './rowInstructions'
-import { parseLineByLine } from './util'
-
-import type { IndexData, OrganismRecord } from './types'
-
-interface Entry {
-  type: string
-  row: number
-  asm: string
-  ref: string
-  start: number
-  strand: number
-  length: number
-}
-
-const toP = (s = 0) => +(+s).toFixed(1)
-
-export default class BgzipTaffyAdapter extends BaseFeatureDataAdapter {
-  public setupP?: Promise<IndexData>
-
-  private cache = new AbortablePromiseCache({
-    cache: new QuickLRU({ maxSize: 50 }),
-    // @ts-expect-error
-    fill: async ({ nextEntry, firstEntry }, signal, statusCallback) => {
-      const file = openLocation(this.getConf('tafGzLocation'))
-      const response = await file.read(
-        nextEntry.virtualOffset.blockPosition -
-          firstEntry.virtualOffset.blockPosition,
-        firstEntry.virtualOffset.blockPosition,
-      )
-      const buffer = await unzip(response)
-      const slice = buffer.slice(firstEntry.virtualOffset.dataPosition)
-      return this.getChunk(slice, {
-        statusCallback: statusCallback as (arg: string) => void,
-        signal,
-      })
-    },
-  })
-
-  async getRefNames() {
-    const data = await this.setup()
-    return Object.keys(data)
-  }
-
-  async getChunk(buffer: Uint8Array, opts?: BaseOptions) {
-    const { statusCallback = () => {} } = opts || {}
-    const alignments = {} as Record<string, OrganismRecord>
-    const data = [] as Entry[]
-    let a0: any
-    let j = 0
-    let b = 0
-    parseLineByLine(buffer, line => {
-      if (j++ % 100 === 0) {
-        statusCallback(
-          `Processing ${toP(b / 1_000_000)}/${toP(buffer.length / 1_000_000)}Mb`,
-        )
-      }
-      b += line.length
-      if (line) {
-        const [lineData, rowInstructions] = line.split(' ; ')
-        if (rowInstructions) {
-          for (const ins of parseRowInstructions(rowInstructions)) {
-            if (ins.type === 'i') {
-              data.splice(ins.row, 0, ins)
-              if (!alignments[ins.asm]) {
-                alignments[ins.asm] = {
-                  start: ins.start,
-                  strand: ins.strand,
-                  srcSize: ins.length,
-                  chr: ins.ref,
-                  data: '',
-                }
-              }
-              const e = alignments[ins.asm]!
-              e.data += ' '.repeat(Math.max(0, j - e.data.length - 1)) // catch it up
-            } else if (ins.type === 's') {
-              if (!alignments[ins.asm]) {
-                alignments[ins.asm] = {
-                  start: ins.start,
-                  strand: ins.strand,
-                  srcSize: ins.length,
-                  chr: ins.ref,
-                  data: '',
-                }
-              }
-              const e = alignments[ins.asm]!
-              e.data += ' '.repeat(Math.max(0, j - e.data.length - 1)) // catch it up
-              data[ins.row] = ins
-            } else if (ins.type === 'd') {
-              data.splice(ins.row, 1)
-            }
-
-            // no gaps for now(?)
-            // else if (ins.type === 'g') {
-            //   console.log('g??')
-            // } else if (ins.type === 'G') {
-            //   console.log('G??')
-            // }
-          }
-          if (!a0) {
-            a0 = data[0]
-          }
-        }
-        const lineLen = lineData!.length
-
-        for (let i = 0; i < lineLen; i++) {
-          const letter = lineData![i]
-          const r = data[i]
-
-          if (r) {
-            alignments[r.asm]!.data += letter
-          } else {
-            // not sure why but chr22_KI270731v1_random.taf.gz ends up here
-          }
-        }
-      }
-    })
-    if (a0) {
-      const row0 = alignments[a0.asm]!
-
-      // see
-      // https://github.com/ComparativeGenomicsToolkit/taffy/blob/f5a5354/docs/taffy_utilities.md#referenced-based-maftaf-and-indexing
-      // for the significance of row[0]:
-      //
-      // "An anchor line in TAF is a column from which all sequence
-      // coordinates can be deduced without scanning backwards to previous
-      // lines "
-      return {
-        uniqueId: `${row0.start}-${row0.data.length}`,
-        start: row0.start,
-        end: row0.start + row0.data.length,
-        strand: row0.strand,
-        alignments,
-        seq: row0.data,
-      }
-    }
-    return undefined
-  }
-
-  setupPre() {
-    if (!this.setupP) {
-      this.setupP = this.readTaiFile().catch((e: unknown) => {
-        this.setupP = undefined
-        throw e
-      })
-    }
-    return this.setupP
-  }
-  setup(opts?: BaseOptions) {
-    const { statusCallback = () => {} } = opts || {}
-    return updateStatus('Downloading index', statusCallback, () =>
-      this.setupPre(),
-    )
-  }
-
-  async readTaiFile() {
-    const text = await openLocation(this.getConf('taiLocation')).readFile(
-      'utf8',
-    )
-    const lines = text
-      .split('\n')
-      .map(f => f.trim())
-      .filter(line => !!line)
-    const entries = {} as IndexData
-    let lastChr = ''
-    let lastChrStart = 0
-    let lastRawVirtualOffset = 0
-    for (const line of lines) {
-      const [chr, chrStart, virtualOffset] = line.split('\t')
-      const relativizedVirtualOffset = lastRawVirtualOffset + +virtualOffset!
-      const currChr = chr === '*' ? lastChr : chr!.split('.').at(-1)!
-
-      // bgzip TAF files store virtual offsets in plaintext in the TAI file
-      // these virtualoffsets are 64bit values, so the long library is needed
-      // to accurately do the bit manipulations needed
-      const x = Long.fromNumber(relativizedVirtualOffset)
-      const y = x.shiftRightUnsigned(16)
-      const z = x.and(0xffff)
-      const voff = new VirtualOffset(y.toNumber(), z.toNumber())
-
-      if (!entries[currChr]) {
-        entries[currChr] = []
-        lastChr = ''
-        lastChrStart = 0
-        lastRawVirtualOffset = 0
-      }
-      const currStart = +chrStart! + lastChrStart
-      entries[currChr].push({
-        chrStart: currStart,
-        virtualOffset: voff,
-      })
-      lastChr = currChr
-      lastChrStart = currStart
-      lastRawVirtualOffset = relativizedVirtualOffset
-    }
-    return entries
-  }
-
-  getFeatures(query: Region, opts?: BaseOptions) {
-    const { statusCallback = () => {} } = opts || {}
-    return ObservableCreate<Feature>(async observer => {
-      try {
-        const byteRanges = await this.setup()
-        const feat = await updateStatus(
-          'Downloading alignments',
-          statusCallback,
-          () => this.getLines(query, byteRanges),
-        )
-        if (feat) {
-          observer.next(
-            // @ts-expect-error
-            new SimpleFeature({
-              ...feat,
-              refName: query.refName,
-            }),
-          )
-        } else {
-          console.error('no feature found')
-        }
-
-        statusCallback('')
-        observer.complete()
-      } catch (e) {
-        observer.error(e)
-      }
-    })
-  }
-
-  async getSamples(_query: Region) {
-    const nhLoc = this.getConf('nhLocation')
-    const nh =
-      nhLoc.uri === '/path/to/my.nh'
-        ? undefined
-        : await openLocation(nhLoc).readFile('utf8')
-
-    // TODO: we may need to resolve the exact set of rows in the visible region
-    // here
-    return {
-      samples: normalize(this.getConf('samples')),
-      tree: nh ? parseNewick(nh) : undefined,
-    }
-  }
-
-  // TODO: cache processed large chunks
-  async getLines(query: Region, byteRanges: IndexData) {
-    const records = byteRanges[query.refName]
-    if (records) {
-      let firstEntry
-      let nextEntry
-
-      // two pass:
-      // first pass: find first block greater than query start, then -1 from
-      // that
-      for (let i = 0; i < records.length; i++) {
-        if (records[i]!.chrStart >= query.start) {
-          firstEntry = records[Math.max(i - 1, 0)]
-          break
-        }
-      }
-      // second pass: find first block where query end less than record start,
-      // and +1 from that
-      for (let i = 0; i < records.length; i++) {
-        if (query.end <= records[i]!.chrStart) {
-          nextEntry = records[i + 1]
-          break
-        }
-      }
-
-      nextEntry = nextEntry ?? records.at(-1)
-      // we NEED at least a firstEntry (validate behavior?) because othrwise it fetches whole
-      // file whn you request e.g. out of range region (e.g. taf in chr22:1-100
-      // and you are at chr22:200-300)
-      if (firstEntry && nextEntry) {
-        return this.cache.get(
-          `${JSON.stringify(nextEntry)}_${JSON.stringify(firstEntry)}`,
-          {
-            nextEntry,
-            firstEntry,
-          },
-        )
-      }
-    }
-    return undefined
-  }
-
-  freeResources(): void {}
-}

package/src/BgzipTaffyAdapter/configSchema.ts

@@ -1,59 +0,0 @@
-import { ConfigurationSchema } from '@jbrowse/core/configuration'
-
-/**
- * #config BgzipTaffyAdapter
- * used to configure BgzipTaffy adapter
- */
-function x() {} // eslint-disable-line @typescript-eslint/no-unused-vars
-
-const configSchema = ConfigurationSchema(
-  'BgzipTaffyAdapter',
-  {
-    /**
-     * #slot
-     */
-    samples: {
-      type: 'frozen',
-      description: 'string[] or {id:string,label:string,color?:string}[]',
-      defaultValue: [],
-    },
-    /**
-     * #slot
-     */
-    tafGzLocation: {
-      type: 'fileLocation',
-      description: 'bgzip taffy file',
-      defaultValue: {
-        uri: '/path/to/my.taf',
-        locationType: 'UriLocation',
-      },
-    },
-    /**
-     * #slot
-     */
-    taiLocation: {
-      type: 'fileLocation',
-      description: 'taffy index',
-      defaultValue: {
-        uri: '/path/to/my.taf.gz.tai',
-        locationType: 'UriLocation',
-      },
-    },
-    /**
-     * #slot
-     */
-    nhLocation: {
-      type: 'fileLocation',
-      description: 'newick tree',
-      defaultValue: {
-        uri: '/path/to/my.nh',
-        locationType: 'UriLocation',
-      },
-    },
-  },
-  {
-    explicitlyTyped: true,
-  },
-)
-
-export default configSchema

package/src/BgzipTaffyAdapter/index.ts

@@ -1,16 +0,0 @@
-import PluginManager from '@jbrowse/core/PluginManager'
-import { AdapterType } from '@jbrowse/core/pluggableElementTypes'
-
-import BgzipTaffyAdapter from './BgzipTaffyAdapter'
-import configSchema from './configSchema'
-
-export default function BgzipTaffyAdapterF(pluginManager: PluginManager) {
-  return pluginManager.addAdapterType(
-    () =>
-      new AdapterType({
-        name: 'BgzipTaffyAdapter',
-        AdapterClass: BgzipTaffyAdapter,
-        configSchema,
-      }),
-  )
-}

package/src/BgzipTaffyAdapter/rowInstructions.ts

@@ -1,91 +0,0 @@
-interface RowInsert {
-  type: 'i'
-  row: number
-  asm: string
-  ref: string
-  start: number
-  strand: number
-  length: number
-}
-interface RowSubstitute {
-  type: 's'
-  row: number
-  asm: string
-  ref: string
-  start: number
-  strand: number
-  length: number
-}
-interface RowDelete {
-  type: 'd'
-  row: number
-}
-interface RowGap {
-  type: 'g'
-  row: number
-  gapLen: number
-}
-interface RowGapSubstring {
-  type: 'G'
-  row: number
-  gapSubstring: string
-}
-type RowInstruction =
-  | RowInsert
-  | RowDelete
-  | RowGap
-  | RowGapSubstring
-  | RowSubstitute
-
-export function parseRowInstructions(meta: string) {
-  const ret = meta.split(' ')
-  const rows = [] as RowInstruction[]
-
-  for (let i = 0; i < ret.length; ) {
-    const type = ret[i++]
-    if (type === 'i') {
-      const row = +ret[i++]!
-      const [asm, ref] = ret[i++]!.split('.')
-      rows.push({
-        type,
-        row,
-        asm: asm!,
-        ref: ref!,
-        start: +ret[i++]!,
-        strand: ret[i++] === '-' ? -1 : 1,
-        length: +ret[i++]!,
-      })
-    }
-    if (type === 's') {
-      const row = +ret[i++]!
-      const [asm, ref] = ret[i++]!.split('.')
-      rows.push({
-        type,
-        row,
-        asm: asm!,
-        ref: ref!,
-        start: +ret[i++]!,
-        strand: ret[i++] === '-' ? -1 : 1,
-        length: +ret[i++]!,
-      })
-    } else if (type === 'd') {
-      rows.push({
-        type,
-        row: +ret[i++]!,
-      })
-    } else if (type === 'g') {
-      rows.push({
-        type,
-        row: +ret[i++]!,
-        gapLen: +ret[i++]!,
-      })
-    } else if (type === 'G') {
-      rows.push({
-        type,
-        row: +ret[i++]!,
-        gapSubstring: ret[i++]!,
-      })
-    }
-  }
-  return rows
-}

package/src/BgzipTaffyAdapter/types.ts

@@ -1,16 +0,0 @@
-import VirtualOffset from './virtualOffset'
-
-export interface OrganismRecord {
-  chr: string
-  start: number
-  srcSize: number
-  strand: number
-  data: string
-}
-
-export interface ByteRange {
-  chrStart: number
-  virtualOffset: VirtualOffset
-}
-
-export type IndexData = Record<string, ByteRange[]>

package/src/BgzipTaffyAdapter/util.ts

@@ -1,25 +0,0 @@
-export function parseLineByLine<T>(
-  buffer: Uint8Array,
-  cb: (line: string) => T | undefined,
-): T[] {
-  let blockStart = 0
-  const entries: T[] = []
-  const decoder = new TextDecoder('utf8')
-  while (blockStart < buffer.length) {
-    const n = buffer.indexOf(10, blockStart)
-    if (n === -1) {
-      break
-    }
-    const b = buffer.subarray(blockStart, n)
-    const line = decoder.decode(b).trim()
-    if (line) {
-      const entry = cb(line)
-      if (entry) {
-        entries.push(entry)
-      }
-    }
-
-    blockStart = n + 1
-  }
-  return entries
-}

package/src/BgzipTaffyAdapter/virtualOffset.ts

@@ -1,29 +0,0 @@
-export default class VirtualOffset {
-  public blockPosition: number
-  public dataPosition: number
-  constructor(blockPosition: number, dataPosition: number) {
-    this.blockPosition = blockPosition // < offset of the compressed data block
-    this.dataPosition = dataPosition // < offset into the uncompressed data
-  }
-
-  toString() {
-    return `${this.blockPosition}:${this.dataPosition}`
-  }
-
-  compareTo(b: VirtualOffset) {
-    return (
-      this.blockPosition - b.blockPosition || this.dataPosition - b.dataPosition
-    )
-  }
-}
-export function fromBytes(bytes: Uint8Array, offset = 0) {
-  return new VirtualOffset(
-    bytes[offset + 7]! * 0x10000000000 +
-      bytes[offset + 6]! * 0x100000000 +
-      bytes[offset + 5]! * 0x1000000 +
-      bytes[offset + 4]! * 0x10000 +
-      bytes[offset + 3]! * 0x100 +
-      bytes[offset + 2]!,
-    (bytes[offset + 1]! << 8) | bytes[offset]!,
-  )
-}