jbrowse-plugin-protein3d 0.4.11 → 0.4.13

package/dist/ProteinView/model.js

@@ -4,11 +4,9 @@ import { addDisposer, types } from '@jbrowse/mobx-state-tree';
 import SettingsIcon from '@mui/icons-material/Settings';
 import Visibility from '@mui/icons-material/Visibility';
 import { autorun } from 'mobx';
-import { addStructureFromData } from './addStructureFromData';
-import { addStructureFromURL } from './addStructureFromURL';
 import { COLOR_SCHEMES, COLOR_SCHEME_VALUES, applyColorTheme, } from './applyColorTheme';
-import { extractPerResidueConfidence } from './extractPerResidueConfidence';
-import { extractStructureSequences } from './extractStructureSequences';
+import { loadStructureData } from './loadStructureData';
+import { makeStructureLoader } from './structureLoader';
 import Structure from './structureModel';
 import { superposeStructures } from './superposeStructures';
 import { DEFAULT_ALIGNMENT_ALGORITHM } from './types';
@@ -21,18 +19,6 @@ const PERSISTED_SETTINGS = [
     'autoScrollAlignment',
     'compactTracks',
 ];
-async function loadStructureData({ structure, plugin, }) {
-    const { model } = structure.data
-        ? await addStructureFromData({ data: structure.data, plugin })
-        : structure.url
-            ? await addStructureFromURL({ url: structure.url, plugin })
-            : { model: undefined };
-    const sequences = model ? extractStructureSequences(model) : undefined;
-    const confidence = model
-        ? extractPerResidueConfidence(model, sequences?.[0]?.length)
-        : undefined;
-    return { sequences, confidence };
-}
 /**
  * #stateModel Protein3dViewPlugin
  * extends
@@ -347,26 +333,10 @@ function stateModelFactory() {
                     });
                 }
             }));
-            addDisposer(self, autorun(async () => {
-                const { structures, molstarPluginContext } = self;
-                if (molstarPluginContext) {
-                    for (const structure of structures) {
-                        if (!structure.loadedToMolstar) {
-                            try {
-                                structure.setStructureData(await loadStructureData({
-                                    structure,
-                                    plugin: molstarPluginContext,
-                                }));
-                                structure.setLoadedToMolstar(true);
-                            }
-                            catch (e) {
-                                self.setError(e);
-                                console.error(e);
-                            }
-                        }
-                    }
-                }
-            }));
+            // Load structures into Molstar as they appear or whenever the plugin
+            // context changes. See makeStructureLoader for why the autorun body is
+            // synchronous and how it guards against duplicate/stale loads.
+            addDisposer(self, autorun(makeStructureLoader(self)));
         },
     }))
         .views(self => ({

package/dist/ProteinView/structureLoader.d.ts

@@ -0,0 +1,30 @@
+import type StructureModel from './structureModel';
+import type { IAnyStateTreeNode, Instance } from '@jbrowse/mobx-state-tree';
+import type { PluginContext } from 'molstar/lib/mol-plugin/context';
+type StructureInstance = Instance<typeof StructureModel>;
+export type StructureLoaderHost = IAnyStateTreeNode & {
+    readonly molstarPluginContext: PluginContext | undefined;
+    readonly structures: StructureInstance[];
+    setError: (error: unknown) => void;
+};
+/**
+ * Builds the body of the autorun that loads structures into Molstar.
+ *
+ * The returned callback is synchronous on purpose: MobX only tracks
+ * observables read before the first `await`, so an async autorun body would
+ * stop reacting to later structures/plugin changes. Instead it reads its
+ * dependencies synchronously and dispatches a guarded fire-and-forget load for
+ * each structure that is neither loaded nor already loading. The guards handle
+ * the lifecycle hazards of an external GPU resource:
+ *
+ *   - a non-observable in-flight Set stops a re-entrant run (a new structure
+ *     pushed, or the plugin swapped mid-load) from starting a duplicate load of
+ *     the same structure;
+ *   - a load whose plugin was replaced or whose model was destroyed while
+ *     awaiting has its result discarded rather than written into a torn-down
+ *     plugin;
+ *   - if the plugin was merely swapped (e.g. a view remount), the structure is
+ *     reloaded into the current plugin so it isn't left stranded unloaded.
+ */
+export declare function makeStructureLoader(host: StructureLoaderHost): () => void;
+export {};

package/dist/ProteinView/structureLoader.js

@@ -0,0 +1,58 @@
+import { isAlive } from '@jbrowse/mobx-state-tree';
+import { loadStructureData } from './loadStructureData';
+/**
+ * Builds the body of the autorun that loads structures into Molstar.
+ *
+ * The returned callback is synchronous on purpose: MobX only tracks
+ * observables read before the first `await`, so an async autorun body would
+ * stop reacting to later structures/plugin changes. Instead it reads its
+ * dependencies synchronously and dispatches a guarded fire-and-forget load for
+ * each structure that is neither loaded nor already loading. The guards handle
+ * the lifecycle hazards of an external GPU resource:
+ *
+ *   - a non-observable in-flight Set stops a re-entrant run (a new structure
+ *     pushed, or the plugin swapped mid-load) from starting a duplicate load of
+ *     the same structure;
+ *   - a load whose plugin was replaced or whose model was destroyed while
+ *     awaiting has its result discarded rather than written into a torn-down
+ *     plugin;
+ *   - if the plugin was merely swapped (e.g. a view remount), the structure is
+ *     reloaded into the current plugin so it isn't left stranded unloaded.
+ */
+export function makeStructureLoader(host) {
+    const loadingStructures = new Set();
+    function loadInto(structure, plugin) {
+        loadingStructures.add(structure);
+        loadStructureData({ structure, plugin })
+            .then(data => {
+            const current = isAlive(structure)
+                ? host.molstarPluginContext
+                : undefined;
+            if (current === plugin) {
+                structure.setStructureData(data);
+                structure.setLoadedToMolstar(true);
+            }
+            loadingStructures.delete(structure);
+            if (current && current !== plugin && !structure.loadedToMolstar) {
+                loadInto(structure, current);
+            }
+        })
+            .catch((e) => {
+            loadingStructures.delete(structure);
+            if (isAlive(host)) {
+                host.setError(e);
+                console.error(e);
+            }
+        });
+    }
+    return function loadPendingStructures() {
+        const { structures, molstarPluginContext } = host;
+        if (molstarPluginContext) {
+            for (const structure of structures) {
+                if (!structure.loadedToMolstar && !loadingStructures.has(structure)) {
+                    loadInto(structure, molstarPluginContext);
+                }
+            }
+        }
+    };
+}

package/dist/config.json

@@ -2,7 +2,7 @@
   "plugins": [
     {
       "name": "Protein3d",
-      "url": "https://unpkg.com/jbrowse-plugin-protein3d/dist/jbrowse-plugin-protein3d.umd.production.min.js"
+      "url": "https://jbrowse.org/plugins/jbrowse-plugin-protein3d/latest/dist/jbrowse-plugin-protein3d.umd.production.min.js"
     }
   ],
   "assemblies": [

package/dist/fetchUtils.d.ts

@@ -1,3 +1,3 @@
 export declare function myfetch(url: string, args?: RequestInit): Promise<Response>;
 export declare function jsonfetch<T = unknown>(url: string, args?: RequestInit): Promise<T>;
-export declare function timeout(time: number): Promise<unknown>;
+export declare function timeout(time: number, signal?: AbortSignal): Promise<void>;

package/dist/fetchUtils.js

@@ -9,6 +9,22 @@ export async function jsonfetch(url, args) {
     const response = await myfetch(url, args);
     return response.json();
 }
-export function timeout(time) {
-    return new Promise(res => setTimeout(res, time));
+function abortError(signal) {
+    return signal.reason instanceof Error
+        ? signal.reason
+        : new Error('Aborted', { cause: signal.reason });
+}
+export function timeout(time, signal) {
+    return new Promise((resolve, reject) => {
+        if (signal?.aborted) {
+            reject(abortError(signal));
+        }
+        else {
+            const id = setTimeout(resolve, time);
+            signal?.addEventListener('abort', () => {
+                clearTimeout(id);
+                reject(abortError(signal));
+            }, { once: true });
+        }
+    });
 }