@jbrowse/plugin-legacy-jbrowse 4.3.0 → 5.0.0-beta.1

package/esm/JBrowse1Connection/model.js

@@ -1,8 +1,13 @@
 import { ConfigurationReference, getConf } from '@jbrowse/core/configuration';
 import { BaseConnectionModelFactory } from '@jbrowse/core/pluggableElementTypes/models';
 import { getSession } from '@jbrowse/core/util';
-import { types } from '@jbrowse/mobx-state-tree';
-import configSchema from "./configSchema.js";
+import { isAlive, types } from '@jbrowse/mobx-state-tree';
+import configSchema from './configSchema.js';
+/**
+ * #stateModel JBrowse1Connection
+ * Connection that imports tracks from a legacy JBrowse 1 data directory,
+ * composed on the base connection model.
+ */
 export default function stateModelFactory(pluginManager) {
     return types
         .compose('JBrowse1Connection', BaseConnectionModelFactory(pluginManager), types.model({
@@ -14,18 +19,27 @@ export default function stateModelFactory(pluginManager) {
             const session = getSession(self);
             try {
                 const dataDirLocation = getConf(self, 'dataDirLocation');
-                const { fetchJb1 } = await import("./jb1ConfigLoad.js");
-                const { convertTrackConfig } = await import("./jb1ToJb2.js");
+                const { fetchJb1 } = await import('./jb1ConfigLoad.js');
+                const { convertTrackConfig } = await import('./jb1ToJb2.js');
                 const config = await fetchJb1(dataDirLocation);
                 const assemblyName = getConf(self, 'assemblyNames')[0];
                 if (!assemblyName) {
                     throw new Error('assembly name required for JBrowse 1 connection');
                 }
-                const jb2Tracks = config.tracks?.map(jb1Track => ({
-                    ...convertTrackConfig(jb1Track, config.dataRoot || ''),
-                    assemblyNames: [assemblyName],
-                }));
-                self.setTrackConfs(jb2Tracks);
+                // a JBrowse 1 sequence store describes the assembly, which the
+                // connection is given rather than supplying. Its ReferenceSequenceTrack
+                // schema declares neither assemblyNames nor category, so passing one
+                // through would stamp two slots JBrowse ignores onto a second copy of
+                // a sequence the assembly already has
+                const jb2Tracks = config.tracks
+                    .map(jb1Track => convertTrackConfig(jb1Track, config.dataRoot || ''))
+                    .filter(conf => conf.type !== 'ReferenceSequenceTrack')
+                    .map(conf => ({ ...conf, assemblyNames: [assemblyName] }));
+                // the node can be destroyed during the awaits above (e.g. a React
+                // StrictMode double-mount disposes the first rootModel)
+                if (isAlive(self)) {
+                    self.setTrackConfs(jb2Tracks);
+                }
             }
             catch (error) {
                 console.error(error);

package/esm/JBrowse1Connection/set-value.d.ts

@@ -0,0 +1 @@
+export default function setValue(target: Record<string, unknown>, path: string, value: unknown): void;

package/esm/JBrowse1Connection/set-value.js

@@ -0,0 +1,14 @@
+// minimal nested setter, replaces the `set-value` dependency. Splits the dot
+// path and creates intermediate objects as needed, mirroring ./get-value.ts
+export default function setValue(target, path, value) {
+    const segs = path.split('.');
+    const last = segs.pop();
+    let obj = target;
+    for (const seg of segs) {
+        if (typeof obj[seg] !== 'object' || obj[seg] === null) {
+            obj[seg] = {};
+        }
+        obj = obj[seg];
+    }
+    obj[last] = value;
+}

package/esm/JBrowse1Connection/types.d.ts

@@ -1,16 +1,11 @@
 export interface ProtoTrack {
-    backendVersion?: number;
-    baseUrl?: string;
+    [key: string]: unknown;
     category?: string;
-    config?: Track;
-    dataRoot?: string;
+    config?: ProtoTrack;
     features?: Feature[];
-    histograms?: Track;
-    index?: number;
     key?: string;
     label?: string;
     metadata?: Metadata;
-    store?: Store | string;
     storeClass?: string;
     type?: string;
     urlTemplate?: string;
@@ -20,7 +15,6 @@ export interface ProtoTrack {
     csiUrlTemplate?: string;
     faiUrlTemplate?: string;
     gziUrlTemplate?: string;
-    useAsRefSeqStore?: boolean;
 }
 export interface Track extends ProtoTrack {
     label: string;
@@ -36,56 +30,9 @@ export interface Feature {
     end: number;
     name?: string;
 }
-export interface Source {
-    url: string;
-    name?: string;
-    type?: string;
-}
-export interface TrackMetadata {
-    sources?: string | Source | (string | Source)[] | Record<string, Source>;
-}
-export interface Store extends ProtoTrack {
-    name?: string;
-}
-export interface Names {
-    baseUrl?: string;
-}
-export interface RefSeq {
-    name: string;
-    length: number;
-    end: number;
-    start: number;
-}
-export interface RefSeqs {
-    url?: string;
-    data?: RefSeq[];
-}
-export interface Include {
-    url: string;
-    cacheBuster?: boolean;
-    format?: string;
-    version?: number;
-}
 export interface Config {
-    baseUrl?: string;
-    cacheBuster?: boolean;
+    [key: string]: unknown;
     dataRoot?: string;
-    include?: string[];
-    names?: Record<string, string>;
-    nameUrl?: string;
-    refSeqs?: string | RefSeqs;
-    sourceUrl?: string;
-    stores?: Record<string, Store>;
-    trackMetadata?: TrackMetadata;
+    include?: string | string[];
     tracks?: Track | Track[] | Record<string, Track | ProtoTrack>;
 }
-export interface UriLocation {
-    uri: string;
-    baseUri?: string;
-    locationType: 'UriLocation';
-}
-export interface LocalPathLocation {
-    localPath: string;
-    locationType: 'LocalPathLocation';
-}
-export type JBLocation = UriLocation | LocalPathLocation;

package/esm/JBrowse1Connection/util.d.ts

@@ -1,8 +1,13 @@
-import type { Source, Track } from './types.ts';
-export declare function isTrack(arg: any): arg is Track;
-export declare function isSource(arg: any): arg is Source;
-type Obj = Record<string, any>;
-export declare function deepUpdate(a: Obj, b: Obj): Obj;
-export declare function fillTemplate(template: string, fillWith: Obj): string;
-export declare function structuredClone(src: any): any;
-export {};
+import type { Track } from './types.ts';
+export declare function isTrack(arg: unknown): arg is Track;
+/**
+ * replace variables in a template string with values
+ *
+ * @param template - String with variable names in curly brackets
+ * e.g., `http://foo/{bar}?arg={baz.foo}`
+ * @param fillWith - object with attribute-value mappings
+ * e.g., `{ 'bar': 'someurl', 'baz': { 'foo': 42 } }`
+ * @returns the template string with variables in fillWith replaced
+ * e.g., 'htp://foo/someurl?arg=valueforbaz'
+ */
+export declare function fillTemplate(template: string, fillWith: Record<string, unknown>): string;

package/esm/JBrowse1Connection/util.js

@@ -1,86 +1,21 @@
-import getValue from "./get-value.js";
+import getValue from './get-value.js';
 export function isTrack(arg) {
-    return arg?.label && typeof arg.label === 'string';
-}
-export function isSource(arg) {
-    return arg?.url && typeof arg.url === 'string';
-}
-export function deepUpdate(a, b) {
-    for (const prop of Object.keys(b)) {
-        if (prop === '__proto__' ||
-            prop === 'constructor' ||
-            prop === 'prototype') {
-            continue;
-        }
-        if (prop in a &&
-            typeof b[prop] === 'object' &&
-            typeof a[prop] === 'object') {
-            deepUpdate(a[prop], b[prop]);
-        }
-        else if (a[prop] === undefined || b[prop] !== undefined) {
-            a[prop] = b[prop];
-        }
-    }
-    return a;
+    const a = arg;
+    return !!a?.label && typeof a.label === 'string';
 }
+/**
+ * replace variables in a template string with values
+ *
+ * @param template - String with variable names in curly brackets
+ * e.g., `http://foo/{bar}?arg={baz.foo}`
+ * @param fillWith - object with attribute-value mappings
+ * e.g., `{ 'bar': 'someurl', 'baz': { 'foo': 42 } }`
+ * @returns the template string with variables in fillWith replaced
+ * e.g., 'htp://foo/someurl?arg=valueforbaz'
+ */
 export function fillTemplate(template, fillWith) {
     return template.replaceAll(/{([\s\w.]+)}/g, (match, varName) => {
-        varName = varName.replaceAll(/\s+/g, '');
-        const fill = getValue(fillWith, varName);
-        if (fill !== undefined) {
-            return typeof fill === 'function' ? fill(varName) : fill;
-        }
-        if (fillWith.callback) {
-            const v = fillWith.callback.call(this, varName);
-            if (v !== undefined) {
-                return v;
-            }
-        }
-        return match;
+        const fill = getValue(fillWith, varName.replaceAll(/\s+/g, ''));
+        return fill === undefined ? match : `${fill}`;
     });
 }
-export function structuredClone(src) {
-    if (!src ||
-        typeof src !== 'object' ||
-        Object.prototype.toString.call(src) === '[object Function]') {
-        return src;
-    }
-    if (src.nodeType && 'cloneNode' in src) {
-        return src.cloneNode(true);
-    }
-    if (src instanceof Date) {
-        return new Date(src);
-    }
-    if (src instanceof RegExp) {
-        return new RegExp(src);
-    }
-    let r;
-    if (Array.isArray(src)) {
-        r = [];
-        for (let i = 0, l = src.length; i < l; ++i) {
-            if (i in src) {
-                r[i] = structuredClone(src[i]);
-            }
-        }
-    }
-    else {
-        r = src.constructor ? new src.constructor() : {};
-    }
-    return mixin(r, src, a => structuredClone(a));
-}
-function mixin(dest, source, copyFunc) {
-    const empty = {};
-    for (const name in source) {
-        if (name === '__proto__' ||
-            name === 'constructor' ||
-            name === 'prototype') {
-            continue;
-        }
-        const s = source[name];
-        if (!(name in dest) ||
-            (dest[name] !== s && (!(name in empty) || empty[name] !== s))) {
-            dest[name] = copyFunc ? copyFunc(s) : s;
-        }
-    }
-    return dest;
-}

package/esm/JBrowse1TextSearchAdapter/HttpMap.d.ts

@@ -1,19 +1,46 @@
+/**
+ * Helper class allows reading names index generated in JBrowse1
+ * Adapted from https://github.com/GMOD/jbrowse/blob/master/src/JBrowse/Store/Hash.js
+ */
+interface Meta {
+    hashHexCharacters: number;
+    compress: number;
+    tracks: string[];
+}
 export default class HttpMap {
     url: string;
+    private metaPromise;
     constructor(args: {
         url: string;
     });
-    readMeta(): Promise<{
-        hashHexCharacters: number;
-        compress: any;
-        tracks: any;
-    }>;
+    /**
+     * loads meta.json file from names directory and reads number of hash_bits used
+     */
+    readMeta(): Promise<Meta>;
     getHashHexCharacters(): Promise<number>;
-    getCompress(): Promise<any>;
-    getTrackNames(): Promise<any>;
+    getCompress(): Promise<number>;
+    getTrackNames(): Promise<string[]>;
+    /**
+     * Returns contents of a bucket given a key
+     * @param key - string
+     */
     get(key: string): Promise<any>;
+    /**
+     * Returns a bucket given a key
+     * @param key - string
+     */
     getBucket(key: string): Promise<any>;
+    /**
+     * Loads a file using the url and provided id.
+     * Returns response object with contents of the file
+     * @param id - string
+     */
     loadFile(id: string): Promise<any>;
+    /**
+     * Returns the corresponding path of the file given a hex string
+     * @param hex - hex string
+     */
     hexToDirPath(hex: string): Promise<string>;
     hash(data: string): string;
 }
+export {};

package/esm/JBrowse1TextSearchAdapter/HttpMap.js

@@ -1,3 +1,7 @@
+/**
+ * Helper class allows reading names index generated in JBrowse1
+ * Adapted from https://github.com/GMOD/jbrowse/blob/master/src/JBrowse/Store/Hash.js
+ */
 const crcTable = new Uint32Array(256);
 for (let i = 0; i < 256; i++) {
     let c = i;
@@ -15,36 +19,54 @@ function crc32(str) {
 }
 export default class HttpMap {
     url;
+    metaPromise;
     constructor(args) {
         this.url = args.url.endsWith('/') ? args.url : `${args.url}/`;
     }
+    /**
+     * loads meta.json file from names directory and reads number of hash_bits used
+     */
     async readMeta() {
-        const meta = await this.loadFile('meta.json');
-        const { compress, track_names: tracks } = meta;
-        const hashHexCharacters = Math.ceil(meta.hash_bits / 4);
-        return { hashHexCharacters, compress, tracks };
+        if (!this.metaPromise) {
+            this.metaPromise = this.loadFile('meta.json').then(meta => ({
+                hashHexCharacters: Math.ceil(meta.hash_bits / 4),
+                compress: meta.compress,
+                tracks: meta.track_names,
+            }));
+        }
+        return this.metaPromise;
     }
     async getHashHexCharacters() {
-        const meta = await this.readMeta();
-        return meta.hashHexCharacters;
+        return (await this.readMeta()).hashHexCharacters;
     }
     async getCompress() {
-        const meta = await this.readMeta();
-        return meta.compress;
+        return (await this.readMeta()).compress;
     }
     async getTrackNames() {
-        const meta = await this.readMeta();
-        return meta.tracks;
+        return (await this.readMeta()).tracks;
     }
+    /**
+     * Returns contents of a bucket given a key
+     * @param key - string
+     */
     async get(key) {
         const bucket = await this.getBucket(key);
         return bucket[key];
     }
+    /**
+     * Returns a bucket given a key
+     * @param key - string
+     */
     async getBucket(key) {
         const bucketIdent = this.hash(key);
         const hexToDirPath = await this.hexToDirPath(bucketIdent);
         return this.loadFile(hexToDirPath);
     }
+    /**
+     * Loads a file using the url and provided id.
+     * Returns response object with contents of the file
+     * @param id - string
+     */
     async loadFile(id) {
         const response = await fetch(`${this.url}${id}`);
         if (!response.ok) {
@@ -52,23 +74,26 @@ export default class HttpMap {
         }
         return response.json();
     }
+    /**
+     * Returns the corresponding path of the file given a hex string
+     * @param hex - hex string
+     */
     async hexToDirPath(hex) {
-        const hashHexCharacters = await this.getHashHexCharacters();
-        if (hashHexCharacters) {
-            const compress = await this.getCompress();
-            while (hex.length < 8) {
-                hex = `0${hex}`;
-            }
-            hex = hex.slice(8 - hashHexCharacters);
-            const dirpath = [];
-            for (let i = 0; i < hex.length; i += 3) {
-                dirpath.push(hex.slice(i, i + 3));
-            }
-            return `${dirpath.join('/')}.json${compress ? 'z' : ''}`;
+        const { hashHexCharacters, compress } = await this.readMeta();
+        if (!hashHexCharacters) {
+            return '';
+        }
+        while (hex.length < 8) {
+            hex = `0${hex}`;
+        }
+        hex = hex.slice(8 - hashHexCharacters);
+        const dirpath = [];
+        for (let i = 0; i < hex.length; i += 3) {
+            dirpath.push(hex.slice(i, i + 3));
         }
-        return '';
+        return `${dirpath.join('/')}.json${compress ? 'z' : ''}`;
     }
     hash(data) {
-        return crc32(data).toString(16).toLowerCase().replace('-', 'n');
+        return crc32(data).toString(16).toLowerCase();
     }
 }

package/esm/JBrowse1TextSearchAdapter/JBrowse1TextSearchAdapter.d.ts

@@ -5,22 +5,22 @@ import type PluginManager from '@jbrowse/core/PluginManager';
 import type { AnyConfigurationModel } from '@jbrowse/core/configuration';
 import type { BaseTextSearchAdapter, BaseTextSearchArgs } from '@jbrowse/core/data_adapters/BaseAdapter';
 import type { getSubAdapterType } from '@jbrowse/core/data_adapters/dataAdapterCache';
-export interface TooManyHits {
-    name: string;
-    hitLimit: number;
-}
 interface SearchResults {
     prefix: ({
         name: string;
     } | string)[];
     exact: [string, number, string, string, number, number][];
 }
-export type NamesIndexRecord = string | (string | number)[];
 type IndexFile = Record<string, SearchResults>;
 export default class JBrowse1TextSearchAdapter extends BaseAdapter implements BaseTextSearchAdapter {
     httpMap: HttpMap;
     tracksNames?: string[];
     constructor(config: AnyConfigurationModel, getSubAdapter?: getSubAdapterType, pluginManager?: PluginManager);
+    /**
+     * Returns the contents of the file containing the query if it exists
+     * else it returns empty
+     * @param query - string query
+     */
     loadIndexFile(query: string): Promise<IndexFile>;
     searchIndex(args: BaseTextSearchArgs): Promise<BaseResult[]>;
     formatResults(results: SearchResults, tracks: string[], searchType?: string): BaseResult[];

package/esm/JBrowse1TextSearchAdapter/JBrowse1TextSearchAdapter.js

@@ -1,7 +1,8 @@
 import BaseResult from '@jbrowse/core/TextSearch/BaseResults';
 import { readConfObject } from '@jbrowse/core/configuration';
 import { BaseAdapter } from '@jbrowse/core/data_adapters/BaseAdapter';
-import HttpMap from "./HttpMap.js";
+import HttpMap from './HttpMap.js';
+// Uses index built by generate-names.pl
 export default class JBrowse1TextSearchAdapter extends BaseAdapter {
     httpMap;
     tracksNames;
@@ -13,17 +14,21 @@ export default class JBrowse1TextSearchAdapter extends BaseAdapter {
             url: baseUri ? new URL(uri, baseUri).href : uri,
         });
     }
+    /**
+     * Returns the contents of the file containing the query if it exists
+     * else it returns empty
+     * @param query - string query
+     */
     async loadIndexFile(query) {
         return this.httpMap.getBucket(query);
     }
     async searchIndex(args) {
         const { searchType, queryString } = args;
-        const tracks = this.tracksNames || (await this.httpMap.getTrackNames());
+        const tracks = this.tracksNames ?? (await this.httpMap.getTrackNames());
         const str = queryString.toLowerCase();
         const entries = await this.loadIndexFile(str);
-        return entries[str]
-            ? this.formatResults(entries[str], tracks, searchType)
-            : [];
+        const results = entries[str];
+        return results ? this.formatResults(results, tracks, searchType) : [];
     }
     formatResults(results, tracks, searchType) {
         return [
@@ -31,24 +36,18 @@ export default class JBrowse1TextSearchAdapter extends BaseAdapter {
                 ? []
                 : results.prefix.map(result => new BaseResult({
                     label: typeof result === 'object' ? result.name : result,
-                    matchedAttribute: 'name',
-                    matchedObject: { result: result },
                 }))),
-            ...results.exact.map(result => {
-                const name = result[0];
-                const trackIndex = result[1];
-                const refName = result[3];
-                const start = result[4];
-                const end = result[5];
-                const locstring = `${refName || name}:${start}-${end}`;
-                return new BaseResult({
-                    locString: locstring,
-                    label: name,
-                    matchedAttribute: 'name',
-                    matchedObject: result,
-                    trackId: tracks[trackIndex],
-                });
-            }),
+            // the bucket is keyed by the query, so everything in its `exact` list
+            // matched it exactly — which is what lets a caller ask once rather than
+            // asking for exact hits and then for all of them
+            ...results.exact.map(([name, trackIndex, , refName, start, end]) => new BaseResult({
+                locString: `${refName || name}:${start}-${end}`,
+                label: name,
+                trackId: tracks[trackIndex],
+                exact: true,
+            })),
+            // the index encodes an overflow bucket as a pseudo-hit; it is a message,
+            // not a navigable location
         ].filter(result => result.getLabel() !== 'too many matches');
     }
 }

package/esm/JBrowse1TextSearchAdapter/configSchema.d.ts

@@ -1,21 +1,49 @@
+/**
+ * #config JBrowse1TextSearchAdapter
+ * #trackType TextSearchAdapter
+ * #fileFormat textsearch | JBrowse 1 names index | From JBrowse 1 `generate-names.pl`
+ * note: metadata about tracks and assemblies covered by text search adapter
+ *
+ * #example
+ * An entry in `aggregateTextSearchAdapters`, pointing at the `names/`
+ * directory JBrowse 1's `generate-names.pl` wrote — so an existing instance's
+ * search index is reused rather than rebuilt with `jbrowse text-index`:
+ * ```js
+ * {
+ *   type: 'JBrowse1TextSearchAdapter',
+ *   textSearchAdapterId: 'jbrowse1-names',
+ *   namesIndexLocation: { uri: 'https://example.com/jbrowse1/data/names/' },
+ *   assemblyNames: ['hg19'],
+ * }
+ * ```
+ */
 declare const _default: import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
-    namesIndexLocation: {
-        type: string;
-        defaultValue: {
-            uri: string;
-            locationType: string;
+    /**
+     * #slot
+     */
+    readonly namesIndexLocation: {
+        readonly type: "fileLocation";
+        readonly defaultValue: {
+            readonly uri: "/volvox/names";
+            readonly locationType: "UriLocation";
         };
-        description: string;
+        readonly description: "the location of the JBrowse1 names index data directory";
     };
-    tracks: {
-        type: string;
-        defaultValue: never[];
-        description: string;
+    /**
+     * #slot
+     */
+    readonly tracks: {
+        readonly type: "stringArray";
+        readonly defaultValue: readonly [];
+        readonly description: "List of tracks covered by text search adapter";
     };
-    assemblyNames: {
-        type: string;
-        defaultValue: never[];
-        description: string;
+    /**
+     * #slot
+     */
+    readonly assemblyNames: {
+        readonly type: "stringArray";
+        readonly defaultValue: readonly [];
+        readonly description: "List of assemblies covered by text search adapter";
     };
 }, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, "textSearchAdapterId">>;
 export default _default;

package/esm/JBrowse1TextSearchAdapter/configSchema.js

@@ -1,16 +1,43 @@
 import { ConfigurationSchema } from '@jbrowse/core/configuration';
-function x() { }
+/**
+ * #config JBrowse1TextSearchAdapter
+ * #trackType TextSearchAdapter
+ * #fileFormat textsearch | JBrowse 1 names index | From JBrowse 1 `generate-names.pl`
+ * note: metadata about tracks and assemblies covered by text search adapter
+ *
+ * #example
+ * An entry in `aggregateTextSearchAdapters`, pointing at the `names/`
+ * directory JBrowse 1's `generate-names.pl` wrote — so an existing instance's
+ * search index is reused rather than rebuilt with `jbrowse text-index`:
+ * ```js
+ * {
+ *   type: 'JBrowse1TextSearchAdapter',
+ *   textSearchAdapterId: 'jbrowse1-names',
+ *   namesIndexLocation: { uri: 'https://example.com/jbrowse1/data/names/' },
+ *   assemblyNames: ['hg19'],
+ * }
+ * ```
+ */
 export default ConfigurationSchema('JBrowse1TextSearchAdapter', {
+    /**
+     * #slot
+     */
     namesIndexLocation: {
         type: 'fileLocation',
         defaultValue: { uri: '/volvox/names', locationType: 'UriLocation' },
         description: 'the location of the JBrowse1 names index data directory',
     },
+    /**
+     * #slot
+     */
     tracks: {
         type: 'stringArray',
         defaultValue: [],
         description: 'List of tracks covered by text search adapter',
     },
+    /**
+     * #slot
+     */
     assemblyNames: {
         type: 'stringArray',
         defaultValue: [],
@@ -18,5 +45,8 @@ export default ConfigurationSchema('JBrowse1TextSearchAdapter', {
     },
 }, {
     explicitlyTyped: true,
+    /**
+     * #identifier
+     */
     explicitIdentifier: 'textSearchAdapterId',
 });