jbrowse-plugin-mafviewer 1.0.1

package/dist/jbrowse-plugin-mafviewer.umd.development.js

@@ -0,0 +1,1310 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@jbrowse/core/Plugin'), require('@jbrowse/core/pluggableElementTypes'), require('@jbrowse/core/configuration'), require('@jbrowse/core/data_adapters/BaseAdapter'), require('mobx-state-tree'), require('@jbrowse/core/util'), require('@jbrowse/core/util/rxjs'), require('react'), require('mobx-react'), require('@jbrowse/core/ui'), require('@mui/material'), require('tss-react/mui')) :
+  typeof define === 'function' && define.amd ? define(['exports', '@jbrowse/core/Plugin', '@jbrowse/core/pluggableElementTypes', '@jbrowse/core/configuration', '@jbrowse/core/data_adapters/BaseAdapter', 'mobx-state-tree', '@jbrowse/core/util', '@jbrowse/core/util/rxjs', 'react', 'mobx-react', '@jbrowse/core/ui', '@mui/material', 'tss-react/mui'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.JBrowsePluginMafViewer = {}, global.JBrowseExports["@jbrowse/core/Plugin"], global.JBrowseExports["@jbrowse/core/pluggableElementTypes"], global.JBrowseExports["@jbrowse/core/configuration"], global.JBrowseExports["@jbrowse/core/data_adapters/BaseAdapter"], global.JBrowseExports["mobx-state-tree"], global.JBrowseExports["@jbrowse/core/util"], global.JBrowseExports["@jbrowse/core/util/rxjs"], global.JBrowseExports.react, global.JBrowseExports["mobx-react"], global.JBrowseExports["@jbrowse/core/ui"], global.JBrowseExports["@mui/material"], global.JBrowseExports["tss-react/mui"]));
+})(this, (function (exports, Plugin, pluggableElementTypes, configuration, BaseAdapter, mobxStateTree, util, rxjs, React, mobxReact, ui, material, mui) { 'use strict';
+
+  var version = "1.0.1";
+
+  const configSchema$2 = configuration.ConfigurationSchema('BigMafAdapter', {
+      /**
+       * #slot
+       */
+      samples: {
+          type: 'stringArray',
+          defaultValue: [],
+      },
+      /**
+       * #slot
+       */
+      bigBedLocation: {
+          type: 'fileLocation',
+          defaultValue: {
+              uri: '/path/to/my.bb',
+              locationType: 'UriLocation',
+          },
+      },
+  }, { explicitlyTyped: true });
+
+  /******************************************************************************
+  Copyright (c) Microsoft Corporation.
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+  PERFORMANCE OF THIS SOFTWARE.
+  ***************************************************************************** */
+  /* global Reflect, Promise, SuppressedError, Symbol */
+
+  var extendStatics = function(d, b) {
+    extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+    return extendStatics(d, b);
+  };
+
+  function __extends(d, b) {
+    if (typeof b !== "function" && b !== null)
+        throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+    extendStatics(d, b);
+    function __() { this.constructor = d; }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+  }
+
+  function __values(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+  }
+
+  function __read(o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+  }
+
+  function __spreadArray(to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+  }
+
+  typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+  };
+
+  function isFunction(value) {
+      return typeof value === 'function';
+  }
+
+  function createErrorClass(createImpl) {
+      var _super = function (instance) {
+          Error.call(instance);
+          instance.stack = new Error().stack;
+      };
+      var ctorFunc = createImpl(_super);
+      ctorFunc.prototype = Object.create(Error.prototype);
+      ctorFunc.prototype.constructor = ctorFunc;
+      return ctorFunc;
+  }
+
+  var UnsubscriptionError = createErrorClass(function (_super) {
+      return function UnsubscriptionErrorImpl(errors) {
+          _super(this);
+          this.message = errors
+              ? errors.length + " errors occurred during unsubscription:\n" + errors.map(function (err, i) { return i + 1 + ") " + err.toString(); }).join('\n  ')
+              : '';
+          this.name = 'UnsubscriptionError';
+          this.errors = errors;
+      };
+  });
+
+  function arrRemove(arr, item) {
+      if (arr) {
+          var index = arr.indexOf(item);
+          0 <= index && arr.splice(index, 1);
+      }
+  }
+
+  var Subscription = (function () {
+      function Subscription(initialTeardown) {
+          this.initialTeardown = initialTeardown;
+          this.closed = false;
+          this._parentage = null;
+          this._finalizers = null;
+      }
+      Subscription.prototype.unsubscribe = function () {
+          var e_1, _a, e_2, _b;
+          var errors;
+          if (!this.closed) {
+              this.closed = true;
+              var _parentage = this._parentage;
+              if (_parentage) {
+                  this._parentage = null;
+                  if (Array.isArray(_parentage)) {
+                      try {
+                          for (var _parentage_1 = __values(_parentage), _parentage_1_1 = _parentage_1.next(); !_parentage_1_1.done; _parentage_1_1 = _parentage_1.next()) {
+                              var parent_1 = _parentage_1_1.value;
+                              parent_1.remove(this);
+                          }
+                      }
+                      catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                      finally {
+                          try {
+                              if (_parentage_1_1 && !_parentage_1_1.done && (_a = _parentage_1.return)) _a.call(_parentage_1);
+                          }
+                          finally { if (e_1) throw e_1.error; }
+                      }
+                  }
+                  else {
+                      _parentage.remove(this);
+                  }
+              }
+              var initialFinalizer = this.initialTeardown;
+              if (isFunction(initialFinalizer)) {
+                  try {
+                      initialFinalizer();
+                  }
+                  catch (e) {
+                      errors = e instanceof UnsubscriptionError ? e.errors : [e];
+                  }
+              }
+              var _finalizers = this._finalizers;
+              if (_finalizers) {
+                  this._finalizers = null;
+                  try {
+                      for (var _finalizers_1 = __values(_finalizers), _finalizers_1_1 = _finalizers_1.next(); !_finalizers_1_1.done; _finalizers_1_1 = _finalizers_1.next()) {
+                          var finalizer = _finalizers_1_1.value;
+                          try {
+                              execFinalizer(finalizer);
+                          }
+                          catch (err) {
+                              errors = errors !== null && errors !== void 0 ? errors : [];
+                              if (err instanceof UnsubscriptionError) {
+                                  errors = __spreadArray(__spreadArray([], __read(errors)), __read(err.errors));
+                              }
+                              else {
+                                  errors.push(err);
+                              }
+                          }
+                      }
+                  }
+                  catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                  finally {
+                      try {
+                          if (_finalizers_1_1 && !_finalizers_1_1.done && (_b = _finalizers_1.return)) _b.call(_finalizers_1);
+                      }
+                      finally { if (e_2) throw e_2.error; }
+                  }
+              }
+              if (errors) {
+                  throw new UnsubscriptionError(errors);
+              }
+          }
+      };
+      Subscription.prototype.add = function (teardown) {
+          var _a;
+          if (teardown && teardown !== this) {
+              if (this.closed) {
+                  execFinalizer(teardown);
+              }
+              else {
+                  if (teardown instanceof Subscription) {
+                      if (teardown.closed || teardown._hasParent(this)) {
+                          return;
+                      }
+                      teardown._addParent(this);
+                  }
+                  (this._finalizers = (_a = this._finalizers) !== null && _a !== void 0 ? _a : []).push(teardown);
+              }
+          }
+      };
+      Subscription.prototype._hasParent = function (parent) {
+          var _parentage = this._parentage;
+          return _parentage === parent || (Array.isArray(_parentage) && _parentage.includes(parent));
+      };
+      Subscription.prototype._addParent = function (parent) {
+          var _parentage = this._parentage;
+          this._parentage = Array.isArray(_parentage) ? (_parentage.push(parent), _parentage) : _parentage ? [_parentage, parent] : parent;
+      };
+      Subscription.prototype._removeParent = function (parent) {
+          var _parentage = this._parentage;
+          if (_parentage === parent) {
+              this._parentage = null;
+          }
+          else if (Array.isArray(_parentage)) {
+              arrRemove(_parentage, parent);
+          }
+      };
+      Subscription.prototype.remove = function (teardown) {
+          var _finalizers = this._finalizers;
+          _finalizers && arrRemove(_finalizers, teardown);
+          if (teardown instanceof Subscription) {
+              teardown._removeParent(this);
+          }
+      };
+      Subscription.EMPTY = (function () {
+          var empty = new Subscription();
+          empty.closed = true;
+          return empty;
+      })();
+      return Subscription;
+  }());
+  function isSubscription(value) {
+      return (value instanceof Subscription ||
+          (value && 'closed' in value && isFunction(value.remove) && isFunction(value.add) && isFunction(value.unsubscribe)));
+  }
+  function execFinalizer(finalizer) {
+      if (isFunction(finalizer)) {
+          finalizer();
+      }
+      else {
+          finalizer.unsubscribe();
+      }
+  }
+
+  var config = {
+      onUnhandledError: null,
+      onStoppedNotification: null,
+      Promise: undefined,
+      useDeprecatedSynchronousErrorHandling: false,
+      useDeprecatedNextContext: false,
+  };
+
+  var timeoutProvider = {
+      setTimeout: function (handler, timeout) {
+          var args = [];
+          for (var _i = 2; _i < arguments.length; _i++) {
+              args[_i - 2] = arguments[_i];
+          }
+          var delegate = timeoutProvider.delegate;
+          if (delegate === null || delegate === void 0 ? void 0 : delegate.setTimeout) {
+              return delegate.setTimeout.apply(delegate, __spreadArray([handler, timeout], __read(args)));
+          }
+          return setTimeout.apply(void 0, __spreadArray([handler, timeout], __read(args)));
+      },
+      clearTimeout: function (handle) {
+          var delegate = timeoutProvider.delegate;
+          return ((delegate === null || delegate === void 0 ? void 0 : delegate.clearTimeout) || clearTimeout)(handle);
+      },
+      delegate: undefined,
+  };
+
+  function reportUnhandledError(err) {
+      timeoutProvider.setTimeout(function () {
+          {
+              throw err;
+          }
+      });
+  }
+
+  function noop() { }
+
+  var Subscriber = (function (_super) {
+      __extends(Subscriber, _super);
+      function Subscriber(destination) {
+          var _this = _super.call(this) || this;
+          _this.isStopped = false;
+          if (destination) {
+              _this.destination = destination;
+              if (isSubscription(destination)) {
+                  destination.add(_this);
+              }
+          }
+          else {
+              _this.destination = EMPTY_OBSERVER;
+          }
+          return _this;
+      }
+      Subscriber.create = function (next, error, complete) {
+          return new SafeSubscriber(next, error, complete);
+      };
+      Subscriber.prototype.next = function (value) {
+          if (this.isStopped) ;
+          else {
+              this._next(value);
+          }
+      };
+      Subscriber.prototype.error = function (err) {
+          if (this.isStopped) ;
+          else {
+              this.isStopped = true;
+              this._error(err);
+          }
+      };
+      Subscriber.prototype.complete = function () {
+          if (this.isStopped) ;
+          else {
+              this.isStopped = true;
+              this._complete();
+          }
+      };
+      Subscriber.prototype.unsubscribe = function () {
+          if (!this.closed) {
+              this.isStopped = true;
+              _super.prototype.unsubscribe.call(this);
+              this.destination = null;
+          }
+      };
+      Subscriber.prototype._next = function (value) {
+          this.destination.next(value);
+      };
+      Subscriber.prototype._error = function (err) {
+          try {
+              this.destination.error(err);
+          }
+          finally {
+              this.unsubscribe();
+          }
+      };
+      Subscriber.prototype._complete = function () {
+          try {
+              this.destination.complete();
+          }
+          finally {
+              this.unsubscribe();
+          }
+      };
+      return Subscriber;
+  }(Subscription));
+  var _bind = Function.prototype.bind;
+  function bind(fn, thisArg) {
+      return _bind.call(fn, thisArg);
+  }
+  var ConsumerObserver = (function () {
+      function ConsumerObserver(partialObserver) {
+          this.partialObserver = partialObserver;
+      }
+      ConsumerObserver.prototype.next = function (value) {
+          var partialObserver = this.partialObserver;
+          if (partialObserver.next) {
+              try {
+                  partialObserver.next(value);
+              }
+              catch (error) {
+                  handleUnhandledError(error);
+              }
+          }
+      };
+      ConsumerObserver.prototype.error = function (err) {
+          var partialObserver = this.partialObserver;
+          if (partialObserver.error) {
+              try {
+                  partialObserver.error(err);
+              }
+              catch (error) {
+                  handleUnhandledError(error);
+              }
+          }
+          else {
+              handleUnhandledError(err);
+          }
+      };
+      ConsumerObserver.prototype.complete = function () {
+          var partialObserver = this.partialObserver;
+          if (partialObserver.complete) {
+              try {
+                  partialObserver.complete();
+              }
+              catch (error) {
+                  handleUnhandledError(error);
+              }
+          }
+      };
+      return ConsumerObserver;
+  }());
+  var SafeSubscriber = (function (_super) {
+      __extends(SafeSubscriber, _super);
+      function SafeSubscriber(observerOrNext, error, complete) {
+          var _this = _super.call(this) || this;
+          var partialObserver;
+          if (isFunction(observerOrNext) || !observerOrNext) {
+              partialObserver = {
+                  next: (observerOrNext !== null && observerOrNext !== void 0 ? observerOrNext : undefined),
+                  error: error !== null && error !== void 0 ? error : undefined,
+                  complete: complete !== null && complete !== void 0 ? complete : undefined,
+              };
+          }
+          else {
+              var context_1;
+              if (_this && config.useDeprecatedNextContext) {
+                  context_1 = Object.create(observerOrNext);
+                  context_1.unsubscribe = function () { return _this.unsubscribe(); };
+                  partialObserver = {
+                      next: observerOrNext.next && bind(observerOrNext.next, context_1),
+                      error: observerOrNext.error && bind(observerOrNext.error, context_1),
+                      complete: observerOrNext.complete && bind(observerOrNext.complete, context_1),
+                  };
+              }
+              else {
+                  partialObserver = observerOrNext;
+              }
+          }
+          _this.destination = new ConsumerObserver(partialObserver);
+          return _this;
+      }
+      return SafeSubscriber;
+  }(Subscriber));
+  function handleUnhandledError(error) {
+      {
+          reportUnhandledError(error);
+      }
+  }
+  function defaultErrorHandler(err) {
+      throw err;
+  }
+  var EMPTY_OBSERVER = {
+      closed: true,
+      next: noop,
+      error: defaultErrorHandler,
+      complete: noop,
+  };
+
+  function hasLift(source) {
+      return isFunction(source === null || source === void 0 ? void 0 : source.lift);
+  }
+  function operate(init) {
+      return function (source) {
+          if (hasLift(source)) {
+              return source.lift(function (liftedSource) {
+                  try {
+                      return init(liftedSource, this);
+                  }
+                  catch (err) {
+                      this.error(err);
+                  }
+              });
+          }
+          throw new TypeError('Unable to lift unknown Observable type');
+      };
+  }
+
+  function createOperatorSubscriber(destination, onNext, onComplete, onError, onFinalize) {
+      return new OperatorSubscriber(destination, onNext, onComplete, onError, onFinalize);
+  }
+  var OperatorSubscriber = (function (_super) {
+      __extends(OperatorSubscriber, _super);
+      function OperatorSubscriber(destination, onNext, onComplete, onError, onFinalize, shouldUnsubscribe) {
+          var _this = _super.call(this, destination) || this;
+          _this.onFinalize = onFinalize;
+          _this.shouldUnsubscribe = shouldUnsubscribe;
+          _this._next = onNext
+              ? function (value) {
+                  try {
+                      onNext(value);
+                  }
+                  catch (err) {
+                      destination.error(err);
+                  }
+              }
+              : _super.prototype._next;
+          _this._error = onError
+              ? function (err) {
+                  try {
+                      onError(err);
+                  }
+                  catch (err) {
+                      destination.error(err);
+                  }
+                  finally {
+                      this.unsubscribe();
+                  }
+              }
+              : _super.prototype._error;
+          _this._complete = onComplete
+              ? function () {
+                  try {
+                      onComplete();
+                  }
+                  catch (err) {
+                      destination.error(err);
+                  }
+                  finally {
+                      this.unsubscribe();
+                  }
+              }
+              : _super.prototype._complete;
+          return _this;
+      }
+      OperatorSubscriber.prototype.unsubscribe = function () {
+          var _a;
+          if (!this.shouldUnsubscribe || this.shouldUnsubscribe()) {
+              var closed_1 = this.closed;
+              _super.prototype.unsubscribe.call(this);
+              !closed_1 && ((_a = this.onFinalize) === null || _a === void 0 ? void 0 : _a.call(this));
+          }
+      };
+      return OperatorSubscriber;
+  }(Subscriber));
+
+  var EmptyError = createErrorClass(function (_super) { return function EmptyErrorImpl() {
+      _super(this);
+      this.name = 'EmptyError';
+      this.message = 'no elements in sequence';
+  }; });
+
+  function firstValueFrom(source, config) {
+      var hasConfig = typeof config === 'object';
+      return new Promise(function (resolve, reject) {
+          var subscriber = new SafeSubscriber({
+              next: function (value) {
+                  resolve(value);
+                  subscriber.unsubscribe();
+              },
+              error: reject,
+              complete: function () {
+                  if (hasConfig) {
+                      resolve(config.defaultValue);
+                  }
+                  else {
+                      reject(new EmptyError());
+                  }
+              },
+          });
+          source.subscribe(subscriber);
+      });
+  }
+
+  function scanInternals(accumulator, seed, hasSeed, emitOnNext, emitBeforeComplete) {
+      return function (source, subscriber) {
+          var hasState = hasSeed;
+          var state = seed;
+          var index = 0;
+          source.subscribe(createOperatorSubscriber(subscriber, function (value) {
+              var i = index++;
+              state = hasState
+                  ?
+                      accumulator(state, value, i)
+                  :
+                      ((hasState = true), value);
+              emitOnNext && subscriber.next(state);
+          }, emitBeforeComplete &&
+              (function () {
+                  hasState && subscriber.next(state);
+                  subscriber.complete();
+              })));
+      };
+  }
+
+  function reduce(accumulator, seed) {
+      return operate(scanInternals(accumulator, seed, arguments.length >= 2, false, true));
+  }
+
+  var arrReducer = function (arr, value) { return (arr.push(value), arr); };
+  function toArray() {
+      return operate(function (source, subscriber) {
+          reduce(arrReducer, [])(source).subscribe(subscriber);
+      });
+  }
+
+  let BigMafAdapter$1 = class BigMafAdapter extends BaseAdapter.BaseFeatureDataAdapter {
+      setupP;
+      async setup() {
+          if (!this.getSubAdapter) {
+              throw new Error('no getSubAdapter available');
+          }
+          const adapter = await this.getSubAdapter({
+              ...mobxStateTree.getSnapshot(this.config),
+              type: 'BigBedAdapter',
+          });
+          return {
+              adapter: adapter.dataAdapter,
+          };
+      }
+      async setupPre() {
+          if (!this.setupP) {
+              this.setupP = this.setup().catch(e => {
+                  this.setupP = undefined;
+                  throw e;
+              });
+          }
+          return this.setupP;
+      }
+      async getRefNames() {
+          const { adapter } = await this.setup();
+          return adapter.getRefNames();
+      }
+      async getHeader() {
+          const { adapter } = await this.setup();
+          return adapter.getHeader();
+      }
+      getFeatures(query) {
+          return rxjs.ObservableCreate(async (observer) => {
+              const { adapter } = await this.setup();
+              const features = await firstValueFrom(adapter.getFeatures(query).pipe(toArray()));
+              for (const feature of features) {
+                  const maf = feature.get('mafBlock');
+                  const blocks = maf.split(';');
+                  let aln;
+                  const alns = [];
+                  const alignments = {};
+                  const blocks2 = [];
+                  for (const block of blocks) {
+                      if (block[0] === 's') {
+                          if (!aln) {
+                              aln = block.split(/ +/)[6];
+                              alns.push(aln);
+                              blocks2.push(block);
+                          }
+                          else {
+                              alns.push(block.split(/ +/)[6]);
+                              blocks2.push(block);
+                          }
+                      }
+                  }
+                  const alns2 = alns.map(() => '');
+                  if (aln) {
+                      for (let i = 0; i < aln?.length; i++) {
+                          if (aln[i] !== '-') {
+                              for (let j = 0; j < alns.length; j++) {
+                                  alns2[j] += alns[j][i];
+                              }
+                          }
+                      }
+                  }
+                  for (let i = 0; i < blocks2.length; i++) {
+                      const elt = blocks2[i];
+                      const ad = elt.split(/ +/);
+                      const y = ad[1].split('.');
+                      const org = y[0];
+                      const chr = y[1];
+                      alignments[org] = {
+                          chr: chr,
+                          start: +ad[1],
+                          srcSize: +ad[2],
+                          strand: ad[3] === '+' ? 1 : -1,
+                          unknown: +ad[4],
+                          data: alns2[i],
+                      };
+                  }
+                  observer.next(new util.SimpleFeature({
+                      id: feature.id(),
+                      data: {
+                          start: feature.get('start'),
+                          end: feature.get('end'),
+                          refName: feature.get('refName'),
+                          seq: alns2[0],
+                          alignments: alignments,
+                      },
+                  }));
+              }
+              observer.complete();
+          });
+      }
+      freeResources() { }
+  };
+
+  function BigMafAdapterF(pluginManager) {
+      return pluginManager.addAdapterType(() => new pluggableElementTypes.AdapterType({
+          name: 'BigMafAdapter',
+          AdapterClass: BigMafAdapter$1,
+          configSchema: configSchema$2,
+      }));
+  }
+
+  function configSchemaF$1(pluginManager) {
+      return configuration.ConfigurationSchema('MafTrack', {}, {
+          /**
+           * #baseConfiguration
+           */
+          baseConfiguration: pluggableElementTypes.createBaseTrackConfig(pluginManager),
+          /**
+           * #identifier
+           */
+          explicitIdentifier: 'trackId',
+      });
+  }
+
+  function MafTrackF(pluginManager) {
+      return pluginManager.addTrackType(() => {
+          const configSchema = configSchemaF$1(pluginManager);
+          return new pluggableElementTypes.TrackType({
+              name: 'MafTrack',
+              configSchema,
+              displayName: 'MAF track',
+              stateModel: pluggableElementTypes.createBaseTrackModel(pluginManager, 'MafTrack', configSchema),
+          });
+      });
+  }
+
+  function configSchemaF(pluginManager) {
+      const LinearGenomePlugin = pluginManager.getPlugin('LinearGenomeViewPlugin');
+      // @ts-expect-error
+      const { linearBasicDisplayConfigSchemaFactory } = LinearGenomePlugin.exports;
+      return configuration.ConfigurationSchema('LinearMafDisplay', {
+          /**
+           * #slot
+           */
+          renderer: pluginManager.pluggableConfigSchemaType('renderer'),
+      }, {
+          baseConfiguration: linearBasicDisplayConfigSchemaFactory(pluginManager),
+          explicitlyTyped: true,
+      });
+  }
+
+  /**
+   * #stateModel LinearMafDisplay
+   * extends LinearBasicDisplay
+   */
+  function stateModelFactory(configSchema, pluginManager) {
+      const LinearGenomePlugin = pluginManager.getPlugin('LinearGenomeViewPlugin');
+      // @ts-expect-error
+      const { linearBasicDisplayModelFactory } = LinearGenomePlugin.exports;
+      return mobxStateTree.types
+          .compose('LinearMafDisplay', linearBasicDisplayModelFactory(configSchema), mobxStateTree.types.model({
+          /**
+           * #property
+           */
+          type: mobxStateTree.types.literal('LinearMafDisplay'),
+          /**
+           * #property
+           */
+          configuration: configuration.ConfigurationReference(configSchema),
+      }))
+          .volatile(() => ({
+          prefersOffset: true,
+      }))
+          .views(self => ({
+          /**
+           * #getter
+           */
+          get samples() {
+              const r = self.adapterConfig.samples;
+              return r.map(elt => ({ name: elt, color: undefined }));
+          },
+          /**
+           * #getter
+           */
+          get rowHeight() {
+              return 20;
+          },
+          /**
+           * #getter
+           */
+          get rendererTypeName() {
+              return 'LinearMafRenderer';
+          },
+          /**
+           * #getter
+           */
+          get rendererConfig() {
+              const configBlob = configuration.getConf(self, ['renderer']) || {};
+              const config = configBlob;
+              return self.rendererType.configSchema.create({
+                  ...config,
+                  type: 'LinearMafRenderer',
+              }, util.getEnv(self));
+          },
+      }))
+          .views(self => {
+          const { renderProps: superRenderProps } = self;
+          return {
+              /**
+               * #method
+               */
+              renderProps() {
+                  return {
+                      ...superRenderProps(),
+                      samples: self.samples,
+                      rowHeight: self.rowHeight,
+                  };
+              },
+          };
+      })
+          .actions(self => {
+          const { renderSvg: superRenderSvg } = self;
+          return {
+              /**
+               * #action
+               */
+              async renderSvg(opts) {
+                  const { renderSvg } = await Promise.resolve().then(function () { return renderSvg$1; });
+                  // @ts-expect-error
+                  return renderSvg(self, opts, superRenderSvg);
+              },
+          };
+      });
+  }
+
+  const RectBg = (props) => {
+      const { color = 'rgb(255,255,255,0.8)' } = props;
+      return React.createElement("rect", { ...props, fill: color });
+  };
+
+  const ColorLegend = mobxReact.observer(function ({ model, labelWidth, }) {
+      const { samples, rowHeight } = model;
+      const svgFontSize = Math.min(rowHeight, 12);
+      const canDisplayLabel = rowHeight > 11;
+      const colorBoxWidth = 15;
+      const legendWidth = labelWidth + colorBoxWidth + 5;
+      const extraOffset = 0;
+      return samples ? (React.createElement(React.Fragment, null, samples.map((source, idx) => {
+          const boxHeight = Math.min(20, rowHeight);
+          return (React.createElement(React.Fragment, { key: `${source.name}-${idx}` },
+              source.color ? (React.createElement(RectBg, { y: idx * rowHeight + 1, x: extraOffset, width: colorBoxWidth, height: boxHeight, color: source.color })) : null,
+              React.createElement(RectBg, { y: idx * rowHeight + 1, x: extraOffset, width: legendWidth, height: boxHeight }),
+              canDisplayLabel ? (React.createElement("text", { y: idx * rowHeight + 13, x: extraOffset + colorBoxWidth + 2, fontSize: svgFontSize }, source.name)) : null));
+      }))) : null;
+  });
+
+  const Wrapper = mobxReact.observer(function ({ children, model, exportSVG, }) {
+      if (exportSVG) {
+          return React.createElement(React.Fragment, null, children);
+      }
+      else {
+          const { rowHeight, samples } = model;
+          return (React.createElement("svg", { style: {
+                  position: 'absolute',
+                  top: 0,
+                  left: 0,
+                  pointerEvents: 'none',
+                  height: samples.length * rowHeight,
+                  width: util.getContainingView(model).width,
+              } }, children));
+      }
+  });
+  const YScaleBars = mobxReact.observer(function (props) {
+      const { model } = props;
+      const { rowHeight, samples } = model;
+      const svgFontSize = Math.min(rowHeight, 12);
+      const canDisplayLabel = rowHeight > 11;
+      const minWidth = 20;
+      const labelWidth = Math.max(...(samples
+          .map(s => util.measureText(s, svgFontSize))
+          .map(width => (canDisplayLabel ? width : minWidth)) || [0]));
+      return (React.createElement(Wrapper, { ...props },
+          React.createElement(ColorLegend, { model: model, labelWidth: labelWidth })));
+  });
+
+  const LinearMafDisplay = mobxReact.observer(function (props) {
+      const { model } = props;
+      const { pluginManager } = util.getEnv(model);
+      const LinearGenomePlugin = pluginManager.getPlugin('LinearGenomeViewPlugin');
+      const { BaseLinearDisplayComponent } = LinearGenomePlugin.exports;
+      return (React.createElement("div", null,
+          React.createElement(BaseLinearDisplayComponent, { ...props }),
+          React.createElement(YScaleBars, { model: model })));
+  });
+
+  function LinearMafDisplayF(pluginManager) {
+      pluginManager.addDisplayType(() => {
+          const configSchema = configSchemaF(pluginManager);
+          const stateModel = stateModelFactory(configSchema, pluginManager);
+          return new pluggableElementTypes.DisplayType({
+              name: 'LinearMafDisplay',
+              configSchema,
+              stateModel,
+              ReactComponent: LinearMafDisplay,
+              viewType: 'LinearGenomeView',
+              trackType: 'MafTrack',
+              displayName: 'MAF display',
+          });
+      });
+  }
+
+  const configSchema$1 = configuration.ConfigurationSchema('LinearMafRenderer', {}, {
+      /**
+       * #baseConfiguration
+       */
+      explicitlyTyped: true,
+  });
+
+  function getCorrectionFactor(scale) {
+      if (scale >= 1) {
+          return 0.6;
+      }
+      else if (scale >= 0.2) {
+          return 0.05;
+      }
+      else if (scale >= 0.02) {
+          return 0.03;
+      }
+      else {
+          return 0.02;
+      }
+  }
+  function getContrastBaseMap(theme) {
+      return Object.fromEntries(Object.entries(getColorBaseMap(theme)).map(([key, value]) => [
+          key,
+          theme.palette.getContrastText(value),
+      ]));
+  }
+  function getColorBaseMap(theme) {
+      const { bases } = theme.palette;
+      return {
+          a: bases.A.main,
+          c: bases.C.main,
+          g: bases.G.main,
+          t: bases.T.main,
+      };
+  }
+  function makeImageData({ ctx, renderArgs, }) {
+      const { regions, bpPerPx, rowHeight, theme: configTheme, samples, } = renderArgs;
+      const [region] = regions;
+      const features = renderArgs.features;
+      const h = rowHeight;
+      const theme = ui.createJBrowseTheme(configTheme);
+      const colorForBase = getColorBaseMap(theme);
+      const contrastForBase = getContrastBaseMap(theme);
+      const sampleToRowMap = new Map(samples.map((s, i) => [s.name, i]));
+      const scale = 1 / bpPerPx;
+      const correctionFactor = getCorrectionFactor(bpPerPx);
+      // sample as alignments
+      ctx.font = 'bold 10px Courier New,monospace';
+      for (const feature of features.values()) {
+          const [leftPx] = util.featureSpanPx(feature, region, bpPerPx);
+          const vals = feature.get('alignments');
+          const seq = feature.get('seq').toLowerCase();
+          for (const [sample, val] of Object.entries(vals)) {
+              const origAlignment = val.data;
+              const alignment = origAlignment.toLowerCase();
+              // gaps
+              ctx.beginPath();
+              ctx.fillStyle = 'black';
+              const offset0 = (5 / 12) * h;
+              const h6 = h / 6;
+              const row = sampleToRowMap.get(sample);
+              if (row === undefined) {
+                  throw new Error(`unknown sample encountered: ${sample}`);
+              }
+              const t = h * row;
+              for (let i = 0; i < alignment.length; i++) {
+                  const l = leftPx + scale * i;
+                  if (alignment[i] === '-') {
+                      ctx.rect(l, offset0 + t, scale + correctionFactor, h6);
+                  }
+              }
+              ctx.fill();
+              const offset = (1 / 4) * h;
+              const h2 = h / 2;
+              // matches
+              ctx.beginPath();
+              ctx.fillStyle = 'lightgrey';
+              for (let i = 0; i < alignment.length; i++) {
+                  const c = alignment[i];
+                  const l = leftPx + scale * i;
+                  if (seq[i] === c && c !== '-') {
+                      ctx.rect(l, offset + t, scale + correctionFactor, h2);
+                  }
+              }
+              ctx.fill();
+              // mismatches
+              for (let i = 0; i < alignment.length; i++) {
+                  const c = alignment[i];
+                  if (seq[i] !== c && c !== '-') {
+                      const l = leftPx + scale * i;
+                      ctx.fillStyle =
+                          colorForBase[c] ?? 'purple';
+                      ctx.fillRect(l, offset + t, scale + correctionFactor, h2);
+                  }
+              }
+              // font
+              const charSize = { w: 10 };
+              if (scale >= charSize.w) {
+                  for (let i = 0; i < alignment.length; i++) {
+                      const l = leftPx + scale * i;
+                      const offset = (scale - charSize.w) / 2 + 1;
+                      const c = alignment[i];
+                      if (seq[i] !== c && c !== '-') {
+                          ctx.fillStyle = contrastForBase[c] ?? 'black';
+                          ctx.fillText(origAlignment[i], l + offset, h2 + t + 3);
+                      }
+                  }
+              }
+          }
+      }
+  }
+  class LinearMafRenderer extends pluggableElementTypes.FeatureRendererType {
+      async render(renderProps) {
+          const { regions, bpPerPx, samples, rowHeight } = renderProps;
+          const [region] = regions;
+          const height = samples.length * rowHeight;
+          const width = (region.end - region.start) / bpPerPx;
+          const features = await this.getFeatures(renderProps);
+          const res = await util.renderToAbstractCanvas(width, height, renderProps, ctx => makeImageData({
+              ctx,
+              renderArgs: {
+                  ...renderProps,
+                  features,
+              },
+          }));
+          const results = await super.render({
+              ...renderProps,
+              ...res,
+              width,
+              height,
+          });
+          return {
+              ...results,
+              ...res,
+              width,
+              height,
+          };
+      }
+  }
+
+  const LinearMafRendering = mobxReact.observer(function (props) {
+      return React.createElement(ui.PrerenderedCanvas, { ...props });
+  });
+
+  function LinearMafRendererF(pluginManager) {
+      pluginManager.addRendererType(() => new LinearMafRenderer({
+          name: 'LinearMafRenderer',
+          ReactComponent: LinearMafRendering,
+          configSchema: configSchema$1,
+          pluginManager,
+      }));
+  }
+
+  const configSchema = configuration.ConfigurationSchema('MafTabixAdapter', {
+      /**
+       * #slot
+       */
+      samples: {
+          type: 'stringArray',
+          defaultValue: [],
+      },
+      /**
+       * #slot
+       */
+      bedGzLocation: {
+          type: 'fileLocation',
+          defaultValue: {
+              uri: '/path/to/my.bed.gz.tbi',
+              locationType: 'UriLocation',
+          },
+      },
+      index: configuration.ConfigurationSchema('Index', {
+          location: {
+              type: 'fileLocation',
+              defaultValue: {
+                  uri: '/path/to/my.bed.gz.tbi',
+              },
+          },
+          indexType: {
+              type: 'string',
+              defaultValue: 'TBI',
+          },
+      }),
+  }, { explicitlyTyped: true });
+
+  class BigMafAdapter extends BaseAdapter.BaseFeatureDataAdapter {
+      setupP;
+      async setup() {
+          const config = this.config;
+          if (!this.getSubAdapter) {
+              throw new Error('no getSubAdapter available');
+          }
+          const adapter = await this.getSubAdapter({
+              ...mobxStateTree.getSnapshot(config),
+              type: 'BedTabixAdapter',
+          });
+          return {
+              adapter: adapter.dataAdapter,
+          };
+      }
+      async setupPre() {
+          if (!this.setupP) {
+              this.setupP = this.setup().catch(e => {
+                  this.setupP = undefined;
+                  throw e;
+              });
+          }
+          return this.setupP;
+      }
+      async getRefNames() {
+          const { adapter } = await this.setup();
+          return adapter.getRefNames();
+      }
+      getFeatures(query) {
+          return rxjs.ObservableCreate(async (observer) => {
+              const { adapter } = await this.setup();
+              const features = await firstValueFrom(adapter.getFeatures(query).pipe(toArray()));
+              for (const feature of features) {
+                  const data = feature.get('field5').split(',');
+                  const alignments = {};
+                  const main = data[0];
+                  const aln = main.split(':')[5];
+                  const alns = data.map(elt => elt.split(':')[5]);
+                  const alns2 = data.map(() => '');
+                  // remove extraneous data in other alignments
+                  // reason being: cannot represent missing data in main species that are in others)
+                  for (let i = 0, o = 0; i < aln.length; i++, o++) {
+                      if (aln[i] !== '-') {
+                          for (let j = 0; j < data.length; j++) {
+                              alns2[j] += alns[j][i];
+                          }
+                      }
+                  }
+                  for (let j = 0; j < data.length; j++) {
+                      const elt = data[j];
+                      const ad = elt.split(':');
+                      const org = ad[0].split('.')[0];
+                      const chr = ad[0].split('.')[1];
+                      alignments[org] = {
+                          chr: chr,
+                          start: +ad[1],
+                          srcSize: +ad[2],
+                          strand: ad[3] === '-' ? -1 : 1,
+                          unknown: +ad[4],
+                          data: alns2[j],
+                      };
+                  }
+                  observer.next(new util.SimpleFeature({
+                      id: feature.id(),
+                      data: {
+                          start: feature.get('start'),
+                          end: feature.get('end'),
+                          refName: feature.get('refName'),
+                          name: feature.get('name'),
+                          score: feature.get('score'),
+                          alignments: alignments,
+                          seq: alns2[0],
+                      },
+                  }));
+              }
+              observer.complete();
+          });
+      }
+      freeResources() { }
+  }
+
+  function MafTabixAdapterF(pluginManager) {
+      return pluginManager.addAdapterType(() => new pluggableElementTypes.AdapterType({
+          name: 'MafTabixAdapter',
+          AdapterClass: BigMafAdapter,
+          configSchema,
+      }));
+  }
+
+  const useStyles = mui.makeStyles()(theme => ({
+      textbox: {
+          width: '100%',
+      },
+      paper: {
+          margin: theme.spacing(),
+          padding: theme.spacing(),
+      },
+      submit: {
+          marginTop: 25,
+          marginBottom: 100,
+          display: 'block',
+      },
+  }));
+  function MultiMAFWidget({ model }) {
+      const { classes } = useStyles();
+      const [samples, setSamples] = React.useState('');
+      const [loc, setLoc] = React.useState();
+      const [indexLoc, setIndexLoc] = React.useState();
+      const [error, setError] = React.useState();
+      const [trackName, setTrackName] = React.useState('MAF track');
+      const [choice, setChoice] = React.useState('BigMafAdapter');
+      const rootModel = mobxStateTree.getRoot(model);
+      return (React.createElement(material.Paper, { className: classes.paper },
+          React.createElement(material.Paper, null,
+              error ? React.createElement(ui.ErrorMessage, { error: error }) : null,
+              React.createElement(material.FormControl, null,
+                  React.createElement(material.FormLabel, null, "File type"),
+                  React.createElement(material.RadioGroup, { value: choice, onChange: event => setChoice(event.target.value) },
+                      React.createElement(material.FormControlLabel, { value: "BigMafAdapter", control: React.createElement(material.Radio, null), checked: choice === 'BigMafAdapter', label: "bigMaf" }),
+                      React.createElement(material.FormControlLabel, { value: "MafTabixAdapter", control: React.createElement(material.Radio, null), checked: choice === 'MafTabixAdapter', label: "mafTabix" }))),
+              choice === 'BigMafAdapter' ? (React.createElement(ui.FileSelector, { location: loc, name: "Path to bigMaf", setLocation: arg => setLoc(arg), rootModel: rootModel })) : (React.createElement(React.Fragment, null,
+                  React.createElement(ui.FileSelector, { location: loc, name: "Path to MAF tabix", setLocation: arg => setLoc(arg), rootModel: rootModel }),
+                  React.createElement(ui.FileSelector, { location: indexLoc, name: "Path to MAF tabix index", setLocation: arg => setIndexLoc(arg), rootModel: rootModel })))),
+          React.createElement(material.TextField, { multiline: true, rows: 10, value: samples, onChange: event => setSamples(event.target.value), placeholder: 'Enter sample names from the MAF file, one per line, or JSON formatted array of samples', variant: "outlined", fullWidth: true }),
+          React.createElement(material.TextField, { value: trackName, onChange: event => setTrackName(event.target.value), helperText: "Track name" }),
+          React.createElement(material.Button, { variant: "contained", className: classes.submit, onClick: () => {
+                  try {
+                      const session = util.getSession(model);
+                      let sampleNames = [];
+                      try {
+                          sampleNames = JSON.parse(samples);
+                      }
+                      catch (e) {
+                          sampleNames = samples.split(/\n|\r\n|\r/);
+                      }
+                      const trackId = [
+                          `${trackName.toLowerCase().replaceAll(' ', '_')}-${Date.now()}`,
+                          `${session.adminMode ? '' : '-sessionTrack'}`,
+                      ].join('');
+                      if (util.isSessionWithAddTracks(session)) {
+                          session.addTrackConf({
+                              trackId,
+                              type: 'MafTrack',
+                              name: trackName,
+                              assemblyNames: [model.assembly],
+                              adapter: choice === 'BigMafAdapter'
+                                  ? {
+                                      type: choice,
+                                      bigBedLocation: loc,
+                                      samples: sampleNames,
+                                  }
+                                  : {
+                                      type: choice,
+                                      bedGzLocation: loc,
+                                      index: { location: indexLoc },
+                                      samples: sampleNames,
+                                  },
+                          });
+                          model.view?.showTrack(trackId);
+                      }
+                      model.clearData();
+                      if (util.isSessionModelWithWidgets(session)) {
+                          session.hideWidget(model);
+                      }
+                  }
+                  catch (e) {
+                      setError(e);
+                  }
+              } }, "Submit")));
+  }
+
+  function MafAddTrackWorkflowF(pluginManager) {
+      pluginManager.addAddTrackWorkflowType(() => new pluggableElementTypes.AddTrackWorkflowType({
+          name: 'MAF track',
+          ReactComponent: MultiMAFWidget,
+          stateModel: mobxStateTree.types.model({}),
+      }));
+  }
+
+  class MafViewerPlugin extends Plugin {
+      name = 'MafViewerPlugin';
+      version = version;
+      install(pluginManager) {
+          BigMafAdapterF(pluginManager);
+          MafTrackF(pluginManager);
+          LinearMafDisplayF(pluginManager);
+          LinearMafRendererF(pluginManager);
+          MafTabixAdapterF(pluginManager);
+          MafAddTrackWorkflowF(pluginManager);
+      }
+      configure(pluginManager) { }
+  }
+
+  async function renderSvg(self, opts, superRenderSvg) {
+      const { offsetPx } = util.getContainingView(self);
+      return (React.createElement(React.Fragment, null,
+          React.createElement("g", { id: "snpcov" }, await superRenderSvg(opts)),
+          React.createElement("g", { transform: `translate(${Math.max(-offsetPx, 0)})` },
+              React.createElement(YScaleBars, { model: self, orientation: "left", exportSVG: true }))));
+  }
+
+  var renderSvg$1 = {
+    __proto__: null,
+    renderSvg: renderSvg
+  };
+
+  exports.default = MafViewerPlugin;
+
+  Object.defineProperty(exports, '__esModule', { value: true });
+
+}));
+//# sourceMappingURL=jbrowse-plugin-mafviewer.umd.development.js.map