@jbrowse/app-core 4.2.1 → 5.0.0-beta.1

package/esm/AppSession/AppSessionMixin.js

@@ -0,0 +1,62 @@
+import { getParent, types } from '@jbrowse/mobx-state-tree';
+/**
+ * #stateModel AppSessionMixin
+ *
+ * Session getters shared by the "app" products (desktop + web) that simply
+ * delegate to the root model — `version`, `history`, `menus`,
+ * `assemblyManager` — plus `renameCurrentSession`. Centralized here so the
+ * products compose one mixin instead of re-declaring (and diverging on) the
+ * same root delegations. The root must satisfy {@link AppRootModel}.
+ */
+export function AppSessionMixin(_pluginManager) {
+    return types
+        .model({})
+        .views(self => ({
+        /**
+         * #getter
+         */
+        get root() {
+            return getParent(self);
+        },
+    }))
+        .views(self => ({
+        /**
+         * #getter
+         */
+        get version() {
+            return self.root.version;
+        },
+        /**
+         * #getter
+         */
+        get gitCommit() {
+            return self.root.gitCommit;
+        },
+        /**
+         * #getter
+         */
+        get history() {
+            return self.root.history;
+        },
+        /**
+         * #getter
+         */
+        get assemblyManager() {
+            return self.root.assemblyManager;
+        },
+        /**
+         * #method
+         */
+        menus() {
+            return self.root.menus();
+        },
+    }))
+        .actions(self => ({
+        /**
+         * #action
+         */
+        renameCurrentSession(sessionName) {
+            self.root.renameCurrentSession(sessionName);
+        },
+    }));
+}

package/esm/AppSession/index.d.ts

@@ -0,0 +1,2 @@
+export { AppSessionMixin } from './AppSessionMixin.ts';
+export type { AppRootModel } from './AppRootModel.ts';

package/esm/AppSession/index.js

@@ -0,0 +1 @@
+export { AppSessionMixin } from './AppSessionMixin.js';

package/esm/Assemblies/AssembliesMixin.d.ts

@@ -0,0 +1,225 @@
+import type PluginManager from '@jbrowse/core/PluginManager';
+import type { BaseAssemblyConfigModel, BaseAssemblyConfigSchema } from '@jbrowse/core/assemblyManager';
+import type { AnyConfiguration } from '@jbrowse/core/configuration';
+/**
+ * #stateModel AssembliesMixin
+ * #category root
+ *
+ * Adds `sessionAssemblies` (admin-aware, persisted-with-session assemblies) and
+ * `temporaryAssemblies` (used for ad-hoc read-vs-ref style assemblies).
+ */
+export declare function AssembliesMixin(_pluginManager: PluginManager, assemblyConfigSchemasType: BaseAssemblyConfigSchema): import("@jbrowse/mobx-state-tree").IModelType<{
+    /**
+     * #property
+     */
+    sessionAssemblies: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").IArrayType<import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
+        readonly aliases: {
+            readonly type: "stringArray";
+            readonly defaultValue: readonly [];
+            readonly description: "Other possible names for the assembly";
+        };
+        readonly sequence: import("@jbrowse/core/configuration").AnyConfigurationSchemaType;
+        readonly refNameColors: {
+            readonly type: "stringArray";
+            readonly defaultValue: readonly [];
+            readonly description: "Define custom colors for each reference sequence. Will cycle through this list if there are not enough colors for every sequence.";
+        };
+        readonly geneticCodes: {
+            readonly type: "frozen";
+            readonly defaultValue: {};
+            readonly description: "Map of reference sequence name to NCBI genetic-code (translation table) id for sequences not using the standard code, e.g. { \"chrM\": 2 }";
+        };
+        readonly geneticCodesLocation: {
+            readonly type: "fileLocation";
+            readonly defaultValue: {
+                readonly uri: "";
+                readonly locationType: "UriLocation";
+            };
+            readonly description: "Optional TSV file of refName<TAB>geneticCodeId, an alternative to inlining the geneticCodes map";
+        };
+        readonly refNameAliases: import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
+            readonly adapter: import("@jbrowse/mobx-state-tree").IAnyType;
+        }, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined>>;
+        readonly cytobands: import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
+            readonly adapter: import("@jbrowse/mobx-state-tree").IAnyType;
+        }, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined>>;
+        readonly displayName: {
+            readonly type: "string";
+            readonly defaultValue: "";
+            readonly description: "A human readable display name for the assembly e.g. \"Homo sapiens (hg38)\" while the assembly name may just be \"hg38\"";
+        };
+    }, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, "name">>>, [undefined]>;
+    /**
+     * #property
+     */
+    temporaryAssemblies: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").IArrayType<import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
+        readonly aliases: {
+            readonly type: "stringArray";
+            readonly defaultValue: readonly [];
+            readonly description: "Other possible names for the assembly";
+        };
+        readonly sequence: import("@jbrowse/core/configuration").AnyConfigurationSchemaType;
+        readonly refNameColors: {
+            readonly type: "stringArray";
+            readonly defaultValue: readonly [];
+            readonly description: "Define custom colors for each reference sequence. Will cycle through this list if there are not enough colors for every sequence.";
+        };
+        readonly geneticCodes: {
+            readonly type: "frozen";
+            readonly defaultValue: {};
+            readonly description: "Map of reference sequence name to NCBI genetic-code (translation table) id for sequences not using the standard code, e.g. { \"chrM\": 2 }";
+        };
+        readonly geneticCodesLocation: {
+            readonly type: "fileLocation";
+            readonly defaultValue: {
+                readonly uri: "";
+                readonly locationType: "UriLocation";
+            };
+            readonly description: "Optional TSV file of refName<TAB>geneticCodeId, an alternative to inlining the geneticCodes map";
+        };
+        readonly refNameAliases: import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
+            readonly adapter: import("@jbrowse/mobx-state-tree").IAnyType;
+        }, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined>>;
+        readonly cytobands: import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
+            readonly adapter: import("@jbrowse/mobx-state-tree").IAnyType;
+        }, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined>>;
+        readonly displayName: {
+            readonly type: "string";
+            readonly defaultValue: "";
+            readonly description: "A human readable display name for the assembly e.g. \"Homo sapiens (hg38)\" while the assembly name may just be \"hg38\"";
+        };
+    }, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, "name">>>, [undefined]>;
+}, {
+    /**
+     * #method
+     * The assembly config already carrying `name`, from any of the three
+     * arrays the assemblyManager draws on, or undefined.
+     *
+     * One namespace, because `name` is the assembly config's MST
+     * identifier: a second config carrying a name one of the others
+     * already has doesn't fail at the add, it makes every
+     * `assembly.configuration` safeReference in the manager ambiguous, and
+     * MST then throws on every read of one — inside the manager's own
+     * autorun and inside `assemblyNameMap`, which takes the session down.
+     * So each add path checks all three, not just the array it pushes to.
+     */
+    findAssemblyConf(name: unknown): BaseAssemblyConfigModel | undefined;
+} & {
+    /**
+     * #action
+     */
+    addSessionAssembly(conf: AnyConfiguration): (import("@jbrowse/mobx-state-tree").ModelInstanceTypeProps<Record<string, any>> & {
+        setSubschema(slotName: string, data: Record<string, unknown>): any;
+        setSlot(slotName: string, value: unknown): void;
+    } & import("@jbrowse/mobx-state-tree").IStateTreeNode<import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
+        readonly aliases: {
+            readonly type: "stringArray";
+            readonly defaultValue: readonly [];
+            readonly description: "Other possible names for the assembly";
+        };
+        readonly sequence: import("@jbrowse/core/configuration").AnyConfigurationSchemaType;
+        readonly refNameColors: {
+            readonly type: "stringArray";
+            readonly defaultValue: readonly [];
+            readonly description: "Define custom colors for each reference sequence. Will cycle through this list if there are not enough colors for every sequence.";
+        };
+        readonly geneticCodes: {
+            readonly type: "frozen";
+            readonly defaultValue: {};
+            readonly description: "Map of reference sequence name to NCBI genetic-code (translation table) id for sequences not using the standard code, e.g. { \"chrM\": 2 }";
+        };
+        readonly geneticCodesLocation: {
+            readonly type: "fileLocation";
+            readonly defaultValue: {
+                readonly uri: "";
+                readonly locationType: "UriLocation";
+            };
+            readonly description: "Optional TSV file of refName<TAB>geneticCodeId, an alternative to inlining the geneticCodes map";
+        };
+        readonly refNameAliases: import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
+            readonly adapter: import("@jbrowse/mobx-state-tree").IAnyType;
+        }, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined>>;
+        readonly cytobands: import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
+            readonly adapter: import("@jbrowse/mobx-state-tree").IAnyType;
+        }, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined>>;
+        readonly displayName: {
+            readonly type: "string";
+            readonly defaultValue: "";
+            readonly description: "A human readable display name for the assembly e.g. \"Homo sapiens (hg38)\" while the assembly name may just be \"hg38\"";
+        };
+    }, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, "name">>>) | undefined;
+    /**
+     * #action
+     */
+    addAssembly(conf: AnyConfiguration): void;
+    /**
+     * #action
+     */
+    removeAssembly(name: string): void;
+    /**
+     * #action
+     */
+    removeSessionAssembly(assemblyName: string): void;
+    /**
+     * #action
+     * used for read vs ref type assemblies.
+     */
+    addTemporaryAssembly(conf: AnyConfiguration): (import("@jbrowse/mobx-state-tree").ModelInstanceTypeProps<Record<string, any>> & {
+        setSubschema(slotName: string, data: Record<string, unknown>): any;
+        setSlot(slotName: string, value: unknown): void;
+    } & import("@jbrowse/mobx-state-tree").IStateTreeNode<import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
+        readonly aliases: {
+            readonly type: "stringArray";
+            readonly defaultValue: readonly [];
+            readonly description: "Other possible names for the assembly";
+        };
+        readonly sequence: import("@jbrowse/core/configuration").AnyConfigurationSchemaType;
+        readonly refNameColors: {
+            readonly type: "stringArray";
+            readonly defaultValue: readonly [];
+            readonly description: "Define custom colors for each reference sequence. Will cycle through this list if there are not enough colors for every sequence.";
+        };
+        readonly geneticCodes: {
+            readonly type: "frozen";
+            readonly defaultValue: {};
+            readonly description: "Map of reference sequence name to NCBI genetic-code (translation table) id for sequences not using the standard code, e.g. { \"chrM\": 2 }";
+        };
+        readonly geneticCodesLocation: {
+            readonly type: "fileLocation";
+            readonly defaultValue: {
+                readonly uri: "";
+                readonly locationType: "UriLocation";
+            };
+            readonly description: "Optional TSV file of refName<TAB>geneticCodeId, an alternative to inlining the geneticCodes map";
+        };
+        readonly refNameAliases: import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
+            readonly adapter: import("@jbrowse/mobx-state-tree").IAnyType;
+        }, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined>>;
+        readonly cytobands: import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
+            readonly adapter: import("@jbrowse/mobx-state-tree").IAnyType;
+        }, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined>>;
+        readonly displayName: {
+            readonly type: "string";
+            readonly defaultValue: "";
+            readonly description: "A human readable display name for the assembly e.g. \"Homo sapiens (hg38)\" while the assembly name may just be \"hg38\"";
+        };
+    }, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, "name">>>) | undefined;
+    /**
+     * #action
+     */
+    removeTemporaryAssembly(name: string): void;
+} & {
+    /**
+     * #getter
+     * sessionAssemblies plus jbrowse config assemblies. Does not include
+     * temporaryAssemblies; this is the list shown in the AssemblySelector
+     * dropdown.
+     */
+    readonly assemblies: BaseAssemblyConfigModel[];
+} & {
+    /**
+     * #getter
+     * names of the assemblies returned by the `assemblies` getter
+     */
+    readonly assemblyNames: string[];
+}, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>;

package/esm/Assemblies/AssembliesMixin.js

@@ -0,0 +1,149 @@
+import { readConfObject } from '@jbrowse/core/configuration';
+import { types } from '@jbrowse/mobx-state-tree';
+import { asSession } from '@jbrowse/product-core';
+/**
+ * #stateModel AssembliesMixin
+ * #category root
+ *
+ * Adds `sessionAssemblies` (admin-aware, persisted-with-session assemblies) and
+ * `temporaryAssemblies` (used for ad-hoc read-vs-ref style assemblies).
+ */
+export function AssembliesMixin(_pluginManager, assemblyConfigSchemasType) {
+    return types
+        .model({
+        /**
+         * #property
+         */
+        sessionAssemblies: types.stripDefault(types.array(assemblyConfigSchemasType), []),
+        /**
+         * #property
+         */
+        temporaryAssemblies: types.stripDefault(types.array(assemblyConfigSchemasType), []),
+    })
+        .views(s => {
+        const self = asSession(s);
+        return {
+            /**
+             * #method
+             * The assembly config already carrying `name`, from any of the three
+             * arrays the assemblyManager draws on, or undefined.
+             *
+             * One namespace, because `name` is the assembly config's MST
+             * identifier: a second config carrying a name one of the others
+             * already has doesn't fail at the add, it makes every
+             * `assembly.configuration` safeReference in the manager ambiguous, and
+             * MST then throws on every read of one — inside the manager's own
+             * autorun and inside `assemblyNameMap`, which takes the session down.
+             * So each add path checks all three, not just the array it pushes to.
+             */
+            findAssemblyConf(name) {
+                return [
+                    ...self.jbrowse.assemblies,
+                    ...self.sessionAssemblies,
+                    ...self.temporaryAssemblies,
+                ].find(f => f.name === name);
+            },
+        };
+    })
+        .actions(s => {
+        const self = asSession(s);
+        return {
+            /**
+             * #action
+             */
+            addSessionAssembly(conf) {
+                const asm = self.findAssemblyConf(conf.name);
+                if (asm) {
+                    console.warn(`Assembly ${conf.name} already exists`);
+                    return asm;
+                }
+                const length = self.sessionAssemblies.push(conf);
+                return self.sessionAssemblies[length - 1];
+            },
+            /**
+             * #action
+             */
+            addAssembly(conf) {
+                // checked here rather than left to jbrowse.addAssemblyConf, which
+                // sees only its own array: in admin mode the name still has to clear
+                // the session-scoped arrays as well
+                const asm = self.findAssemblyConf(conf.name);
+                if (asm) {
+                    console.warn(`Assembly ${conf.name} already exists`);
+                    return;
+                }
+                if (self.adminMode) {
+                    self.jbrowse.addAssemblyConf(conf);
+                }
+                else {
+                    this.addSessionAssembly(conf);
+                }
+            },
+            /**
+             * #action
+             */
+            removeAssembly(name) {
+                if (self.adminMode) {
+                    self.jbrowse.removeAssemblyConf(name);
+                }
+                else {
+                    this.removeSessionAssembly(name);
+                }
+            },
+            /**
+             * #action
+             */
+            removeSessionAssembly(assemblyName) {
+                const elt = self.sessionAssemblies.find(a => a.name === assemblyName);
+                if (elt) {
+                    self.sessionAssemblies.remove(elt);
+                }
+            },
+            /**
+             * #action
+             * used for read vs ref type assemblies.
+             */
+            addTemporaryAssembly(conf) {
+                const asm = self.findAssemblyConf(conf.name);
+                if (asm) {
+                    console.warn(`Assembly ${conf.name} already exists`);
+                    return asm;
+                }
+                const length = self.temporaryAssemblies.push(conf);
+                return self.temporaryAssemblies[length - 1];
+            },
+            /**
+             * #action
+             */
+            removeTemporaryAssembly(name) {
+                const elt = self.temporaryAssemblies.find(a => a.name === name);
+                if (elt) {
+                    self.temporaryAssemblies.remove(elt);
+                }
+            },
+        };
+    })
+        .views(s => {
+        const self = asSession(s);
+        return {
+            /**
+             * #getter
+             * sessionAssemblies plus jbrowse config assemblies. Does not include
+             * temporaryAssemblies; this is the list shown in the AssemblySelector
+             * dropdown.
+             */
+            get assemblies() {
+                return [...self.jbrowse.assemblies, ...self.sessionAssemblies];
+            },
+        };
+    })
+        .views(self => ({
+        /**
+         * #getter
+         * names of the assemblies returned by the `assemblies` getter
+         */
+        get assemblyNames() {
+            return self.assemblies.map(a => readConfObject(a, 'name'));
+        },
+    }));
+}

package/esm/Assemblies/index.d.ts

@@ -1,2 +1 @@
-export * from './SessionAssembliesMixin.ts';
-export * from './TemporaryAssembliesMixin.ts';
+export { AssembliesMixin } from './AssembliesMixin.ts';

package/esm/Assemblies/index.js

@@ -1,2 +1 @@
-export * from "./SessionAssembliesMixin.js";
-export * from "./TemporaryAssembliesMixin.js";
+export { AssembliesMixin } from './AssembliesMixin.js';

package/esm/HistoryManagement/index.d.ts

@@ -1,4 +1,23 @@
+/**
+ * Whether the user is typing into something with an undo stack of its own.
+ *
+ * Session undo must not steal the text editor's. The keydown listener below is
+ * on `document`, so it sees ctrl+z no matter what has focus — including the
+ * multiline TextFields the config editor, the jexl/JSON monospace field, and
+ * the paste-config workflows are built from. Those render a `<textarea>`, not
+ * an `<input>`, so an INPUT-only check let a keystroke meant to undo typing
+ * roll back the whole session instead.
+ */
+export declare function isTextEntryFocused(): boolean;
+/**
+ * #stateModel HistoryManagementMixin
+ * #category root
+ */
 export declare function HistoryManagementMixin(): import("@jbrowse/mobx-state-tree").IModelType<{
+    /**
+     * #property
+     * used for undo/redo
+     */
     history: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").IModelType<{
         undoIdx: import("@jbrowse/mobx-state-tree").IType<number | undefined, number, number>;
         targetPath: import("@jbrowse/mobx-state-tree").IType<string | undefined, string, string>;

package/esm/HistoryManagement/index.js

@@ -1,24 +1,57 @@
 import TimeTraveller from '@jbrowse/core/util/TimeTraveller';
 import { addDisposer, types } from '@jbrowse/mobx-state-tree';
+import { asRoot } from '@jbrowse/product-core';
 import { autorun } from 'mobx';
+/**
+ * Whether the user is typing into something with an undo stack of its own.
+ *
+ * Session undo must not steal the text editor's. The keydown listener below is
+ * on `document`, so it sees ctrl+z no matter what has focus — including the
+ * multiline TextFields the config editor, the jexl/JSON monospace field, and
+ * the paste-config workflows are built from. Those render a `<textarea>`, not
+ * an `<input>`, so an INPUT-only check let a keystroke meant to undo typing
+ * roll back the whole session instead.
+ */
+export function isTextEntryFocused() {
+    const el = document.activeElement;
+    if (!(el instanceof HTMLElement)) {
+        return false;
+    }
+    const tag = el.tagName.toUpperCase();
+    // coerced: isContentEditable is declared boolean but is undefined in jsdom,
+    // so the raw expression returns undefined for an ordinary focused element
+    return tag === 'INPUT' || tag === 'TEXTAREA' || !!el.isContentEditable;
+}
+/**
+ * #stateModel HistoryManagementMixin
+ * #category root
+ */
 export function HistoryManagementMixin() {
     return types
         .model({
+        /**
+         * #property
+         * used for undo/redo
+         */
         history: types.optional(TimeTraveller, { targetPath: '../session' }),
     })
         .actions(self => {
         const keydownListener = (e) => {
+            if (isTextEntryFocused()) {
+                return;
+            }
             if (self.history.canRedo &&
+                // ctrl+shift+z or cmd+shift+z
                 (((e.ctrlKey || e.metaKey) && e.shiftKey && e.code === 'KeyZ') ||
-                    (e.ctrlKey && !e.shiftKey && e.code === 'KeyY')) &&
-                document.activeElement?.tagName.toUpperCase() !== 'INPUT') {
+                    // ctrl+y
+                    (e.ctrlKey && !e.shiftKey && e.code === 'KeyY'))) {
                 self.history.redo();
             }
             if (self.history.canUndo &&
+                // ctrl+z or cmd+z
                 (e.ctrlKey || e.metaKey) &&
                 !e.shiftKey &&
-                e.code === 'KeyZ' &&
-                document.activeElement?.tagName.toUpperCase() !== 'INPUT') {
+                e.code === 'KeyZ') {
                 self.history.undo();
             }
         };
@@ -26,8 +59,12 @@ export function HistoryManagementMixin() {
             afterCreate() {
                 document.addEventListener('keydown', keydownListener);
                 addDisposer(self, autorun(function historyInitAutorun() {
-                    const { session } = self;
+                    const { session } = asRoot(self);
                     if (session) {
+                        // we use a specific initialization routine after session is
+                        // created to get it to start tracking itself sort of related
+                        // issue here
+                        // https://github.com/mobxjs/mobx-state-tree/issues/1089#issuecomment-441207911
                         self.history.initialize();
                     }
                 }, { name: 'HistoryInit' }));