@jbrowse/plugin-linear-genome-view/esm/searchUtils.js

JBrowse 2 linear genome view

import BaseResult from '@jbrowse/core/TextSearch/BaseResults';
import { dedupe, getEnv, getSession } from '@jbrowse/core/util';
export async function navToOption({ option, model, assemblyName, }) {
    const location = option.getLocation();
    const trackId = option.getTrackId();
    if (location) {
        await model.navToLocString(location, assemblyName, 0.2);
        if (trackId) {
            model.showTrack(trackId);
        }
    }
    const session = getSession(model);
    const { pluginManager } = getEnv(session);
    await pluginManager.evaluateAsyncExtensionPoint('LinearGenomeView-searchResultSelected', undefined, { session, result: option, model, assemblyName });
}
export async function handleSelectedRegion({ input, model, assembly, }) {
    const allRefs = assembly.allRefNamesWithLowerCase || [];
    const assemblyName = assembly.name;
    if (input.split(' ').every(entry => checkRef(entry, allRefs))) {
        await model.navToLocString(input, assembly.name);
    }
    else {
        const searchScope = model.searchScope(assemblyName);
        const { textSearchManager } = getSession(model);
        const results = await fetchResults({
            queryString: input,
            searchType: 'exact',
            searchScope,
            rankSearchResults: model.rankSearchResults,
            textSearchManager,
            assembly,
        });
        if (results.length > 1) {
            model.setSearchResults(results, input.toLowerCase(), assemblyName);
        }
        else if (results.length === 1) {
            await navToOption({
                option: results[0],
                model,
                assemblyName,
            });
        }
        else {
            await model.navToLocString(input, assemblyName);
        }
    }
}
export function checkRef(str, allRefs) {
    const [ref, rest] = splitLast(str, ':');
    return (allRefs.includes(str) ||
        (allRefs.includes(ref) && !Number.isNaN(Number.parseInt(rest, 10))));
}
export async function fetchResults({ queryString, searchType, searchScope, rankSearchResults, textSearchManager, assembly, }) {
    if (!textSearchManager) {
        console.warn('No text search manager');
    }
    const textSearchResults = await textSearchManager?.search({
        queryString,
        searchType,
    }, searchScope, rankSearchResults);
    const refNameResults = [
        ...new Set(assembly?.allRefNames
            ?.filter(ref => ref.toLowerCase().startsWith(queryString.toLowerCase()))
            .map(ref => assembly.getCanonicalRefName(ref) ?? ref)
            .slice(0, 10)),
    ].map(r => new BaseResult({ label: r, matchedObject: { refName: r } }));
    return dedupe([...refNameResults, ...(textSearchResults ?? [])], elt => elt.getId());
}
export function splitLast(str, split) {
    const lastIndex = str.lastIndexOf(split);
    if (lastIndex === -1) {
        return [str, ''];
    }
    const before = str.slice(0, lastIndex);
    const after = str.slice(lastIndex + 1);
    return [before, after];
}