@jbrowse/core 2.17.0 → 2.18.0

package/configuration/util.js

@@ -9,22 +9,12 @@ exports.isConfigurationModel = isConfigurationModel;
 exports.isConfigurationSlotType = isConfigurationSlotType;
 const mobx_state_tree_1 = require("mobx-state-tree");
 const mst_reflection_1 = require("../util/mst-reflection");
-/**
- * given a configuration model (an instance of a ConfigurationSchema),
- * read the configuration variable at the given path
- *
- * @param model - instance of ConfigurationSchema
- * @param slotPaths - array of paths to read
- * @param args - extra arguments e.g. for a feature callback,
- *  will be sent to each of the slotNames
- */
 function readConfObject(confObject, slotPath, args = {}) {
     if (!slotPath) {
-        return JSON.parse(JSON.stringify((0, mobx_state_tree_1.getSnapshot)(confObject)));
+        return structuredClone((0, mobx_state_tree_1.getSnapshot)(confObject));
     }
-    if (typeof slotPath === 'string') {
+    else if (typeof slotPath === 'string') {
         let slot = confObject[slotPath];
-        // check for the subconf being a map if we don't find it immediately
         if (!slot &&
             (0, mobx_state_tree_1.isStateTreeNode)(confObject) &&
             (0, mobx_state_tree_1.isMapType)((0, mobx_state_tree_1.getType)(confObject))) {
@@ -32,28 +22,19 @@ function readConfObject(confObject, slotPath, args = {}) {
         }
         if (!slot) {
             return undefined;
-            // if we want to be very strict about config slots, we could uncomment the below
-            // instead of returning undefined
-            //
-            // const modelType = getType(model)
-            // const schemaType = model.configuration && getType(model.configuration)
-            // throw new Error(
-            //   `no slot "${slotName}" found in ${modelType.name} configuration (${
-            //     schemaType.name
-            //   })`,
-            // )
         }
-        const val = slot.expr ? slot.expr.evalSync(args) : slot;
-        return (0, mobx_state_tree_1.isStateTreeNode)(val)
-            ? JSON.parse(JSON.stringify((0, mobx_state_tree_1.getSnapshot)(val)))
-            : val;
+        else {
+            const val = slot.expr ? slot.expr.evalSync(args) : slot;
+            return (0, mobx_state_tree_1.isStateTreeNode)(val)
+                ? JSON.parse(JSON.stringify((0, mobx_state_tree_1.getSnapshot)(val)))
+                : val;
+        }
     }
-    if (Array.isArray(slotPath)) {
+    else 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))) {
@@ -65,14 +46,6 @@ function readConfObject(confObject, slotPath, args = {}) {
     }
     throw new TypeError('slotPath must be a string or array');
 }
-/**
- * helper method for readConfObject, reads the config from a mst model
- *
- * @param model - object containing a 'configuration' member
- * @param slotPaths - array of paths to read
- * @param args - extra arguments e.g. for a feature callback,
- *   will be sent to each of the slotNames
- */
 function getConf(model, slotPath, args) {
     const { configuration } = model;
     if (isConfigurationModel(configuration)) {
@@ -80,17 +53,9 @@ function getConf(model, slotPath, args) {
     }
     throw new TypeError('cannot getConf on this model, it has no configuration');
 }
-/**
- * given a union of explicitly typed configuration schema types,
- * extract an array of the type names contained in the union
- *
- * @param unionType -
- * @returns Array of type names contained in the union
- */
 function getTypeNamesFromExplicitlyTypedUnion(maybeUnionType) {
     if ((0, mobx_state_tree_1.isType)(maybeUnionType)) {
         maybeUnionType = (0, mst_reflection_1.resolveLateType)(maybeUnionType);
-        // @ts-expect-error
         if ((0, mobx_state_tree_1.isUnionType)(maybeUnionType)) {
             const typeNames = [];
             (0, mst_reflection_1.getUnionSubTypes)(maybeUnionType).forEach(type => {
@@ -101,7 +66,6 @@ function getTypeNamesFromExplicitlyTypedUnion(maybeUnionType) {
                     typeName = [def.type];
                 }
                 if (!typeName[0]) {
-                    // debugger
                     throw new Error(`invalid config schema type ${type}`);
                 }
                 typeNames.push(...typeName);
@@ -118,7 +82,6 @@ function isBareConfigurationSchemaType(thing) {
                 thing.name.includes('ConfigurationSchema'))) {
             return true;
         }
-        // if it's a late type, assume its a config schema
         if ((0, mobx_state_tree_1.isLateType)(thing)) {
             return true;
         }
@@ -129,26 +92,26 @@ function isConfigurationSchemaType(thing) {
     if (!(0, mobx_state_tree_1.isType)(thing)) {
         return false;
     }
-    // written as a series of if-statements instead of a big logical OR
-    // because this construction gives much better debugging backtraces.
-    // also, note that the order of these statements matters, because
-    // for example some union types are also optional types
-    if (isBareConfigurationSchemaType(thing)) {
+    else if (isBareConfigurationSchemaType(thing)) {
         return true;
     }
-    if ((0, mobx_state_tree_1.isUnionType)(thing)) {
+    else if ((0, mobx_state_tree_1.isUnionType)(thing)) {
         return (0, mst_reflection_1.getUnionSubTypes)(thing).every(t => isConfigurationSchemaType(t) || t.name === 'undefined');
     }
-    if ((0, mobx_state_tree_1.isOptionalType)(thing) && isConfigurationSchemaType((0, mst_reflection_1.getSubType)(thing))) {
+    else if ((0, mobx_state_tree_1.isOptionalType)(thing) &&
+        isConfigurationSchemaType((0, mst_reflection_1.getSubType)(thing))) {
         return true;
     }
-    if ((0, mobx_state_tree_1.isArrayType)(thing) && isConfigurationSchemaType((0, mst_reflection_1.getSubType)(thing))) {
+    else if ((0, mobx_state_tree_1.isArrayType)(thing) &&
+        isConfigurationSchemaType((0, mst_reflection_1.getSubType)(thing))) {
         return true;
     }
-    if ((0, mobx_state_tree_1.isMapType)(thing) && isConfigurationSchemaType((0, mst_reflection_1.getSubType)(thing))) {
+    else if ((0, mobx_state_tree_1.isMapType)(thing) && isConfigurationSchemaType((0, mst_reflection_1.getSubType)(thing))) {
         return true;
     }
-    return false;
+    else {
+        return false;
+    }
 }
 function isConfigurationModel(thing) {
     return (0, mobx_state_tree_1.isStateTreeNode)(thing) && isConfigurationSchemaType((0, mobx_state_tree_1.getType)(thing));

package/data_adapters/BaseAdapter/BaseAdapter.d.ts

@@ -1,7 +1,7 @@
-import { AnyConfigurationModel } from '../../configuration';
-import { getSubAdapterType } from '../dataAdapterCache';
-import { AugmentedRegion as Region } from '../../util/types';
-import PluginManager from '../../PluginManager';
+import type PluginManager from '../../PluginManager';
+import type { AnyConfigurationModel } from '../../configuration';
+import type { AugmentedRegion as Region } from '../../util/types';
+import type { getSubAdapterType } from '../dataAdapterCache';
 export declare abstract class BaseAdapter {
     config: AnyConfigurationModel;
     getSubAdapter?: getSubAdapterType | undefined;
@@ -9,16 +9,6 @@ export declare abstract class BaseAdapter {
     id: string;
     static capabilities: string[];
     constructor(config?: AnyConfigurationModel, getSubAdapter?: getSubAdapterType | undefined, pluginManager?: PluginManager | undefined);
-    /**
-     * Same as `readConfObject(this.config, arg)`.
-     * Note: 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

@@ -5,18 +5,14 @@ var __importDefault = (this && this.__importDefault) || function (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', {});
+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)}`;
@@ -25,11 +21,6 @@ class BaseAdapter {
             this.id = 'test';
         }
     }
-    /**
-     * Same as `readConfObject(this.config, arg)`.
-     * Note: Does not offer the same TS type checking as `readConfObject`,
-     * consider using that instead.
-     */
     getConf(arg) {
         return (0, configuration_1.readConfObject)(this.config, arg);
     }

package/data_adapters/BaseAdapter/BaseFeatureDataAdapter.d.ts

@@ -1,129 +1,20 @@
-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.
- */
+import type { BaseOptions } from './BaseOptions';
+import type { FeatureDensityStats } from './types';
+import type { Feature } from '../../util/simpleFeature';
+import type { AugmentedRegion as Region } from '../../util/types';
+import type { Observable } from 'rxjs';
 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>;
     getSources(regions: Region[]): Promise<{
         name: string;

package/data_adapters/BaseAdapter/BaseFeatureDataAdapter.js

@@ -3,41 +3,22 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseFeatureDataAdapter = void 0;
 const rxjs_1 = require("rxjs");
 const operators_1 = require("rxjs/operators");
-// locals
 const BaseAdapter_1 = require("./BaseAdapter");
-const rxjs_2 = require("../../util/rxjs");
 const util_1 = require("../../util");
+const rxjs_2 = require("../../util/rxjs");
 const stats_1 = require("../../util/stats");
-/**
- * Base class for feature adapters to extend. Defines some methods that
- * subclasses must implement.
- */
+const stopToken_1 = require("../../util/stopToken");
 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
-     * 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
-     */
     async getHeader(_opts) {
         return null;
     }
-    /**
-     * Return info that is primarily used for interpreting the data that is there,
-     * primarily in reference to being used for augmenting feature details panels
-     */
     async getMetadata(_opts) {
         return null;
     }
-    /**
-     * 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, opts = {}) {
         return (0, rxjs_2.ObservableCreate)(async (observer) => {
             const hasData = await this.hasDataForRefName(region.refName, opts);
-            (0, util_1.checkAbortSignal)(opts.signal);
+            (0, stopToken_1.checkStopToken)(opts.stopToken);
             if (!hasData) {
                 observer.complete();
             }
@@ -46,46 +27,17 @@ class BaseFeatureDataAdapter extends BaseAdapter_1.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.
-     *
-     * @param regions - Regions
-     * @param opts - Feature adapter options
-     * @returns Observable of Feature objects in the regions
-     */
     getFeaturesInMultipleRegions(regions, opts = {}) {
         return (0, rxjs_1.merge)(...regions.map(region => this.getFeaturesInRegion(region, opts)));
     }
-    /**
-     * 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
-     */
     async hasDataForRefName(refName, opts = {}) {
         const refNames = await this.getRefNames(opts);
         return refNames.includes(refName);
     }
-    /**
-     * 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);
     }
-    /**
-     * 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)();
@@ -106,20 +58,6 @@ class BaseFeatureDataAdapter extends BaseAdapter_1.BaseAdapter {
             scoreSum,
         });
     }
-    /**
-     * 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) => {
@@ -150,20 +88,6 @@ class BaseFeatureDataAdapter extends BaseAdapter_1.BaseAdapter {
         };
         return statsFromInterval(1000, 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');

package/data_adapters/BaseAdapter/BaseOptions.d.ts

@@ -1,5 +1,5 @@
 export interface BaseOptions {
-    signal?: AbortSignal;
+    stopToken?: string;
     bpPerPx?: number;
     sessionId?: string;
     statusCallback?: (message: string) => void;
@@ -10,7 +10,7 @@ export type SearchType = 'full' | 'prefix' | 'exact';
 export interface BaseTextSearchArgs {
     queryString: string;
     searchType?: SearchType;
-    signal?: AbortSignal;
+    stopToken?: string;
     limit?: number;
     pageNumber?: number;
 }

package/data_adapters/BaseAdapter/BaseRefNameAliasAdapter.d.ts

@@ -1,5 +1,5 @@
-import { BaseAdapter } from './BaseAdapter';
-import { BaseOptions } from './types';
+import type { BaseAdapter } from './BaseAdapter';
+import type { BaseOptions } from './types';
 export interface Alias {
     refName: string;
     aliases: string[];

package/data_adapters/BaseAdapter/BaseSequenceAdapter.d.ts

@@ -1,13 +1,10 @@
-import { NoAssemblyRegion } from '../../util';
-import { BaseOptions } from './types';
-import { RegionsAdapter } from '../BaseAdapter';
 import { BaseFeatureDataAdapter } from './BaseFeatureDataAdapter';
+import type { BaseOptions } from './types';
+import type { NoAssemblyRegion } from '../../util';
+import type { RegionsAdapter } from '../BaseAdapter';
 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/BaseTextSearchAdapter.d.ts

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

package/data_adapters/BaseAdapter/RegionsAdapter.d.ts

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

package/data_adapters/BaseAdapter/index.d.ts

@@ -1,7 +1,7 @@
-import { AnyConfigurationModel } from '../../configuration';
-import PluginManager from '../../PluginManager';
-import { getSubAdapterType } from '../dataAdapterCache';
-import { AnyDataAdapter } from './util';
+import type PluginManager from '../../PluginManager';
+import type { AnyConfigurationModel } from '../../configuration';
+import type { getSubAdapterType } from '../dataAdapterCache';
+import type { AnyDataAdapter } from './util';
 export * from './util';
 export * from './types';
 export { BaseAdapter } from './BaseAdapter';

package/data_adapters/BaseAdapter/types.d.ts

@@ -1,5 +1,5 @@
 export interface BaseOptions {
-    signal?: AbortSignal;
+    stopToken?: string;
     bpPerPx?: number;
     sessionId?: string;
     statusCallback?: (message: string) => void;
@@ -10,7 +10,7 @@ export type SearchType = 'full' | 'prefix' | 'exact';
 export interface BaseTextSearchArgs {
     queryString: string;
     searchType?: SearchType;
-    signal?: AbortSignal;
+    stopToken?: string;
     limit?: number;
     pageNumber?: number;
 }

package/data_adapters/BaseAdapter/util.d.ts

@@ -1,9 +1,9 @@
-import { BaseAdapter } from './BaseAdapter';
-import { BaseFeatureDataAdapter } from './BaseFeatureDataAdapter';
-import { BaseRefNameAliasAdapter } from './BaseRefNameAliasAdapter';
-import { BaseSequenceAdapter } from './BaseSequenceAdapter';
-import { BaseTextSearchAdapter } from './BaseTextSearchAdapter';
-import { RegionsAdapter } from './RegionsAdapter';
+import type { BaseAdapter } from './BaseAdapter';
+import type { BaseFeatureDataAdapter } from './BaseFeatureDataAdapter';
+import type { BaseRefNameAliasAdapter } from './BaseRefNameAliasAdapter';
+import type { BaseSequenceAdapter } from './BaseSequenceAdapter';
+import type { BaseTextSearchAdapter } from './BaseTextSearchAdapter';
+import type { RegionsAdapter } from './RegionsAdapter';
 export type AnyDataAdapter = BaseAdapter | BaseFeatureDataAdapter | BaseRefNameAliasAdapter | BaseTextSearchAdapter | RegionsAdapter | BaseSequenceAdapter;
 export declare function isSequenceAdapter(t: AnyDataAdapter): t is BaseSequenceAdapter;
 export declare function isRegionsAdapter(t: AnyDataAdapter): t is RegionsAdapter;

package/data_adapters/CytobandAdapter/CytobandAdapter.d.ts

@@ -1,6 +1,6 @@
 import { SimpleFeature } from '../../util';
 import { BaseAdapter } from '../BaseAdapter';
-import { BaseOptions } from '../BaseAdapter/BaseOptions';
+import type { BaseOptions } from '../BaseAdapter/BaseOptions';
 export default class CytobandAdapter extends BaseAdapter {
     getData(opts?: BaseOptions): Promise<SimpleFeature[]>;
     freeResources(): void;

package/data_adapters/CytobandAdapter/CytobandAdapter.js

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-// locals
 const util_1 = require("../../util");
 const io_1 = require("../../util/io");
 const BaseAdapter_1 = require("../BaseAdapter");
@@ -30,6 +29,6 @@ class CytobandAdapter extends BaseAdapter_1.BaseAdapter {
             });
         });
     }
-    freeResources( /* { region } */) { }
+    freeResources() { }
 }
 exports.default = CytobandAdapter;

package/data_adapters/CytobandAdapter/configSchema.d.ts

@@ -1,7 +1,4 @@
 declare const configSchema: import("../../configuration/configurationSchema").ConfigurationSchemaType<{
-    /**
-     * #slot
-     */
     cytobandLocation: {
         type: string;
         defaultValue: {

package/data_adapters/CytobandAdapter/configSchema.js

@@ -1,14 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const configuration_1 = require("../../configuration");
-/**
- * #config CytobandAdapter
- */
-function x() { } // eslint-disable-line @typescript-eslint/no-unused-vars
+function x() { }
 const configSchema = (0, configuration_1.ConfigurationSchema)('CytobandAdapter', {
-    /**
-     * #slot
-     */
     cytobandLocation: {
         type: 'fileLocation',
         defaultValue: { uri: '/path/to/cytoband.txt.gz' },

package/data_adapters/CytobandAdapter/index.d.ts

@@ -1,2 +1,2 @@
-import PluginManager from '../../PluginManager';
+import type PluginManager from '../../PluginManager';
 export default function CytobandAdapterF(pluginManager: PluginManager): void;

package/data_adapters/CytobandAdapter/index.js

@@ -27,8 +27,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = CytobandAdapterF;
-const pluggableElementTypes_1 = require("../../pluggableElementTypes");
 const configSchema_1 = __importDefault(require("./configSchema"));
+const pluggableElementTypes_1 = require("../../pluggableElementTypes");
 function CytobandAdapterF(pluginManager) {
     pluginManager.addAdapterType(() => new pluggableElementTypes_1.AdapterType({
         name: 'CytobandAdapter',