@jbrowse/plugin-sequence 2.1.0 → 2.1.3

package/src/IndexedFastaAdapter/IndexedFastaAdapter.ts

@@ -9,23 +9,20 @@ import { ObservableCreate } from '@jbrowse/core/util/rxjs'
 import { SimpleFeature, Feature } from '@jbrowse/core/util'
 import { AnyConfigurationModel } from '@jbrowse/core/configuration'
 import AbortablePromiseCache from 'abortable-promise-cache'
-import LRU from '@jbrowse/core/util/QuickLRU'
+import QuickLRU from '@jbrowse/core/util/QuickLRU'
 import PluginManager from '@jbrowse/core/PluginManager'
 import { getSubAdapterType } from '@jbrowse/core/data_adapters/dataAdapterCache'
 
-export default class extends BaseSequenceAdapter {
-  protected fasta: IndexedFasta
+type T = { refName: string; start: number; end: number; fasta: IndexedFasta }
 
-  protected header?: Promise<string>
+export default class extends BaseSequenceAdapter {
+  protected setupP?: Promise<{ fasta: IndexedFasta }>
 
-  private seqCache = new AbortablePromiseCache({
-    cache: new LRU({ maxSize: 200 }),
-    fill: async (
-      args: { refName: string; start: number; end: number },
-      signal?: AbortSignal,
-    ) => {
-      const { refName, start, end } = args
-      return this.fasta.getSequence(refName, start, end, { ...args, signal })
+  private seqCache = new AbortablePromiseCache<T, string | undefined>({
+    cache: new QuickLRU({ maxSize: 200 }),
+    fill: async (args: T, signal?: AbortSignal) => {
+      const { refName, start, end, fasta } = args
+      return fasta.getSequence(refName, start, end, { ...args, signal })
     },
   })
 
@@ -35,22 +32,16 @@ export default class extends BaseSequenceAdapter {
     pluginManager?: PluginManager,
   ) {
     super(config, getSubAdapter, pluginManager)
-    const fastaLocation = this.getConf('fastaLocation')
-    const faiLocation = this.getConf('faiLocation')
-    const fastaOpts = {
-      fasta: openLocation(fastaLocation as FileLocation, this.pluginManager),
-      fai: openLocation(faiLocation as FileLocation, this.pluginManager),
-    }
-
-    this.fasta = new IndexedFasta(fastaOpts)
   }
 
-  public getRefNames(opts?: BaseOptions) {
-    return this.fasta.getSequenceNames(opts)
+  public async getRefNames(opts?: BaseOptions) {
+    const { fasta } = await this.setup()
+    return fasta.getSequenceNames(opts)
   }
 
   public async getRegions(opts?: BaseOptions) {
-    const seqSizes = await this.fasta.getSequenceSizes(opts)
+    const { fasta } = await this.setup()
+    const seqSizes = await fasta.getSequenceSizes(opts)
     return Object.keys(seqSizes).map(refName => ({
       refName,
       start: 0,
@@ -58,30 +49,40 @@ export default class extends BaseSequenceAdapter {
     }))
   }
 
-  public async getHeader() {
-    if (this.header) {
-      return this.header
-    }
-    const loc = this.getConf('metadataLocation')
+  public async setupPre() {
+    const fastaLocation = this.getConf('fastaLocation') as FileLocation
+    const faiLocation = this.getConf('faiLocation') as FileLocation
 
-    if (loc.uri === '' || loc.uri === '/path/to/fa.metadata.yaml') {
-      return null
+    return {
+      fasta: new IndexedFasta({
+        fasta: openLocation(fastaLocation, this.pluginManager),
+        fai: openLocation(faiLocation, this.pluginManager),
+      }),
     }
+  }
 
-    this.header = openLocation(loc)
-      .readFile('utf8')
-      .catch(e => {
-        this.header = undefined
+  public async getHeader() {
+    const loc = this.getConf('metadataLocation')
+    return loc.uri === '' || loc.uri === '/path/to/fa.metadata.yaml'
+      ? null
+      : openLocation(loc).readFile('utf8')
+  }
+
+  public async setup() {
+    if (!this.setupP) {
+      this.setupP = this.setupPre().catch(e => {
+        this.setupP = undefined
         throw e
       })
-
-    return this.header
+    }
+    return this.setupP
   }
 
   public getFeatures(region: NoAssemblyRegion, opts?: BaseOptions) {
     const { refName, start, end } = region
     return ObservableCreate<Feature>(async observer => {
-      const size = await this.fasta.getSequenceSize(refName, opts)
+      const { fasta } = await this.setup()
+      const size = await fasta.getSequenceSize(refName, opts)
       const regionEnd = size !== undefined ? Math.min(size, end) : end
       const chunks = []
       const chunkSize = 128000
@@ -94,7 +95,9 @@ export default class extends BaseSequenceAdapter {
           start: chunkStart,
           end: chunkStart + chunkSize,
         }
-        chunks.push(this.seqCache.get(JSON.stringify(r), r, opts?.signal))
+        chunks.push(
+          this.seqCache.get(JSON.stringify(r), { ...r, fasta }, opts?.signal),
+        )
       }
       const seq = (await Promise.all(chunks))
         .join('')

package/src/IndexedFastaAdapter/index.ts

@@ -1 +1,22 @@
-export { default as configSchema } from './configSchema'
+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: 'IndexedFastaAdapter',
+        configSchema,
+        adapterMetadata: {
+          category: null,
+          hiddenFromGUI: true,
+          displayName: null,
+          description: null,
+        },
+        getAdapterClass: () =>
+          import('./IndexedFastaAdapter').then(r => r.default),
+      }),
+  )
+}

package/src/LinearReferenceSequenceDisplay/configSchema.ts

@@ -1,5 +1,5 @@
 import { ConfigurationSchema } from '@jbrowse/core/configuration'
-import { configSchema as divSequenceRendererConfigSchema } from '../DivSequenceRenderer'
+import { default as divSequenceRendererConfigSchema } from '../DivSequenceRenderer/configSchema'
 
 export const configSchema = ConfigurationSchema(
   'LinearReferenceSequenceDisplay',

package/src/LinearReferenceSequenceDisplay/index.ts

@@ -1,2 +1,19 @@
-export { configSchema } from './configSchema'
-export { modelFactory } from './model'
+import PluginManager from '@jbrowse/core/PluginManager'
+import { BaseLinearDisplayComponent } from '@jbrowse/plugin-linear-genome-view'
+
+import { configSchema } from './configSchema'
+import { modelFactory } from './model'
+
+export default (pluginManager: PluginManager) => {
+  pluginManager.addDisplayType(() => {
+    const stateModel = modelFactory(configSchema)
+    return {
+      name: 'LinearReferenceSequenceDisplay',
+      configSchema,
+      stateModel,
+      trackType: 'ReferenceSequenceTrack',
+      viewType: 'LinearGenomeView',
+      ReactComponent: BaseLinearDisplayComponent,
+    }
+  })
+}

package/src/ReferenceSequenceTrack/index.ts

@@ -0,0 +1,21 @@
+import PluginManager from '@jbrowse/core/PluginManager'
+
+import TrackType from '@jbrowse/core/pluggableElementTypes/TrackType'
+import { createBaseTrackModel } from '@jbrowse/core/pluggableElementTypes/models'
+import { createReferenceSeqTrackConfig } from './configSchema'
+
+export default (pluginManager: PluginManager) => {
+  pluginManager.addTrackType(() => {
+    const configSchema = createReferenceSeqTrackConfig(pluginManager)
+
+    return new TrackType({
+      name: 'ReferenceSequenceTrack',
+      configSchema,
+      stateModel: createBaseTrackModel(
+        pluginManager,
+        'ReferenceSequenceTrack',
+        configSchema,
+      ),
+    })
+  })
+}

package/src/SequenceSearchAdapter/SequenceSearchAdapter.ts

@@ -0,0 +1,103 @@
+import {
+  BaseFeatureDataAdapter,
+  BaseOptions,
+} from '@jbrowse/core/data_adapters/BaseAdapter'
+import { ObservableCreate } from '@jbrowse/core/util/rxjs'
+import {
+  SimpleFeature,
+  Feature,
+  Region,
+  revcom,
+  doesIntersect2,
+} from '@jbrowse/core/util'
+import { toArray } from 'rxjs/operators'
+
+export default class extends BaseFeatureDataAdapter {
+  public async configure() {
+    const adapter = await this.getSubAdapter?.(this.getConf('sequenceAdapter'))
+    if (!adapter) {
+      throw new Error('Error getting subadapter')
+    }
+    return adapter.dataAdapter as BaseFeatureDataAdapter
+  }
+
+  public async getRefNames() {
+    const adapter = await this.configure()
+    return adapter.getRefNames()
+  }
+
+  public getFeatures(query: Region, opts: BaseOptions) {
+    return ObservableCreate<Feature>(async observer => {
+      const sequenceAdapter = await this.configure()
+      const hw = 1000
+      let { start: queryStart, end: queryEnd } = query
+      queryStart = Math.max(0, queryStart - hw)
+      queryEnd += hw
+
+      if (queryEnd < 0 || queryStart > queryEnd) {
+        observer.complete()
+        return
+      }
+
+      const ret = sequenceAdapter.getFeatures(
+        {
+          ...query,
+          start: queryStart,
+          end: queryEnd,
+        },
+        opts,
+      )
+      const feats = await ret.pipe(toArray()).toPromise()
+      const residues: string = feats[0]?.get('seq') || ''
+      const search = this.getConf('search')
+      const searchFoward = this.getConf('searchForward')
+      const searchReverse = this.getConf('searchReverse')
+      const caseInsensitive = this.getConf('caseInsensitive')
+      const re = new RegExp(search, 'g' + (caseInsensitive ? 'i' : ''))
+
+      if (search) {
+        if (searchFoward) {
+          const matches = residues.matchAll(re)
+          for (const match of matches) {
+            const s = queryStart + (match.index || 0)
+
+            if (doesIntersect2(s, s + search.length, query.start, query.end)) {
+              observer.next(
+                new SimpleFeature({
+                  uniqueId: `${this.id}-match-${s}-p`,
+                  refName: query.refName,
+                  start: s,
+                  end: s + match[0].length,
+                  name: match[0],
+                  strand: 1,
+                }),
+              )
+            }
+          }
+        }
+        if (searchReverse) {
+          const matches = revcom(residues).matchAll(re)
+          for (const match of matches) {
+            const s = queryEnd - (match.index || 0)
+            if (doesIntersect2(s, s + search.length, query.start, query.end)) {
+              observer.next(
+                new SimpleFeature({
+                  uniqueId: `${this.id}-match-${s}-n`,
+                  refName: query.refName,
+                  start: s - match[0].length,
+                  name: match[0],
+                  end: s,
+                  strand: -1,
+                }),
+              )
+            }
+          }
+        }
+      }
+
+      observer.complete()
+    })
+  }
+
+  public freeResources() {}
+}

package/src/SequenceSearchAdapter/configSchema.ts

@@ -0,0 +1,31 @@
+import { ConfigurationSchema } from '@jbrowse/core/configuration'
+
+const configSchema = ConfigurationSchema(
+  'SequenceSearchAdapter',
+  {
+    search: {
+      type: 'string',
+      defaultValue: '',
+      description: 'Search string or regex to search for',
+    },
+    sequenceAdapter: {
+      type: 'frozen',
+      defaultValue: null,
+    },
+    searchForward: {
+      type: 'boolean',
+      defaultValue: true,
+    },
+    searchReverse: {
+      type: 'boolean',
+      defaultValue: true,
+    },
+    caseInsensitive: {
+      type: 'boolean',
+      defaultValue: true,
+    },
+  },
+  { explicitlyTyped: true },
+)
+
+export default configSchema

package/src/SequenceSearchAdapter/index.ts

@@ -0,0 +1,22 @@
+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: 'SequenceSearchAdapter',
+        adapterMetadata: {
+          category: null,
+          hiddenFromGUI: true,
+          displayName: null,
+          description: null,
+        },
+        configSchema,
+        getAdapterClass: () =>
+          import('./SequenceSearchAdapter').then(r => r.default),
+      }),
+  )
+}

package/src/TwoBitAdapter/index.ts

@@ -1 +1,21 @@
-export { default as configSchema } from './configSchema'
+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: 'TwoBitAdapter',
+        configSchema,
+        adapterMetadata: {
+          category: null,
+          hiddenFromGUI: true,
+          displayName: null,
+          description: null,
+        },
+        getAdapterClass: () => import('./TwoBitAdapter').then(r => r.default),
+      }),
+  )
+}

package/src/createExtensionPoints.ts

@@ -0,0 +1,122 @@
+import PluginManager from '@jbrowse/core/PluginManager'
+import { FileLocation } from '@jbrowse/core/util/types'
+import {
+  makeIndex,
+  getFileName,
+  AdapterGuesser,
+  TrackTypeGuesser,
+} from '@jbrowse/core/util/tracks'
+
+export default (pluginManager: PluginManager) => {
+  pluginManager.addToExtensionPoint(
+    'Core-guessAdapterForLocation',
+    (adapterGuesser: AdapterGuesser) => {
+      return (
+        file: FileLocation,
+        index?: FileLocation,
+        adapterHint?: string,
+      ) => {
+        const regexGuess = /\.2bit$/i
+        const adapterName = 'TwoBitAdapter'
+        const fileName = getFileName(file)
+        const obj = {
+          type: adapterName,
+          twoBitLocation: file,
+        }
+        if (regexGuess.test(fileName) && !adapterHint) {
+          return obj
+        } else if (adapterHint === adapterName) {
+          return obj
+        }
+        return adapterGuesser(file, index, adapterHint)
+      }
+    },
+  )
+  pluginManager.addToExtensionPoint(
+    'Core-guessTrackTypeForLocation',
+    (trackTypeGuesser: TrackTypeGuesser) => {
+      return (adapterName: string) => {
+        if (adapterName === 'TwoBitAdapter') {
+          return 'ReferenceSequenceTrack'
+        }
+        return trackTypeGuesser(adapterName)
+      }
+    },
+  )
+
+  pluginManager.addToExtensionPoint(
+    'Core-guessAdapterForLocation',
+    (adapterGuesser: AdapterGuesser) => {
+      return (
+        file: FileLocation,
+        index?: FileLocation,
+        adapterHint?: string,
+      ) => {
+        const regexGuess = /\.(fa|fasta|fas|fna|mfa)$/i
+        const adapterName = 'IndexedFastaAdapter'
+        const fileName = getFileName(file)
+        const obj = {
+          type: adapterName,
+          fastaLocation: file,
+          faiLocation: index || makeIndex(file, '.fai'),
+        }
+
+        if (regexGuess.test(fileName) && !adapterHint) {
+          return obj
+        } else if (adapterHint === adapterName) {
+          return obj
+        }
+        return adapterGuesser(file, index, adapterHint)
+      }
+    },
+  )
+  pluginManager.addToExtensionPoint(
+    'Core-guessTrackTypeForLocation',
+    (trackTypeGuesser: TrackTypeGuesser) => {
+      return (adapterName: string) => {
+        if (adapterName === 'IndexedFastaAdapter') {
+          return 'ReferenceSequenceTrack'
+        }
+        return trackTypeGuesser(adapterName)
+      }
+    },
+  )
+
+  pluginManager.addToExtensionPoint(
+    'Core-guessAdapterForLocation',
+    (adapterGuesser: AdapterGuesser) => {
+      return (
+        file: FileLocation,
+        index?: FileLocation,
+        adapterHint?: string,
+      ) => {
+        const regexGuess = /\.(fa|fasta|fas|fna|mfa)\.b?gz$/i
+        const adapterName = 'BgzipFastaAdapter'
+        const fileName = getFileName(file)
+        const obj = {
+          type: adapterName,
+          faiLocation: makeIndex(file, '.fai'),
+          gziLocation: makeIndex(file, '.gzi'),
+        }
+
+        if (regexGuess.test(fileName) && !adapterHint) {
+          return obj
+        } else if (adapterHint === adapterName) {
+          return obj
+        }
+        return adapterGuesser(file, index, adapterHint)
+      }
+    },
+  )
+  pluginManager.addToExtensionPoint(
+    'Core-guessTrackTypeForLocation',
+    (trackTypeGuesser: TrackTypeGuesser) => {
+      return (adapterName: string) => {
+        if (adapterName === 'BgzipFastaAdapter') {
+          return 'ReferenceSequenceTrack'
+        }
+        return trackTypeGuesser(adapterName)
+      }
+    },
+  )
+}