@jbrowse/core 3.7.0 → 4.0.1

package/esm/assemblyManager/assemblyManager.d.ts

@@ -0,0 +1,528 @@
+import type { Assembly } from './assembly.ts';
+import type PluginManager from '../PluginManager.ts';
+import type { AnyConfigurationModel } from '../configuration/index.ts';
+import type RpcManager from '../rpc/RpcManager.ts';
+import type { StopToken } from '../util/stopToken.ts';
+import type { IAnyType } from '@jbrowse/mobx-state-tree';
+type AdapterConf = Record<string, unknown>;
+export interface AssemblyBaseOpts {
+    stopToken?: StopToken;
+    sessionId: string;
+    statusCallback?: (arg: string) => void;
+}
+declare function assemblyManagerFactory(conf: IAnyType, pm: PluginManager): import("@jbrowse/mobx-state-tree").IModelType<{
+    assemblies: import("@jbrowse/mobx-state-tree").IArrayType<import("@jbrowse/mobx-state-tree").IModelType<{
+        configuration: import("@jbrowse/mobx-state-tree").IMaybe<import("@jbrowse/mobx-state-tree").IReferenceType<IAnyType>>;
+    }, {
+        error: unknown;
+        loadingP: Promise<void> | undefined;
+        volatileRegions: import("./assembly.ts").BasicRegion[] | undefined;
+        refNameAliases: {
+            [x: string]: string;
+        } | undefined;
+        canonicalToSeqAdapterRefNames: Record<string, string> | undefined;
+        cytobands: import("../util/simpleFeature.ts").Feature[] | undefined;
+    } & {
+        getConf(arg: string): any;
+        readonly lowerCaseRefNameAliases: {
+            [k: string]: string;
+        } | undefined;
+    } & {
+        readonly initialized: boolean;
+        readonly name: string;
+        readonly regions: import("./assembly.ts").BasicRegion[] | undefined;
+        readonly aliases: string[];
+        readonly displayName: string;
+        hasName(name: string): boolean;
+        readonly allAliases: string[];
+        readonly allRefNames: string[] | undefined;
+        readonly lowerCaseRefNames: string[] | undefined;
+        readonly allRefNamesWithLowerCase: string[] | undefined;
+        readonly rpcManager: RpcManager;
+        readonly refNameColors: string[];
+    } & {
+        readonly refNames: string[] | undefined;
+    } & {
+        getCanonicalRefName(refName: string): string | undefined;
+        getCanonicalRefName2(refName: string): string;
+        getRefNameColor(refName: string): string | undefined;
+        isValidRefName(refName: string): boolean;
+        getSeqAdapterRefName(canonicalRefName: string): string;
+    } & {
+        setLoaded({ regions, refNameAliases, cytobands, }: {
+            regions: import("../util/index.ts").Region[];
+            refNameAliases: {
+                [x: string]: string;
+            };
+            cytobands: import("../util/simpleFeature.ts").Feature[];
+        }): void;
+        setError(e: unknown): void;
+        setRegions(regions: import("../util/index.ts").Region[]): void;
+        setRefNameAliases(aliases: {
+            [x: string]: string;
+        }): void;
+        setCytobands(cytobands: import("../util/simpleFeature.ts").Feature[]): void;
+        setCanonicalToSeqAdapterRefNames(map: Record<string, string>): void;
+        setLoadingP(p?: Promise<void>): void;
+        load(): Promise<void>;
+        loadPre(): Promise<void>;
+    } & {
+        getAdapterMapEntry(adapterConf: {
+            [x: string]: unknown;
+        }, options: import("../data_adapters/BaseAdapter/types.ts").BaseOptions): Promise<import("./assembly.ts").RefNameMap>;
+        getRefNameMapForAdapter(adapterConf: {
+            [x: string]: unknown;
+        }, opts: import("../data_adapters/BaseAdapter/types.ts").BaseOptions): Promise<{
+            [x: string]: string;
+        }>;
+        getReverseRefNameMapForAdapter(adapterConf: {
+            [x: string]: unknown;
+        }, opts: import("../data_adapters/BaseAdapter/types.ts").BaseOptions): Promise<{
+            [x: string]: string;
+        }>;
+        afterCreate(): void;
+    }, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>>;
+}, {
+    readonly assemblyNameMap: Record<string, {
+        configuration: any;
+    } & import("@jbrowse/mobx-state-tree/dist/internal").NonEmptyObject & {
+        error: unknown;
+        loadingP: Promise<void> | undefined;
+        volatileRegions: import("./assembly.ts").BasicRegion[] | undefined;
+        refNameAliases: {
+            [x: string]: string;
+        } | undefined;
+        canonicalToSeqAdapterRefNames: Record<string, string> | undefined;
+        cytobands: import("../util/simpleFeature.ts").Feature[] | undefined;
+    } & {
+        getConf(arg: string): any;
+        readonly lowerCaseRefNameAliases: {
+            [k: string]: string;
+        } | undefined;
+    } & {
+        readonly initialized: boolean;
+        readonly name: string;
+        readonly regions: import("./assembly.ts").BasicRegion[] | undefined;
+        readonly aliases: string[];
+        readonly displayName: string;
+        hasName(name: string): boolean;
+        readonly allAliases: string[];
+        readonly allRefNames: string[] | undefined;
+        readonly lowerCaseRefNames: string[] | undefined;
+        readonly allRefNamesWithLowerCase: string[] | undefined;
+        readonly rpcManager: RpcManager;
+        readonly refNameColors: string[];
+    } & {
+        readonly refNames: string[] | undefined;
+    } & {
+        getCanonicalRefName(refName: string): string | undefined;
+        getCanonicalRefName2(refName: string): string;
+        getRefNameColor(refName: string): string | undefined;
+        isValidRefName(refName: string): boolean;
+        getSeqAdapterRefName(canonicalRefName: string): string;
+    } & {
+        setLoaded({ regions, refNameAliases, cytobands, }: {
+            regions: import("../util/index.ts").Region[];
+            refNameAliases: {
+                [x: string]: string;
+            };
+            cytobands: import("../util/simpleFeature.ts").Feature[];
+        }): void;
+        setError(e: unknown): void;
+        setRegions(regions: import("../util/index.ts").Region[]): void;
+        setRefNameAliases(aliases: {
+            [x: string]: string;
+        }): void;
+        setCytobands(cytobands: import("../util/simpleFeature.ts").Feature[]): void;
+        setCanonicalToSeqAdapterRefNames(map: Record<string, string>): void;
+        setLoadingP(p?: Promise<void>): void;
+        load(): Promise<void>;
+        loadPre(): Promise<void>;
+    } & {
+        getAdapterMapEntry(adapterConf: {
+            [x: string]: unknown;
+        }, options: import("../data_adapters/BaseAdapter/types.ts").BaseOptions): Promise<import("./assembly.ts").RefNameMap>;
+        getRefNameMapForAdapter(adapterConf: {
+            [x: string]: unknown;
+        }, opts: import("../data_adapters/BaseAdapter/types.ts").BaseOptions): Promise<{
+            [x: string]: string;
+        }>;
+        getReverseRefNameMapForAdapter(adapterConf: {
+            [x: string]: unknown;
+        }, opts: import("../data_adapters/BaseAdapter/types.ts").BaseOptions): Promise<{
+            [x: string]: string;
+        }>;
+        afterCreate(): void;
+    } & import("@jbrowse/mobx-state-tree").IStateTreeNode<import("@jbrowse/mobx-state-tree").IModelType<{
+        configuration: import("@jbrowse/mobx-state-tree").IMaybe<import("@jbrowse/mobx-state-tree").IReferenceType<IAnyType>>;
+    }, {
+        error: unknown;
+        loadingP: Promise<void> | undefined;
+        volatileRegions: import("./assembly.ts").BasicRegion[] | undefined;
+        refNameAliases: {
+            [x: string]: string;
+        } | undefined;
+        canonicalToSeqAdapterRefNames: Record<string, string> | undefined;
+        cytobands: import("../util/simpleFeature.ts").Feature[] | undefined;
+    } & {
+        getConf(arg: string): any;
+        readonly lowerCaseRefNameAliases: {
+            [k: string]: string;
+        } | undefined;
+    } & {
+        readonly initialized: boolean;
+        readonly name: string;
+        readonly regions: import("./assembly.ts").BasicRegion[] | undefined;
+        readonly aliases: string[];
+        readonly displayName: string;
+        hasName(name: string): boolean;
+        readonly allAliases: string[];
+        readonly allRefNames: string[] | undefined;
+        readonly lowerCaseRefNames: string[] | undefined;
+        readonly allRefNamesWithLowerCase: string[] | undefined;
+        readonly rpcManager: RpcManager;
+        readonly refNameColors: string[];
+    } & {
+        readonly refNames: string[] | undefined;
+    } & {
+        getCanonicalRefName(refName: string): string | undefined;
+        getCanonicalRefName2(refName: string): string;
+        getRefNameColor(refName: string): string | undefined;
+        isValidRefName(refName: string): boolean;
+        getSeqAdapterRefName(canonicalRefName: string): string;
+    } & {
+        setLoaded({ regions, refNameAliases, cytobands, }: {
+            regions: import("../util/index.ts").Region[];
+            refNameAliases: {
+                [x: string]: string;
+            };
+            cytobands: import("../util/simpleFeature.ts").Feature[];
+        }): void;
+        setError(e: unknown): void;
+        setRegions(regions: import("../util/index.ts").Region[]): void;
+        setRefNameAliases(aliases: {
+            [x: string]: string;
+        }): void;
+        setCytobands(cytobands: import("../util/simpleFeature.ts").Feature[]): void;
+        setCanonicalToSeqAdapterRefNames(map: Record<string, string>): void;
+        setLoadingP(p?: Promise<void>): void;
+        load(): Promise<void>;
+        loadPre(): Promise<void>;
+    } & {
+        getAdapterMapEntry(adapterConf: {
+            [x: string]: unknown;
+        }, options: import("../data_adapters/BaseAdapter/types.ts").BaseOptions): Promise<import("./assembly.ts").RefNameMap>;
+        getRefNameMapForAdapter(adapterConf: {
+            [x: string]: unknown;
+        }, opts: import("../data_adapters/BaseAdapter/types.ts").BaseOptions): Promise<{
+            [x: string]: string;
+        }>;
+        getReverseRefNameMapForAdapter(adapterConf: {
+            [x: string]: unknown;
+        }, opts: import("../data_adapters/BaseAdapter/types.ts").BaseOptions): Promise<{
+            [x: string]: string;
+        }>;
+        afterCreate(): void;
+    }, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>>>;
+} & {
+    getCanonicalAssemblyName(asmName: string): string | undefined;
+    getCanonicalAssemblyName2(asmName: string): string;
+    get(asmName: string): ({
+        configuration: any;
+    } & import("@jbrowse/mobx-state-tree/dist/internal").NonEmptyObject & {
+        error: unknown;
+        loadingP: Promise<void> | undefined;
+        volatileRegions: import("./assembly.ts").BasicRegion[] | undefined;
+        refNameAliases: {
+            [x: string]: string;
+        } | undefined;
+        canonicalToSeqAdapterRefNames: Record<string, string> | undefined;
+        cytobands: import("../util/simpleFeature.ts").Feature[] | undefined;
+    } & {
+        getConf(arg: string): any;
+        readonly lowerCaseRefNameAliases: {
+            [k: string]: string;
+        } | undefined;
+    } & {
+        readonly initialized: boolean;
+        readonly name: string;
+        readonly regions: import("./assembly.ts").BasicRegion[] | undefined;
+        readonly aliases: string[];
+        readonly displayName: string;
+        hasName(name: string): boolean;
+        readonly allAliases: string[];
+        readonly allRefNames: string[] | undefined;
+        readonly lowerCaseRefNames: string[] | undefined;
+        readonly allRefNamesWithLowerCase: string[] | undefined;
+        readonly rpcManager: RpcManager;
+        readonly refNameColors: string[];
+    } & {
+        readonly refNames: string[] | undefined;
+    } & {
+        getCanonicalRefName(refName: string): string | undefined;
+        getCanonicalRefName2(refName: string): string;
+        getRefNameColor(refName: string): string | undefined;
+        isValidRefName(refName: string): boolean;
+        getSeqAdapterRefName(canonicalRefName: string): string;
+    } & {
+        setLoaded({ regions, refNameAliases, cytobands, }: {
+            regions: import("../util/index.ts").Region[];
+            refNameAliases: {
+                [x: string]: string;
+            };
+            cytobands: import("../util/simpleFeature.ts").Feature[];
+        }): void;
+        setError(e: unknown): void;
+        setRegions(regions: import("../util/index.ts").Region[]): void;
+        setRefNameAliases(aliases: {
+            [x: string]: string;
+        }): void;
+        setCytobands(cytobands: import("../util/simpleFeature.ts").Feature[]): void;
+        setCanonicalToSeqAdapterRefNames(map: Record<string, string>): void;
+        setLoadingP(p?: Promise<void>): void;
+        load(): Promise<void>;
+        loadPre(): Promise<void>;
+    } & {
+        getAdapterMapEntry(adapterConf: {
+            [x: string]: unknown;
+        }, options: import("../data_adapters/BaseAdapter/types.ts").BaseOptions): Promise<import("./assembly.ts").RefNameMap>;
+        getRefNameMapForAdapter(adapterConf: {
+            [x: string]: unknown;
+        }, opts: import("../data_adapters/BaseAdapter/types.ts").BaseOptions): Promise<{
+            [x: string]: string;
+        }>;
+        getReverseRefNameMapForAdapter(adapterConf: {
+            [x: string]: unknown;
+        }, opts: import("../data_adapters/BaseAdapter/types.ts").BaseOptions): Promise<{
+            [x: string]: string;
+        }>;
+        afterCreate(): void;
+    } & import("@jbrowse/mobx-state-tree").IStateTreeNode<import("@jbrowse/mobx-state-tree").IModelType<{
+        configuration: import("@jbrowse/mobx-state-tree").IMaybe<import("@jbrowse/mobx-state-tree").IReferenceType<IAnyType>>;
+    }, {
+        error: unknown;
+        loadingP: Promise<void> | undefined;
+        volatileRegions: import("./assembly.ts").BasicRegion[] | undefined;
+        refNameAliases: {
+            [x: string]: string;
+        } | undefined;
+        canonicalToSeqAdapterRefNames: Record<string, string> | undefined;
+        cytobands: import("../util/simpleFeature.ts").Feature[] | undefined;
+    } & {
+        getConf(arg: string): any;
+        readonly lowerCaseRefNameAliases: {
+            [k: string]: string;
+        } | undefined;
+    } & {
+        readonly initialized: boolean;
+        readonly name: string;
+        readonly regions: import("./assembly.ts").BasicRegion[] | undefined;
+        readonly aliases: string[];
+        readonly displayName: string;
+        hasName(name: string): boolean;
+        readonly allAliases: string[];
+        readonly allRefNames: string[] | undefined;
+        readonly lowerCaseRefNames: string[] | undefined;
+        readonly allRefNamesWithLowerCase: string[] | undefined;
+        readonly rpcManager: RpcManager;
+        readonly refNameColors: string[];
+    } & {
+        readonly refNames: string[] | undefined;
+    } & {
+        getCanonicalRefName(refName: string): string | undefined;
+        getCanonicalRefName2(refName: string): string;
+        getRefNameColor(refName: string): string | undefined;
+        isValidRefName(refName: string): boolean;
+        getSeqAdapterRefName(canonicalRefName: string): string;
+    } & {
+        setLoaded({ regions, refNameAliases, cytobands, }: {
+            regions: import("../util/index.ts").Region[];
+            refNameAliases: {
+                [x: string]: string;
+            };
+            cytobands: import("../util/simpleFeature.ts").Feature[];
+        }): void;
+        setError(e: unknown): void;
+        setRegions(regions: import("../util/index.ts").Region[]): void;
+        setRefNameAliases(aliases: {
+            [x: string]: string;
+        }): void;
+        setCytobands(cytobands: import("../util/simpleFeature.ts").Feature[]): void;
+        setCanonicalToSeqAdapterRefNames(map: Record<string, string>): void;
+        setLoadingP(p?: Promise<void>): void;
+        load(): Promise<void>;
+        loadPre(): Promise<void>;
+    } & {
+        getAdapterMapEntry(adapterConf: {
+            [x: string]: unknown;
+        }, options: import("../data_adapters/BaseAdapter/types.ts").BaseOptions): Promise<import("./assembly.ts").RefNameMap>;
+        getRefNameMapForAdapter(adapterConf: {
+            [x: string]: unknown;
+        }, opts: import("../data_adapters/BaseAdapter/types.ts").BaseOptions): Promise<{
+            [x: string]: string;
+        }>;
+        getReverseRefNameMapForAdapter(adapterConf: {
+            [x: string]: unknown;
+        }, opts: import("../data_adapters/BaseAdapter/types.ts").BaseOptions): Promise<{
+            [x: string]: string;
+        }>;
+        afterCreate(): void;
+    }, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>>) | undefined;
+    readonly assemblyNamesList: any[];
+    readonly assemblyList: AnyConfigurationModel[];
+    readonly rpcManager: RpcManager;
+} & {
+    waitForAssembly(assemblyName: string): Promise<({
+        configuration: any;
+    } & import("@jbrowse/mobx-state-tree/dist/internal").NonEmptyObject & {
+        error: unknown;
+        loadingP: Promise<void> | undefined;
+        volatileRegions: import("./assembly.ts").BasicRegion[] | undefined;
+        refNameAliases: {
+            [x: string]: string;
+        } | undefined;
+        canonicalToSeqAdapterRefNames: Record<string, string> | undefined;
+        cytobands: import("../util/simpleFeature.ts").Feature[] | undefined;
+    } & {
+        getConf(arg: string): any;
+        readonly lowerCaseRefNameAliases: {
+            [k: string]: string;
+        } | undefined;
+    } & {
+        readonly initialized: boolean;
+        readonly name: string;
+        readonly regions: import("./assembly.ts").BasicRegion[] | undefined;
+        readonly aliases: string[];
+        readonly displayName: string;
+        hasName(name: string): boolean;
+        readonly allAliases: string[];
+        readonly allRefNames: string[] | undefined;
+        readonly lowerCaseRefNames: string[] | undefined;
+        readonly allRefNamesWithLowerCase: string[] | undefined;
+        readonly rpcManager: RpcManager;
+        readonly refNameColors: string[];
+    } & {
+        readonly refNames: string[] | undefined;
+    } & {
+        getCanonicalRefName(refName: string): string | undefined;
+        getCanonicalRefName2(refName: string): string;
+        getRefNameColor(refName: string): string | undefined;
+        isValidRefName(refName: string): boolean;
+        getSeqAdapterRefName(canonicalRefName: string): string;
+    } & {
+        setLoaded({ regions, refNameAliases, cytobands, }: {
+            regions: import("../util/index.ts").Region[];
+            refNameAliases: {
+                [x: string]: string;
+            };
+            cytobands: import("../util/simpleFeature.ts").Feature[];
+        }): void;
+        setError(e: unknown): void;
+        setRegions(regions: import("../util/index.ts").Region[]): void;
+        setRefNameAliases(aliases: {
+            [x: string]: string;
+        }): void;
+        setCytobands(cytobands: import("../util/simpleFeature.ts").Feature[]): void;
+        setCanonicalToSeqAdapterRefNames(map: Record<string, string>): void;
+        setLoadingP(p?: Promise<void>): void;
+        load(): Promise<void>;
+        loadPre(): Promise<void>;
+    } & {
+        getAdapterMapEntry(adapterConf: {
+            [x: string]: unknown;
+        }, options: import("../data_adapters/BaseAdapter/types.ts").BaseOptions): Promise<import("./assembly.ts").RefNameMap>;
+        getRefNameMapForAdapter(adapterConf: {
+            [x: string]: unknown;
+        }, opts: import("../data_adapters/BaseAdapter/types.ts").BaseOptions): Promise<{
+            [x: string]: string;
+        }>;
+        getReverseRefNameMapForAdapter(adapterConf: {
+            [x: string]: unknown;
+        }, opts: import("../data_adapters/BaseAdapter/types.ts").BaseOptions): Promise<{
+            [x: string]: string;
+        }>;
+        afterCreate(): void;
+    } & import("@jbrowse/mobx-state-tree").IStateTreeNode<import("@jbrowse/mobx-state-tree").IModelType<{
+        configuration: import("@jbrowse/mobx-state-tree").IMaybe<import("@jbrowse/mobx-state-tree").IReferenceType<IAnyType>>;
+    }, {
+        error: unknown;
+        loadingP: Promise<void> | undefined;
+        volatileRegions: import("./assembly.ts").BasicRegion[] | undefined;
+        refNameAliases: {
+            [x: string]: string;
+        } | undefined;
+        canonicalToSeqAdapterRefNames: Record<string, string> | undefined;
+        cytobands: import("../util/simpleFeature.ts").Feature[] | undefined;
+    } & {
+        getConf(arg: string): any;
+        readonly lowerCaseRefNameAliases: {
+            [k: string]: string;
+        } | undefined;
+    } & {
+        readonly initialized: boolean;
+        readonly name: string;
+        readonly regions: import("./assembly.ts").BasicRegion[] | undefined;
+        readonly aliases: string[];
+        readonly displayName: string;
+        hasName(name: string): boolean;
+        readonly allAliases: string[];
+        readonly allRefNames: string[] | undefined;
+        readonly lowerCaseRefNames: string[] | undefined;
+        readonly allRefNamesWithLowerCase: string[] | undefined;
+        readonly rpcManager: RpcManager;
+        readonly refNameColors: string[];
+    } & {
+        readonly refNames: string[] | undefined;
+    } & {
+        getCanonicalRefName(refName: string): string | undefined;
+        getCanonicalRefName2(refName: string): string;
+        getRefNameColor(refName: string): string | undefined;
+        isValidRefName(refName: string): boolean;
+        getSeqAdapterRefName(canonicalRefName: string): string;
+    } & {
+        setLoaded({ regions, refNameAliases, cytobands, }: {
+            regions: import("../util/index.ts").Region[];
+            refNameAliases: {
+                [x: string]: string;
+            };
+            cytobands: import("../util/simpleFeature.ts").Feature[];
+        }): void;
+        setError(e: unknown): void;
+        setRegions(regions: import("../util/index.ts").Region[]): void;
+        setRefNameAliases(aliases: {
+            [x: string]: string;
+        }): void;
+        setCytobands(cytobands: import("../util/simpleFeature.ts").Feature[]): void;
+        setCanonicalToSeqAdapterRefNames(map: Record<string, string>): void;
+        setLoadingP(p?: Promise<void>): void;
+        load(): Promise<void>;
+        loadPre(): Promise<void>;
+    } & {
+        getAdapterMapEntry(adapterConf: {
+            [x: string]: unknown;
+        }, options: import("../data_adapters/BaseAdapter/types.ts").BaseOptions): Promise<import("./assembly.ts").RefNameMap>;
+        getRefNameMapForAdapter(adapterConf: {
+            [x: string]: unknown;
+        }, opts: import("../data_adapters/BaseAdapter/types.ts").BaseOptions): Promise<{
+            [x: string]: string;
+        }>;
+        getReverseRefNameMapForAdapter(adapterConf: {
+            [x: string]: unknown;
+        }, opts: import("../data_adapters/BaseAdapter/types.ts").BaseOptions): Promise<{
+            [x: string]: string;
+        }>;
+        afterCreate(): void;
+    }, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>>) | undefined>;
+    getRefNameMapForAdapter(adapterConf: AdapterConf, assemblyName: string | undefined, opts: AssemblyBaseOpts): Promise<{
+        [x: string]: string;
+    } | undefined>;
+    getReverseRefNameMapForAdapter(adapterConf: AdapterConf, assemblyName: string | undefined, opts: AssemblyBaseOpts): Promise<{
+        [x: string]: string;
+    } | undefined>;
+    isValidRefName(refName: string, assemblyName: string): boolean;
+} & {
+    afterAttach(): void;
+    removeAssembly(asm: Assembly): void;
+    addAssembly(configuration: any): void;
+}, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>;
+export default assemblyManagerFactory;

package/esm/assemblyManager/assemblyManager.js

@@ -0,0 +1,131 @@
+import { addDisposer, getParent, types } from '@jbrowse/mobx-state-tree';
+import { reaction } from 'mobx';
+import assemblyFactory from "./assembly.js";
+import { readConfObject } from "../configuration/index.js";
+import { when } from "../util/index.js";
+function assemblyManagerFactory(conf, pm) {
+    return types
+        .model({
+        assemblies: types.array(assemblyFactory(conf, pm)),
+    })
+        .views(self => ({
+        get assemblyNameMap() {
+            const obj = {};
+            for (const assembly of self.assemblies) {
+                for (const name of assembly.allAliases) {
+                    obj[name] = assembly;
+                }
+            }
+            return obj;
+        },
+    }))
+        .views(self => ({
+        getCanonicalAssemblyName(asmName) {
+            return self.assemblyNameMap[asmName]?.name;
+        },
+        getCanonicalAssemblyName2(asmName) {
+            return self.assemblyNameMap[asmName]?.name || asmName;
+        },
+        get(asmName) {
+            if (asmName) {
+                const assembly = self.assemblyNameMap[asmName];
+                if (assembly) {
+                    return assembly;
+                }
+                else if (!this.assemblyNamesList.includes(asmName)) {
+                    pm.evaluateExtensionPoint('Core-handleUnrecognizedAssembly', undefined, {
+                        assemblyName: asmName,
+                        session: getParent(self).session,
+                    });
+                }
+            }
+            return undefined;
+        },
+        get assemblyNamesList() {
+            return this.assemblyList.map(asm => asm.name);
+        },
+        get assemblyList() {
+            const { jbrowse: { assemblies }, session: { sessionAssemblies = [], temporaryAssemblies = [] } = {}, } = getParent(self);
+            return [
+                ...assemblies,
+                ...sessionAssemblies,
+                ...temporaryAssemblies,
+            ];
+        },
+        get rpcManager() {
+            return getParent(self).rpcManager;
+        },
+    }))
+        .views(self => ({
+        async waitForAssembly(assemblyName) {
+            if (!assemblyName) {
+                throw new Error('no assembly name supplied to waitForAssembly');
+            }
+            let assembly = self.get(assemblyName);
+            if (!assembly) {
+                try {
+                    await when(() => Boolean(self.get(assemblyName)), {
+                        timeout: 10000,
+                    });
+                    assembly = self.get(assemblyName);
+                }
+                catch (e) {
+                }
+            }
+            if (!assembly) {
+                return undefined;
+            }
+            await assembly.load();
+            await when(() => !!(assembly.regions && assembly.refNameAliases) || !!assembly.error);
+            if (assembly.error) {
+                throw assembly.error;
+            }
+            return assembly;
+        },
+        async getRefNameMapForAdapter(adapterConf, assemblyName, opts) {
+            if (assemblyName) {
+                const asm = await this.waitForAssembly(assemblyName);
+                return asm?.getRefNameMapForAdapter(adapterConf, opts);
+            }
+            return {};
+        },
+        async getReverseRefNameMapForAdapter(adapterConf, assemblyName, opts) {
+            if (assemblyName) {
+                const asm = await this.waitForAssembly(assemblyName);
+                return asm?.getReverseRefNameMapForAdapter(adapterConf, opts);
+            }
+            return {};
+        },
+        isValidRefName(refName, assemblyName) {
+            const assembly = self.get(assemblyName);
+            if (assembly) {
+                return assembly.isValidRefName(refName);
+            }
+            throw new Error(`Failed to look up refName:${refName} on assemblyName:${assemblyName} (assembly does not exist)`);
+        },
+    }))
+        .actions(self => ({
+        afterAttach() {
+            addDisposer(self, reaction(() => self.assemblyList, assemblyConfs => {
+                for (const asm of self.assemblies) {
+                    if (!asm.configuration) {
+                        this.removeAssembly(asm);
+                    }
+                }
+                for (const conf of assemblyConfs) {
+                    const name = readConfObject(conf, 'name');
+                    if (!self.assemblies.some(a => a.name === name)) {
+                        this.addAssembly(conf);
+                    }
+                }
+            }, { fireImmediately: true, name: 'assemblyManagerAfterAttach' }));
+        },
+        removeAssembly(asm) {
+            self.assemblies.remove(asm);
+        },
+        addAssembly(configuration) {
+            self.assemblies.push({ configuration });
+        },
+    }));
+}
+export default assemblyManagerFactory;

package/esm/assemblyManager/index.d.ts

@@ -0,0 +1,3 @@
+export { default } from './assemblyManager.ts';
+export { default as assemblyConfigSchemaFactory } from './assemblyConfigSchema.ts';
+export type { BaseAssemblyConfigSchema } from './assemblyConfigSchema.ts';

package/esm/assemblyManager/index.js

@@ -0,0 +1,2 @@
+export { default } from "./assemblyManager.js";
+export { default as assemblyConfigSchemaFactory } from "./assemblyConfigSchema.js";