@jbrowse/plugin-comparative-adapters 2.6.1

package/src/MCScanAnchorsAdapter/configSchema.ts

@@ -0,0 +1,52 @@
+import { ConfigurationSchema } from '@jbrowse/core/configuration'
+
+/**
+ * #config MCScanAnchorsAdapter
+ */
+function x() {} // eslint-disable-line @typescript-eslint/no-unused-vars
+
+const MCScanAnchorsAdapter = ConfigurationSchema(
+  'MCScanAnchorsAdapter',
+  {
+    /**
+     * #slot
+     */
+    mcscanAnchorsLocation: {
+      type: 'fileLocation',
+      defaultValue: {
+        uri: '/path/to/mcscan.anchors',
+        locationType: 'UriLocation',
+      },
+    },
+    /**
+     * #slot
+     */
+    bed1Location: {
+      type: 'fileLocation',
+      defaultValue: {
+        uri: '/path/to/file.bed',
+        locationType: 'UriLocation',
+      },
+    },
+    /**
+     * #slot
+     */
+    bed2Location: {
+      type: 'fileLocation',
+      defaultValue: {
+        uri: '/path/to/file.bed',
+        locationType: 'UriLocation',
+      },
+    },
+    /**
+     * #slot
+     */
+    assemblyNames: {
+      type: 'stringArray',
+      defaultValue: [],
+    },
+  },
+  { explicitlyTyped: true },
+)
+
+export default MCScanAnchorsAdapter

package/src/MCScanAnchorsAdapter/index.ts

@@ -0,0 +1,20 @@
+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: 'MCScanAnchorsAdapter',
+        displayName: 'MCScan anchors adapter',
+        configSchema,
+        adapterMetadata: {
+          hiddenFromGUI: true,
+        },
+
+        getAdapterClass: () =>
+          import('./MCScanAnchorsAdapter').then(r => r.default),
+      }),
+  )
+}

package/src/MCScanSimpleAnchorsAdapter/MCScanSimpleAnchorsAdapter.ts

@@ -0,0 +1,157 @@
+import {
+  BaseFeatureDataAdapter,
+  BaseOptions,
+} from '@jbrowse/core/data_adapters/BaseAdapter'
+import { Region } from '@jbrowse/core/util/types'
+import { openLocation } from '@jbrowse/core/util/io'
+import { doesIntersect2 } from '@jbrowse/core/util'
+import { ObservableCreate } from '@jbrowse/core/util/rxjs'
+import SimpleFeature, { Feature } from '@jbrowse/core/util/simpleFeature'
+import { readFile, parseBed } from '../util'
+
+interface BareFeature {
+  refName: string
+  start: number
+  end: number
+  score: number
+  name: string
+}
+
+type Row = [
+  BareFeature,
+  BareFeature,
+  BareFeature,
+  BareFeature,
+  number,
+  number,
+  number,
+]
+
+export default class MCScanAnchorsAdapter extends BaseFeatureDataAdapter {
+  private setupP?: Promise<{
+    assemblyNames: string[]
+    feats: Row[]
+  }>
+
+  public static capabilities = ['getFeatures', 'getRefNames']
+
+  async setup(opts: BaseOptions) {
+    if (!this.setupP) {
+      this.setupP = this.setupPre(opts).catch(e => {
+        this.setupP = undefined
+        throw e
+      })
+    }
+    return this.setupP
+  }
+  async setupPre(opts: BaseOptions) {
+    const assemblyNames = this.getConf('assemblyNames') as string[]
+    const pm = this.pluginManager
+    const bed1 = openLocation(this.getConf('bed1Location'), pm)
+    const bed2 = openLocation(this.getConf('bed2Location'), pm)
+    const mcscan = openLocation(this.getConf('mcscanSimpleAnchorsLocation'), pm)
+    const [bed1text, bed2text, mcscantext] = await Promise.all(
+      [bed1, bed2, mcscan].map(r => readFile(r, opts)),
+    )
+    const bed1Map = parseBed(bed1text)
+    const bed2Map = parseBed(bed2text)
+    const feats = mcscantext
+      .split(/\n|\r\n|\r/)
+      .filter(f => !!f && f !== '###')
+      .map((line, index) => {
+        const [n11, n12, n21, n22, score, strand] = line.split('\t')
+        const r11 = bed1Map.get(n11)
+        const r12 = bed1Map.get(n12)
+        const r21 = bed2Map.get(n21)
+        const r22 = bed2Map.get(n22)
+        if (!r11 || !r12 || !r21 || !r22) {
+          throw new Error(
+            `feature not found, ${n11} ${n12} ${n21} ${n22} ${r11} ${r12} ${r21} ${r22}`,
+          )
+        }
+        return [
+          r11,
+          r12,
+          r21,
+          r22,
+          +score,
+          strand === '-' ? -1 : 1,
+          index,
+        ] as Row
+      })
+
+    return {
+      assemblyNames,
+      feats,
+    }
+  }
+
+  async hasDataForRefName() {
+    // determining this properly is basically a call to getFeatures
+    // so is not really that important, and has to be true or else
+    // getFeatures is never called (BaseFeatureDataAdapter filters it out)
+    return true
+  }
+
+  async getRefNames() {
+    // we cannot determine this accurately
+    return []
+  }
+
+  getFeatures(region: Region, opts: BaseOptions = {}) {
+    return ObservableCreate<Feature>(async observer => {
+      const { assemblyNames, feats } = await this.setup(opts)
+
+      // The index of the assembly name in the region list corresponds to
+      // the adapter in the subadapters list
+      const index = assemblyNames.indexOf(region.assemblyName)
+      if (index !== -1) {
+        const flip = index === 0
+        feats.forEach(f => {
+          const [f11, f12, f21, f22, score, strand, rowNum] = f
+          let r1 = {
+            refName: f11.refName,
+            start: Math.min(f11.start, f12.start),
+            end: Math.max(f11.end, f12.end),
+          }
+          let r2 = {
+            refName: f21.refName,
+            start: Math.min(f21.start, f22.start),
+            end: Math.max(f21.end, f22.end),
+          }
+          if (!flip) {
+            ;[r2, r1] = [r1, r2]
+          }
+          if (
+            r1.refName === region.refName &&
+            doesIntersect2(r1.start, r1.end, region.start, region.end)
+          ) {
+            observer.next(
+              new SimpleFeature({
+                ...r1,
+                uniqueId: `${rowNum}`,
+                syntenyId: rowNum,
+                assemblyName: assemblyNames[+!flip],
+                score,
+                strand,
+                mate: {
+                  ...r2,
+                  assemblyName: assemblyNames[+flip],
+                },
+              }),
+            )
+          }
+        })
+      }
+
+      observer.complete()
+    })
+  }
+
+  /**
+   * called to provide a hint that data tied to a certain region
+   * will not be needed for the foreseeable future and can be purged
+   * from caches, etc
+   */
+  freeResources(/* { region } */): void {}
+}

package/src/MCScanSimpleAnchorsAdapter/configSchema.ts

@@ -0,0 +1,52 @@
+import { ConfigurationSchema } from '@jbrowse/core/configuration'
+
+/**
+ * #config MCScanSimpleAnchorsAdapter
+ */
+function x() {} // eslint-disable-line @typescript-eslint/no-unused-vars
+
+const MCScanSimpleAnchorsAdapter = ConfigurationSchema(
+  'MCScanSimpleAnchorsAdapter',
+  {
+    /**
+     * #slot
+     */
+    mcscanSimpleAnchorsLocation: {
+      type: 'fileLocation',
+      defaultValue: {
+        uri: '/path/to/mcscan.anchors.simple',
+        locationType: 'UriLocation',
+      },
+    },
+    /**
+     * #slot
+     */
+    bed1Location: {
+      type: 'fileLocation',
+      defaultValue: {
+        uri: '/path/to/file.bed',
+        locationType: 'UriLocation',
+      },
+    },
+    /**
+     * #slot
+     */
+    bed2Location: {
+      type: 'fileLocation',
+      defaultValue: {
+        uri: '/path/to/file.bed',
+        locationType: 'UriLocation',
+      },
+    },
+
+    /**
+     * #slot
+     */
+    assemblyNames: {
+      type: 'stringArray',
+      defaultValue: [],
+    },
+  },
+  { explicitlyTyped: true },
+)
+export default MCScanSimpleAnchorsAdapter

package/src/MCScanSimpleAnchorsAdapter/index.ts

@@ -0,0 +1,19 @@
+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: 'MCScanSimpleAnchorsAdapter',
+        displayName: 'MCScan anchors.simple adapter',
+        configSchema,
+        adapterMetadata: {
+          hiddenFromGUI: true,
+        },
+        getAdapterClass: () =>
+          import('./MCScanSimpleAnchorsAdapter').then(r => r.default),
+      }),
+  )
+}

package/src/MashMapAdapter/MashMapAdapter.ts

@@ -0,0 +1,40 @@
+import { BaseOptions } from '@jbrowse/core/data_adapters/BaseAdapter'
+import { openLocation } from '@jbrowse/core/util/io'
+import { unzip } from '@gmod/bgzf-filehandle'
+import PAFAdapter from '../PAFAdapter/PAFAdapter'
+import { parseLineByLine } from '../util'
+
+function isGzip(buf: Buffer) {
+  return buf[0] === 31 && buf[1] === 139 && buf[2] === 8
+}
+
+export default class MashMapAdapter extends PAFAdapter {
+  async setupPre(opts?: BaseOptions) {
+    const outLoc = openLocation(this.getConf('outLocation'), this.pluginManager)
+    const buffer = (await outLoc.readFile(opts)) as Buffer
+    const buf = isGzip(buffer) ? await unzip(buffer) : buffer
+    return parseLineByLine(buf, parseMashMapLine)
+  }
+}
+
+function parseMashMapLine(line: string) {
+  const fields = line.split(' ')
+  if (fields.length < 9) {
+    // xref https://github.com/marbl/MashMap/issues/38
+    throw new Error('improperly formatted line: ' + line)
+  }
+  const [qname, , qstart, qend, strand, tname, , tstart, tend, mq] = fields
+
+  return {
+    tname,
+    tstart: +tstart,
+    tend: +tend,
+    qname,
+    qstart: +qstart,
+    qend: +qend,
+    strand: strand === '-' ? -1 : 1,
+    extra: {
+      mappingQual: +mq,
+    },
+  }
+}

package/src/MashMapAdapter/configSchema.ts

@@ -0,0 +1,51 @@
+import { ConfigurationSchema } from '@jbrowse/core/configuration'
+
+/**
+ * #config MashMapAdapter
+ */
+function x() {} // eslint-disable-line @typescript-eslint/no-unused-vars
+
+const MashMapAdapter = ConfigurationSchema(
+  'MashMapAdapter',
+  {
+    /**
+     * #slot
+     */
+    assemblyNames: {
+      type: 'stringArray',
+      defaultValue: [],
+      description:
+        'Target is the first value in the array, query is the second',
+    },
+
+    /**
+     * #slot
+     */
+    targetAssembly: {
+      type: 'string',
+      defaultValue: '',
+      description: 'Alternative to assemblyNames array: the target assembly',
+    },
+    /**
+     * #slot
+     */
+    queryAssembly: {
+      type: 'string',
+      defaultValue: '',
+      description: 'Alternative to assemblyNames array: the query assembly',
+    },
+    /**
+     * #slot
+     */
+    outLocation: {
+      type: 'fileLocation',
+      defaultValue: {
+        uri: '/path/to/mashmap.out',
+        locationType: 'UriLocation',
+      },
+    },
+  },
+  { explicitlyTyped: true },
+)
+
+export default MashMapAdapter

package/src/MashMapAdapter/index.ts

@@ -0,0 +1,18 @@
+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: 'MashMapAdapter',
+        displayName: 'MashMap adapter',
+        configSchema,
+        adapterMetadata: {
+          hiddenFromGUI: true,
+        },
+        getAdapterClass: () => import('./MashMapAdapter').then(r => r.default),
+      }),
+  )
+}

package/src/PAFAdapter/PAFAdapter.test.ts

@@ -0,0 +1,37 @@
+import { toArray } from 'rxjs/operators'
+import { firstValueFrom } from 'rxjs'
+import Adapter from './PAFAdapter'
+import MyConfigSchema from './configSchema'
+
+test('adapter can fetch features from peach_grape.paf', async () => {
+  const adapter = new Adapter(
+    MyConfigSchema.create({
+      pafLocation: {
+        localPath: require.resolve('./test_data/peach_grape.paf'),
+        locationType: 'LocalPathLocation',
+      },
+      assemblyNames: ['peach', 'grape'],
+    }),
+  )
+
+  const features1 = adapter.getFeatures({
+    refName: 'Pp01',
+    start: 0,
+    end: 200000,
+    assemblyName: 'peach',
+  })
+
+  const features2 = adapter.getFeatures({
+    refName: 'chr1',
+    start: 0,
+    end: 200000,
+    assemblyName: 'grape',
+  })
+
+  const fa1 = await firstValueFrom(features1.pipe(toArray()))
+  const fa2 = await firstValueFrom(features2.pipe(toArray()))
+  expect(fa1.length).toBe(11)
+  expect(fa2.length).toBe(5)
+  expect(fa1[0].get('refName')).toBe('Pp01')
+  expect(fa2[0].get('refName')).toBe('chr1')
+})

package/src/PAFAdapter/PAFAdapter.ts

@@ -0,0 +1,181 @@
+import {
+  BaseFeatureDataAdapter,
+  BaseOptions,
+} from '@jbrowse/core/data_adapters/BaseAdapter'
+import { Region } from '@jbrowse/core/util/types'
+import { doesIntersect2 } from '@jbrowse/core/util/range'
+import { openLocation } from '@jbrowse/core/util/io'
+import { ObservableCreate } from '@jbrowse/core/util/rxjs'
+import { Feature } from '@jbrowse/core/util'
+import {
+  AnyConfigurationModel,
+  readConfObject,
+} from '@jbrowse/core/configuration'
+import { unzip } from '@gmod/bgzf-filehandle'
+import { MismatchParser } from '@jbrowse/plugin-alignments'
+
+// locals
+import SyntenyFeature from './SyntenyFeature'
+import { isGzip, parseLineByLine } from '../util'
+import {
+  getWeightedMeans,
+  flipCigar,
+  swapIndelCigar,
+  parsePAFLine,
+  PAFRecord,
+} from './util'
+
+const { parseCigar } = MismatchParser
+
+interface PAFOptions extends BaseOptions {
+  config?: AnyConfigurationModel
+}
+
+export default class PAFAdapter extends BaseFeatureDataAdapter {
+  private setupP?: Promise<PAFRecord[]>
+
+  public static capabilities = ['getFeatures', 'getRefNames']
+
+  async setup(opts?: BaseOptions) {
+    if (!this.setupP) {
+      this.setupP = this.setupPre(opts).catch(e => {
+        this.setupP = undefined
+        throw e
+      })
+    }
+    return this.setupP
+  }
+
+  async setupPre(opts?: BaseOptions) {
+    const pm = this.pluginManager
+    const pafLocation = openLocation(this.getConf('pafLocation'), pm)
+    const buffer = (await pafLocation.readFile(opts)) as Buffer
+    const buf = isGzip(buffer) ? await unzip(buffer) : buffer
+    return parseLineByLine(buf, parsePAFLine)
+  }
+
+  async hasDataForRefName() {
+    // determining this properly is basically a call to getFeatures
+    // so is not really that important, and has to be true or else
+    // getFeatures is never called (BaseAdapter filters it out)
+    return true
+  }
+
+  getAssemblyNames() {
+    const assemblyNames = this.getConf('assemblyNames') as string[]
+    if (assemblyNames.length === 0) {
+      const query = this.getConf('queryAssembly') as string
+      const target = this.getConf('targetAssembly') as string
+      return [query, target]
+    }
+    return assemblyNames
+  }
+
+  async getRefNames(opts: BaseOptions = {}) {
+    // @ts-expect-error
+    const r1 = opts.regions?.[0].assemblyName
+    const feats = await this.setup(opts)
+
+    const idx = this.getAssemblyNames().indexOf(r1)
+    if (idx !== -1) {
+      const set = new Set<string>()
+      for (const feat of feats) {
+        set.add(idx === 0 ? feat.qname : feat.tname)
+      }
+      return [...set]
+    }
+    console.warn('Unable to do ref renaming on adapter')
+    return []
+  }
+
+  getFeatures(query: Region, opts: PAFOptions = {}) {
+    return ObservableCreate<Feature>(async observer => {
+      let pafRecords = await this.setup(opts)
+      const { config } = opts
+
+      // note: this is not the adapter config, it is responding to a display
+      // setting passed in via the opts parameter
+      if (config && readConfObject(config, 'colorBy') === 'meanQueryIdentity') {
+        pafRecords = getWeightedMeans(pafRecords)
+      }
+      const assemblyNames = this.getAssemblyNames()
+
+      // The index of the assembly name in the query list corresponds to the
+      // adapter in the subadapters list
+      const index = assemblyNames.indexOf(query.assemblyName)
+      const { start: qstart, end: qend, refName: qref, assemblyName } = query
+      if (index === -1) {
+        console.warn(`${assemblyName} not found in this adapter`)
+        observer.complete()
+      }
+
+      for (let i = 0; i < pafRecords.length; i++) {
+        const r = pafRecords[i]
+        let start = 0
+        let end = 0
+        let refName = ''
+        let mateName = ''
+        let mateStart = 0
+        let mateEnd = 0
+        const flip = index === 0
+        const assemblyName = assemblyNames[+!flip]
+        if (index === 0) {
+          start = r.qstart
+          end = r.qend
+          refName = r.qname
+          mateName = r.tname
+          mateStart = r.tstart
+          mateEnd = r.tend
+        } else {
+          start = r.tstart
+          end = r.tend
+          refName = r.tname
+          mateName = r.qname
+          mateStart = r.qstart
+          mateEnd = r.qend
+        }
+        const { extra, strand } = r
+        if (refName === qref && doesIntersect2(qstart, qend, start, end)) {
+          const { numMatches = 0, blockLen = 1, cg, ...rest } = extra
+
+          let CIGAR = extra.cg
+          if (extra.cg) {
+            if (flip && strand === -1) {
+              CIGAR = flipCigar(parseCigar(extra.cg)).join('')
+            } else if (flip) {
+              CIGAR = swapIndelCigar(extra.cg)
+            }
+          }
+
+          observer.next(
+            new SyntenyFeature({
+              uniqueId: i + assemblyName,
+              assemblyName,
+              start,
+              end,
+              type: 'match',
+              refName,
+              strand,
+              ...rest,
+              CIGAR,
+              syntenyId: i,
+              identity: numMatches / blockLen,
+              numMatches,
+              blockLen,
+              mate: {
+                start: mateStart,
+                end: mateEnd,
+                refName: mateName,
+                assemblyName: assemblyNames[+flip],
+              },
+            }),
+          )
+        }
+      }
+
+      observer.complete()
+    })
+  }
+
+  freeResources(/* { query } */): void {}
+}

package/src/PAFAdapter/SyntenyFeature.ts

@@ -0,0 +1,15 @@
+import { SimpleFeature } from '@jbrowse/core/util'
+import { MismatchParser } from '@jbrowse/plugin-alignments'
+
+// locals
+const { getMismatches } = MismatchParser
+
+export default class SyntenyFeature extends SimpleFeature {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  get(arg: string): any {
+    if (arg === 'mismatches') {
+      return getMismatches(this.get('CIGAR'))
+    }
+    return super.get(arg)
+  }
+}