@jbrowse/plugin-linear-genome-view 1.6.9 → 1.7.3

package/dist/BaseLinearDisplay/models/baseLinearDisplayConfigSchema.d.ts

@@ -1 +1 @@
-export declare const baseLinearDisplayConfigSchema: import("@jbrowse/core/configuration").AnyConfigurationSchemaType;
+export declare const baseLinearDisplayConfigSchema: import("@jbrowse/core/configuration").AnyConfigurationSchemaType;

package/dist/BaseLinearDisplay/models/baseLinearDisplayConfigSchema.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.baseLinearDisplayConfigSchema = void 0;
+
+var _configuration = require("@jbrowse/core/configuration");
+
+var baseLinearDisplayConfigSchema = (0, _configuration.ConfigurationSchema)('BaseLinearDisplay', {
+  maxFeatureScreenDensity: {
+    type: 'number',
+    description: 'maximum features per pixel that is displayed in the view, used if byte size estimates not available',
+    defaultValue: 0.3
+  },
+  fetchSizeLimit: {
+    type: 'number',
+    defaultValue: 1000000,
+    description: "maximum data to attempt to download for a given track, used if adapter doesn't specify one"
+  }
+}, {
+  explicitIdentifier: 'displayId'
+});
+exports.baseLinearDisplayConfigSchema = baseLinearDisplayConfigSchema;

package/dist/BaseLinearDisplay/models/serverSideRenderedBlock.d.ts

@@ -1,96 +1,96 @@
-import { Instance } from 'mobx-state-tree';
-import { Feature } from '@jbrowse/core/util/simpleFeature';
-import { AbstractDisplayModel } from '@jbrowse/core/util/types';
-import React from 'react';
-declare const blockState: import("mobx-state-tree").IModelType<{
-    key: import("mobx-state-tree").ISimpleType<string>;
-    region: import("mobx-state-tree").IModelType<{
-        refName: import("mobx-state-tree").ISimpleType<string>;
-        start: import("mobx-state-tree").ISimpleType<number>;
-        end: import("mobx-state-tree").ISimpleType<number>;
-        reversed: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<boolean>, [undefined]>;
-    } & {
-        assemblyName: import("mobx-state-tree").ISimpleType<string>;
-    }, {
-        setRefName(newRefName: string): void;
-    }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>;
-    reloadFlag: import("mobx-state-tree").IType<number | undefined, number, number>;
-    isLeftEndOfDisplayedRegion: import("mobx-state-tree").IType<boolean | undefined, boolean, boolean>;
-    isRightEndOfDisplayedRegion: import("mobx-state-tree").IType<boolean | undefined, boolean, boolean>;
-}, {
-    renderInProgress: AbortController | undefined;
-    filled: boolean;
-    reactElement: React.ReactElement<any, string | ((props: any) => React.ReactElement<any, any> | null) | (new (props: any) => React.Component<any, any, any>)> | undefined;
-    features: Map<string, Feature> | undefined;
-    layout: any;
-    status: string;
-    error: unknown;
-    message: string | undefined;
-    maxHeightReached: boolean;
-    ReactComponent: ({ model, }: {
-        model: any;
-    }) => any;
-    renderProps: any;
-} & {
-    doReload(): void;
-    afterAttach(): void;
-    setStatus(message: string): void;
-    setLoading(abortController: AbortController): void;
-    setMessage(messageText: string): void;
-    setRendered(props: {
-        reactElement: React.ReactElement;
-        features: Map<string, Feature>;
-        layout: any;
-        maxHeightReached: boolean;
-        renderProps: any;
-    } | undefined): void;
-    setError(error: Error | unknown): void;
-    reload(): void;
-    beforeDestroy(): void;
-}, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>;
-export default blockState;
-export declare type BlockStateModel = typeof blockState;
-export declare type BlockModel = Instance<BlockStateModel>;
-export declare function renderBlockData(self: Instance<BlockStateModel>, optDisplay?: AbstractDisplayModel): {
-    rendererType: any;
-    rpcManager: import("@jbrowse/core/rpc/RpcManager").default;
-    renderProps: any;
-    cannotBeRenderedReason: any;
-    displayError: any;
-    renderArgs: {
-        statusCallback: (message: string) => void;
-        assemblyName: string;
-        regions: (import("mobx-state-tree").ModelInstanceTypeProps<{
-            refName: import("mobx-state-tree").ISimpleType<string>;
-            start: import("mobx-state-tree").ISimpleType<number>;
-            end: import("mobx-state-tree").ISimpleType<number>;
-            reversed: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<boolean>, [undefined]>;
-        } & {
-            assemblyName: import("mobx-state-tree").ISimpleType<string>;
-        }> & {
-            setRefName(newRefName: string): void;
-        } & import("mobx-state-tree").IStateTreeNode<import("mobx-state-tree").IModelType<{
-            refName: import("mobx-state-tree").ISimpleType<string>;
-            start: import("mobx-state-tree").ISimpleType<number>;
-            end: import("mobx-state-tree").ISimpleType<number>;
-            reversed: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<boolean>, [undefined]>;
-        } & {
-            assemblyName: import("mobx-state-tree").ISimpleType<string>;
-        }, {
-            setRefName(newRefName: string): void;
-        }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>>)[];
-        adapterConfig: any;
-        rendererType: any;
-        sessionId: string;
-        blockKey: string;
-        reloadFlag: number;
-        timeout: number;
-    };
-} | {
-    displayError: any;
-    rendererType?: undefined;
-    rpcManager?: undefined;
-    renderProps?: undefined;
-    cannotBeRenderedReason?: undefined;
-    renderArgs?: undefined;
-};
+import React from 'react';
+import { Instance } from 'mobx-state-tree';
+import { Feature } from '@jbrowse/core/util';
+import { AbstractDisplayModel } from '@jbrowse/core/util/types';
+declare const blockState: import("mobx-state-tree").IModelType<{
+    key: import("mobx-state-tree").ISimpleType<string>;
+    region: import("mobx-state-tree").IModelType<{
+        refName: import("mobx-state-tree").ISimpleType<string>;
+        start: import("mobx-state-tree").ISimpleType<number>;
+        end: import("mobx-state-tree").ISimpleType<number>;
+        reversed: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<boolean>, [undefined]>;
+    } & {
+        assemblyName: import("mobx-state-tree").ISimpleType<string>;
+    }, {
+        setRefName(newRefName: string): void;
+    }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>;
+    reloadFlag: import("mobx-state-tree").IType<number | undefined, number, number>;
+    isLeftEndOfDisplayedRegion: import("mobx-state-tree").IType<boolean | undefined, boolean, boolean>;
+    isRightEndOfDisplayedRegion: import("mobx-state-tree").IType<boolean | undefined, boolean, boolean>;
+}, {
+    renderInProgress: AbortController | undefined;
+    filled: boolean;
+    reactElement: React.ReactElement<any, string | React.JSXElementConstructor<any>> | undefined;
+    features: Map<string, Feature> | undefined;
+    layout: any;
+    status: string;
+    error: unknown;
+    message: string | undefined;
+    maxHeightReached: boolean;
+    ReactComponent: ({ model, }: {
+        model: any;
+    }) => any;
+    renderProps: any;
+} & {
+    doReload(): void;
+    afterAttach(): void;
+    setStatus(message: string): void;
+    setLoading(abortController: AbortController): void;
+    setMessage(messageText: string): void;
+    setRendered(props: {
+        reactElement: React.ReactElement;
+        features: Map<string, Feature>;
+        layout: any;
+        maxHeightReached: boolean;
+        renderProps: any;
+    } | undefined): void;
+    setError(error: Error | unknown): void;
+    reload(): void;
+    beforeDestroy(): void;
+}, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>;
+export default blockState;
+export declare type BlockStateModel = typeof blockState;
+export declare type BlockModel = Instance<BlockStateModel>;
+export declare function renderBlockData(self: Instance<BlockStateModel>, optDisplay?: AbstractDisplayModel): {
+    rendererType: any;
+    rpcManager: import("@jbrowse/core/rpc/RpcManager").default;
+    renderProps: any;
+    cannotBeRenderedReason: any;
+    displayError: any;
+    renderArgs: {
+        statusCallback: (message: string) => void;
+        assemblyName: string;
+        regions: (import("mobx-state-tree").ModelInstanceTypeProps<{
+            refName: import("mobx-state-tree").ISimpleType<string>;
+            start: import("mobx-state-tree").ISimpleType<number>;
+            end: import("mobx-state-tree").ISimpleType<number>;
+            reversed: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<boolean>, [undefined]>;
+        } & {
+            assemblyName: import("mobx-state-tree").ISimpleType<string>;
+        }> & {
+            setRefName(newRefName: string): void;
+        } & import("mobx-state-tree").IStateTreeNode<import("mobx-state-tree").IModelType<{
+            refName: import("mobx-state-tree").ISimpleType<string>;
+            start: import("mobx-state-tree").ISimpleType<number>;
+            end: import("mobx-state-tree").ISimpleType<number>;
+            reversed: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<boolean>, [undefined]>;
+        } & {
+            assemblyName: import("mobx-state-tree").ISimpleType<string>;
+        }, {
+            setRefName(newRefName: string): void;
+        }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>>)[];
+        adapterConfig: any;
+        rendererType: any;
+        sessionId: string;
+        blockKey: string;
+        reloadFlag: number;
+        timeout: number;
+    };
+} | {
+    displayError: unknown;
+    rendererType?: undefined;
+    rpcManager?: undefined;
+    renderProps?: undefined;
+    cannotBeRenderedReason?: undefined;
+    renderArgs?: undefined;
+};

package/dist/BaseLinearDisplay/models/serverSideRenderedBlock.js

@@ -0,0 +1,328 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+exports.renderBlockData = renderBlockData;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _mobxStateTree = require("mobx-state-tree");
+
+var _configuration = require("@jbrowse/core/configuration");
+
+var _util = require("@jbrowse/core/util");
+
+var _mst = require("@jbrowse/core/util/types/mst");
+
+var _types = require("@jbrowse/core/util/types");
+
+var _tracks = require("@jbrowse/core/util/tracks");
+
+var _ServerSideRenderedBlockContent = _interopRequireDefault(require("../components/ServerSideRenderedBlockContent"));
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+// the MST state of a single server-side-rendered block in a display
+var blockState = _mobxStateTree.types.model('BlockState', {
+  key: _mobxStateTree.types.string,
+  region: _mst.Region,
+  reloadFlag: 0,
+  isLeftEndOfDisplayedRegion: false,
+  isRightEndOfDisplayedRegion: false
+}) // NOTE: all this volatile stuff has to be filled in at once, so that it stays consistent
+["volatile"](function () {
+  return {
+    renderInProgress: undefined,
+    filled: false,
+    reactElement: undefined,
+    features: undefined,
+    layout: undefined,
+    status: '',
+    error: undefined,
+    message: undefined,
+    maxHeightReached: false,
+    ReactComponent: _ServerSideRenderedBlockContent["default"],
+    renderProps: undefined
+  };
+}).actions(function (self) {
+  var renderInProgress;
+  return {
+    doReload: function doReload() {
+      self.reloadFlag = self.reloadFlag + 1;
+    },
+    afterAttach: function afterAttach() {
+      var display = (0, _util.getContainingDisplay)(self);
+      (0, _util.makeAbortableReaction)(self, renderBlockData, renderBlockEffect, // reaction doesn't expect async here
+      {
+        name: "".concat(display.id, "/").concat((0, _util.assembleLocString)(self.region), " rendering"),
+        delay: display.renderDelay,
+        fireImmediately: true
+      }, this.setLoading, this.setRendered, this.setError);
+    },
+    setStatus: function setStatus(message) {
+      self.status = message;
+    },
+    setLoading: function setLoading(abortController) {
+      if (renderInProgress !== undefined) {
+        if (!renderInProgress.signal.aborted) {
+          renderInProgress.abort();
+        }
+      }
+
+      self.filled = false;
+      self.message = undefined;
+      self.reactElement = undefined;
+      self.features = undefined;
+      self.layout = undefined;
+      self.error = undefined;
+      self.maxHeightReached = false;
+      self.renderProps = undefined;
+      renderInProgress = abortController;
+    },
+    setMessage: function setMessage(messageText) {
+      if (renderInProgress && !renderInProgress.signal.aborted) {
+        renderInProgress.abort();
+      }
+
+      self.filled = false;
+      self.message = messageText;
+      self.reactElement = undefined;
+      self.features = undefined;
+      self.layout = undefined;
+      self.error = undefined;
+      self.maxHeightReached = false;
+      self.renderProps = undefined;
+      renderInProgress = undefined;
+    },
+    setRendered: function setRendered(props) {
+      if (!props) {
+        return;
+      }
+
+      var reactElement = props.reactElement,
+          features = props.features,
+          layout = props.layout,
+          maxHeightReached = props.maxHeightReached,
+          renderProps = props.renderProps;
+      self.filled = true;
+      self.message = undefined;
+      self.reactElement = reactElement;
+      self.features = features;
+      self.layout = layout;
+      self.error = undefined;
+      self.maxHeightReached = maxHeightReached;
+      self.renderProps = renderProps;
+      renderInProgress = undefined;
+    },
+    setError: function setError(error) {
+      console.error(error);
+
+      if (renderInProgress && !renderInProgress.signal.aborted) {
+        renderInProgress.abort();
+      } // the rendering failed for some reason
+
+
+      self.filled = false;
+      self.message = undefined;
+      self.reactElement = undefined;
+      self.features = undefined;
+      self.layout = undefined;
+      self.maxHeightReached = false;
+      self.error = error;
+      self.renderProps = undefined;
+      renderInProgress = undefined;
+
+      if ((0, _types.isRetryException)(error)) {
+        this.reload();
+      }
+    },
+    reload: function reload() {
+      self.renderInProgress = undefined;
+      self.filled = false;
+      self.reactElement = undefined;
+      self.features = undefined;
+      self.layout = undefined;
+      self.error = undefined;
+      self.message = undefined;
+      self.maxHeightReached = false;
+      self.ReactComponent = _ServerSideRenderedBlockContent["default"];
+      self.renderProps = undefined;
+      (0, _mobxStateTree.getParent)(self, 2).reload();
+    },
+    beforeDestroy: function beforeDestroy() {
+      if (renderInProgress && !renderInProgress.signal.aborted) {
+        renderInProgress.abort();
+      }
+
+      var display = (0, _util.getContainingDisplay)(self);
+
+      var _getSession = (0, _util.getSession)(self),
+          rpcManager = _getSession.rpcManager;
+
+      var rendererType = display.rendererType;
+
+      var _renderBlockData = renderBlockData((0, _mobxStateTree.cast)(self)),
+          renderArgs = _renderBlockData.renderArgs; // renderArgs can be undefined if an error occured in this block
+
+
+      if (renderArgs) {
+        rendererType.freeResourcesInClient(rpcManager, JSON.parse(JSON.stringify(renderArgs)))["catch"](function (e) {
+          // just console.error if it's something while it's being destroyed
+          console.warn('Error while destroying block', e);
+        });
+      }
+    }
+  };
+});
+
+var _default = blockState;
+exports["default"] = _default;
+
+// calls the render worker to render the block content not using a flow for
+// this, because the flow doesn't work with autorun
+function renderBlockData(self, optDisplay) {
+  try {
+    var display = optDisplay || (0, _util.getContainingDisplay)(self);
+
+    var _getSession2 = (0, _util.getSession)(display),
+        assemblyManager = _getSession2.assemblyManager,
+        rpcManager = _getSession2.rpcManager;
+
+    var adapterConfig = display.adapterConfig,
+        rendererType = display.rendererType,
+        error = display.error,
+        parentTrack = display.parentTrack;
+    var assemblyNames = (0, _tracks.getTrackAssemblyNames)(parentTrack);
+    var regionAsm = self.region.assemblyName;
+
+    if (!assemblyNames.includes(regionAsm) && !assemblyNames.find(function (name) {
+      var _assemblyManager$get;
+
+      return (_assemblyManager$get = assemblyManager.get(name)) === null || _assemblyManager$get === void 0 ? void 0 : _assemblyManager$get.hasName(regionAsm);
+    })) {
+      throw new Error("region assembly (".concat(regionAsm, ") does not match track assemblies (").concat(assemblyNames, ")"));
+    }
+
+    var renderProps = display.renderProps();
+    var config = renderProps.config; // This line is to trigger the mobx reaction when the config changes
+    // It won't trigger the reaction if it doesn't think we're accessing it
+
+    (0, _configuration.readConfObject)(config);
+    var sessionId = (0, _tracks.getRpcSessionId)(display);
+    var cannotBeRenderedReason = display.regionCannotBeRendered(self.region);
+    return {
+      rendererType: rendererType,
+      rpcManager: rpcManager,
+      renderProps: renderProps,
+      cannotBeRenderedReason: cannotBeRenderedReason,
+      displayError: error,
+      renderArgs: {
+        statusCallback: function statusCallback(message) {
+          if ((0, _mobxStateTree.isAlive)(self)) {
+            self.setStatus(message);
+          }
+        },
+        assemblyName: self.region.assemblyName,
+        regions: [self.region],
+        adapterConfig: adapterConfig,
+        rendererType: rendererType.name,
+        sessionId: sessionId,
+        blockKey: self.key,
+        reloadFlag: self.reloadFlag,
+        timeout: 1000000 // 10000,
+
+      }
+    };
+  } catch (e) {
+    return {
+      displayError: e
+    };
+  }
+}
+
+function renderBlockEffect(_x, _x2, _x3) {
+  return _renderBlockEffect.apply(this, arguments);
+}
+
+function _renderBlockEffect() {
+  _renderBlockEffect = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee(props, signal, self) {
+    var _ref, rendererType, renderProps, rpcManager, renderArgs, cannotBeRenderedReason, displayError, _yield$rendererType$r, reactElement, features, layout, maxHeightReached;
+
+    return _regenerator["default"].wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            _ref = props, rendererType = _ref.rendererType, renderProps = _ref.renderProps, rpcManager = _ref.rpcManager, renderArgs = _ref.renderArgs, cannotBeRenderedReason = _ref.cannotBeRenderedReason, displayError = _ref.displayError;
+
+            if ((0, _mobxStateTree.isAlive)(self)) {
+              _context.next = 3;
+              break;
+            }
+
+            return _context.abrupt("return", undefined);
+
+          case 3:
+            if (!displayError) {
+              _context.next = 6;
+              break;
+            }
+
+            self.setError(displayError);
+            return _context.abrupt("return", undefined);
+
+          case 6:
+            if (!cannotBeRenderedReason) {
+              _context.next = 9;
+              break;
+            }
+
+            self.setMessage(cannotBeRenderedReason);
+            return _context.abrupt("return", undefined);
+
+          case 9:
+            if (!renderProps.notReady) {
+              _context.next = 11;
+              break;
+            }
+
+            return _context.abrupt("return", undefined);
+
+          case 11:
+            _context.next = 13;
+            return rendererType.renderInClient(rpcManager, _objectSpread(_objectSpread(_objectSpread({}, renderArgs), renderProps), {}, {
+              viewParams: (0, _util.getViewParams)(self),
+              signal: signal
+            }));
+
+          case 13:
+            _yield$rendererType$r = _context.sent;
+            reactElement = _yield$rendererType$r.reactElement;
+            features = _yield$rendererType$r.features;
+            layout = _yield$rendererType$r.layout;
+            maxHeightReached = _yield$rendererType$r.maxHeightReached;
+            return _context.abrupt("return", {
+              reactElement: reactElement,
+              features: features,
+              layout: layout,
+              maxHeightReached: maxHeightReached
+            });
+
+          case 19:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+  return _renderBlockEffect.apply(this, arguments);
+}

package/dist/LinearBareDisplay/configSchema.d.ts

@@ -1,2 +1,2 @@
-import PluginManager from '@jbrowse/core/PluginManager';
-export declare function configSchemaFactory(pluginManager: PluginManager): import("@jbrowse/core/configuration").AnyConfigurationSchemaType;
+import PluginManager from '@jbrowse/core/PluginManager';
+export declare function configSchemaFactory(pluginManager: PluginManager): import("@jbrowse/core/configuration").AnyConfigurationSchemaType;

package/dist/LinearBareDisplay/configSchema.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.configSchemaFactory = configSchemaFactory;
+
+var _configuration = require("@jbrowse/core/configuration");
+
+var _BaseLinearDisplay = require("../BaseLinearDisplay");
+
+function configSchemaFactory(pluginManager) {
+  return (0, _configuration.ConfigurationSchema)('LinearBareDisplay', {
+    renderer: pluginManager.pluggableConfigSchemaType('renderer')
+  }, {
+    baseConfiguration: _BaseLinearDisplay.baseLinearDisplayConfigSchema,
+    explicitlyTyped: true
+  });
+}

package/dist/LinearBareDisplay/index.d.ts

@@ -1,2 +1,2 @@
-export { configSchemaFactory } from './configSchema';
-export { stateModelFactory } from './model';
+export { configSchemaFactory } from './configSchema';
+export { stateModelFactory } from './model';

package/dist/LinearBareDisplay/index.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "configSchemaFactory", {
+  enumerable: true,
+  get: function get() {
+    return _configSchema.configSchemaFactory;
+  }
+});
+Object.defineProperty(exports, "stateModelFactory", {
+  enumerable: true,
+  get: function get() {
+    return _model.stateModelFactory;
+  }
+});
+
+var _configSchema = require("./configSchema");
+
+var _model = require("./model");

package/dist/LinearBareDisplay/index.test.js

@@ -0,0 +1,33 @@
+"use strict";
+
+var _mobxStateTree = require("mobx-state-tree");
+
+var _configuration = require("@jbrowse/core/configuration");
+
+var _ = require(".");
+
+test('config schema renderer type', function () {
+  var stubPluginManager = {
+    pluggableConfigSchemaType: function pluggableConfigSchemaType(type) {
+      var one = (0, _configuration.ConfigurationSchema)("".concat(type, "_TypeOne"), {}, {
+        explicitlyTyped: true
+      });
+      var two = (0, _configuration.ConfigurationSchema)("".concat(type, "_TypeTwo"), {}, {
+        explicitlyTyped: true
+      });
+      var three = (0, _configuration.ConfigurationSchema)("".concat(type, "_TypeThree"), {}, {
+        explicitlyTyped: true
+      });
+      return _mobxStateTree.types.union(one, two, three);
+    }
+  };
+  var configSchema = (0, _.configSchemaFactory)(stubPluginManager);
+  var instance = configSchema.create({
+    type: 'LinearBareDisplay',
+    displayId: 'displayId0',
+    renderer: {
+      type: 'renderer_TypeTwo'
+    }
+  });
+  expect(instance.renderer.type).toBe('renderer_TypeTwo');
+});