@jbrowse/core 3.6.5 → 4.0.0

package/esm/configuration/util.js

@@ -0,0 +1,123 @@
+import { getSnapshot, getType, isArrayType, isLateType, isMapType, isModelType, isOptionalType, isStateTreeNode, isType, isUnionType, } from '@jbrowse/mobx-state-tree';
+function isConfigSlot(slot) {
+    return typeof slot?.getValue === 'function';
+}
+import { getDefaultValue, getSubType, getUnionSubTypes, resolveLateType, } from "../util/mst-reflection.js";
+export function readConfObject(confObject, slotPath, args = {}) {
+    if (!slotPath) {
+        return isStateTreeNode(confObject)
+            ? structuredClone(getSnapshot(confObject))
+            : structuredClone(confObject);
+    }
+    else if (typeof slotPath === 'string') {
+        let slot = confObject[slotPath];
+        if (!slot) {
+            if (isStateTreeNode(confObject) && isMapType(getType(confObject))) {
+                slot = confObject.get(slotPath);
+            }
+            if (!slot) {
+                return undefined;
+            }
+        }
+        const val = isConfigSlot(slot) ? slot.getValue(args) : slot;
+        if (val === null || typeof val !== 'object') {
+            return val;
+        }
+        return isStateTreeNode(val) ? structuredClone(getSnapshot(val)) : val;
+    }
+    else if (Array.isArray(slotPath)) {
+        const slotName = slotPath[0];
+        if (slotPath.length > 1) {
+            const newPath = slotPath.slice(1);
+            let subConf = confObject[slotName];
+            if (!subConf &&
+                isStateTreeNode(confObject) &&
+                isMapType(getType(confObject))) {
+                subConf = confObject.get(slotName);
+            }
+            return subConf ? readConfObject(subConf, newPath, args) : undefined;
+        }
+        return readConfObject(confObject, slotName, args);
+    }
+    throw new TypeError('slotPath must be a string or array');
+}
+export function getConf(model, slotPath, args) {
+    return readConfObject(model.configuration, slotPath, args);
+}
+export function getTypeNamesFromExplicitlyTypedUnion(maybeUnionType) {
+    if (isType(maybeUnionType)) {
+        maybeUnionType = resolveLateType(maybeUnionType);
+        if (isUnionType(maybeUnionType)) {
+            const typeNames = [];
+            for (let type of getUnionSubTypes(maybeUnionType)) {
+                type = resolveLateType(type);
+                let typeName = getTypeNamesFromExplicitlyTypedUnion(type);
+                if (!typeName.length) {
+                    const def = getDefaultValue(type);
+                    typeName = [def.type];
+                }
+                if (!typeName[0]) {
+                    throw new Error(`invalid config schema type ${type}`);
+                }
+                typeNames.push(...typeName);
+            }
+            return typeNames;
+        }
+    }
+    return [];
+}
+export function isBareConfigurationSchemaType(thing) {
+    if (isType(thing)) {
+        if (isModelType(thing) &&
+            ('isJBrowseConfigurationSchema' in thing ||
+                thing.name.includes('ConfigurationSchema'))) {
+            return true;
+        }
+        if (isLateType(thing)) {
+            return true;
+        }
+    }
+    return false;
+}
+export function isConfigurationSchemaType(thing) {
+    if (!isType(thing)) {
+        return false;
+    }
+    else if (isBareConfigurationSchemaType(thing)) {
+        return true;
+    }
+    else if (isUnionType(thing)) {
+        return getUnionSubTypes(thing).every(t => isConfigurationSchemaType(t) || t.name === 'undefined');
+    }
+    else if (isOptionalType(thing) &&
+        isConfigurationSchemaType(getSubType(thing))) {
+        return true;
+    }
+    else if (isArrayType(thing) &&
+        isConfigurationSchemaType(getSubType(thing))) {
+        return true;
+    }
+    else if (isMapType(thing) && isConfigurationSchemaType(getSubType(thing))) {
+        return true;
+    }
+    else {
+        return false;
+    }
+}
+const configurationModelCache = new WeakMap();
+export function isConfigurationModel(thing) {
+    if (!thing || typeof thing !== 'object') {
+        return false;
+    }
+    let cached = configurationModelCache.get(thing);
+    if (cached === undefined) {
+        cached = isStateTreeNode(thing) && isConfigurationSchemaType(getType(thing));
+        configurationModelCache.set(thing, cached);
+    }
+    return cached;
+}
+export function isConfigurationSlotType(thing) {
+    return (typeof thing === 'object' &&
+        thing !== null &&
+        'isJBrowseConfigurationSlot' in thing);
+}

package/esm/data_adapters/BaseAdapter/BaseAdapter.d.ts

@@ -0,0 +1,16 @@
+import type PluginManager from '../../PluginManager.ts';
+import type { AnyConfigurationModel } from '../../configuration/index.ts';
+import type { AugmentedRegion as Region } from '../../util/types/index.ts';
+import type { getSubAdapterType } from '../dataAdapterCache.ts';
+export declare class BaseAdapter {
+    config: AnyConfigurationModel;
+    getSubAdapter?: getSubAdapterType | undefined;
+    pluginManager?: PluginManager | undefined;
+    id: string;
+    sequenceAdapterConfig?: Record<string, unknown>;
+    static capabilities: string[];
+    constructor(config?: AnyConfigurationModel, getSubAdapter?: getSubAdapterType | undefined, pluginManager?: PluginManager | undefined);
+    setSequenceAdapterConfig(config: Record<string, unknown>): void;
+    getConf(arg: string | string[]): any;
+    freeResources(_region: Region): void;
+}

package/esm/data_adapters/BaseAdapter/BaseAdapter.js

@@ -0,0 +1,31 @@
+import { getSnapshot, isStateTreeNode } from '@jbrowse/mobx-state-tree';
+import { ConfigurationSchema, readConfObject, } from "../../configuration/index.js";
+import idMaker from "../../util/idMaker.js";
+const EmptyConfig = ConfigurationSchema('empty', {});
+export class BaseAdapter {
+    config;
+    getSubAdapter;
+    pluginManager;
+    id;
+    sequenceAdapterConfig;
+    static capabilities = [];
+    constructor(config = EmptyConfig.create(), getSubAdapter, pluginManager) {
+        this.config = config;
+        this.getSubAdapter = getSubAdapter;
+        this.pluginManager = pluginManager;
+        if (typeof jest === 'undefined') {
+            const data = isStateTreeNode(config) ? getSnapshot(config) : config;
+            this.id = `${idMaker(data)}`;
+        }
+        else {
+            this.id = 'test';
+        }
+    }
+    setSequenceAdapterConfig(config) {
+        this.sequenceAdapterConfig = config;
+    }
+    getConf(arg) {
+        return readConfObject(this.config, arg);
+    }
+    freeResources(_region) { }
+}

package/esm/data_adapters/BaseAdapter/BaseFeatureDataAdapter.d.ts

@@ -0,0 +1,24 @@
+import { type Observable } from 'rxjs';
+import { BaseAdapter } from './BaseAdapter.ts';
+import type { BaseOptions } from './BaseOptions.ts';
+import type { Feature } from '../../util/simpleFeature.ts';
+import type { AugmentedRegion as Region } from '../../util/types/index.ts';
+export declare abstract class BaseFeatureDataAdapter extends BaseAdapter {
+    abstract getRefNames(opts?: BaseOptions): Promise<string[]>;
+    abstract getFeatures(region: Region, opts?: BaseOptions): Observable<Feature>;
+    getHeader(_opts?: BaseOptions): Promise<unknown>;
+    getMetadata(_opts?: BaseOptions): Promise<unknown>;
+    getFeaturesInRegion(region: Region, opts?: BaseOptions): Observable<Feature>;
+    getFeaturesInMultipleRegions(regions: Region[], opts?: BaseOptions): Observable<Feature>;
+    hasDataForRefName(refName: string, opts?: BaseOptions): Promise<boolean>;
+    getRegionQuantitativeStats(region: Region, opts?: BaseOptions): Promise<import("../../util/stats.ts").RectifiedQuantitativeStats>;
+    getMultiRegionQuantitativeStats(regions?: Region[], opts?: BaseOptions): Promise<import("../../util/stats.ts").RectifiedQuantitativeStats>;
+    getRegionFeatureDensityStats(region: Region, opts?: BaseOptions): Promise<import("./types.ts").FeatureDensityStats>;
+    getMultiRegionFeatureDensityStats(regions: Region[], opts?: BaseOptions): Promise<import("./types.ts").FeatureDensityStats>;
+    getSources(regions: Region[]): Promise<{
+        name: string;
+        color?: string;
+        [key: string]: unknown;
+    }[]>;
+    getExportData(_regions: Region[], _formatType: string, _opts?: BaseOptions): Promise<string | undefined>;
+}

package/esm/data_adapters/BaseAdapter/BaseFeatureDataAdapter.js

@@ -0,0 +1,68 @@
+import { firstValueFrom, merge } from 'rxjs';
+import { toArray } from 'rxjs/operators';
+import { BaseAdapter } from "./BaseAdapter.js";
+import { aggregateQuantitativeStats, calculateFeatureDensityStats, } from "./stats.js";
+import { ObservableCreate } from "../../util/rxjs.js";
+import { blankStats, scoresToStats } from "../../util/stats.js";
+export class BaseFeatureDataAdapter extends BaseAdapter {
+    async getHeader(_opts) {
+        return null;
+    }
+    async getMetadata(_opts) {
+        return null;
+    }
+    getFeaturesInRegion(region, opts = {}) {
+        return ObservableCreate(async (observer) => {
+            const hasData = await this.hasDataForRefName(region.refName, opts);
+            if (!hasData) {
+                observer.complete();
+            }
+            else {
+                this.getFeatures(region, opts).subscribe(observer);
+            }
+        });
+    }
+    getFeaturesInMultipleRegions(regions, opts = {}) {
+        return merge(...regions.map(region => this.getFeaturesInRegion(region, opts)));
+    }
+    async hasDataForRefName(refName, opts = {}) {
+        const refNames = await this.getRefNames(opts);
+        return refNames.includes(refName);
+    }
+    async getRegionQuantitativeStats(region, opts) {
+        const feats = this.getFeatures(region, {
+            ...opts,
+            statsEstimationMode: true,
+        });
+        return scoresToStats(region, feats);
+    }
+    async getMultiRegionQuantitativeStats(regions = [], opts) {
+        if (!regions.length) {
+            return blankStats();
+        }
+        const stats = await Promise.all(regions.map(region => this.getRegionQuantitativeStats(region, opts)));
+        return aggregateQuantitativeStats(stats);
+    }
+    getRegionFeatureDensityStats(region, opts) {
+        return calculateFeatureDensityStats(region, (region2, opts2) => this.getFeatures(region2, opts2), opts);
+    }
+    async getMultiRegionFeatureDensityStats(regions, opts) {
+        if (!regions.length) {
+            throw new Error('No regions supplied');
+        }
+        return this.getRegionFeatureDensityStats(regions[0], opts);
+    }
+    async getSources(regions) {
+        const features = await firstValueFrom(this.getFeaturesInMultipleRegions(regions).pipe(toArray()));
+        const sources = new Set();
+        for (const f of features) {
+            sources.add(f.get('source'));
+        }
+        return [...sources].map(source => ({
+            name: source,
+        }));
+    }
+    async getExportData(_regions, _formatType, _opts) {
+        return undefined;
+    }
+}

package/esm/data_adapters/BaseAdapter/BaseOptions.d.ts

@@ -0,0 +1,18 @@
+import type { StopToken } from '../../util/stopToken.ts';
+export interface BaseOptions {
+    stopToken?: StopToken;
+    bpPerPx?: number;
+    sessionId?: string;
+    trackInstanceId?: string;
+    statusCallback?: (message: string) => void;
+    headers?: Record<string, string>;
+    statsEstimationMode?: boolean;
+}
+export type SearchType = 'full' | 'prefix' | 'exact';
+export interface BaseTextSearchArgs {
+    queryString: string;
+    searchType?: SearchType;
+    stopToken?: StopToken;
+    limit?: number;
+    pageNumber?: number;
+}

package/esm/data_adapters/BaseAdapter/BaseOptions.js

@@ -0,0 +1 @@
+export {};

package/esm/data_adapters/BaseAdapter/BaseRefNameAliasAdapter.d.ts

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

package/esm/data_adapters/BaseAdapter/BaseRefNameAliasAdapter.js

@@ -0,0 +1 @@
+export {};

package/esm/data_adapters/BaseAdapter/BaseSequenceAdapter.d.ts

@@ -0,0 +1,11 @@
+import { BaseFeatureDataAdapter } from './BaseFeatureDataAdapter.ts';
+import type { BaseOptions } from './types.ts';
+import type { NoAssemblyRegion } from '../../util/index.ts';
+import type { RegionsAdapter } from '../BaseAdapter/index.ts';
+export declare abstract class BaseSequenceAdapter extends BaseFeatureDataAdapter implements RegionsAdapter {
+    getMultiRegionFeatureDensityStats(): Promise<{
+        featureDensity: number;
+    }>;
+    abstract getRegions(opts: BaseOptions): Promise<NoAssemblyRegion[]>;
+    getSequence(region: NoAssemblyRegion, opts?: BaseOptions): Promise<string | undefined>;
+}

package/esm/data_adapters/BaseAdapter/BaseSequenceAdapter.js

@@ -0,0 +1,12 @@
+import { firstValueFrom } from 'rxjs';
+import { toArray } from 'rxjs/operators';
+import { BaseFeatureDataAdapter } from "./BaseFeatureDataAdapter.js";
+export class BaseSequenceAdapter extends BaseFeatureDataAdapter {
+    async getMultiRegionFeatureDensityStats() {
+        return { featureDensity: 0 };
+    }
+    async getSequence(region, opts) {
+        const features = await firstValueFrom(this.getFeatures({ ...region, assemblyName: '' }, opts).pipe(toArray()));
+        return features[0]?.get('seq');
+    }
+}

package/esm/data_adapters/BaseAdapter/BaseTextSearchAdapter.d.ts

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

package/esm/data_adapters/BaseAdapter/BaseTextSearchAdapter.js

@@ -0,0 +1 @@
+export {};

package/esm/data_adapters/BaseAdapter/RegionsAdapter.d.ts

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

package/esm/data_adapters/BaseAdapter/RegionsAdapter.js

@@ -0,0 +1 @@
+export {};

package/esm/data_adapters/BaseAdapter/index.d.ts

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

package/esm/data_adapters/BaseAdapter/index.js

@@ -0,0 +1,5 @@
+export * from "./util.js";
+export * from "./types.js";
+export { BaseAdapter } from "./BaseAdapter.js";
+export { BaseFeatureDataAdapter } from "./BaseFeatureDataAdapter.js";
+export { BaseSequenceAdapter } from "./BaseSequenceAdapter.js";

package/esm/data_adapters/BaseAdapter/stats.d.ts

@@ -0,0 +1,10 @@
+import { type Observable } from 'rxjs';
+import type { BaseOptions } from './BaseOptions.ts';
+import type { FeatureDensityStats } from './types.ts';
+import type { Feature } from '../../util/simpleFeature.ts';
+import type { RectifiedQuantitativeStats } from '../../util/stats.ts';
+import type { AugmentedRegion as Region } from '../../util/types/index.ts';
+export declare function aggregateQuantitativeStats(stats: RectifiedQuantitativeStats[]): RectifiedQuantitativeStats;
+export declare function sampleFeaturesForInterval(region: Region, interval: number, getFeatures: (region: Region, opts?: BaseOptions) => Observable<Feature>, opts?: BaseOptions): Promise<Feature[]>;
+export declare function calculateFeatureDensityStats(region: Region, getFeatures: (region: Region, opts?: BaseOptions) => Observable<Feature>, opts?: BaseOptions): Promise<FeatureDensityStats>;
+export { blankStats } from '../../util/stats.ts';

package/esm/data_adapters/BaseAdapter/stats.js

@@ -0,0 +1,48 @@
+import { firstValueFrom } from 'rxjs';
+import { toArray } from 'rxjs/operators';
+import { max, min, sum } from "../../util/index.js";
+import { rectifyStats } from "../../util/stats.js";
+const DENSITY_SAMPLE_INITIAL_INTERVAL = 1000;
+const DENSITY_SAMPLE_MIN_FEATURES = 70;
+const DENSITY_SAMPLE_TIMEOUT_MS = 5000;
+export function aggregateQuantitativeStats(stats) {
+    return rectifyStats({
+        scoreMax: max(stats.map(s => s.scoreMax)),
+        scoreMin: min(stats.map(s => s.scoreMin)),
+        scoreSum: sum(stats.map(s => s.scoreSum)),
+        scoreSumSquares: sum(stats.map(s => s.scoreSumSquares)),
+        featureCount: sum(stats.map(s => s.featureCount)),
+        basesCovered: sum(stats.map(s => s.basesCovered)),
+    });
+}
+export function sampleFeaturesForInterval(region, interval, getFeatures, opts) {
+    const { start, end } = region;
+    const sampleCenter = start * 0.75 + end * 0.25;
+    return firstValueFrom(getFeatures({
+        ...region,
+        start: Math.max(0, Math.round(sampleCenter - interval / 2)),
+        end: Math.min(Math.round(sampleCenter + interval / 2), end),
+    }, opts).pipe(toArray()));
+}
+export async function calculateFeatureDensityStats(region, getFeatures, opts) {
+    const refLen = region.end - region.start;
+    let interval = DENSITY_SAMPLE_INITIAL_INTERVAL;
+    let expansionTime = 0;
+    let lastTime = performance.now();
+    while (true) {
+        const features = await sampleFeaturesForInterval(region, interval, getFeatures, opts);
+        const featureCount = features.length;
+        if (featureCount >= DENSITY_SAMPLE_MIN_FEATURES || interval * 2 > refLen) {
+            return { featureDensity: featureCount / interval };
+        }
+        if (expansionTime > DENSITY_SAMPLE_TIMEOUT_MS) {
+            console.warn("Stats estimation reached timeout, or didn't get enough features");
+            return { featureDensity: Number.POSITIVE_INFINITY };
+        }
+        const currTime = performance.now();
+        expansionTime += currTime - lastTime;
+        lastTime = currTime;
+        interval *= 2;
+    }
+}
+export { blankStats } from "../../util/stats.js";

package/esm/data_adapters/BaseAdapter/types.d.ts

@@ -0,0 +1,23 @@
+import type { StopToken } from '../../util/stopToken.ts';
+export interface BaseOptions {
+    stopToken?: StopToken;
+    bpPerPx?: number;
+    sessionId?: string;
+    trackInstanceId?: string;
+    signal?: AbortSignal;
+    statusCallback?: (message: string) => void;
+    headers?: Record<string, string>;
+}
+export type SearchType = 'full' | 'prefix' | 'exact';
+export interface BaseTextSearchArgs {
+    queryString: string;
+    searchType?: SearchType;
+    stopToken?: StopToken;
+    limit?: number;
+    pageNumber?: number;
+}
+export interface FeatureDensityStats {
+    featureDensity?: number;
+    fetchSizeLimit?: number;
+    bytes?: number;
+}

package/esm/data_adapters/BaseAdapter/types.js

@@ -0,0 +1 @@
+export {};

package/esm/data_adapters/BaseAdapter/util.d.ts

@@ -0,0 +1,12 @@
+import type { BaseAdapter } from './BaseAdapter.ts';
+import type { BaseFeatureDataAdapter } from './BaseFeatureDataAdapter.ts';
+import type { BaseRefNameAliasAdapter } from './BaseRefNameAliasAdapter.ts';
+import type { BaseSequenceAdapter } from './BaseSequenceAdapter.ts';
+import type { BaseTextSearchAdapter } from './BaseTextSearchAdapter.ts';
+import type { RegionsAdapter } from './RegionsAdapter.ts';
+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;
+export declare function isFeatureAdapter(t: AnyDataAdapter): t is BaseFeatureDataAdapter;
+export declare function isRefNameAliasAdapter(t: object): t is BaseRefNameAliasAdapter;
+export declare function isTextSearchAdapter(t: AnyDataAdapter): t is BaseTextSearchAdapter;

package/esm/data_adapters/BaseAdapter/util.js

@@ -0,0 +1,15 @@
+export function isSequenceAdapter(t) {
+    return 'getRegions' in t && 'getFeatures' in t;
+}
+export function isRegionsAdapter(t) {
+    return 'getRegions' in t;
+}
+export function isFeatureAdapter(t) {
+    return 'getFeatures' in t;
+}
+export function isRefNameAliasAdapter(t) {
+    return 'getRefNameAliases' in t;
+}
+export function isTextSearchAdapter(t) {
+    return 'searchIndex' in t;
+}

package/esm/data_adapters/CytobandAdapter/CytobandAdapter.d.ts

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

package/esm/data_adapters/CytobandAdapter/CytobandAdapter.js

@@ -0,0 +1,28 @@
+import { SimpleFeature, fetchAndMaybeUnzipText } from "../../util/index.js";
+import { openLocation } from "../../util/io/index.js";
+import { BaseAdapter } from "../BaseAdapter/index.js";
+export default class CytobandAdapter extends BaseAdapter {
+    async getData(opts) {
+        const conf = this.getConf('cytobandLocation');
+        if (conf.uri === '' || conf.uri === '/path/to/cytoband.txt.gz') {
+            return [];
+        }
+        const text = await fetchAndMaybeUnzipText(openLocation(conf, this.pluginManager), opts);
+        return text
+            .split(/\n|\r\n|\r/)
+            .filter(f => !!f.trim())
+            .filter(f => !f.startsWith('#'))
+            .map((line, i) => {
+            const [refName, start, end, name, type] = line.split('\t');
+            return new SimpleFeature({
+                uniqueId: `${i}`,
+                refName: refName,
+                start: +start,
+                end: +end,
+                name,
+                type,
+                gieStain: type || name,
+            });
+        });
+    }
+}

package/esm/data_adapters/CytobandAdapter/configSchema.d.ts

@@ -0,0 +1,9 @@
+declare const configSchema: import("../../configuration/configurationSchema.ts").ConfigurationSchemaType<{
+    cytobandLocation: {
+        type: string;
+        defaultValue: {
+            uri: string;
+        };
+    };
+}, import("../../configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, undefined>>;
+export default configSchema;

package/esm/data_adapters/CytobandAdapter/configSchema.js

@@ -0,0 +1,24 @@
+import { ConfigurationSchema } from "../../configuration/index.js";
+function x() { }
+const configSchema = ConfigurationSchema('CytobandAdapter', {
+    cytobandLocation: {
+        type: 'fileLocation',
+        defaultValue: {
+            uri: '/path/to/cytoband.txt.gz',
+        },
+    },
+}, {
+    explicitlyTyped: true,
+    preProcessSnapshot: snap => {
+        return snap.uri
+            ? {
+                ...snap,
+                cytobandLocation: {
+                    uri: snap.uri,
+                    baseUri: snap.baseUri,
+                },
+            }
+            : snap;
+    },
+});
+export default configSchema;

package/esm/data_adapters/CytobandAdapter/index.d.ts

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

package/esm/data_adapters/CytobandAdapter/index.js

@@ -0,0 +1,12 @@
+import configSchema from "./configSchema.js";
+import { AdapterType } from "../../pluggableElementTypes/index.js";
+export default function CytobandAdapterF(pluginManager) {
+    pluginManager.addAdapterType(() => new AdapterType({
+        name: 'CytobandAdapter',
+        configSchema,
+        adapterMetadata: {
+            hiddenFromGUI: true,
+        },
+        getAdapterClass: () => import("./CytobandAdapter.js").then(f => f.default),
+    }));
+}

package/esm/data_adapters/dataAdapterCache.d.ts

@@ -0,0 +1,14 @@
+import type PluginManager from '../PluginManager.ts';
+import type { AnyConfigurationSchemaType } from '../configuration/index.ts';
+import type { AnyDataAdapter } from './BaseAdapter/index.ts';
+import type { SnapshotIn } from '@jbrowse/mobx-state-tree';
+type ConfigSnap = SnapshotIn<AnyConfigurationSchemaType>;
+interface AdapterCacheEntry {
+    dataAdapter: AnyDataAdapter;
+    sessionIds: Set<string>;
+}
+export declare function getAdapter(pluginManager: PluginManager, sessionId: string, adapterConfigSnapshot: SnapshotIn<AnyConfigurationSchemaType>): Promise<AdapterCacheEntry>;
+export type getSubAdapterType = (adapterConfigSnap: ConfigSnap) => ReturnType<typeof getAdapter>;
+export declare function freeAdapterResources(args: Record<string, any>): Promise<void>;
+export declare function clearAdapterCache(): void;
+export {};

package/esm/data_adapters/dataAdapterCache.js

@@ -0,0 +1,54 @@
+import { adapterConfigCacheKey } from "./util.js";
+let adapterCache = {};
+async function getAdapterPre(pluginManager, sessionId, adapterConfigSnapshot) {
+    const adapterType = adapterConfigSnapshot?.type;
+    if (!adapterType) {
+        throw new Error(`could not determine adapter type from adapter config snapshot ${JSON.stringify(adapterConfigSnapshot)}`);
+    }
+    const dataAdapterType = pluginManager.getAdapterType(adapterType);
+    if (!dataAdapterType) {
+        throw new Error(`unknown data adapter type ${adapterType}`);
+    }
+    const adapterConfig = dataAdapterType.configSchema.create(adapterConfigSnapshot, { pluginManager });
+    const getSubAdapter = getAdapter.bind(null, pluginManager, sessionId);
+    const CLASS = await dataAdapterType.getAdapterClass();
+    const dataAdapter = new CLASS(adapterConfig, getSubAdapter, pluginManager);
+    return {
+        dataAdapter,
+        sessionIds: new Set([sessionId]),
+    };
+}
+export async function getAdapter(pluginManager, sessionId, adapterConfigSnapshot) {
+    const cacheKey = adapterConfigCacheKey(adapterConfigSnapshot);
+    adapterCache[cacheKey] ??= getAdapterPre(pluginManager, sessionId, adapterConfigSnapshot);
+    const ret = await adapterCache[cacheKey];
+    ret.sessionIds.add(sessionId);
+    return ret;
+}
+export async function freeAdapterResources(args) {
+    const specKeys = Object.keys(args);
+    if (specKeys.length === 1 && specKeys[0] === 'sessionId') {
+        const { sessionId } = args;
+        for (const [cacheKey, cacheEntryP] of Object.entries(adapterCache)) {
+            const cacheEntry = await cacheEntryP;
+            cacheEntry.sessionIds.delete(sessionId);
+            if (cacheEntry.sessionIds.size === 0) {
+                delete adapterCache[cacheKey];
+            }
+        }
+    }
+    else {
+        for (const cacheEntryP of Object.values(adapterCache)) {
+            const cacheEntry = await cacheEntryP;
+            const regions = args.regions || (args.region ? [args.region] : []);
+            for (const region of regions) {
+                if (region.refName !== undefined) {
+                    cacheEntry.dataAdapter.freeResources(region);
+                }
+            }
+        }
+    }
+}
+export function clearAdapterCache() {
+    adapterCache = {};
+}