@jbrowse/core 2.4.2 → 2.6.0

package/configuration/configurationSchema.d.ts

@@ -1,31 +1,29 @@
-import { Instance, IAnyType } from 'mobx-state-tree';
-import ConfigSlot, { ConfigSlotDefinition } from './configurationSlot';
+import { IAnyType } from 'mobx-state-tree';
+import { ConfigSlotDefinition } from './configurationSlot';
+import { AnyConfigurationSchemaType } from './types';
+export type { AnyConfigurationSchemaType, AnyConfigurationModel, AnyConfigurationSlot, AnyConfigurationSlotType, } from './types';
 export interface ConfigurationSchemaDefinition {
     [n: string]: ConfigSlotDefinition | ConfigurationSchemaDefinition | string | number | IAnyType;
 }
-interface ConfigurationSchemaOptions {
+export interface ConfigurationSchemaOptions<BASE_SCHEMA extends AnyConfigurationSchemaType | undefined, EXPLICIT_IDENTIFIER extends string | undefined> {
     explicitlyTyped?: boolean;
-    explicitIdentifier?: string;
+    explicitIdentifier?: EXPLICIT_IDENTIFIER;
     implicitIdentifier?: string | boolean;
-    baseConfiguration?: AnyConfigurationSchemaType;
+    baseConfiguration?: BASE_SCHEMA;
     actions?: (self: unknown) => any;
     views?: (self: unknown) => any;
     extend?: (self: unknown) => any;
     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>, {
+declare function makeConfigurationSchemaModel<DEFINITION extends ConfigurationSchemaDefinition, OPTIONS extends ConfigurationSchemaOptions<any, any>>(modelName: string, schemaDefinition: DEFINITION, options: OPTIONS): import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").IModelType<Record<string, 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> {
+export interface ConfigurationSchemaType<DEFINITION extends ConfigurationSchemaDefinition, OPTIONS extends ConfigurationSchemaOptions<any, any>> extends ReturnType<typeof makeConfigurationSchemaModel<DEFINITION, OPTIONS>> {
     isJBrowseConfigurationSchema: boolean;
-    jbrowseSchemaDefinition: ConfigurationSchemaDefinition;
-    jbrowseSchemaOptions: ConfigurationSchemaOptions;
+    jbrowseSchemaDefinition: DEFINITION;
+    jbrowseSchemaOptions: OPTIONS;
     type: string;
+    [key: string]: unknown;
 }
-export type AnyConfigurationModel = Instance<AnyConfigurationSchemaType>;
-export type AnyConfigurationSlotType = ReturnType<typeof ConfigSlot>;
-export type AnyConfigurationSlot = Instance<AnyConfigurationSlotType>;
-export type ConfigurationModel<SCHEMA extends AnyConfigurationSchemaType> = Instance<SCHEMA>;
-export declare function ConfigurationSchema<DEFINITION extends ConfigurationSchemaDefinition, OPTIONS extends ConfigurationSchemaOptions>(modelName: string, inputSchemaDefinition: DEFINITION, inputOptions?: OPTIONS): AnyConfigurationSchemaType;
-export declare function ConfigurationReference(schemaType: IAnyType): import("mobx-state-tree").ITypeUnion<any, any, any>;
-export {};
+export declare function ConfigurationSchema<DEFINITION extends ConfigurationSchemaDefinition, OPTIONS extends ConfigurationSchemaOptions<BASE_SCHEMA, EXPLICIT_IDENTIFIER>, BASE_SCHEMA extends AnyConfigurationSchemaType | undefined = undefined, EXPLICIT_IDENTIFIER extends string | undefined = undefined>(modelName: string, inputSchemaDefinition: DEFINITION, inputOptions?: ConfigurationSchemaOptions<BASE_SCHEMA, EXPLICIT_IDENTIFIER>): ConfigurationSchemaType<DEFINITION, OPTIONS>;
+export declare function ConfigurationReference<SCHEMATYPE extends AnyConfigurationSchemaType>(schemaType: SCHEMATYPE): SCHEMATYPE;

package/configuration/configurationSchema.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConfigurationReference = exports.ConfigurationSchema = void 0;
+/* eslint-disable @typescript-eslint/no-explicit-any */
 const mobx_state_tree_1 = require("mobx-state-tree");
 const mst_1 = require("../util/types/mst");
 const configurationSlot_1 = __importDefault(require("./configurationSlot"));
@@ -41,7 +42,6 @@ function preprocessConfigurationSchemaArguments(modelName, inputSchemaDefinition
 }
 function makeConfigurationSchemaModel(modelName, schemaDefinition, options) {
     // now assemble the MST model of the configuration schema
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const modelDefinition = {};
     let identifier;
     if (options.explicitlyTyped) {
@@ -70,7 +70,6 @@ function makeConfigurationSchemaModel(modelName, schemaDefinition, options) {
             identifier = 'id';
         }
     }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const volatileConstants = {
         isJBrowseConfigurationSchema: true,
         jbrowseSchema: {
@@ -181,6 +180,9 @@ function ConfigurationSchema(modelName, inputSchemaDefinition, inputOptions) {
 }
 exports.ConfigurationSchema = ConfigurationSchema;
 function ConfigurationReference(schemaType) {
+    // we cast this to SCHEMATYPE, because the reference *should* behave just
+    // like the object it points to. It won't be undefined (this is a
+    // `reference`, not a `safeReference`)
     return mobx_state_tree_1.types.union(mobx_state_tree_1.types.reference(schemaType), schemaType);
 }
 exports.ConfigurationReference = ConfigurationReference;

package/configuration/index.d.ts

@@ -1,3 +1,3 @@
 export { ConfigurationSchema, ConfigurationReference, } from './configurationSchema';
-export type { AnyConfigurationModel, AnyConfigurationSchemaType, } from './configurationSchema';
+export type { AnyConfigurationSchemaType, AnyConfigurationModel, AnyConfigurationSlot, AnyConfigurationSlotType, AnyConfiguration, } from './types';
 export * from './util';

package/configuration/types.d.ts

@@ -0,0 +1,15 @@
+import type { IStateTreeNode, Instance, SnapshotOut } from 'mobx-state-tree';
+import type { ConfigurationSchemaType, ConfigurationSchemaOptions } from './configurationSchema';
+import type ConfigSlot from './configurationSlot';
+export type GetOptions<SCHEMA> = SCHEMA extends ConfigurationSchemaType<any, infer OPTIONS> ? OPTIONS : never;
+export type GetBase<SCHEMA> = SCHEMA extends undefined ? never : GetOptions<SCHEMA> extends ConfigurationSchemaOptions<undefined, any> ? undefined : GetOptions<SCHEMA> extends ConfigurationSchemaOptions<infer BASE extends AnyConfigurationSchemaType, any> ? BASE : never;
+export type GetExplicitIdentifier<SCHEMA> = GetOptions<SCHEMA> extends ConfigurationSchemaOptions<any, infer EXPLICIT_IDENTIFIER extends string> ? EXPLICIT_IDENTIFIER : never;
+export type ConfigurationSchemaForModel<MODEL> = MODEL extends IStateTreeNode<infer SCHEMA extends AnyConfigurationSchemaType> ? SCHEMA : never;
+export type ConfigurationSlotName<SCHEMA> = SCHEMA extends undefined ? never : SCHEMA extends ConfigurationSchemaType<infer D, any> ? (keyof D & string) | GetExplicitIdentifier<SCHEMA> | (GetBase<SCHEMA> extends ConfigurationSchemaType<any, any> ? ConfigurationSlotName<GetBase<SCHEMA>> : never) : never;
+export type AnyConfigurationSchemaType = ConfigurationSchemaType<any, any>;
+export type AnyConfigurationModel = Instance<AnyConfigurationSchemaType>;
+export type AnyConfigurationSlotType = ReturnType<typeof ConfigSlot>;
+export type AnyConfigurationSlot = Instance<AnyConfigurationSlotType>;
+/** any configuration model, or snapshot thereof */
+export type AnyConfiguration = AnyConfigurationModel | SnapshotOut<AnyConfigurationModel>;
+export type ConfigurationModel<SCHEMA extends AnyConfigurationSchemaType> = Instance<SCHEMA>;

package/configuration/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/configuration/util.d.ts

@@ -1,4 +1,4 @@
-import { AnyConfigurationModel, AnyConfigurationSchemaType } from './configurationSchema';
+import { AnyConfigurationModel, AnyConfigurationSchemaType, ConfigurationSlotName, ConfigurationSchemaForModel } from './types';
 /**
  * given a configuration model (an instance of a ConfigurationSchema),
  * read the configuration variable at the given path
@@ -8,7 +8,7 @@ import { AnyConfigurationModel, AnyConfigurationSchemaType } from './configurati
  * @param args - extra arguments e.g. for a feature callback,
  *  will be sent to each of the slotNames
  */
-export declare function readConfObject(confObject: AnyConfigurationModel, slotPath?: string[] | string | undefined, args?: Record<string, any>): any;
+export declare function readConfObject<CONFMODEL extends AnyConfigurationModel>(confObject: CONFMODEL, slotPath?: ConfigurationSlotName<ConfigurationSchemaForModel<CONFMODEL>> | string[], args?: Record<string, unknown>): any;
 /**
  * helper method for readConfObject, reads the config from a mst model
  *
@@ -17,7 +17,9 @@ export declare function readConfObject(confObject: AnyConfigurationModel, slotPa
  * @param args - extra arguments e.g. for a feature callback,
  *   will be sent to each of the slotNames
  */
-export declare function getConf(model: unknown, slotPath?: string[] | string | undefined, args?: Record<string, any>): any;
+export declare function getConf<CONFMODEL extends AnyConfigurationModel>(model: {
+    configuration: CONFMODEL;
+}, slotPath?: Parameters<typeof readConfObject<CONFMODEL>>[1], args?: Parameters<typeof readConfObject<CONFMODEL>>[2]): any;
 /**
  * given a union of explicitly typed configuration schema types,
  * extract an array of the type names contained in the union

package/configuration/util.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isConfigurationSlotType = exports.isConfigurationModel = exports.isConfigurationSchemaType = exports.isBareConfigurationSchemaType = exports.getTypeNamesFromExplicitlyTypedUnion = exports.getConf = exports.readConfObject = void 0;
+/* eslint-disable @typescript-eslint/no-explicit-any */
 const mobx_state_tree_1 = require("mobx-state-tree");
 const mst_reflection_1 = require("../util/mst-reflection");
 /**
@@ -12,9 +13,7 @@ const mst_reflection_1 = require("../util/mst-reflection");
  * @param args - extra arguments e.g. for a feature callback,
  *  will be sent to each of the slotNames
  */
-function readConfObject(confObject, slotPath = undefined, 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-args = {}) {
+function readConfObject(confObject, slotPath, args = {}) {
     if (!confObject) {
         throw new TypeError('must provide conf object to read');
     }
@@ -32,7 +31,7 @@ args = {}) {
         if (!slot) {
             return undefined;
             // if we want to be very strict about config slots, we could uncomment the below
-            // instead of returning undefine
+            // instead of returning undefined
             //
             // const modelType = getType(model)
             // const schemaType = model.configuration && getType(model.configuration)
@@ -54,19 +53,22 @@ args = {}) {
         }
         return slot;
     }
-    const slotName = slotPath[0];
-    if (slotPath.length > 1) {
-        const newPath = slotPath.slice(1);
-        let subConf = confObject[slotName];
-        // check for the subconf being a map if we don't find it immediately
-        if (!subConf &&
-            (0, mobx_state_tree_1.isStateTreeNode)(confObject) &&
-            (0, mobx_state_tree_1.isMapType)((0, mobx_state_tree_1.getType)(confObject))) {
-            subConf = confObject.get(slotName);
+    if (Array.isArray(slotPath)) {
+        const slotName = slotPath[0];
+        if (slotPath.length > 1) {
+            const newPath = slotPath.slice(1);
+            let subConf = confObject[slotName];
+            // check for the subconf being a map if we don't find it immediately
+            if (!subConf &&
+                (0, mobx_state_tree_1.isStateTreeNode)(confObject) &&
+                (0, mobx_state_tree_1.isMapType)((0, mobx_state_tree_1.getType)(confObject))) {
+                subConf = confObject.get(slotName);
+            }
+            return subConf ? readConfObject(subConf, newPath, args) : undefined;
         }
-        return subConf ? readConfObject(subConf, newPath, args) : undefined;
+        return readConfObject(confObject, slotName, args);
     }
-    return readConfObject(confObject, slotName, args);
+    throw new TypeError('slotPath must be a string or array');
 }
 exports.readConfObject = readConfObject;
 /**
@@ -77,9 +79,7 @@ exports.readConfObject = readConfObject;
  * @param args - extra arguments e.g. for a feature callback,
  *   will be sent to each of the slotNames
  */
-function getConf(model, slotPath = undefined, 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-args = {}) {
+function getConf(model, slotPath, args) {
     if (!model) {
         throw new TypeError('must provide a model object');
     }

package/data_adapters/BaseAdapter/BaseAdapter.d.ts

@@ -0,0 +1,23 @@
+import { AnyConfigurationModel } from '../../configuration';
+import { getSubAdapterType } from '../dataAdapterCache';
+import { AugmentedRegion as Region } from '../../util/types';
+import PluginManager from '../../PluginManager';
+export declare abstract class BaseAdapter {
+    config: AnyConfigurationModel;
+    getSubAdapter?: getSubAdapterType | undefined;
+    pluginManager?: PluginManager | undefined;
+    id: string;
+    static capabilities: string[];
+    constructor(config?: AnyConfigurationModel, getSubAdapter?: getSubAdapterType | undefined, pluginManager?: PluginManager | undefined);
+    /**
+     * Same as `readConfObject(this.config, arg)`.
+     * @deprecated Does not offer the same TS type checking as `readConfObject`, consider using that instead.
+     */
+    getConf(arg: string | string[]): any;
+    /**
+     * Called to provide a hint that data tied to a certain region will not be
+     * needed for the foreseeable future and can be purged from caches, etc
+     * @param region - Region
+     */
+    abstract freeResources(region: Region): void;
+}

package/data_adapters/BaseAdapter/BaseAdapter.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseAdapter = void 0;
+const mobx_state_tree_1 = require("mobx-state-tree");
+// locals
+const configuration_1 = require("../../configuration");
+const idMaker_1 = __importDefault(require("../../util/idMaker"));
+const configuration_2 = require("../../configuration");
+const EmptyConfig = (0, configuration_2.ConfigurationSchema)('empty', {});
+class BaseAdapter {
+    constructor(config = EmptyConfig.create(), getSubAdapter, pluginManager) {
+        this.config = config;
+        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') {
+            const data = (0, mobx_state_tree_1.isStateTreeNode)(config) ? (0, mobx_state_tree_1.getSnapshot)(config) : config;
+            this.id = `${(0, idMaker_1.default)(data)}`;
+        }
+        else {
+            this.id = 'test';
+        }
+    }
+    /**
+     * Same as `readConfObject(this.config, arg)`.
+     * @deprecated Does not offer the same TS type checking as `readConfObject`, consider using that instead.
+     */
+    getConf(arg) {
+        return (0, configuration_1.readConfObject)(this.config, arg);
+    }
+}
+exports.BaseAdapter = BaseAdapter;
+BaseAdapter.capabilities = [];

package/data_adapters/BaseAdapter/BaseFeatureDataAdapter.d.ts

@@ -0,0 +1,128 @@
+import { Observable } from 'rxjs';
+import { BaseAdapter } from './BaseAdapter';
+import { BaseOptions } from './BaseOptions';
+import { FeatureDensityStats } from './types';
+import { Feature } from '../../util/simpleFeature';
+import { AugmentedRegion as Region } from '../../util/types';
+/**
+ * Base class for feature adapters to extend. Defines some methods that
+ * subclasses must implement.
+ */
+export declare abstract class BaseFeatureDataAdapter extends BaseAdapter {
+    /**
+     * Get all reference sequence names used in the data source
+     * Example:
+     * public async getRefNames(opts?: BaseOptions): Promise\<string[]\> \}
+     *   await this.setup()
+     *   const \{ refNames \} = this.metadata
+     *   return refNames
+     * \}
+     *
+     *
+     * NOTE: If an adapter is unable to determine the reference sequence names,
+     * the array will be empty
+     * @param opts - Feature adapter options
+     */
+    abstract getRefNames(opts?: BaseOptions): Promise<string[]>;
+    /**
+     * Get features from the data source that overlap a region
+     * Example:
+     * public getFeatures(
+     *   region: Region,
+     *   opts: BaseOptions,
+     * ): Observable<Feature> \{
+     *   return ObservableCreate(observer =\> \{
+     *     const records = getRecords(assembly, refName, start, end)
+     *     records.forEach(record =\> \{
+     *       observer.next(this.recordToFeature(record))
+     *     \})
+     *     observer.complete()
+     *   \})
+     * \}
+     * @param region - Region
+     * @param opts - Feature adapter options
+     * @returns Observable of Feature objects in the region
+     */
+    abstract getFeatures(region: Region, opts?: BaseOptions): Observable<Feature>;
+    /**
+     * Return "header info" that is fetched from the data file, or other info
+     * that would not simply be in the config of the file. The return value can
+     * be `{tag:string, data: any}[]` e.g. list of tags with their values which
+     * is how VCF,BAM,CRAM return values for getInfo or it can be a nested JSON
+     * object
+     */
+    getHeader(_opts?: BaseOptions): Promise<unknown>;
+    /**
+     * Return info that is primarily used for interpreting the data that is there,
+     * primarily in reference to being used for augmenting feature details panels
+     */
+    getMetadata(_opts?: BaseOptions): Promise<unknown>;
+    /**
+     * Checks if the store has data for the given assembly and reference
+     * sequence, and then gets the features in the region if it does.
+     */
+    getFeaturesInRegion(region: Region, opts?: BaseOptions): Observable<Feature>;
+    /**
+     * Checks if the store has data for the given assembly and reference
+     * sequence, and then gets the features in the region if it does.
+     *
+     * Currently this just calls getFeatureInRegion for each region. Adapters that
+     * are frequently called on multiple regions simultaneously may want to
+     * implement a more efficient custom version of this method.
+     *
+     * Currently this just calls getFeatureInRegion for each region. Adapters that
+     * are frequently called on multiple regions simultaneously may want to
+     * implement a more efficient custom version of this method.
+     *
+     * @param regions - Regions
+     * @param opts - Feature adapter options
+     * @returns Observable of Feature objects in the regions
+     */
+    getFeaturesInMultipleRegions(regions: Region[], opts?: BaseOptions): Observable<Feature>;
+    /**
+     * Check if the store has data for the given reference name.
+     * @param refName - Name of the reference sequence
+     * @returns Whether data source has data for the given reference name
+     */
+    hasDataForRefName(refName: string, opts?: BaseOptions): Promise<boolean>;
+    /**
+     * Calculates the minimum score, maximum score, and other statistics from
+     * features over a region, primarily used for quantitative tracks
+     */
+    getRegionQuantitativeStats(region: Region, opts?: BaseOptions): Promise<import("../../util/stats").QuantitativeStats>;
+    /**
+     * Calculates the minimum score, maximum score, and other statistics from
+     * features over multiple regions, primarily used for quantitative tracks
+     */
+    getMultiRegionQuantitativeStats(regions?: Region[], opts?: BaseOptions): Promise<import("../../util/stats").QuantitativeStats>;
+    /**
+     * Calculates the "feature density" of a region. The primary purpose of this
+     * API is to alert the user if they are going to be downloading too much
+     * information, and give them a hint to zoom in to see more. The default
+     * implementation samples from the regions, downloads feature data with
+     * getFeatures, and returns an object with the form \{featureDensity:number\}
+     *
+     * Derived classes can override this to return alternative calculations for
+     * featureDensity, or they can also return an object containing a byte size
+     * calculation with the format \{bytes:number, fetchSizeLimit:number\} where
+     * fetchSizeLimit is the adapter-defined limit for what it thinks is 'too much
+     * data' (e.g. CRAM and
+     * BAM may vary on what they think too much data is)
+     */
+    getRegionFeatureDensityStats(region: Region, opts?: BaseOptions): Promise<FeatureDensityStats>;
+    /**
+     * Calculates the "feature density" of a set of regions. The primary purpose
+     * of this API is to alert the user if they are going to be downloading too
+     * much information, and give them a hint to zoom in to see more. The default
+     * implementation samples from the regions, downloads feature data with
+     * getFeatures, and returns an object with the form \{featureDensity:number\}
+     *
+     * Derived classes can override this to return alternative calculations for
+     * featureDensity, or they can also return an object containing a byte size
+     * calculation with the format \{bytes:number, fetchSizeLimit:number\} where
+     * fetchSizeLimit is the adapter-defined limit for what it thinks is 'too much
+     * data' (e.g. CRAM and
+     * BAM may vary on what they think too much data is)
+     */
+    getMultiRegionFeatureDensityStats(regions: Region[], opts?: BaseOptions): Promise<FeatureDensityStats>;
+}

package/data_adapters/{BaseAdapter.js → BaseAdapter/BaseFeatureDataAdapter.js}

@@ -1,57 +1,18 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isTextSearchAdapter = exports.isRefNameAliasAdapter = exports.isFeatureAdapter = exports.isRegionsAdapter = exports.isSequenceAdapter = exports.BaseSequenceAdapter = exports.BaseFeatureDataAdapter = exports.BaseAdapter = void 0;
+exports.BaseFeatureDataAdapter = void 0;
 const rxjs_1 = require("rxjs");
 const operators_1 = require("rxjs/operators");
-const mobx_state_tree_1 = require("mobx-state-tree");
 // locals
-const rxjs_2 = require("../util/rxjs");
-const util_1 = require("../util");
-const configuration_1 = require("../configuration");
-const stats_1 = require("../util/stats");
-const idMaker_1 = __importDefault(require("../util/idMaker"));
-const EmptyConfig = (0, configuration_1.ConfigurationSchema)('empty', {});
-class BaseAdapter {
-    constructor(config = EmptyConfig.create(), getSubAdapter, pluginManager) {
-        this.config = config;
-        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') {
-            const data = (0, mobx_state_tree_1.isStateTreeNode)(config) ? (0, mobx_state_tree_1.getSnapshot)(config) : config;
-            this.id = `${(0, idMaker_1.default)(data)}`;
-        }
-        else {
-            this.id = 'test';
-        }
-    }
-    getConf(arg) {
-        return (0, configuration_1.readConfObject)(this.config, arg);
-    }
-}
-exports.BaseAdapter = BaseAdapter;
-BaseAdapter.capabilities = [];
+const BaseAdapter_1 = require("./BaseAdapter");
+const rxjs_2 = require("../../util/rxjs");
+const util_1 = require("../../util");
+const stats_1 = require("../../util/stats");
 /**
  * Base class for feature adapters to extend. Defines some methods that
  * subclasses must implement.
  */
-class BaseFeatureDataAdapter extends BaseAdapter {
-    // public abstract getFeatures(
-    //   region: Region,
-    //   opts: BaseOptions,
-    // ): Observable<Feature> {
-    //   return ObservableCreate(observer => {
-    //     const records = getRecords(assembly, refName, start, end)
-    //     records.forEach(record => {
-    //       observer.next(this.recordToFeature(record))
-    //     })
-    //     observer.complete()
-    //   })
-    // }
+class BaseFeatureDataAdapter extends BaseAdapter_1.BaseAdapter {
     /**
      * Return "header info" that is fetched from the data file, or other info
      * that would not simply be in the config of the file. The return value can
@@ -89,9 +50,9 @@ class BaseFeatureDataAdapter extends BaseAdapter {
      * Checks if the store has data for the given assembly and reference
      * sequence, and then gets the features in the region if it does.
      *
-     * Currently this just calls getFeatureInRegion for each region. Adapters
-     * that are frequently called on multiple regions simultaneously may
-     * want to implement a more efficient custom version of this method.
+     * Currently this just calls getFeatureInRegion for each region. Adapters that
+     * are frequently called on multiple regions simultaneously may want to
+     * implement a more efficient custom version of this method.
      *
      * Currently this just calls getFeatureInRegion for each region. Adapters that
      * are frequently called on multiple regions simultaneously may want to
@@ -102,9 +63,7 @@ class BaseFeatureDataAdapter extends BaseAdapter {
      * @returns Observable of Feature objects in the regions
      */
     getFeaturesInMultipleRegions(regions, opts = {}) {
-        return (0, rxjs_1.merge)(...regions.map(region => {
-            return this.getFeaturesInRegion(region, opts);
-        }));
+        return (0, rxjs_1.merge)(...regions.map(region => this.getFeaturesInRegion(region, opts)));
     }
     /**
      * Check if the store has data for the given reference name.
@@ -115,15 +74,23 @@ class BaseFeatureDataAdapter extends BaseAdapter {
         const refNames = await this.getRefNames(opts);
         return refNames.includes(refName);
     }
-    async getRegionStats(region, opts) {
+    /**
+     * Calculates the minimum score, maximum score, and other statistics from
+     * features over a region, primarily used for quantitative tracks
+     */
+    async getRegionQuantitativeStats(region, opts) {
         const feats = this.getFeatures(region, opts);
         return (0, stats_1.scoresToStats)(region, feats);
     }
-    async getMultiRegionStats(regions = [], opts) {
+    /**
+     * Calculates the minimum score, maximum score, and other statistics from
+     * features over multiple regions, primarily used for quantitative tracks
+     */
+    async getMultiRegionQuantitativeStats(regions = [], opts) {
         if (!regions.length) {
             return (0, stats_1.blankStats)();
         }
-        const feats = await Promise.all(regions.map(region => this.getRegionStats(region, opts)));
+        const feats = await Promise.all(regions.map(region => this.getRegionQuantitativeStats(region, opts)));
         const scoreMax = (0, util_1.max)(feats.map(a => a.scoreMax));
         const scoreMin = (0, util_1.min)(feats.map(a => a.scoreMin));
         const scoreSum = (0, util_1.sum)(feats.map(a => a.scoreSum));
@@ -139,21 +106,30 @@ class BaseFeatureDataAdapter extends BaseAdapter {
             scoreSum,
         });
     }
-    async estimateRegionsStats(regions, opts) {
-        if (!regions.length) {
-            throw new Error('No regions to estimate stats for');
-        }
-        const region = regions[0];
+    /**
+     * Calculates the "feature density" of a region. The primary purpose of this
+     * API is to alert the user if they are going to be downloading too much
+     * information, and give them a hint to zoom in to see more. The default
+     * implementation samples from the regions, downloads feature data with
+     * getFeatures, and returns an object with the form \{featureDensity:number\}
+     *
+     * Derived classes can override this to return alternative calculations for
+     * featureDensity, or they can also return an object containing a byte size
+     * calculation with the format \{bytes:number, fetchSizeLimit:number\} where
+     * fetchSizeLimit is the adapter-defined limit for what it thinks is 'too much
+     * data' (e.g. CRAM and
+     * BAM may vary on what they think too much data is)
+     */
+    getRegionFeatureDensityStats(region, opts) {
         let lastTime = +Date.now();
         const statsFromInterval = async (length, expansionTime) => {
             const { start, end } = region;
             const sampleCenter = start * 0.75 + end * 0.25;
-            const query = {
+            const features = await (0, rxjs_1.firstValueFrom)(this.getFeatures({
                 ...region,
                 start: Math.max(0, Math.round(sampleCenter - length / 2)),
                 end: Math.min(Math.round(sampleCenter + length / 2), end),
-            };
-            const features = await (0, rxjs_1.firstValueFrom)(this.getFeatures(query, opts).pipe((0, operators_1.toArray)()));
+            }, opts).pipe((0, operators_1.toArray)()));
             return maybeRecordStats(length, { featureDensity: features.length / length }, features.length, expansionTime);
         };
         const maybeRecordStats = async (interval, stats, statsSampleFeatures, expansionTime) => {
@@ -174,31 +150,25 @@ class BaseFeatureDataAdapter extends BaseAdapter {
         };
         return statsFromInterval(1000, 0);
     }
-}
-exports.BaseFeatureDataAdapter = BaseFeatureDataAdapter;
-class BaseSequenceAdapter extends BaseFeatureDataAdapter {
-    async estimateRegionsStats() {
-        return { featureDensity: 0 };
+    /**
+     * Calculates the "feature density" of a set of regions. The primary purpose
+     * of this API is to alert the user if they are going to be downloading too
+     * much information, and give them a hint to zoom in to see more. The default
+     * implementation samples from the regions, downloads feature data with
+     * getFeatures, and returns an object with the form \{featureDensity:number\}
+     *
+     * Derived classes can override this to return alternative calculations for
+     * featureDensity, or they can also return an object containing a byte size
+     * calculation with the format \{bytes:number, fetchSizeLimit:number\} where
+     * fetchSizeLimit is the adapter-defined limit for what it thinks is 'too much
+     * data' (e.g. CRAM and
+     * BAM may vary on what they think too much data is)
+     */
+    async getMultiRegionFeatureDensityStats(regions, opts) {
+        if (!regions.length) {
+            throw new Error('No regions supplied');
+        }
+        return this.getRegionFeatureDensityStats(regions[0], opts);
     }
 }
-exports.BaseSequenceAdapter = BaseSequenceAdapter;
-function isSequenceAdapter(thing) {
-    return 'getRegions' in thing && 'getFeatures' in thing;
-}
-exports.isSequenceAdapter = isSequenceAdapter;
-function isRegionsAdapter(thing) {
-    return 'getRegions' in thing;
-}
-exports.isRegionsAdapter = isRegionsAdapter;
-function isFeatureAdapter(thing) {
-    return 'getFeatures' in thing;
-}
-exports.isFeatureAdapter = isFeatureAdapter;
-function isRefNameAliasAdapter(thing) {
-    return 'getRefNameAliases' in thing;
-}
-exports.isRefNameAliasAdapter = isRefNameAliasAdapter;
-function isTextSearchAdapter(thing) {
-    return 'searchIndex' in thing;
-}
-exports.isTextSearchAdapter = isTextSearchAdapter;
+exports.BaseFeatureDataAdapter = BaseFeatureDataAdapter;

package/data_adapters/BaseAdapter/BaseOptions.d.ts

@@ -0,0 +1,16 @@
+export interface BaseOptions {
+    signal?: AbortSignal;
+    bpPerPx?: number;
+    sessionId?: string;
+    statusCallback?: (message: string) => void;
+    headers?: Record<string, string>;
+    [key: string]: unknown;
+}
+export type SearchType = 'full' | 'prefix' | 'exact';
+export interface BaseTextSearchArgs {
+    queryString: string;
+    searchType?: SearchType;
+    signal?: AbortSignal;
+    limit?: number;
+    pageNumber?: number;
+}

package/data_adapters/BaseAdapter/BaseOptions.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/data_adapters/BaseAdapter/BaseRefNameAliasAdapter.d.ts

@@ -0,0 +1,9 @@
+import { BaseAdapter } from './BaseAdapter';
+import { BaseOptions } from './types';
+export interface Alias {
+    refName: string;
+    aliases: string[];
+}
+export interface BaseRefNameAliasAdapter extends BaseAdapter {
+    getRefNameAliases(opts: BaseOptions): Promise<Alias[]>;
+}

package/data_adapters/BaseAdapter/BaseRefNameAliasAdapter.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });