@jbrowse/core 4.3.0 → 5.0.0-beta.1

package/esm/util/applyRowResizeWheel.js

@@ -0,0 +1,34 @@
+// shift+wheel resizes the sample rows (a vertical-zoom gesture) rather than
+// scrolling, keeping the row under the cursor pinned in place as the height
+// changes. Shared by every row-stack display — both variant displays and MAF —
+// so the gesture stays identical wherever rows have a resolved height and a
+// scroll offset. setScrollTop clamps to the new scrollableHeight, so the raw
+// target is passed through unclamped.
+import { normalizeWheelDelta } from './wheelZoom.js';
+const MAX_ROW_HEIGHT = 20;
+// px of row-height change per pixel of normalized wheel scroll. A mouse notch
+// (~100px) nudges the height ~0.4px; a trackpad's small continuous deltas
+// accumulate smoothly instead of the old sign-based ±1-per-event, which flew
+// through the whole range on a trackpad's event flood.
+const RESIZE_PX_PER_WHEEL_PX = 1 / 240;
+export function applyRowResizeWheel(e, el, model) {
+    e.preventDefault();
+    // scroll up (deltaY < 0) grows rows; proportional to the normalized delta so
+    // the speed is consistent across mice/trackpads and finer than ±1/event.
+    const delta = -normalizeWheelDelta(e.deltaY, e.deltaMode) * RESIZE_PX_PER_WHEEL_PX;
+    // guard nrow=0 (no samples) so the auto-fit floor stays finite
+    const minRowHeight = model.viewportHeight / Math.max(1, model.nrow);
+    // The cap may stop the gesture going further; it may never move the rows on
+    // its own. So both heights that can already sit above MAX_ROW_HEIGHT raise
+    // it: the auto-fit floor (few samples), and the current height (a pinned
+    // `rowHeight` — the config slot and the "Custom..." dialog are both
+    // unbounded, and MAF's own docs example is 12 while a bases-mode row wants
+    // more). Without the second, a 40px pinned row met `min(20, 40.4)` on the
+    // first notch of a *grow* gesture and halved.
+    const maxRowHeight = Math.max(MAX_ROW_HEIGHT, minRowHeight, model.effectiveRowHeight);
+    const newRowHeight = Math.max(minRowHeight, Math.min(maxRowHeight, model.effectiveRowHeight + delta));
+    const mouseY = e.clientY - el.getBoundingClientRect().top;
+    const rowUnderMouse = (mouseY + model.scrollTop) / model.effectiveRowHeight;
+    model.setRowHeight(newRowHeight);
+    model.setScrollTop(rowUnderMouse * newRowHeight - mouseY);
+}

package/esm/util/assemblyConfigUtils.d.ts

@@ -0,0 +1,144 @@
+import type { FileLocation } from './types/data.ts';
+export declare const adapterTypes: readonly ['IndexedFastaAdapter', 'BgzipFastaAdapter', 'FastaAdapter', 'TwoBitAdapter', 'ChromSizesAdapter'];
+export type AdapterType = (typeof adapterTypes)[number];
+export declare const adapterLabels: Record<AdapterType, string>;
+export declare function adapterHasSequence(adapterSelection: AdapterType): adapterSelection is "BgzipFastaAdapter" | "FastaAdapter" | "IndexedFastaAdapter" | "TwoBitAdapter";
+export interface FormState {
+    adapterSelection: AdapterType;
+    assemblyName: string;
+    assemblyDisplayName: string;
+    fastaLocation: FileLocation;
+    faiLocation: FileLocation;
+    gziLocation: FileLocation;
+    twoBitLocation: FileLocation;
+    chromSizesLocation: FileLocation;
+    refNameAliasesLocation: FileLocation;
+    cytobandsLocation: FileLocation;
+}
+export type LocationField = {
+    [K in keyof FormState]: FormState[K] extends FileLocation ? K : never;
+}[keyof FormState];
+export declare const sidecarRoles: readonly ['fai', 'gzi'];
+export type SidecarRole = (typeof sidecarRoles)[number];
+export declare const sidecars: {
+    readonly fai: {
+        readonly field: 'faiLocation';
+        readonly ext: '.fai';
+        readonly label: 'FASTA index (.fai) file';
+    };
+    readonly gzi: {
+        readonly field: 'gziLocation';
+        readonly ext: '.gzi';
+        readonly label: 'FASTA gzip index (.gzi) file';
+    };
+};
+export declare function makeSetField(setForm: (update: (prev: FormState) => FormState) => void): <K extends keyof FormState>(key: K) => (value: FormState[K]) => void;
+export declare function initialFormState(): FormState;
+export declare function applyPrimaryFile(state: FormState, location: FileLocation): FormState;
+export declare function applyTwoBitFile(state: FormState, location: FileLocation): FormState;
+export declare function clearFormFields(state: FormState): FormState;
+export declare function clearSequenceFiles(state: FormState): FormState;
+export declare function getBaseAssemblyConfig(state: FormState): {
+    name: string;
+    displayName?: string | undefined;
+    refNameAliases?: {
+        adapter: {
+            type: string;
+            location: FileLocation;
+        };
+    } | undefined;
+    cytobands?: {
+        adapter: {
+            type: string;
+            cytobandLocation: FileLocation;
+        };
+    } | undefined;
+};
+export type AssemblyAdapter = {
+    type: 'IndexedFastaAdapter';
+    fastaLocation: FileLocation;
+    faiLocation: FileLocation;
+} | {
+    type: 'BgzipFastaAdapter';
+    fastaLocation: FileLocation;
+    faiLocation: FileLocation;
+    gziLocation: FileLocation;
+} | {
+    type: 'UnindexedFastaAdapter';
+    fastaLocation: FileLocation;
+} | {
+    type: 'TwoBitAdapter';
+    twoBitLocation: FileLocation;
+    chromSizesLocation?: FileLocation;
+} | {
+    type: 'ChromSizesAdapter';
+    chromSizesLocation: FileLocation;
+};
+export type AssemblyConf = ReturnType<typeof getBaseAssemblyConfig> & {
+    sequence: {
+        type: 'ReferenceSequenceTrack';
+        trackId: string;
+        adapter: AssemblyAdapter;
+    };
+};
+export declare function isBlank(location: FileLocation): boolean;
+export declare function formHasSequence(form: FormState): boolean;
+export declare function getAssemblyName(form: FormState): string;
+export declare function getMissingSidecars(form: FormState): ({
+    readonly field: 'faiLocation';
+    readonly ext: '.fai';
+    readonly label: 'FASTA index (.fai) file';
+} | {
+    readonly field: 'gziLocation';
+    readonly ext: '.gzi';
+    readonly label: 'FASTA gzip index (.gzi) file';
+})[];
+export declare function isFormReady(form: FormState): boolean;
+export declare function isFormDirty(form: FormState): boolean;
+export declare function partitionExtraLocations(form: FormState): {
+    used: FileLocation[];
+    unused: FileLocation[];
+};
+export declare function getAssemblyNameFromFilename(filename: string): string;
+export declare function detectAdapterType(filename: string): AdapterType | undefined;
+export type FileRole = 'fasta' | 'fastaGz' | 'fai' | 'gzi' | 'twoBit' | 'chromSizes' | 'cytobands' | 'refNameAliases';
+export declare function classifyFilename(filename: string): FileRole | undefined;
+export declare function classifyAssemblyFiles(locations: FileLocation[]): Partial<FormState>;
+export declare function isSequenceRole(role: FileRole | undefined): boolean;
+export interface ClassifiedLocation {
+    location: FileLocation;
+    role: FileRole | undefined;
+}
+export declare function classifyLocations(locations: FileLocation[]): ClassifiedLocation[];
+/**
+ * Rebuild the file-location fields (plus adapter/name) of `state` from a freshly
+ * classified set of dropped/pasted files.
+ *
+ * The file set is authoritative: a field it says nothing about resets, so
+ * deleting a URL from the box clears the slot it filled. `edited` is the way out
+ * — the fields the user set by hand, which the classifier never gets to answer
+ * for. Without it, typing a .fai into the "this format needs its index" input
+ * and then adding one more URL wiped the .fai and the pane re-asked for it.
+ *
+ * refName aliases and cytobands merge instead of resetting even when untouched:
+ * they are the two slots "More options" also fills, and no file set that omits
+ * them is making a claim about them.
+ */
+export declare function applyClassifiedFiles(state: FormState, locations: FileLocation[], edited: ReadonlySet<keyof FormState>): FormState;
+export declare function buildAssemblyConf(form: FormState, resolveFastaAdapter: (fastaLocation: FileLocation) => Promise<AssemblyAdapter> | AssemblyAdapter): Promise<AssemblyConf>;
+export declare function urlTextToLocations(text: string): FileLocation[];
+export type AdapterConfigResult = {
+    kind: 'ready';
+    adapter: AssemblyAdapter;
+} | {
+    kind: 'needsFastaIndex';
+    fastaLocation: FileLocation;
+};
+export declare function getAdapterConfig({ adapterSelection, fastaLocation, faiLocation, gziLocation, twoBitLocation, chromSizesLocation, }: {
+    adapterSelection: AdapterType;
+    fastaLocation: FileLocation;
+    faiLocation: FileLocation;
+    gziLocation: FileLocation;
+    twoBitLocation: FileLocation;
+    chromSizesLocation: FileLocation;
+}): AdapterConfigResult;

package/esm/util/assemblyConfigUtils.js

@@ -0,0 +1,498 @@
+import { getFileName } from './getFileName.js';
+import { isLocalPathLocation, isUriLocation } from './types/data.js';
+// Shared assembly "add sequence" form logic used by both the jbrowse-desktop
+// Open genome(s) dialog and the in-app data-management Assembly manager. Pure
+// (no React, no MST, no product wiring) so it can live in core and be reused by
+// both surfaces. The one product-specific step — turning a plain FASTA into a
+// usable adapter — is injected into buildAssemblyConf (desktop runs samtools
+// faidx to produce an IndexedFastaAdapter; web keeps an UnindexedFastaAdapter).
+export const adapterTypes = [
+    'IndexedFastaAdapter',
+    'BgzipFastaAdapter',
+    'FastaAdapter',
+    'TwoBitAdapter',
+    'ChromSizesAdapter',
+];
+export const adapterLabels = {
+    IndexedFastaAdapter: 'FASTA with index (.fa + .fai)',
+    BgzipFastaAdapter: 'Compressed FASTA (.fa.gz + .fai + .gzi)',
+    FastaAdapter: 'FASTA (automatically indexed)',
+    TwoBitAdapter: '2bit file (.2bit)',
+    ChromSizesAdapter: 'Chromosome sizes, no sequence (.chrom.sizes)',
+};
+// The formats that bring bases with them. ChromSizesAdapter is the one that
+// does not: it names the assembly's sequences and their lengths and stops
+// there, which is the whole point of it (six wheat genomes are tens of
+// gigabytes as sequence and a few kilobytes as names and lengths) and also
+// everything a caller has to warn about. `jbrowse add-assembly` has taken
+// `--type chromSizes` since long before this pane offered it.
+export function adapterHasSequence(adapterSelection) {
+    return adapterSelection !== 'ChromSizesAdapter';
+}
+export const sidecarRoles = ['fai', 'gzi'];
+// What each index sidecar is called, where it lives on the form, and the
+// extension it takes next to its sequence file.
+export const sidecars = {
+    fai: {
+        field: 'faiLocation',
+        ext: '.fai',
+        label: 'FASTA index (.fai) file',
+    },
+    gzi: {
+        field: 'gziLocation',
+        ext: '.gzi',
+        label: 'FASTA gzip index (.gzi) file',
+    },
+};
+// The sidecars each format cannot load without. One table because the same
+// condition was written out at four sites and they drifted: the staging button
+// gated on a copy that let a .fa.gz through with neither index, straight into
+// getAdapterConfig's "FASTA, FAI, and GZI locations are all required".
+const requiredSidecars = {
+    IndexedFastaAdapter: ['fai'],
+    BgzipFastaAdapter: ['fai', 'gzi'],
+    FastaAdapter: [],
+    TwoBitAdapter: [],
+    ChromSizesAdapter: [],
+};
+// The file each format is opened by. A table rather than an `=== 'TwoBit'` test
+// per site, because chrom.sizes is the primary for one format and a 2bit's
+// optional sidecar for another, and the two answers were about to be spelled
+// out at three call sites.
+const primaryFields = {
+    IndexedFastaAdapter: 'fastaLocation',
+    BgzipFastaAdapter: 'fastaLocation',
+    FastaAdapter: 'fastaLocation',
+    TwoBitAdapter: 'twoBitLocation',
+    ChromSizesAdapter: 'chromSizesLocation',
+};
+// Curried field setter for the add-assembly form:
+// makeSetField(setForm)('faiLocation') returns a value setter that merges just
+// that field. Shared by AdvancedOptions and SequenceAdapterInputs so the
+// immutable-update logic lives in one place.
+export function makeSetField(setForm) {
+    return (key) => (value) => {
+        setForm(f => ({ ...f, [key]: value }));
+    };
+}
+const blank = { uri: '', locationType: 'UriLocation' };
+export function initialFormState() {
+    return {
+        adapterSelection: adapterTypes[0],
+        assemblyName: '',
+        assemblyDisplayName: '',
+        fastaLocation: blank,
+        faiLocation: blank,
+        gziLocation: blank,
+        twoBitLocation: blank,
+        chromSizesLocation: blank,
+        refNameAliasesLocation: blank,
+        cytobandsLocation: blank,
+    };
+}
+export function applyPrimaryFile(state, location) {
+    const filename = getFileName(location);
+    const detected = filename ? detectAdapterType(filename) : undefined;
+    const assemblyName = filename && !state.assemblyName
+        ? getAssemblyNameFromFilename(filename)
+        : state.assemblyName;
+    if (detected === 'TwoBitAdapter' || detected === 'ChromSizesAdapter') {
+        return {
+            ...state,
+            [primaryFields[detected]]: location,
+            adapterSelection: detected,
+            assemblyName,
+        };
+    }
+    const adapterSelection = detected ?? state.adapterSelection;
+    return {
+        ...state,
+        fastaLocation: location,
+        adapterSelection,
+        assemblyName,
+        ...guessSidecarLocations(state, location, adapterSelection),
+    };
+}
+// Prefill conventional .fai/.gzi sidecars sitting next to the chosen FASTA,
+// leaving any field the user already set untouched. Spreading the source
+// location carries over its baseUri/auth so the sidecars use the same access.
+function guessSidecarLocations(state, location, adapterSelection) {
+    const guesses = {};
+    for (const role of requiredSidecars[adapterSelection]) {
+        const { field, ext } = sidecars[role];
+        const guess = isBlank(state[field]) ? sidecar(location, ext) : undefined;
+        if (guess) {
+            guesses[field] = guess;
+        }
+    }
+    return guesses;
+}
+function sidecar(location, ext) {
+    if (isUriLocation(location)) {
+        return { ...location, uri: `${location.uri}${ext}` };
+    }
+    if (isLocalPathLocation(location)) {
+        return { ...location, localPath: `${location.localPath}${ext}` };
+    }
+    return undefined;
+}
+export function applyTwoBitFile(state, location) {
+    const filename = getFileName(location);
+    const assemblyName = filename && !state.assemblyName
+        ? getAssemblyNameFromFilename(filename)
+        : state.assemblyName;
+    return { ...state, twoBitLocation: location, assemblyName };
+}
+// Everything about the genome just staged, gone, so the next one starts clean.
+// The chosen format survives on purpose: in the manual form it is what the user
+// picked, and the guided path overwrites it from the next file set anyway.
+export function clearFormFields(state) {
+    return { ...initialFormState(), adapterSelection: state.adapterSelection };
+}
+// Clear only the sequence-file fields (and their required index sidecars),
+// keeping assembly-level metadata the user already entered — name, display name,
+// refName aliases, cytobands. Used by the recognition card's "change" link so
+// swapping a mis-picked sequence file doesn't discard everything else.
+export function clearSequenceFiles(state) {
+    return {
+        ...state,
+        fastaLocation: blank,
+        faiLocation: blank,
+        gziLocation: blank,
+        twoBitLocation: blank,
+        chromSizesLocation: blank,
+    };
+}
+export function getBaseAssemblyConfig(state) {
+    return {
+        name: state.assemblyName,
+        ...(state.assemblyDisplayName
+            ? { displayName: state.assemblyDisplayName }
+            : {}),
+        ...(!isBlank(state.refNameAliasesLocation)
+            ? {
+                refNameAliases: {
+                    adapter: {
+                        type: 'RefNameAliasAdapter',
+                        location: state.refNameAliasesLocation,
+                    },
+                },
+            }
+            : {}),
+        ...(!isBlank(state.cytobandsLocation)
+            ? {
+                cytobands: {
+                    adapter: {
+                        type: 'CytobandAdapter',
+                        cytobandLocation: state.cytobandsLocation,
+                    },
+                },
+            }
+            : {}),
+    };
+}
+export function isBlank(location) {
+    return 'uri' in location && location.uri === '';
+}
+// The form can be opened only once the chosen format's primary file is there.
+// Secondary files (.fai/.gzi) are validated later in getAdapterConfig.
+export function formHasSequence(form) {
+    return !isBlank(form[primaryFields[form.adapterSelection]]);
+}
+// The name the assembly is saved under. Trimmed because surrounding whitespace
+// is never intentional and would otherwise create near-duplicate assemblies
+// ("hg38" vs "hg38 ") that a caller's duplicate check can't catch.
+export function getAssemblyName(form) {
+    return form.assemblyName.trim();
+}
+// The index files the chosen format requires that the form doesn't have yet.
+// getAdapterConfig throws on the same condition; asking first is what lets a
+// caller disable its submit button instead of letting the user click it and
+// read a stack trace back, and lets the pane offer an input for each one.
+export function getMissingSidecars(form) {
+    return requiredSidecars[form.adapterSelection]
+        .map(role => sidecars[role])
+        .filter(({ field }) => isBlank(form[field]));
+}
+// Whether the form can be submitted/staged: a primary sequence file, everything
+// that file's format requires, and a (non-whitespace) name. Shared so every
+// add-assembly surface gates its submit button the same way.
+export function isFormReady(form) {
+    return (formHasSequence(form) &&
+        !!getAssemblyName(form) &&
+        !getMissingSidecars(form).length);
+}
+// Whether the user has put anything in the form. A caller that submits a
+// separate list (desktop stages several genomes) uses this to refuse rather
+// than silently drop a genome the user was halfway through entering.
+export function isFormDirty(form) {
+    return formHasSequence(form) || !!getAssemblyName(form);
+}
+// The non-primary files the built config will actually reference, and the ones
+// it won't. chrom.sizes reaches a TwoBitAdapter and nothing else, so listing it
+// under a FASTA promises a file getAdapterConfig drops on the floor.
+export function partitionExtraLocations(form) {
+    const { adapterSelection } = form;
+    const required = requiredSidecars[adapterSelection];
+    // it is the primary file for ChromSizesAdapter and listed by the row above
+    // the extras, so it belongs in neither list there
+    const chromSizesReaches = adapterSelection === 'TwoBitAdapter' ||
+        adapterSelection === 'ChromSizesAdapter';
+    const sidecarLocation = (role) => form[sidecars[role].field];
+    const used = [
+        ...required.map(sidecarLocation),
+        ...(adapterSelection === 'TwoBitAdapter' ? [form.chromSizesLocation] : []),
+        form.refNameAliasesLocation,
+        form.cytobandsLocation,
+    ].filter(loc => !isBlank(loc));
+    const unused = [
+        ...sidecarRoles
+            .filter(role => !required.includes(role))
+            .map(sidecarLocation),
+        ...(chromSizesReaches ? [] : [form.chromSizesLocation]),
+    ].filter(loc => !isBlank(loc));
+    return { used, unused };
+}
+// The FASTA extensions the sequence plugin's adapter guessers accept, so the
+// add-genome pane places exactly the files that load everywhere else. Its own
+// table used to be `(fa|fasta|fna).gz`, case-sensitive, which silently refused
+// .fas, .mfa, .FA and .fa.bgz.
+const FASTA_EXT = /\.(fa|fasta|fas|fna|mfa)$/i;
+const FASTA_GZ_EXT = /\.(fa|fasta|fas|fna|mfa)\.b?gz$/i;
+const TWOBIT_EXT = /\.2bit$/i;
+// the same pattern `jbrowse add-assembly` infers `--type chromSizes` from, so a
+// file that works there is recognized here
+const CHROM_SIZES_EXT = /\.chrom\.sizes$/i;
+// Every pattern here anchors to the end of the name, which is why getFileName
+// drops a URI's query string — a presigned link's few hundred characters of
+// signature would otherwise be what these match against.
+export function getAssemblyNameFromFilename(filename) {
+    return filename
+        .replace(FASTA_GZ_EXT, '')
+        .replace(FASTA_EXT, '')
+        .replace(TWOBIT_EXT, '')
+        .replace(CHROM_SIZES_EXT, '');
+}
+export function detectAdapterType(filename) {
+    return FASTA_GZ_EXT.test(filename)
+        ? 'BgzipFastaAdapter'
+        : TWOBIT_EXT.test(filename)
+            ? 'TwoBitAdapter'
+            : CHROM_SIZES_EXT.test(filename)
+                ? 'ChromSizesAdapter'
+                : undefined;
+}
+// Classify a single filename into the assembly slot it belongs to, by
+// extension. Returns undefined for files we can't place. Order matters: index
+// sidecars (.fai/.gzi) are checked before the fasta patterns they share a stem
+// with, and the fasta patterns before the looser cytoband/alias name matches.
+export function classifyFilename(filename) {
+    return /\.fai$/i.test(filename)
+        ? 'fai'
+        : /\.gzi$/i.test(filename)
+            ? 'gzi'
+            : TWOBIT_EXT.test(filename)
+                ? 'twoBit'
+                : FASTA_GZ_EXT.test(filename)
+                    ? 'fastaGz'
+                    : FASTA_EXT.test(filename)
+                        ? 'fasta'
+                        : /\.chrom\.sizes$/i.test(filename)
+                            ? 'chromSizes'
+                            : /cytoband/i.test(filename)
+                                ? 'cytobands'
+                                : /alias/i.test(filename)
+                                    ? 'refNameAliases'
+                                    : undefined;
+}
+// Sort a dropped/pasted set of files into the assembly form fields, picking the
+// adapter and assembly name from whichever file is the primary sequence.
+//
+// The primary is chosen once, up front, and then answers for the adapter, the
+// sequence field and the name together. Letting each branch overwrite as it went
+// ran two independent last-wins rules that could disagree: a .2bit ahead of a .fa
+// took the adapter while the .fa took the name, so the form opened one genome's
+// sequence under the other genome's name, and the "more than one genome" notice
+// named the file it was not reading.
+export function classifyAssemblyFiles(locations) {
+    const result = {};
+    const classified = classifyLocations(locations);
+    for (const { location, role } of classified) {
+        const field = role && extraFields[role];
+        if (field) {
+            result[field] = location;
+        }
+    }
+    const primary = classified.filter(f => isSequenceRole(f.role)).at(-1);
+    // A chrom.sizes leads only when nothing that carries bases is in the set: it
+    // is the 2bit's optional sequence-name sidecar in every other drop, and
+    // promoting it would silently downgrade `hg38.2bit + hg38.chrom.sizes` to an
+    // assembly with no sequence.
+    if (!primary && !isBlank(result.chromSizesLocation ?? blank)) {
+        return {
+            ...result,
+            adapterSelection: 'ChromSizesAdapter',
+            assemblyName: getAssemblyNameFromFilename(getFileName(result.chromSizesLocation)),
+        };
+    }
+    if (primary) {
+        result.assemblyName = getAssemblyNameFromFilename(getFileName(primary.location));
+        if (primary.role === 'twoBit') {
+            result.twoBitLocation = primary.location;
+            result.adapterSelection = 'TwoBitAdapter';
+        }
+        else {
+            result.fastaLocation = primary.location;
+            result.adapterSelection =
+                primary.role === 'fastaGz'
+                    ? 'BgzipFastaAdapter'
+                    : // a plain FASTA with no .fai in the set indexes itself on submit
+                        result.faiLocation
+                            ? 'IndexedFastaAdapter'
+                            : 'FastaAdapter';
+        }
+    }
+    return result;
+}
+// The roles that describe the sequence itself. Exactly one of these is the
+// genome being added, so a set holding two holds two genomes and the caller
+// warns about it.
+const sequenceRoles = new Set([
+    'fasta',
+    'fastaGz',
+    'twoBit',
+]);
+export function isSequenceRole(role) {
+    return role !== undefined && sequenceRoles.has(role);
+}
+// Where each non-sequence role lands on the form. The sequence roles map to
+// nothing on purpose: which field they fill depends on which one is the primary,
+// so classifyAssemblyFiles decides that in one place rather than per file.
+const extraFields = {
+    fai: 'faiLocation',
+    gzi: 'gziLocation',
+    chromSizes: 'chromSizesLocation',
+    cytobands: 'cytobandsLocation',
+    refNameAliases: 'refNameAliasesLocation',
+    fasta: undefined,
+    fastaGz: undefined,
+    twoBit: undefined,
+};
+// Every location paired with the slot it belongs in, `undefined` for the ones
+// that could not be placed. Callers needing more than one answer about the same
+// set — what was placed, what wasn't, which files are sequences — get all of
+// them out of this one pass.
+export function classifyLocations(locations) {
+    return locations.map(location => ({
+        location,
+        role: classifyFilename(getFileName(location)),
+    }));
+}
+/**
+ * Rebuild the file-location fields (plus adapter/name) of `state` from a freshly
+ * classified set of dropped/pasted files.
+ *
+ * The file set is authoritative: a field it says nothing about resets, so
+ * deleting a URL from the box clears the slot it filled. `edited` is the way out
+ * — the fields the user set by hand, which the classifier never gets to answer
+ * for. Without it, typing a .fai into the "this format needs its index" input
+ * and then adding one more URL wiped the .fai and the pane re-asked for it.
+ *
+ * refName aliases and cytobands merge instead of resetting even when untouched:
+ * they are the two slots "More options" also fills, and no file set that omits
+ * them is making a claim about them.
+ */
+export function applyClassifiedFiles(state, locations, edited) {
+    const classified = classifyAssemblyFiles(locations);
+    const pick = (key, reset) => edited.has(key) ? state[key] : (classified[key] ?? reset);
+    return {
+        ...state,
+        fastaLocation: pick('fastaLocation', blank),
+        faiLocation: pick('faiLocation', blank),
+        gziLocation: pick('gziLocation', blank),
+        twoBitLocation: pick('twoBitLocation', blank),
+        chromSizesLocation: pick('chromSizesLocation', blank),
+        refNameAliasesLocation: pick('refNameAliasesLocation', state.refNameAliasesLocation),
+        cytobandsLocation: pick('cytobandsLocation', state.cytobandsLocation),
+        adapterSelection: pick('adapterSelection', state.adapterSelection),
+        assemblyName: pick('assemblyName', ''),
+    };
+}
+// Build a full assembly config from the form. A plain FASTA has no index, so
+// the caller supplies a resolveFastaAdapter callback (desktop runs an
+// out-of-process samtools faidx to make an IndexedFastaAdapter; web keeps an
+// UnindexedFastaAdapter) used only for the needsFastaIndex case. The name is
+// trimmed and reused for a unique-per-open sequence trackId.
+export async function buildAssemblyConf(form, resolveFastaAdapter) {
+    const name = getAssemblyName(form);
+    const result = getAdapterConfig(form);
+    const adapter = result.kind === 'needsFastaIndex'
+        ? await resolveFastaAdapter(result.fastaLocation)
+        : result.adapter;
+    return {
+        ...getBaseAssemblyConfig({ ...form, assemblyName: name }),
+        sequence: {
+            type: 'ReferenceSequenceTrack',
+            trackId: `${name}-${Date.now()}`,
+            adapter,
+        },
+    };
+}
+export function urlTextToLocations(text) {
+    return text
+        .split('\n')
+        .map(line => line.trim())
+        .filter(Boolean)
+        .map(uri => ({ uri, locationType: 'UriLocation' }));
+}
+export function getAdapterConfig({ adapterSelection, fastaLocation, faiLocation, gziLocation, twoBitLocation, chromSizesLocation, }) {
+    if (adapterSelection === 'FastaAdapter') {
+        if (isBlank(fastaLocation)) {
+            throw new Error('FASTA location is required');
+        }
+        return { kind: 'needsFastaIndex', fastaLocation };
+    }
+    if (adapterSelection === 'IndexedFastaAdapter') {
+        if (isBlank(fastaLocation) || isBlank(faiLocation)) {
+            throw new Error('Both FASTA and FAI locations are required');
+        }
+        return {
+            kind: 'ready',
+            adapter: { type: 'IndexedFastaAdapter', fastaLocation, faiLocation },
+        };
+    }
+    if (adapterSelection === 'BgzipFastaAdapter') {
+        if (isBlank(fastaLocation) ||
+            isBlank(faiLocation) ||
+            isBlank(gziLocation)) {
+            throw new Error('FASTA, FAI, and GZI locations are all required');
+        }
+        return {
+            kind: 'ready',
+            adapter: {
+                type: 'BgzipFastaAdapter',
+                fastaLocation,
+                faiLocation,
+                gziLocation,
+            },
+        };
+    }
+    if (adapterSelection === 'ChromSizesAdapter') {
+        if (isBlank(chromSizesLocation)) {
+            throw new Error('Chromosome sizes location is required');
+        }
+        return {
+            kind: 'ready',
+            adapter: { type: 'ChromSizesAdapter', chromSizesLocation },
+        };
+    }
+    if (isBlank(twoBitLocation)) {
+        throw new Error('2bit location is required');
+    }
+    return {
+        kind: 'ready',
+        adapter: isBlank(chromSizesLocation)
+            ? { type: 'TwoBitAdapter', twoBitLocation }
+            : { type: 'TwoBitAdapter', twoBitLocation, chromSizesLocation },
+    };
+}