@jbrowse/core 1.4.1 → 1.5.2

package/assemblyManager/assemblyManager.d.ts

@@ -1,4 +1,4 @@
-import { IAnyType, Instance } from 'mobx-state-tree';
+import { Instance, IAnyType } from 'mobx-state-tree';
 import PluginManager from '../PluginManager';
 export default function assemblyManagerFactory(assemblyConfigType: IAnyType, pluginManager: PluginManager): import("mobx-state-tree").IModelType<{
     assemblies: import("mobx-state-tree").IArrayType<import("mobx-state-tree").IModelType<{
@@ -9,6 +9,7 @@ export default function assemblyManagerFactory(assemblyConfigType: IAnyType, plu
         refNameAliases: {
             [key: string]: string;
         } | undefined;
+        cytobands: import("../util/simpleFeature").Feature[] | undefined;
     } & {
         readonly initialized: boolean;
         readonly name: string;
@@ -25,21 +26,35 @@ export default function assemblyManagerFactory(assemblyConfigType: IAnyType, plu
         isValidRefName(refName: string): boolean;
     } & {
         setLoading(): void;
-        setLoaded({ adapterRegionsWithAssembly, refNameAliases, }: {
+        setLoaded({ adapterRegionsWithAssembly, refNameAliases, cytobands, }: {
             adapterRegionsWithAssembly: import("../util").Region[];
-            refNameAliases: Record<string, string>;
+            refNameAliases: {
+                [x: string]: string;
+            };
+            cytobands: import("../util/simpleFeature").Feature[];
         }): void;
-        setError(error: Error): void;
+        setError(e: Error): void;
         setRegions(regions: import("../util").Region[]): void;
-        setRefNameAliases(refNameAliases: Record<string, string>): void;
+        setRefNameAliases(refNameAliases: {
+            [x: string]: string;
+        }): void;
+        setCytobands(cytobands: import("../util/simpleFeature").Feature[]): void;
         afterAttach(): void;
     } & {
         getAdapterMapEntry(adapterConf: unknown, options: import("./assembly").BaseOptions): Promise<{
-            forwardMap: Record<string, string>;
-            reverseMap: Record<string, string>;
+            forwardMap: {
+                [k: string]: string;
+            };
+            reverseMap: {
+                [k: string]: string;
+            };
+        }>;
+        getRefNameMapForAdapter(adapterConf: unknown, opts: import("./assembly").BaseOptions): Promise<{
+            [k: string]: string;
+        }>;
+        getReverseRefNameMapForAdapter(adapterConf: unknown, opts: import("./assembly").BaseOptions): Promise<{
+            [k: string]: string;
         }>;
-        getRefNameMapForAdapter(adapterConf: unknown, opts: import("./assembly").BaseOptions): Promise<Record<string, string>>;
-        getReverseRefNameMapForAdapter(adapterConf: unknown, opts: import("./assembly").BaseOptions): Promise<Record<string, string>>;
     }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>>;
 }, {
     get(assemblyName: string): (import("mobx-state-tree").ModelInstanceTypeProps<{
@@ -50,6 +65,7 @@ export default function assemblyManagerFactory(assemblyConfigType: IAnyType, plu
         refNameAliases: {
             [key: string]: string;
         } | undefined;
+        cytobands: import("../util/simpleFeature").Feature[] | undefined;
     } & {
         readonly initialized: boolean;
         readonly name: string;
@@ -66,21 +82,35 @@ export default function assemblyManagerFactory(assemblyConfigType: IAnyType, plu
         isValidRefName(refName: string): boolean;
     } & {
         setLoading(): void;
-        setLoaded({ adapterRegionsWithAssembly, refNameAliases, }: {
+        setLoaded({ adapterRegionsWithAssembly, refNameAliases, cytobands, }: {
             adapterRegionsWithAssembly: import("../util").Region[];
-            refNameAliases: Record<string, string>;
+            refNameAliases: {
+                [x: string]: string;
+            };
+            cytobands: import("../util/simpleFeature").Feature[];
         }): void;
-        setError(error: Error): void;
+        setError(e: Error): void;
         setRegions(regions: import("../util").Region[]): void;
-        setRefNameAliases(refNameAliases: Record<string, string>): void;
+        setRefNameAliases(refNameAliases: {
+            [x: string]: string;
+        }): void;
+        setCytobands(cytobands: import("../util/simpleFeature").Feature[]): void;
         afterAttach(): void;
     } & {
         getAdapterMapEntry(adapterConf: unknown, options: import("./assembly").BaseOptions): Promise<{
-            forwardMap: Record<string, string>;
-            reverseMap: Record<string, string>;
+            forwardMap: {
+                [k: string]: string;
+            };
+            reverseMap: {
+                [k: string]: string;
+            };
+        }>;
+        getRefNameMapForAdapter(adapterConf: unknown, opts: import("./assembly").BaseOptions): Promise<{
+            [k: string]: string;
+        }>;
+        getReverseRefNameMapForAdapter(adapterConf: unknown, opts: import("./assembly").BaseOptions): Promise<{
+            [k: string]: string;
         }>;
-        getRefNameMapForAdapter(adapterConf: unknown, opts: import("./assembly").BaseOptions): Promise<Record<string, string>>;
-        getReverseRefNameMapForAdapter(adapterConf: unknown, opts: import("./assembly").BaseOptions): Promise<Record<string, string>>;
     } & import("mobx-state-tree").IStateTreeNode<import("mobx-state-tree").IModelType<{
         configuration: import("mobx-state-tree").IMaybe<import("mobx-state-tree").IReferenceType<IAnyType>>;
     }, {
@@ -89,6 +119,7 @@ export default function assemblyManagerFactory(assemblyConfigType: IAnyType, plu
         refNameAliases: {
             [key: string]: string;
         } | undefined;
+        cytobands: import("../util/simpleFeature").Feature[] | undefined;
     } & {
         readonly initialized: boolean;
         readonly name: string;
@@ -105,25 +136,39 @@ export default function assemblyManagerFactory(assemblyConfigType: IAnyType, plu
         isValidRefName(refName: string): boolean;
     } & {
         setLoading(): void;
-        setLoaded({ adapterRegionsWithAssembly, refNameAliases, }: {
+        setLoaded({ adapterRegionsWithAssembly, refNameAliases, cytobands, }: {
             adapterRegionsWithAssembly: import("../util").Region[];
-            refNameAliases: Record<string, string>;
+            refNameAliases: {
+                [x: string]: string;
+            };
+            cytobands: import("../util/simpleFeature").Feature[];
         }): void;
-        setError(error: Error): void;
+        setError(e: Error): void;
         setRegions(regions: import("../util").Region[]): void;
-        setRefNameAliases(refNameAliases: Record<string, string>): void;
+        setRefNameAliases(refNameAliases: {
+            [x: string]: string;
+        }): void;
+        setCytobands(cytobands: import("../util/simpleFeature").Feature[]): void;
         afterAttach(): void;
     } & {
         getAdapterMapEntry(adapterConf: unknown, options: import("./assembly").BaseOptions): Promise<{
-            forwardMap: Record<string, string>;
-            reverseMap: Record<string, string>;
+            forwardMap: {
+                [k: string]: string;
+            };
+            reverseMap: {
+                [k: string]: string;
+            };
+        }>;
+        getRefNameMapForAdapter(adapterConf: unknown, opts: import("./assembly").BaseOptions): Promise<{
+            [k: string]: string;
+        }>;
+        getReverseRefNameMapForAdapter(adapterConf: unknown, opts: import("./assembly").BaseOptions): Promise<{
+            [k: string]: string;
         }>;
-        getRefNameMapForAdapter(adapterConf: unknown, opts: import("./assembly").BaseOptions): Promise<Record<string, string>>;
-        getReverseRefNameMapForAdapter(adapterConf: unknown, opts: import("./assembly").BaseOptions): Promise<Record<string, string>>;
     }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>>) | undefined;
     readonly assemblyNamesList: string[];
     readonly assemblyList: (import("mobx-state-tree").ModelInstanceTypeProps<Record<string, any>> & {
-        setSubschema(slotName: string, data: import("mobx-state-tree").ModelPropertiesDeclaration | import("../configuration/configurationSchema").AnyConfigurationSchemaType): any;
+        setSubschema(slotName: string, data: unknown): any;
     } & import("mobx-state-tree").IStateTreeNode<import("../configuration/configurationSchema").AnyConfigurationSchemaType> & {
         name: string;
     })[];
@@ -139,6 +184,7 @@ export default function assemblyManagerFactory(assemblyConfigType: IAnyType, plu
         refNameAliases: {
             [key: string]: string;
         } | undefined;
+        cytobands: import("../util/simpleFeature").Feature[] | undefined;
     } & {
         readonly initialized: boolean;
         readonly name: string;
@@ -155,21 +201,35 @@ export default function assemblyManagerFactory(assemblyConfigType: IAnyType, plu
         isValidRefName(refName: string): boolean;
     } & {
         setLoading(): void;
-        setLoaded({ adapterRegionsWithAssembly, refNameAliases, }: {
+        setLoaded({ adapterRegionsWithAssembly, refNameAliases, cytobands, }: {
             adapterRegionsWithAssembly: import("../util").Region[];
-            refNameAliases: Record<string, string>;
+            refNameAliases: {
+                [x: string]: string;
+            };
+            cytobands: import("../util/simpleFeature").Feature[];
         }): void;
-        setError(error: Error): void;
+        setError(e: Error): void;
         setRegions(regions: import("../util").Region[]): void;
-        setRefNameAliases(refNameAliases: Record<string, string>): void;
+        setRefNameAliases(refNameAliases: {
+            [x: string]: string;
+        }): void;
+        setCytobands(cytobands: import("../util/simpleFeature").Feature[]): void;
         afterAttach(): void;
     } & {
         getAdapterMapEntry(adapterConf: unknown, options: import("./assembly").BaseOptions): Promise<{
-            forwardMap: Record<string, string>;
-            reverseMap: Record<string, string>;
+            forwardMap: {
+                [k: string]: string;
+            };
+            reverseMap: {
+                [k: string]: string;
+            };
+        }>;
+        getRefNameMapForAdapter(adapterConf: unknown, opts: import("./assembly").BaseOptions): Promise<{
+            [k: string]: string;
+        }>;
+        getReverseRefNameMapForAdapter(adapterConf: unknown, opts: import("./assembly").BaseOptions): Promise<{
+            [k: string]: string;
         }>;
-        getRefNameMapForAdapter(adapterConf: unknown, opts: import("./assembly").BaseOptions): Promise<Record<string, string>>;
-        getReverseRefNameMapForAdapter(adapterConf: unknown, opts: import("./assembly").BaseOptions): Promise<Record<string, string>>;
     } & import("mobx-state-tree").IStateTreeNode<import("mobx-state-tree").IModelType<{
         configuration: import("mobx-state-tree").IMaybe<import("mobx-state-tree").IReferenceType<IAnyType>>;
     }, {
@@ -178,6 +238,7 @@ export default function assemblyManagerFactory(assemblyConfigType: IAnyType, plu
         refNameAliases: {
             [key: string]: string;
         } | undefined;
+        cytobands: import("../util/simpleFeature").Feature[] | undefined;
     } & {
         readonly initialized: boolean;
         readonly name: string;
@@ -194,30 +255,48 @@ export default function assemblyManagerFactory(assemblyConfigType: IAnyType, plu
         isValidRefName(refName: string): boolean;
     } & {
         setLoading(): void;
-        setLoaded({ adapterRegionsWithAssembly, refNameAliases, }: {
+        setLoaded({ adapterRegionsWithAssembly, refNameAliases, cytobands, }: {
             adapterRegionsWithAssembly: import("../util").Region[];
-            refNameAliases: Record<string, string>;
+            refNameAliases: {
+                [x: string]: string;
+            };
+            cytobands: import("../util/simpleFeature").Feature[];
         }): void;
-        setError(error: Error): void;
+        setError(e: Error): void;
         setRegions(regions: import("../util").Region[]): void;
-        setRefNameAliases(refNameAliases: Record<string, string>): void;
+        setRefNameAliases(refNameAliases: {
+            [x: string]: string;
+        }): void;
+        setCytobands(cytobands: import("../util/simpleFeature").Feature[]): void;
         afterAttach(): void;
     } & {
         getAdapterMapEntry(adapterConf: unknown, options: import("./assembly").BaseOptions): Promise<{
-            forwardMap: Record<string, string>;
-            reverseMap: Record<string, string>;
+            forwardMap: {
+                [k: string]: string;
+            };
+            reverseMap: {
+                [k: string]: string;
+            };
+        }>;
+        getRefNameMapForAdapter(adapterConf: unknown, opts: import("./assembly").BaseOptions): Promise<{
+            [k: string]: string;
+        }>;
+        getReverseRefNameMapForAdapter(adapterConf: unknown, opts: import("./assembly").BaseOptions): Promise<{
+            [k: string]: string;
         }>;
-        getRefNameMapForAdapter(adapterConf: unknown, opts: import("./assembly").BaseOptions): Promise<Record<string, string>>;
-        getReverseRefNameMapForAdapter(adapterConf: unknown, opts: import("./assembly").BaseOptions): Promise<Record<string, string>>;
     }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>>) | undefined>;
     getRefNameMapForAdapter(adapterConf: unknown, assemblyName: string, opts: {
         signal?: AbortSignal;
         sessionId: string;
-    }): Promise<Record<string, string> | undefined>;
+    }): Promise<{
+        [k: string]: string;
+    } | undefined>;
     getReverseRefNameMapForAdapter(adapterConf: unknown, assemblyName: string, opts: {
         signal?: AbortSignal;
         sessionId: string;
-    }): Promise<Record<string, string> | undefined>;
+    }): Promise<{
+        [k: string]: string;
+    } | undefined>;
     isValidRefName(refName: string, assemblyName?: string | undefined): boolean;
 } & {
     removeAssembly(asm: import("mobx-state-tree").ModelInstanceTypeProps<{
@@ -228,6 +307,7 @@ export default function assemblyManagerFactory(assemblyConfigType: IAnyType, plu
         refNameAliases: {
             [key: string]: string;
         } | undefined;
+        cytobands: import("../util/simpleFeature").Feature[] | undefined;
     } & {
         readonly initialized: boolean;
         readonly name: string;
@@ -244,21 +324,35 @@ export default function assemblyManagerFactory(assemblyConfigType: IAnyType, plu
         isValidRefName(refName: string): boolean;
     } & {
         setLoading(): void;
-        setLoaded({ adapterRegionsWithAssembly, refNameAliases, }: {
+        setLoaded({ adapterRegionsWithAssembly, refNameAliases, cytobands, }: {
             adapterRegionsWithAssembly: import("../util").Region[];
-            refNameAliases: Record<string, string>;
+            refNameAliases: {
+                [x: string]: string;
+            };
+            cytobands: import("../util/simpleFeature").Feature[];
         }): void;
-        setError(error: Error): void;
+        setError(e: Error): void;
         setRegions(regions: import("../util").Region[]): void;
-        setRefNameAliases(refNameAliases: Record<string, string>): void;
+        setRefNameAliases(refNameAliases: {
+            [x: string]: string;
+        }): void;
+        setCytobands(cytobands: import("../util/simpleFeature").Feature[]): void;
         afterAttach(): void;
     } & {
         getAdapterMapEntry(adapterConf: unknown, options: import("./assembly").BaseOptions): Promise<{
-            forwardMap: Record<string, string>;
-            reverseMap: Record<string, string>;
+            forwardMap: {
+                [k: string]: string;
+            };
+            reverseMap: {
+                [k: string]: string;
+            };
+        }>;
+        getRefNameMapForAdapter(adapterConf: unknown, opts: import("./assembly").BaseOptions): Promise<{
+            [k: string]: string;
+        }>;
+        getReverseRefNameMapForAdapter(adapterConf: unknown, opts: import("./assembly").BaseOptions): Promise<{
+            [k: string]: string;
         }>;
-        getRefNameMapForAdapter(adapterConf: unknown, opts: import("./assembly").BaseOptions): Promise<Record<string, string>>;
-        getReverseRefNameMapForAdapter(adapterConf: unknown, opts: import("./assembly").BaseOptions): Promise<Record<string, string>>;
     } & import("mobx-state-tree").IStateTreeNode<import("mobx-state-tree").IModelType<{
         configuration: import("mobx-state-tree").IMaybe<import("mobx-state-tree").IReferenceType<IAnyType>>;
     }, {
@@ -267,6 +361,7 @@ export default function assemblyManagerFactory(assemblyConfigType: IAnyType, plu
         refNameAliases: {
             [key: string]: string;
         } | undefined;
+        cytobands: import("../util/simpleFeature").Feature[] | undefined;
     } & {
         readonly initialized: boolean;
         readonly name: string;
@@ -283,21 +378,35 @@ export default function assemblyManagerFactory(assemblyConfigType: IAnyType, plu
         isValidRefName(refName: string): boolean;
     } & {
         setLoading(): void;
-        setLoaded({ adapterRegionsWithAssembly, refNameAliases, }: {
+        setLoaded({ adapterRegionsWithAssembly, refNameAliases, cytobands, }: {
             adapterRegionsWithAssembly: import("../util").Region[];
-            refNameAliases: Record<string, string>;
+            refNameAliases: {
+                [x: string]: string;
+            };
+            cytobands: import("../util/simpleFeature").Feature[];
         }): void;
-        setError(error: Error): void;
+        setError(e: Error): void;
         setRegions(regions: import("../util").Region[]): void;
-        setRefNameAliases(refNameAliases: Record<string, string>): void;
+        setRefNameAliases(refNameAliases: {
+            [x: string]: string;
+        }): void;
+        setCytobands(cytobands: import("../util/simpleFeature").Feature[]): void;
         afterAttach(): void;
     } & {
         getAdapterMapEntry(adapterConf: unknown, options: import("./assembly").BaseOptions): Promise<{
-            forwardMap: Record<string, string>;
-            reverseMap: Record<string, string>;
+            forwardMap: {
+                [k: string]: string;
+            };
+            reverseMap: {
+                [k: string]: string;
+            };
+        }>;
+        getRefNameMapForAdapter(adapterConf: unknown, opts: import("./assembly").BaseOptions): Promise<{
+            [k: string]: string;
+        }>;
+        getReverseRefNameMapForAdapter(adapterConf: unknown, opts: import("./assembly").BaseOptions): Promise<{
+            [k: string]: string;
         }>;
-        getRefNameMapForAdapter(adapterConf: unknown, opts: import("./assembly").BaseOptions): Promise<Record<string, string>>;
-        getReverseRefNameMapForAdapter(adapterConf: unknown, opts: import("./assembly").BaseOptions): Promise<Record<string, string>>;
     }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>>): void;
     afterAttach(): void;
     addAssembly(assemblyConfig: Instance<typeof assemblyConfigType> | string): void;

package/assemblyManager/index.d.ts

@@ -1,2 +1,2 @@
 export { default } from './assemblyManager';
-export { default as assemblyConfigSchemas } from './assemblyConfigSchemas';
+export { default as assemblyConfigSchemaFactory } from './assemblyConfigSchema';

package/assemblyManager/index.js

@@ -5,19 +5,19 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-Object.defineProperty(exports, "default", {
+Object.defineProperty(exports, "assemblyConfigSchemaFactory", {
   enumerable: true,
   get: function get() {
-    return _assemblyManager.default;
+    return _assemblyConfigSchema.default;
   }
 });
-Object.defineProperty(exports, "assemblyConfigSchemas", {
+Object.defineProperty(exports, "default", {
   enumerable: true,
   get: function get() {
-    return _assemblyConfigSchemas.default;
+    return _assemblyManager.default;
   }
 });
 
 var _assemblyManager = _interopRequireDefault(require("./assemblyManager"));
 
-var _assemblyConfigSchemas = _interopRequireDefault(require("./assemblyConfigSchemas"));
+var _assemblyConfigSchema = _interopRequireDefault(require("./assemblyConfigSchema"));

package/configuration/configurationSchema.d.ts

@@ -1,4 +1,4 @@
-import { Instance, IAnyType, ModelPropertiesDeclaration } from 'mobx-state-tree';
+import { Instance, IAnyType } from 'mobx-state-tree';
 import { ConfigSlotDefinition } from './configurationSlot';
 export interface ConfigurationSchemaDefinition {
     [n: string]: ConfigSlotDefinition | ConfigurationSchemaDefinition | string | number | IAnyType;
@@ -14,12 +14,13 @@ interface ConfigurationSchemaOptions {
     preProcessSnapshot?: (snapshot: {}) => {};
 }
 declare function makeConfigurationSchemaModel<DEFINITION extends ConfigurationSchemaDefinition, OPTIONS extends ConfigurationSchemaOptions>(modelName: string, schemaDefinition: DEFINITION, options: OPTIONS): import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").IModelType<Record<string, any>, {
-    setSubschema(slotName: string, data: ModelPropertiesDeclaration | AnyConfigurationSchemaType): any;
+    setSubschema(slotName: string, data: unknown): any;
 }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>, [undefined]>;
 export interface AnyConfigurationSchemaType extends ReturnType<typeof makeConfigurationSchemaModel> {
     isJBrowseConfigurationSchema: boolean;
     jbrowseSchemaDefinition: ConfigurationSchemaDefinition;
     jbrowseSchemaOptions: ConfigurationSchemaOptions;
+    type: string;
 }
 export declare type AnyConfigurationModel = Instance<AnyConfigurationSchemaType>;
 export declare type ConfigurationModel<SCHEMA extends AnyConfigurationSchemaType> = Instance<SCHEMA>;

package/configuration/configurationSchema.js

@@ -5,8 +5,8 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.ConfigurationSchema = ConfigurationSchema;
 exports.ConfigurationReference = ConfigurationReference;
+exports.ConfigurationSchema = ConfigurationSchema;
 
 var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
 
@@ -119,7 +119,7 @@ function makeConfigurationSchemaModel(modelName, schemaDefinition, options) {
       try {
         modelDefinition[slotName] = (0, _configurationSlot.default)(slotName, slotDefinition);
       } catch (e) {
-        throw new Error("invalid config slot definition for ".concat(modelName, ".").concat(slotName, ": ").concat(e.message));
+        throw new Error("invalid config slot definition for ".concat(modelName, ".").concat(slotName, ": ").concat(e));
       }
     } else {
       throw new Error("invalid configuration schema definition, \"".concat(slotName, "\" must be either a valid configuration slot definition, a constant, or a nested configuration schema"));
@@ -141,11 +141,10 @@ function makeConfigurationSchemaModel(modelName, schemaDefinition, options) {
   });
 
   if (Object.keys(volatileConstants).length) {
-    completeModel = completeModel.volatile(function () {
-      return (
-        /* self */
-        volatileConstants
-      );
+    completeModel = completeModel.volatile(function
+      /* self */
+    () {
+      return volatileConstants;
     });
   }
 
@@ -202,9 +201,7 @@ function makeConfigurationSchemaModel(modelName, schemaDefinition, options) {
     completeModel = completeModel.preProcessSnapshot(options.preProcessSnapshot);
   }
 
-  var schemaType = _mobxStateTree.types.optional(completeModel, modelDefault);
-
-  return schemaType;
+  return _mobxStateTree.types.optional(completeModel, modelDefault);
 }
 
 function ConfigurationSchema(modelName, inputSchemaDefinition, inputOptions) {

package/configuration/configurationSchema.test.js

@@ -229,7 +229,8 @@ describe('configuration schemas', function () {
       gffGzLocation: {
         type: 'fileLocation',
         defaultValue: {
-          uri: '/path/to/my.gff.gz'
+          uri: '/path/to/my.gff.gz',
+          locationType: 'UriLocation'
         }
       },
       index: (0, _configurationSchema.ConfigurationSchema)('Gff3TabixIndex', {
@@ -241,7 +242,8 @@ describe('configuration schemas', function () {
         location: {
           type: 'fileLocation',
           defaultValue: {
-            uri: '/path/to/my.gff.gz.tbi'
+            uri: '/path/to/my.gff.gz.tbi',
+            locationType: 'UriLocation'
           }
         }
       }),

package/configuration/configurationSlot.js

@@ -16,9 +16,9 @@ var _jexlStrings = require("../util/jexlStrings");
 var _mst = require("../util/types/mst");
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
-function isValidColorString()
-/* str */
-{
+function
+  /* str */
+isValidColorString() {
   // TODO: check all the crazy cases for whether it's a valid HTML/CSS color string
   return true;
 }
@@ -48,7 +48,8 @@ var fallbackDefaults = {
   string: '',
   text: '',
   fileLocation: {
-    uri: '/path/to/resource.txt'
+    uri: '/path/to/resource.txt',
+    locationType: 'UriLocation'
   },
   frozen: {}
 };

package/configuration/index.js

@@ -7,16 +7,16 @@ var _exportNames = {
   ConfigurationSchema: true,
   ConfigurationReference: true
 };
-Object.defineProperty(exports, "ConfigurationSchema", {
+Object.defineProperty(exports, "ConfigurationReference", {
   enumerable: true,
   get: function get() {
-    return _configurationSchema.ConfigurationSchema;
+    return _configurationSchema.ConfigurationReference;
   }
 });
-Object.defineProperty(exports, "ConfigurationReference", {
+Object.defineProperty(exports, "ConfigurationSchema", {
   enumerable: true,
   get: function get() {
-    return _configurationSchema.ConfigurationReference;
+    return _configurationSchema.ConfigurationSchema;
   }
 });
 

package/configuration/util.js

@@ -5,13 +5,13 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.readConfObject = readConfObject;
 exports.getConf = getConf;
 exports.getTypeNamesFromExplicitlyTypedUnion = getTypeNamesFromExplicitlyTypedUnion;
 exports.isBareConfigurationSchemaType = isBareConfigurationSchemaType;
-exports.isConfigurationSchemaType = isConfigurationSchemaType;
 exports.isConfigurationModel = isConfigurationModel;
+exports.isConfigurationSchemaType = isConfigurationSchemaType;
 exports.isConfigurationSlotType = isConfigurationSlotType;
+exports.readConfObject = readConfObject;
 
 var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
 
@@ -39,7 +39,7 @@ function readConfObject(confObject) {
   }
 
   if (!slotPath) {
-    return (0, _mobxStateTree.getSnapshot)(confObject);
+    return JSON.parse(JSON.stringify((0, _mobxStateTree.getSnapshot)(confObject)));
   }
 
   if (typeof slotPath === 'string') {
@@ -66,14 +66,14 @@ function readConfObject(confObject) {
       var appliedFunc = slot.expr.evalSync(args);
 
       if ((0, _mobxStateTree.isStateTreeNode)(appliedFunc)) {
-        return (0, _mobxStateTree.getSnapshot)(appliedFunc);
+        return JSON.parse(JSON.stringify((0, _mobxStateTree.getSnapshot)(appliedFunc)));
       }
 
       return appliedFunc;
     }
 
     if ((0, _mobxStateTree.isStateTreeNode)(slot)) {
-      return (0, _mobxStateTree.getSnapshot)(slot);
+      return JSON.parse(JSON.stringify((0, _mobxStateTree.getSnapshot)(slot)));
     }
 
     return slot;

package/data_adapters/BaseAdapter.d.ts

@@ -2,8 +2,9 @@ import { Observable } from 'rxjs';
 import { Feature } from '../util/simpleFeature';
 import { AnyConfigurationModel } from '../configuration/configurationSchema';
 import { getSubAdapterType } from './dataAdapterCache';
-import { Region, NoAssemblyRegion } from '../util/types';
+import { AugmentedRegion as Region, NoAssemblyRegion } from '../util/types';
 import BaseResult from '../TextSearch/BaseResults';
+import PluginManager from '../PluginManager';
 export interface BaseOptions {
     signal?: AbortSignal;
     bpPerPx?: number;
@@ -21,7 +22,7 @@ export interface BaseArgs {
     pageNumber?: number;
 }
 export interface AnyAdapter {
-    new (config: AnyConfigurationModel, getSubAdapter?: getSubAdapterType): AnyDataAdapter;
+    new (config: AnyConfigurationModel, getSubAdapter?: getSubAdapterType, pluginManager?: PluginManager | undefined): AnyDataAdapter;
 }
 export declare type AnyDataAdapter = BaseAdapter | BaseFeatureDataAdapter | BaseRefNameAliasAdapter | BaseTextSearchAdapter | RegionsAdapter | SequenceAdapter;
 export declare abstract class BaseAdapter {
@@ -29,7 +30,8 @@ export declare abstract class BaseAdapter {
     static capabilities: string[];
     config: AnyConfigurationModel;
     getSubAdapter?: getSubAdapterType;
-    constructor(config?: AnyConfigurationModel, getSubAdapter?: getSubAdapterType);
+    pluginManager: PluginManager | undefined;
+    constructor(config?: AnyConfigurationModel, getSubAdapter?: getSubAdapterType, pluginManager?: PluginManager);
     /**
      * Called to provide a hint that data tied to a certain region will not be
      * needed for the forseeable future and can be purged from caches, etc

package/data_adapters/BaseAdapter.js

@@ -5,12 +5,12 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.isSequenceAdapter = isSequenceAdapter;
-exports.isRegionsAdapter = isRegionsAdapter;
+exports.BaseFeatureDataAdapter = exports.BaseAdapter = void 0;
 exports.isFeatureAdapter = isFeatureAdapter;
 exports.isRefNameAliasAdapter = isRefNameAliasAdapter;
+exports.isRegionsAdapter = isRegionsAdapter;
+exports.isSequenceAdapter = isSequenceAdapter;
 exports.isTextSearchAdapter = isTextSearchAdapter;
-exports.BaseFeatureDataAdapter = exports.BaseAdapter = void 0;
 
 var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
 
@@ -53,12 +53,15 @@ function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Re
 var BaseAdapter = function BaseAdapter() {
   var config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : (0, _configurationSchema.ConfigurationSchema)('empty', {}).create();
   var getSubAdapter = arguments.length > 1 ? arguments[1] : undefined;
+  var pluginManager = arguments.length > 2 ? arguments[2] : undefined;
   (0, _classCallCheck2.default)(this, BaseAdapter);
   (0, _defineProperty2.default)(this, "id", void 0);
   (0, _defineProperty2.default)(this, "config", void 0);
   (0, _defineProperty2.default)(this, "getSubAdapter", void 0);
+  (0, _defineProperty2.default)(this, "pluginManager", void 0);
   this.config = config;
-  this.getSubAdapter = getSubAdapter; // note: we use switch on jest here for more simple feature IDs
+  this.getSubAdapter = getSubAdapter;
+  this.pluginManager = pluginManager; // note: we use switch on jest here for more simple feature IDs
   // in test environment
 
   if (typeof jest === 'undefined') {