@jbrowse/core 4.2.1 → 5.0.0-beta.1

package/esm/util/fetchSeq.d.ts

@@ -1,8 +1,12 @@
+import type { StatusCallback } from './progress.ts';
+import type { StopToken } from './stopToken.ts';
 import type { AbstractSessionModel } from './types/index.ts';
-export declare function fetchSeq({ start, end, refName, assemblyName, session, }: {
+export declare function fetchSeq({ start, end, refName, assemblyName, session, stopToken, statusCallback, }: {
     start: number;
     end: number;
     refName: string;
     assemblyName: string;
     session: AbstractSessionModel;
+    stopToken?: StopToken;
+    statusCallback?: StatusCallback;
 }): Promise<string>;

package/esm/util/fetchSeq.js

@@ -1,23 +1,35 @@
-import { getConf } from "../configuration/index.js";
-export async function fetchSeq({ start, end, refName, assemblyName, session, }) {
+import { getSequenceAdapterConfig } from '../assemblyManager/getSequenceAdapterConfig.js';
+export async function fetchSeq({ start, end, refName, assemblyName, session, stopToken, statusCallback, }) {
     const { rpcManager, assemblyManager } = session;
     const assembly = await assemblyManager.waitForAssembly(assemblyName);
     if (!assembly) {
         throw new Error('assembly not found');
     }
     const sessionId = 'getSequence';
-    const adapterConfig = getConf(assembly, ['sequence', 'adapter']);
+    // Undefined here means the assembly's `configuration` safeReference is
+    // unresolved — the assembly outlived the config entry it points at. NOT an
+    // assembly whose sequence carries no residues: a ChromSizesAdapter one still
+    // has a `sequence.adapter`, and fails later, inside the adapter. Say which
+    // this is; passing the undefined on fails in getAdapterPre as "could not
+    // determine adapter type", naming neither the assembly nor what was wanted.
+    const adapterConfig = getSequenceAdapterConfig(assembly);
+    if (!adapterConfig) {
+        throw new Error(`assembly ${assemblyName} has no resolved configuration, so its sequence adapter cannot be read`);
+    }
+    // Get the canonical refName, then translate to the sequence adapter refName
+    // (in FASTA). These may differ when refNameAliases override.
     const canonicalRefName = assembly.getCanonicalRefName2(refName);
     const seqAdapterRefName = assembly.getSeqAdapterRefName(canonicalRefName);
-    const seq = (await rpcManager.call(sessionId, 'CoreGetSequence', {
+    const seq = await rpcManager.call(sessionId, 'CoreGetSequence', {
         adapterConfig,
-        sessionId,
         region: {
             start,
             end,
             refName: seqAdapterRefName,
             assemblyName,
         },
-    }));
+        stopToken,
+        statusCallback,
+    });
     return seq ?? '';
 }

package/esm/util/fileHandleStore.d.ts

@@ -1,6 +1,23 @@
+declare global {
+    interface FileSystemFileHandle {
+        queryPermission(options: {
+            mode: 'read' | 'readwrite';
+        }): Promise<PermissionState>;
+        requestPermission(options: {
+            mode: 'read' | 'readwrite';
+        }): Promise<PermissionState>;
+    }
+}
 export declare function isFileSystemAccessSupported(): boolean;
+/**
+ * Which stored handles the pruner drops: everything past the
+ * MAX_STORED_HANDLES first-picked most recently.
+ *
+ * Split out and exported for the same reason staleSessionIds is — jsdom has no
+ * IndexedDB, so the transaction around it never runs under jest, and this is the
+ * one part of the decision that is testable at all.
+ */
+export declare function staleHandleIds(keys: string[]): string[];
 export declare function storeFileHandle(handle: FileSystemFileHandle): Promise<string>;
 export declare function getFileHandle(handleId: string): Promise<FileSystemFileHandle | undefined>;
-export declare function removeFileHandle(handleId: string): Promise<void>;
 export declare function verifyPermission(handle: FileSystemFileHandle, requestPermission?: boolean): Promise<boolean>;
-export declare function cleanupStaleHandles(maxAgeMs: number): Promise<void>;

package/esm/util/fileHandleStore.js

@@ -4,39 +4,113 @@ const DB_VERSION = 1;
 const STORE_NAME = 'handles';
 let dbPromise;
 function getDB() {
-    if (!dbPromise) {
-        dbPromise = openDB(DB_NAME, DB_VERSION, {
-            upgrade(db) {
-                if (!db.objectStoreNames.contains(STORE_NAME)) {
-                    db.createObjectStore(STORE_NAME);
-                }
-            },
-        });
-    }
+    dbPromise ??= openDB(DB_NAME, DB_VERSION, {
+        upgrade(db) {
+            db.createObjectStore(STORE_NAME);
+        },
+    }).catch((error) => {
+        // drop the rejected promise, so a transient open failure (a blocked
+        // upgrade, a storage prompt the user has since answered) doesn't make every
+        // later call replay the same error for the life of the page
+        dbPromise = undefined;
+        throw error;
+    });
     return dbPromise;
 }
 export function isFileSystemAccessSupported() {
     return typeof window !== 'undefined' && 'showOpenFilePicker' in window;
 }
 let counter = 0;
+/**
+ * Handles accumulated here forever: every pick wrote a row, nothing ever
+ * deleted one, and re-picking a file the session already had wrote a second row
+ * for the same file. Bounded the way the autosaved sessions are — keep the
+ * newest N, drop the rest.
+ *
+ * "Newest" is FIRST-picked, not last-used, and the two genuinely differ here.
+ * An id is minted once and then reused: `findStoredHandleId` hands the original
+ * id back on every re-pick, precisely so the row count tracks the number of
+ * distinct files rather than the number of times they were reopened. The id
+ * carries its mint time, so a file opened daily since January ages from
+ * January, and is evicted ahead of one picked once last week. That is the
+ * tradeoff and not an oversight: re-minting on re-pick would refresh the age
+ * but orphan every stored FileHandleLocation naming the old id, and pruning on
+ * true last-use would mean storing a timestamp beside the handle, which is a
+ * schema version bump for a store whose worst case is one re-pick.
+ *
+ * Losing an old handle costs a re-pick, which is the same thing that happens
+ * when the browser drops its permission, and never the data: a FileHandleLocation
+ * that cannot be resolved is reported by ensureFileHandleReady and offered back
+ * to the user through the restore banner.
+ */
+const MAX_STORED_HANDLES = 200;
+/**
+ * The `Date.now()` a `fh<ms>-<n>` id was minted at, or 0 for anything else.
+ * Minted at FIRST pick and never refreshed — see MAX_STORED_HANDLES for why
+ * this is the file's age rather than its last use.
+ */
+function handleIdTime(id) {
+    return +(/^fh(\d+)-/.exec(id)?.[1] ?? 0);
+}
+/**
+ * Which stored handles the pruner drops: everything past the
+ * MAX_STORED_HANDLES first-picked most recently.
+ *
+ * Split out and exported for the same reason staleSessionIds is — jsdom has no
+ * IndexedDB, so the transaction around it never runs under jest, and this is the
+ * one part of the decision that is testable at all.
+ */
+export function staleHandleIds(keys) {
+    return keys.length <= MAX_STORED_HANDLES
+        ? []
+        : [...keys]
+            .sort((a, b) => handleIdTime(b) - handleIdTime(a))
+            .slice(MAX_STORED_HANDLES);
+}
+async function pruneHandles(db) {
+    const stale = staleHandleIds(await db.getAllKeys(STORE_NAME));
+    if (!stale.length) {
+        return;
+    }
+    const tx = db.transaction(STORE_NAME, 'readwrite');
+    await Promise.all([...stale.map(k => tx.store.delete(k)), tx.done]);
+}
+/**
+ * The id an equivalent handle is already stored under, if there is one.
+ *
+ * Re-picking a file the session already holds is the common case — the restore
+ * banner asks for exactly that — and without this each re-pick minted a fresh
+ * id, so the row count grew with the number of times a user reopened the same
+ * files rather than with the number of files.
+ */
+async function findStoredHandleId(db, handle) {
+    // one transaction, so the keys and the values it indexes cannot come from two
+    // different states of the store. Both requests are issued before either is
+    // awaited, which is what keeps the transaction from closing between them.
+    const tx = db.transaction(STORE_NAME, 'readonly');
+    const [keys, stored] = await Promise.all([
+        tx.store.getAllKeys(),
+        tx.store.getAll(),
+    ]);
+    // settled per comparison rather than thrown: isSameEntry rejects for a handle
+    // the browser can no longer resolve, and one dead row must not stop the pick
+    const matches = await Promise.all(stored.map(s => handle.isSameEntry(s).catch(() => false)));
+    return keys[matches.indexOf(true)];
+}
 export async function storeFileHandle(handle) {
-    const handleId = `fh${Date.now()}-${counter++}`;
     const db = await getDB();
-    await db.put(STORE_NAME, {
-        handle,
-        name: handle.name,
-        createdAt: Date.now(),
-    }, handleId);
+    const existing = await findStoredHandleId(db, handle);
+    if (existing) {
+        return existing;
+    }
+    const handleId = `fh${Date.now()}-${counter++}`;
+    await db.put(STORE_NAME, handle, handleId);
+    await pruneHandles(db);
     return handleId;
 }
 export async function getFileHandle(handleId) {
     const db = await getDB();
-    const entry = await db.get(STORE_NAME, handleId);
-    return entry?.handle;
-}
-export async function removeFileHandle(handleId) {
-    const db = await getDB();
-    await db.delete(STORE_NAME, handleId);
+    return db.get(STORE_NAME, handleId);
 }
 export async function verifyPermission(handle, requestPermission = false) {
     const options = { mode: 'read' };
@@ -52,17 +126,3 @@ export async function verifyPermission(handle, requestPermission = false) {
     }
     return false;
 }
-export async function cleanupStaleHandles(maxAgeMs) {
-    const db = await getDB();
-    const now = Date.now();
-    const tx = db.transaction(STORE_NAME, 'readwrite');
-    const store = tx.objectStore(STORE_NAME);
-    let cursor = await store.openCursor();
-    while (cursor) {
-        if (now - cursor.value.createdAt > maxAgeMs) {
-            await cursor.delete();
-        }
-        cursor = await cursor.continue();
-    }
-    await tx.done;
-}

package/esm/util/flatbush/index.d.ts

@@ -1,11 +1,12 @@
 type TypedArrayConstructor = Int8ArrayConstructor | Uint8ArrayConstructor | Uint8ClampedArrayConstructor | Int16ArrayConstructor | Uint16ArrayConstructor | Int32ArrayConstructor | Uint32ArrayConstructor | Float32ArrayConstructor | Float64ArrayConstructor;
+type FilterFn = (index: number, x0: number, y0: number, x1: number, y1: number) => boolean;
 export default class Flatbush {
     numItems: number;
     nodeSize: number;
     byteOffset: number;
     ArrayType: TypedArrayConstructor;
     IndexArrayType: Uint16ArrayConstructor | Uint32ArrayConstructor;
-    data: ArrayBufferLike;
+    data: ArrayBuffer;
     minX: number;
     minY: number;
     maxX: number;
@@ -14,12 +15,32 @@ export default class Flatbush {
     private _boxes;
     private _indices;
     private _pos;
-    private _queue;
-    static from(data: ArrayBufferLike, byteOffset?: number): Flatbush;
-    constructor(numItems: number, nodeSize?: number, ArrayType?: TypedArrayConstructor, ArrayBufferType?: ArrayBufferConstructor | SharedArrayBufferConstructor, data?: ArrayBufferLike, byteOffset?: number);
+    /**
+     * Recreate a Flatbush index from raw `ArrayBuffer` data.
+     */
+    static from(data: ArrayBuffer, byteOffset?: number): Flatbush;
+    /**
+     * Create a Flatbush index that will hold a given number of items.
+     */
+    constructor(numItems: number, nodeSize?: number, ArrayType?: TypedArrayConstructor, ArrayBufferType?: ArrayBufferConstructor, data?: ArrayBuffer, byteOffset?: number);
+    /**
+     * Add a given rectangle to the index.
+     * @returns A zero-based, incremental number that represents the newly added rectangle.
+     */
     add(minX: number, minY: number, maxX?: number, maxY?: number): number;
+    /** Perform indexing of the added rectangles. */
     finish(): void;
-    search(minX: number, minY: number, maxX: number, maxY: number, filterFn?: (index: number, x0: number, y0: number, x1: number, y1: number) => boolean): number[];
-    neighbors(x: number, y: number, maxResults?: number, maxDistance?: number, filterFn?: (index: number) => boolean): number[];
+    /**
+     * Search the index by a bounding box.
+     * @param filterFn An optional function that is called on every found item; if supplied, only items for which this function returns true will be included in the results array.
+     * @returns An array of indices of items intersecting or touching the given bounding box.
+     */
+    search(minX: number, minY: number, maxX: number, maxY: number, filterFn?: FilterFn): number[];
+    /**
+     * Collect all leaves of a subtree that's fully inside the query, skipping intersection tests.
+     * Because the tree is packed bottom-up, those leaves occupy one contiguous block of the leaf
+     * level, so we skip traversal entirely: descend to the first leaf, then sweep the flat range.
+     */
+    private _collectContained;
 }
 export {};