genoverse 3.2.0 → 4.0.1

package/src/js/Track/Model/File/BAM.js

@@ -0,0 +1,47 @@
+import makeBam                         from '../../../lib/dalliance/bam';
+import { URLFetchable, BlobFetchable } from '../../../lib/dalliance/bin';
+import Model                           from '../File';
+
+export default Model.extend({
+  getData: function (chr, start, end) {
+    const deferred = this.browser.jQuery.Deferred();
+
+    if (!this.bamFile) {
+      if (this.url) {
+        this.bamFile = new URLFetchable(this.url);
+        this.baiFile = new URLFetchable(this.url + this.prop('indexExt'));
+      } else if (this.dataFile && this.indexFile) {
+        this.bamFile = new BlobFetchable(this.dataFile);
+        this.baiFile = new BlobFetchable(this.indexFile);
+      } else {
+        return deferred.reject(new Error('BAM files must be accompanied by a .bai index file'));
+      }
+    }
+
+    makeBam(this.bamFile, this.baiFile, null, (bam, makeBamError) => {
+      if (makeBamError) {
+        console.error(makeBamError); // eslint-disable-line no-console
+      } else {
+        bam.fetch(chr, start, end, (features, fetchBamError) => {
+          if (fetchBamError) {
+            console.error(fetchBamError); // eslint-disable-line no-console
+          } else {
+            this.receiveData(features, chr, start, end);
+            deferred.resolve();
+          }
+        });
+      }
+    });
+
+    return deferred;
+  },
+
+  insertFeature: function (feature) {
+    feature.id       = `${feature.chr}:${feature.readName}:${feature.pos}`;
+    feature.start    = feature.pos + 1;
+    feature.end      = feature.start + feature.seq.length;
+    feature.sequence = feature.seq;
+
+    return this.base(feature);
+  },
+});

package/src/js/Track/Model/File/BED.js

@@ -0,0 +1,122 @@
+import Model from '../File';
+
+export default Model.extend({
+  parseData: function (data, chr) {
+    const lines       = typeof data === 'string' ? data.split('\n') : data;
+    const thinHeight  = this.prop('thinHeight');
+    const thickHeight = this.prop('thickHeight');
+
+    function filterNumber(n) {
+      return !isNaN(n);
+    }
+
+    lines.forEach(
+      (line) => {
+        const fields = line.split('\t').filter(f => f);
+
+        if (fields.length < 3 || fields[0] === 'track' || fields[0] === 'browser') {
+          return;
+        }
+
+        const len = fields.length;
+
+        if (fields[0] === String(chr) || fields[0].toLowerCase() === `chr${chr}` || fields[0].match(`[^1-9]${chr}$`)) {
+          const feature = {
+            chr             : chr,
+            start           : parseInt(fields[1], 10) + 1,
+            end             : parseInt(fields[2], 10),
+            name            : fields[3],
+            color           : '#000000',
+            originalFeature : fields,
+          };
+
+          if (len > 3) { feature.score = parseFloat(fields[4], 10); }
+          if (len > 5) { feature.strand = fields[5];                }
+
+          if (len > 7) {
+            feature.thickStart = parseInt(fields[6], 10) + 1;
+            feature.thickEnd   = parseInt(fields[7], 10);
+            feature.drawThick  = fields[6] !== fields[7];
+          }
+
+          if (fields[8]) {
+            feature.color = `rgb(${fields[8]})`;
+          } else {
+            feature.color = this.scoreColor(isNaN(feature.score) ? 1000 : feature.score);
+          }
+
+          if (len === 12) { // subfeatures present
+            feature.blockCount = parseInt(fields[9], 10);
+
+            const subfeatures = [];
+            const blockSizes  = fields[10].split(',').filter(filterNumber);
+            const blockStarts = fields[11].split(',').filter(filterNumber);
+
+            blockSizes.forEach(
+              (blockSize, i) => {
+                const subfeature = {
+                  start  : feature.start + parseInt(blockStarts[i], 10),
+                  height : thinHeight, // if subfeature lies entirely left / right to [ thickStart, thickEnd ]
+                };
+
+                subfeature.end = subfeature.start + parseInt(blockSize, 10) - 1;
+
+                if (feature.drawThick && subfeature.start <= feature.thickEnd && subfeature.end >= feature.thickStart) {
+                  // some kind of an overlap for sure
+                  if (subfeature.start >= feature.thickStart && subfeature.end <= feature.thickEnd) {
+                    // subfeature within thickBlock, draw thick
+                    subfeature.height = thickHeight;
+                    subfeatures.push(subfeature);
+                  } else if (subfeature.start < feature.thickStart && subfeature.end <= feature.thickEnd) {
+                    // left overlap, split subfeature into 2 - thin | thick
+                    const thinFeature  = { ...subfeature, end: feature.thickStart };
+                    const thickFeature = { ...subfeature, start: feature.thickStart, height: thickHeight };
+
+                    subfeatures.push(...[ thinFeature, thickFeature ]);
+                  } else if (subfeature.start >= feature.thickStart && subfeature.end > feature.thickEnd) {
+                    // right overlap, split subfeature into 2 - thick | thin
+                    const thinFeature  = { ...subfeature, start: feature.thickEnd };
+                    const thickFeature = { ...subfeature, end: feature.thickEnd, height: thickHeight };
+
+                    subfeatures.push(...[ thickFeature, thinFeature ]);
+                  } else {
+                    // thickBlock lies within subfeature, split into 3 - thin | thick | thin
+                    // the least possible case but lets be prepared for the outliers
+                    const thinFeature1 = { ...subfeature, end: feature.thickStart };
+                    const thinFeature2 = { ...subfeature, start: feature.thickEnd };
+                    const thickFeature = { start: feature.thickStart, end: feature.thickEnd, height: thickHeight };
+
+                    subfeatures.push(...[ thinFeature1, thickFeature, thinFeature2 ]);
+                  }
+                } else {
+                  // no thick block
+                  subfeatures.push(subfeature);
+                }
+              }
+            );
+
+            if (subfeatures.length) {
+              feature.subFeatures = subfeatures;
+            }
+          }
+
+          this.insertFeature(feature);
+        }
+      }
+    );
+  },
+
+  // As per https://genome.ucsc.edu/FAQ/FAQformat.html#format1 specification
+  scoreColor: function (score) {
+    if (score <= 166) { return 'rgb(219,219,219)'; }
+    if (score <= 277) { return 'rgb(186,186,186)'; }
+    if (score <= 388) { return 'rgb(154,154,154)'; }
+    if (score <= 499) { return 'rgb(122,122,122)'; }
+    if (score <= 611) { return 'rgb(94,94,94)';    }
+    if (score <= 722) { return 'rgb(67,67,67)';    }
+    if (score <= 833) { return 'rgb(42,42,42)';    }
+    if (score <= 944) { return 'rgb(21,21,21)';    }
+
+    return '#000000';
+  },
+});

package/src/js/Track/Model/File/GFF.js

@@ -0,0 +1,42 @@
+import Model from '../File';
+
+export default Model.extend({
+  parseData: function (text, chr) {
+    const lines = text.split('\n');
+
+    lines.forEach(
+      (line) => {
+        if (!line.length || line.indexOf('#') === 0) {
+          return;
+        }
+
+        const fields = line.split('\t');
+
+        if (fields.length < 5) {
+          return;
+        }
+
+        const seqId = fields[0].toLowerCase();
+
+        if (
+          seqId === String(chr)        ||
+          seqId === `chr${chr}`        ||
+          seqId.match(`[^1-9]${chr}$`) ||
+          seqId.match(`^${chr}\\b`)
+        ) {
+          this.insertFeature({
+            id     : fields.slice(0, 5).join('|'),
+            chr    : chr,
+            start  : parseInt(fields[3], 10),
+            end    : parseInt(fields[4], 10),
+            source : fields[1],
+            type   : fields[2],
+            score  : fields[5],
+            strand : fields[6] === '-' ? -1 : 1,
+            label  : `${fields[1]} ${fields[2]} ${fields[3]}-${fields[4]}`,
+          });
+        }
+      }
+    );
+  },
+});

package/src/js/Track/Model/File/VCF.js

@@ -0,0 +1,109 @@
+import VCFReader                       from '../../../lib/VCFReader';
+import { URLFetchable, BlobFetchable } from '../../../lib/dalliance/bin';
+import Model                           from '../File';
+
+export default Model.extend({
+  getData: function (chr, start, end, done) {
+    if (!this.prop('gz')) {
+      return this.base(chr, start, end, done);
+    }
+
+    const deferred = this.browser.jQuery.Deferred();
+
+    if (!this.vcfFile) {
+      if (this.url) {
+        this.vcfFile = new URLFetchable(this.url);
+        this.tbiFile = new URLFetchable(this.url + this.prop('indexExt'));
+      } else if (this.dataFile && this.indexFile) {
+        this.vcfFile = new BlobFetchable(this.dataFile);
+        this.tbiFile = new BlobFetchable(this.indexFile);
+      } else {
+        return deferred.reject(new Error('GZipped VCF files must be accompanied by a .tbi index file'));
+      }
+    }
+
+    this.makeVCF(this.vcfFile, this.tbiFile).then((vcf) => {
+      this.cachedVCF = vcf;
+
+      vcf.getRecords(chr, start, end, (records) => {
+        this.receiveData(records, chr, start, end);
+        deferred.resolve();
+      });
+    });
+
+    return deferred;
+  },
+
+  makeVCF: function (vcfFile, tbiFile) {
+    const deferred = this.browser.jQuery.Deferred();
+
+    if (this.cachedVCF) {
+      deferred.resolve(this.cachedVCF);
+    } else {
+      const vcf = new VCFReader(vcfFile, tbiFile);
+
+      vcf.readTabix((tabix) => {
+        vcf.tabix = tabix;
+        deferred.resolve(vcf);
+      });
+    }
+
+    return deferred;
+  },
+
+  parseData: function (text, chr) {
+    const lines = text.split('\n');
+
+    let maxQual = this.allData ? this.prop('maxQual') || 0 : false;
+
+    lines.forEach(
+      (line) => {
+        if (!line.length || line.indexOf('#') === 0) {
+          return;
+        }
+
+        const fields = line.split('\t');
+
+        if (fields.length < 5) {
+          return;
+        }
+
+        if (fields[0] === String(chr) || fields[0] === `chr${chr}`) {
+          const id      = fields.slice(0, 3).join('|');
+          const start   = parseInt(fields[1], 10);
+          const alleles = fields[4].split(',');
+
+          alleles.unshift(fields[3]);
+
+          alleles.forEach(
+            (allele, i) => {
+              const end = start + allele.length - 1;
+
+              this.insertFeature({
+                id              : `${id}|${allele}`,
+                sort            : i,
+                chr             : chr,
+                start           : start,
+                end             : end,
+                width           : end - start,
+                allele          : i === 0 ? 'REF' : 'ALT',
+                sequence        : allele,
+                label           : allele,
+                labelColor      : '#FFFFFF',
+                originalFeature : fields,
+              });
+            }
+          );
+
+          if (maxQual !== false) {
+            maxQual = Math.max(maxQual, fields[5]);
+          }
+        }
+      }
+    );
+
+    if (maxQual) {
+      this.prop('maxQual', maxQual);
+    }
+  },
+});

package/src/js/Track/Model/File/WIG.js

@@ -0,0 +1,82 @@
+import { Model as BarGraphModel } from '../../library/Graph/Bar';
+import Model                      from '../File';
+
+export default BarGraphModel.extend({
+  dataType: 'text',
+
+  getData: function (...args) {
+    if (!this.url) {
+      this.isLocal  = true;
+      this.dataFile = this.track.dataFile;
+
+      return Model.prototype.getData(...args);
+    }
+
+    return this.base(...args);
+  },
+
+  parseData: function (text, chr, s, e) {
+    const lines    = text.split('\n');
+    const features = [];
+
+    let firstFeatureLine;
+
+    while (lines.length) {
+      firstFeatureLine = lines.shift();
+
+      if (!firstFeatureLine) {
+        break;
+      }
+
+      if (firstFeatureLine.indexOf('#') !== -1 || firstFeatureLine.indexOf('browser') !== -1 || firstFeatureLine.indexOf('track') !== -1) {
+        continue;
+      } else {
+        break;
+      }
+    }
+
+    if (firstFeatureLine) {
+      const fields = firstFeatureLine.split(/\s+/);
+      const chrom  = parseInt(fields[1].split('=')[1].replace('chr', ''), 10);
+
+      if (fields[0] === 'fixedStep') {
+        const step = parseInt(fields[3].split('=')[1], 10);
+        const span = fields[4] ? parseInt(fields[4].split('=')[1], 10) : 1;
+
+        let start = parseInt(fields[2].split('=')[1], 10);
+
+        lines.forEach(
+          (line) => {
+            features.push({
+              chr    : chrom,
+              start  : start,
+              end    : start + span,
+              height : parseFloat(line),
+            });
+
+            start += step;
+          }
+        );
+      } else if (fields[0] === 'variableStep') {
+        const span = fields[2] ? parseInt(fields[2].split('=')[1], 10) : 1;
+
+        lines.forEach(
+          (line) => {
+            const lineFields = line.split(/\s+/);
+            const feature    = {
+              chr    : chrom,
+              start  : parseInt(lineFields[0], 10),
+              height : parseFloat(lineFields[1]),
+            };
+
+            feature.end = feature.start + span;
+
+            features.push(feature);
+          }
+        );
+      }
+    }
+
+    return this.base.call(this, features, chr, s, e);
+  },
+});

package/src/js/Track/Model/File.js

@@ -0,0 +1,36 @@
+import Model from '../Model';
+
+export default Model.extend({
+  dataType: 'text',
+
+  init: function (...args) {
+    if (this.isLocal) {
+      this.url = false;
+    }
+
+    if (!(this.largeFile || this.indexFile)) {
+      this.allData = true;
+    }
+
+    this.base(...args);
+  },
+
+  getData: function (chr, ...args) {
+    if (this.isLocal && this.dataFile) {
+      const reader   = new FileReader();
+      const deferred = this.browser.jQuery.Deferred();
+
+      reader.onload = (e) => {
+        deferred.done(() => {
+          this.receiveData(e.target.result, chr, 1, this.browser.getChromosomeSize(chr));
+        }).resolve();
+      };
+
+      reader.readAsText(this.dataFile);
+
+      return deferred;
+    }
+
+    return this.base(chr, ...args);
+  },
+});

package/src/js/Track/Model/Gene/Ensembl.js

@@ -0,0 +1,24 @@
+import Model from '../Gene';
+
+// Ensembl REST API Gene model
+export default Model.extend({
+  url              : '//rest.ensembl.org/overlap/region/human/__CHR__:__START__-__END__?feature=gene;content-type=application/json',
+  dataRequestLimit : 5000000, // As per e! REST API restrictions
+
+  // The url above responds in json format, data is an array
+  // We assume that parents always preceed children in data array, gene -> transcript -> exon
+  // See rest.ensembl.org/documentation/info/feature_region for more details
+  parseData: function (data, chr) {
+    data.forEach(
+      (feature) => {
+        if (feature.feature_type === 'gene' && !this.featuresById[feature.id]) {
+          feature.chr         = feature.chr || chr;
+          feature.label       = parseInt(feature.strand, 10) === 1 ? `${feature.external_name || feature.id} >` : `< ${feature.external_name || feature.id}`;
+          feature.transcripts = [];
+
+          this.insertFeature(feature);
+        }
+      }
+    );
+  },
+});

package/{js → src/js}/Track/Model/Gene.js

@@ -1,5 +1,7 @@
+import Model from '../Model';
+
 // Abstract Gene model
 // see sub-models for more specific examples
-Genoverse.Track.Model.Gene = Genoverse.Track.Model.extend({
+export default Model.extend({
 
 });

package/src/js/Track/Model/Sequence/Ensembl.js

@@ -0,0 +1,6 @@
+import Model from '../Sequence';
+
+export default Model.extend({
+  url              : '//rest.ensembl.org/sequence/region/human/__CHR__:__START__-__END__?content-type=text/plain', // Example url
+  dataRequestLimit : 10000000, // As per e! REST API restrictions
+});

package/{js → src/js}/Track/Model/Sequence/Fasta.js

@@ -1,4 +1,6 @@
-Genoverse.Track.Model.Sequence.Fasta = Genoverse.Track.Model.Sequence.extend({
+import Model from '../Sequence';
+
+export default Model.extend({
   url: 'https://wtsi-web.github.io/Genoverse/data/Homo_sapiens.GRCh37.72.dna.chromosome.1.fa', // Example url
 
   // Following settings could be left undefined and will be detected automatically via .getStartByte()
@@ -8,25 +10,31 @@ Genoverse.Track.Model.Sequence.Fasta = Genoverse.Track.Model.Sequence.extend({
   // TODO: Check if URL provided
 
   getData: function (chr, start, end) {
-    var deferred = $.Deferred();
+    const jQuery   = this.browser.jQuery;
+    const deferred = jQuery.Deferred();
 
-    $.when(this.getStartByte()).done(function () {
+    jQuery.when(this.getStartByte()).done(() => {
       start = start - (start % this.chunkSize) + 1;
       end   = end + this.chunkSize - (end % this.chunkSize);
 
-      var startByte = start - 1 + Math.floor((start - 1) / this.lineLength) + this.startByte;
-      var endByte   = end   - 1 + Math.floor((end   - 1) / this.lineLength) + this.startByte;
+      const startByte = start - 1 + Math.floor((start - 1) / this.lineLength) + this.startByte;
+      const endByte   = end   - 1 + Math.floor((end   - 1) / this.lineLength) + this.startByte;
 
-      $.ajax({
+      jQuery.ajax({
         url       : this.parseURL(),
         dataType  : this.dataType,
-        context   : this,
-        headers   : { Range: 'bytes=' + startByte + '-' + endByte },
+        headers   : { Range: `bytes=${startByte}-${endByte}` },
         xhrFields : this.xhrFields,
-        success   : function (data) { this.receiveData(data, chr, start, end); },
-        error     : this.track.controller.showError
-      }).done(function () { deferred.resolveWith(this); }).fail(function () { deferred.rejectWith(this); });
-    }).fail(function () { deferred.rejectWith(this); });
+        success   : (data) =>  { this.receiveData(data, chr, start, end); },
+        error     : this.track.controller.showError,
+      }).done(() => {
+        deferred.resolve();
+      }).fail(() => {
+        deferred.reject();
+      });
+    }).fail(() => {
+      deferred.reject();
+    });
 
     return deferred;
   },
@@ -37,13 +45,12 @@ Genoverse.Track.Model.Sequence.Fasta = Genoverse.Track.Model.Sequence.extend({
     }
 
     if (this.startByte === undefined || this.lineLength === undefined) {
-      this.startByteRequest = $.ajax({
+      this.startByteRequest = this.browser.jQuery.ajax({
         url       : this.parseURL(),
         dataType  : 'text',
-        context   : this,
         headers   : { 'Range': 'bytes=0-300' },
         xhrFields : this.xhrFields,
-        success   : function (data) {
+        success   : (data) => {
           if (data.indexOf('>') === 0) {
             this.startByte = data.indexOf('\n') + 1;
           } else {
@@ -51,10 +58,10 @@ Genoverse.Track.Model.Sequence.Fasta = Genoverse.Track.Model.Sequence.extend({
           }
 
           this.lineLength = data.indexOf('\n', this.startByte) - this.startByte;
-        }
+        },
       });
 
       return this.startByteRequest;
     }
-  }
+  },
 });

package/{js → src/js}/Track/Model/Sequence.js

@@ -1,14 +1,16 @@
+import Model from '../Model';
+
 // Abstract Sequence model
 // assumes that the data source responds with raw sequence text
 // see Fasta model for more specific example
-Genoverse.Track.Model.Sequence = Genoverse.Track.Model.extend({
+export default Model.extend({
   threshold : 100000,
   chunkSize : 1000,
   buffer    : 0,
   dataType  : 'text',
 
   setChrProps: function () {
-    var chr = this.browser.chr;
+    const chr = this.browser.chr;
 
     this.base();
 
@@ -19,6 +21,7 @@ Genoverse.Track.Model.Sequence = Genoverse.Track.Model.extend({
   getData: function (chr, start, end) {
     start = start - (start % this.chunkSize) + 1;
     end   = end + this.chunkSize - (end % this.chunkSize);
+
     return this.base(chr, start, end);
   },
 
@@ -29,22 +32,22 @@ Genoverse.Track.Model.Sequence = Genoverse.Track.Model.extend({
       data = data.toLowerCase();
     }
 
-    for (var i = 0; i < data.length; i += this.chunkSize) {
+    for (let i = 0; i < data.length; i += this.chunkSize) {
       if (this.chunksByChr[chr][start + i]) {
         continue;
       }
 
-      var feature = {
-        id       : chr + ':' + start + ':' + i,
+      const feature = {
+        id       : `${chr}:${start}:${i}`,
         chr      : chr,
         start    : start + i,
         end      : start + i + this.chunkSize - 1,
         sequence : data.substr(i, this.chunkSize),
-        sort     : start + i
+        sort     : start + i,
       };
 
       this.chunksByChr[chr][feature.start] = feature;
       this.insertFeature(feature);
     }
-  }
+  },
 });

package/{js → src/js}/Track/Model/SequenceVariation.js

@@ -1,18 +1,23 @@
-Genoverse.Track.Model.SequenceVariation = Genoverse.Track.Model.extend({
-  seqModel: Genoverse.Track.Model.Sequence.Ensembl,
+import Model         from '../Model';
+import SequenceModel from './Sequence/Ensembl';
+
+export default Model.extend({
+  seqModel: SequenceModel,
 
   getSeqModel: function () {
-    var models = this.prop('models');
+    const models = this.prop('models');
+
     models.seq = models.seq || this.track.newMVC(this.seqModel);
+
     return models.seq;
   },
 
   getData: function (chr, start, end) {
-    var model    = this;
-    var deferred = $.Deferred();
-    var seqData  = this.getSeqModel().checkDataRange(chr, start, end);
+    const model    = this;
+    const deferred = this.browser.jQuery.Deferred();
+    const seqData  = this.getSeqModel().checkDataRange(chr, start, end);
 
-    this.base(chr, start, end).done(function () {
+    this.base(chr, start, end).done(() => {
       if (seqData) {
         deferred.resolve();
       } else {
@@ -24,11 +29,12 @@ Genoverse.Track.Model.SequenceVariation = Genoverse.Track.Model.extend({
   },
 
   insertFeature: function (feature) {
-    return this.base($.extend(feature, {
+    return this.base({
+      ...feature,
       end      : feature.start + feature.alt_allele.length - 1,
       length   : feature.alt_allele.length,
-      sequence : feature.alt_allele
-    }));
+      sequence : feature.alt_allele,
+    });
   },
 
   checkDataRange: function (chr, start, end) {
@@ -37,5 +43,5 @@ Genoverse.Track.Model.SequenceVariation = Genoverse.Track.Model.extend({
 
   findFeatures: function (chr, start, end) {
     return this.getSeqModel().findFeatures(chr, start, end).concat(this.base(chr, start, end));
-  }
+  },
 });