@jbrowse/core 2.4.1 → 2.5.0

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);
+    }
+}
+BaseAdapter.capabilities = [];
+exports.BaseAdapter = BaseAdapter;

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 });

package/data_adapters/BaseAdapter/BaseSequenceAdapter.d.ts

@@ -0,0 +1,13 @@
+import { NoAssemblyRegion } from '../../util';
+import { BaseOptions } from './types';
+import { RegionsAdapter } from '../BaseAdapter';
+import { BaseFeatureDataAdapter } from './BaseFeatureDataAdapter';
+export declare abstract class BaseSequenceAdapter extends BaseFeatureDataAdapter implements RegionsAdapter {
+    getMultiRegionFeatureDensityStats(): Promise<{
+        featureDensity: number;
+    }>;
+    /**
+     * Fetches a list of 'regions' with refName, start, and extends
+     */
+    abstract getRegions(opts: BaseOptions): Promise<NoAssemblyRegion[]>;
+}

package/data_adapters/BaseAdapter/BaseSequenceAdapter.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseSequenceAdapter = void 0;
+const BaseFeatureDataAdapter_1 = require("./BaseFeatureDataAdapter");
+class BaseSequenceAdapter extends BaseFeatureDataAdapter_1.BaseFeatureDataAdapter {
+    async getMultiRegionFeatureDensityStats() {
+        return { featureDensity: 0 };
+    }
+}
+exports.BaseSequenceAdapter = BaseSequenceAdapter;

package/data_adapters/BaseAdapter/BaseTextSearchAdapter.d.ts

@@ -0,0 +1,6 @@
+import BaseResult from '../../TextSearch/BaseResults';
+import { BaseTextSearchArgs } from './types';
+import { BaseAdapter } from './BaseAdapter';
+export interface BaseTextSearchAdapter extends BaseAdapter {
+    searchIndex(args: BaseTextSearchArgs): Promise<BaseResult[]>;
+}

package/data_adapters/BaseAdapter/BaseTextSearchAdapter.js

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

package/data_adapters/BaseAdapter/RegionsAdapter.d.ts

@@ -0,0 +1,6 @@
+import { NoAssemblyRegion } from '../../util';
+import { BaseAdapter } from './BaseAdapter';
+import { BaseOptions } from './types';
+export interface RegionsAdapter extends BaseAdapter {
+    getRegions(opts: BaseOptions): Promise<NoAssemblyRegion[]>;
+}

package/data_adapters/BaseAdapter/RegionsAdapter.js

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

package/data_adapters/BaseAdapter/index.d.ts

@@ -0,0 +1,15 @@
+import { AnyConfigurationModel } from '../../configuration';
+import PluginManager from '../../PluginManager';
+import { getSubAdapterType } from '../dataAdapterCache';
+import { AnyDataAdapter } from './util';
+export * from './util';
+export * from './types';
+export { BaseAdapter } from './BaseAdapter';
+export { BaseFeatureDataAdapter } from './BaseFeatureDataAdapter';
+export { BaseSequenceAdapter } from './BaseSequenceAdapter';
+export type { BaseTextSearchAdapter } from './BaseTextSearchAdapter';
+export type { BaseRefNameAliasAdapter } from './BaseRefNameAliasAdapter';
+export type { RegionsAdapter } from './RegionsAdapter';
+export interface AnyAdapter {
+    new (config: AnyConfigurationModel, getSubAdapter?: getSubAdapterType, pluginManager?: PluginManager | undefined): AnyDataAdapter;
+}

package/data_adapters/BaseAdapter/index.js

@@ -0,0 +1,25 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseSequenceAdapter = exports.BaseFeatureDataAdapter = exports.BaseAdapter = void 0;
+__exportStar(require("./util"), exports);
+__exportStar(require("./types"), exports);
+var BaseAdapter_1 = require("./BaseAdapter");
+Object.defineProperty(exports, "BaseAdapter", { enumerable: true, get: function () { return BaseAdapter_1.BaseAdapter; } });
+var BaseFeatureDataAdapter_1 = require("./BaseFeatureDataAdapter");
+Object.defineProperty(exports, "BaseFeatureDataAdapter", { enumerable: true, get: function () { return BaseFeatureDataAdapter_1.BaseFeatureDataAdapter; } });
+var BaseSequenceAdapter_1 = require("./BaseSequenceAdapter");
+Object.defineProperty(exports, "BaseSequenceAdapter", { enumerable: true, get: function () { return BaseSequenceAdapter_1.BaseSequenceAdapter; } });

package/data_adapters/BaseAdapter/types.d.ts

@@ -0,0 +1,21 @@
+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;
+}
+export interface FeatureDensityStats {
+    featureDensity?: number;
+    fetchSizeLimit?: number;
+    bytes?: number;
+}

package/data_adapters/BaseAdapter/types.js

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