@jbrowse/core 4.3.0 → 5.0.0-beta.10

package/esm/pluggableElementTypes/models/saveTrackFileTypes/genbank.js

@@ -1,104 +1,203 @@
-import { fetchSequence } from "./fetchSequence.js";
-import { max, min } from "../../../util/index.js";
-const coreFields = new Set([
-    'uniqueId',
-    'id',
-    'refName',
+import { fetchSeq } from '../../../util/fetchSeq.js';
+import { createStatusFanOut, groupBy, max, min } from '../../../util/index.js';
+import { coreFeatureFields, formatAttributeValue } from './util.js';
+// name becomes the /label qualifier rather than one of its own
+const coreFields = new Set([...coreFeatureFields, 'name']);
+// GenBank fixed-column layout: feature keys occupy cols 6-20, locations and
+// qualifiers start at col 22. See https://www.insdc.org/submitting-standards/feature-table/
+const TYPE_COLUMN_WIDTH = 15;
+const QUALIFIER_INDENT = ' '.repeat(21);
+const DATE = '10-JAN-1970';
+// Free-text qualifiers are wrapped in double quotes; literal quotes inside the
+// value are escaped by doubling them, per the GenBank spec.
+function qualifier(key, value) {
+    return `${QUALIFIER_INDENT}/${key}="${value.replaceAll('"', '""')}"`;
+}
+function loc(f, minPos) {
+    const start = f.get('start') - minPos + 1;
+    const end = f.get('end') - minPos;
+    return `${start}..${end}`;
+}
+// Build a (possibly spliced) location expression for a set of segments,
+// e.g. join(1..100,201..300) or complement(join(...)) for the minus strand.
+function joinLoc(feats, strand, minPos) {
+    const locs = feats
+        .toSorted((a, b) => a.get('start') - b.get('start'))
+        .map(f => loc(f, minPos));
+    const expr = locs.length === 1 ? locs.join(',') : `join(${locs.join(',')})`;
+    return strand === -1 ? `complement(${expr})` : expr;
+}
+function featureLine(type, location) {
+    return `     ${type.slice(0, TYPE_COLUMN_WIDTH).padEnd(TYPE_COLUMN_WIDTH)} ${location}`;
+}
+/**
+ * The feature key column holds one of a closed list, so a SO term JBrowse names
+ * a feature with is not a key by virtue of being a type. A reader that does not
+ * recognize the key falls back to drawing nothing in particular — which is what
+ * a BLAT hit, a CRISPR guide, a restriction site and an hgPcr product all got,
+ * and what `primer` got where SnapGene draws a primer only for `primer_bind`.
+ *
+ * https://www.insdc.org/submitting-standards/feature-table/
+ */
+const INSDC_KEYS = new Set([
+    "3'UTR",
+    "5'UTR",
+    'assembly_gap',
+    'C_region',
+    'CDS',
+    'centromere',
+    'D-loop',
+    'D_segment',
+    'exon',
+    'gap',
+    'gene',
+    'iDNA',
+    'intron',
+    'J_segment',
+    'mat_peptide',
+    'misc_binding',
+    'misc_difference',
+    'misc_feature',
+    'misc_recomb',
+    'misc_RNA',
+    'misc_structure',
+    'mobile_element',
+    'modified_base',
+    'mRNA',
+    'N_region',
+    'ncRNA',
+    'old_sequence',
+    'operon',
+    'oriT',
+    'polyA_site',
+    'precursor_RNA',
+    'prim_transcript',
+    'primer_bind',
+    'propeptide',
+    'protein_bind',
+    'regulatory',
+    'rep_origin',
+    'repeat_region',
+    'rRNA',
+    'S_region',
+    'sig_peptide',
     'source',
-    'type',
-    'start',
-    'end',
-    'strand',
-    'parent',
-    'parentId',
-    'score',
-    'subfeatures',
-    'phase',
+    'stem_loop',
+    'STS',
+    'telomere',
+    'tmRNA',
+    'transit_peptide',
+    'tRNA',
+    'unsure',
+    'V_region',
+    'V_segment',
+    'variation',
 ]);
-const TYPE_COLUMN_WIDTH = 16;
-const blank = '                     ';
-const retitle = {
-    name: 'Name',
+// SO terms this tree emits that the feature table spells differently. Anything
+// absent from both this and INSDC_KEYS is a real feature with no key of its own
+// — a guide, a PAM, a restriction site, a BLAT hit, an hgPcr product — and
+// becomes misc_feature, which is what the key exists for.
+const SO_TO_INSDC = {
+    five_prime_UTR: "5'UTR",
+    three_prime_UTR: "3'UTR",
+    primer: 'primer_bind',
+    primer_binding_site: 'primer_bind',
+    transcript: 'mRNA',
+    pseudogene: 'gene',
+    promoter: 'regulatory',
+    enhancer: 'regulatory',
+    terminator: 'regulatory',
+    polyA_site: 'polyA_site',
+    origin_of_replication: 'rep_origin',
+    repeat_unit: 'repeat_region',
+    SNV: 'variation',
+    SNP: 'variation',
 };
-function fmt(obj) {
-    if (obj === null || obj === undefined) {
-        return undefined;
-    }
-    if (Array.isArray(obj)) {
-        const items = obj.map(o => fmt(o)).filter(o => o !== undefined);
-        return items.length > 0 ? items.join(',') : undefined;
-    }
-    if (typeof obj === 'object') {
-        return JSON.stringify(obj);
-    }
-    return `${obj}`;
+// The keys whose group shares one /gene symbol. A feature with children is not
+// a gene by having them: threading the symbol off any parent labelled an hgPcr
+// product `/gene="100 bp"` and a BLAT hit `/gene="YourSeq 99.1%"`, which reads
+// downstream as a gene of that name.
+const GENE_GROUP_KEYS = new Set([
+    'gene',
+    'mRNA',
+    'ncRNA',
+    'rRNA',
+    'tRNA',
+    'tmRNA',
+    'misc_RNA',
+    'precursor_RNA',
+    'prim_transcript',
+    'CDS',
+    'exon',
+]);
+export function insdcFeatureKey(type) {
+    const mapped = SO_TO_INSDC[type] ?? type;
+    return INSDC_KEYS.has(mapped) ? mapped : 'misc_feature';
 }
-function formatTags(f, parentId, parentType) {
+function formatTags({ feature, gene, key, }) {
     const tags = [];
-    if (parentId && parentType) {
-        tags.push(`${blank}/${parentType}="${parentId}"`);
+    // /gene ties gene/mRNA/CDS together; /label is what SnapGene/Geneious/ApE
+    // display as the feature name on the map
+    if (gene) {
+        tags.push(qualifier('gene', gene));
+    }
+    const label = feature.get('name') ?? feature.get('id');
+    if (label) {
+        tags.push(qualifier('label', label));
     }
-    const id = f.get('id');
-    if (id) {
-        tags.push(`${blank}/name="${id}"`);
+    // a feature that had to become misc_feature still knows what it is, so the
+    // term it came in as rides along rather than being dropped at the key column
+    const type = `${feature.get('type')}`;
+    if (key === 'misc_feature' && type && type !== 'misc_feature') {
+        tags.push(qualifier('note', type));
     }
-    for (const key of Object.keys(f.toJSON())) {
-        if (!coreFields.has(key) && key !== parentType) {
-            const value = fmt(f.get(key));
+    for (const key of Object.keys(feature.toJSON())) {
+        if (!coreFields.has(key)) {
+            const value = formatAttributeValue(feature.get(key));
             if (value) {
-                tags.push(`${blank}/${retitle[key] || key}="${value}"`);
+                tags.push(qualifier(key, value));
             }
         }
     }
     return tags;
 }
-function relativeStart(f, min) {
-    return f.get('start') - min + 1;
-}
-function relativeEnd(f, min) {
-    return f.get('end') - min;
-}
-function loc(f, min) {
-    return `${relativeStart(f, min)}..${relativeEnd(f, min)}`;
-}
-function formatFeat(f, min, parentType, parentId) {
-    const type = `${f.get('type')}`.slice(0, TYPE_COLUMN_WIDTH);
-    const l = loc(f, min);
-    const locstrand = f.get('strand') === -1 ? `complement(${l})` : l;
-    return [
-        `     ${type.padEnd(TYPE_COLUMN_WIDTH)}${locstrand}`,
-        ...formatTags(f, parentType, parentId),
-    ];
-}
-function formatCDS(feats, parentId, parentType, strand, min) {
+function formatCDS({ feats, gene, strand, minPos, }) {
     if (feats.length === 0) {
         return [];
     }
-    const locs = feats.map(f => loc(f, min));
-    const locExpr = locs.length === 1 ? locs[0] : `join(${locs.join(',')})`;
-    const strandExpr = strand === -1 ? `complement(${locExpr})` : locExpr;
     return [
-        `     ${'CDS'.padEnd(TYPE_COLUMN_WIDTH)}${strandExpr}`,
-        `${blank}/${parentType}="${parentId}"`,
+        featureLine('CDS', joinLoc(feats, strand, minPos)),
+        ...(gene ? [qualifier('gene', gene), qualifier('label', gene)] : []),
+        `${QUALIFIER_INDENT}/codon_start=1`,
     ];
 }
-export function formatFeatWithSubfeatures(feature, min, parentId, parentType) {
-    const primary = formatFeat(feature, min, parentId, parentType);
-    const subfeatures = feature.get('subfeatures') || [];
-    const cds = subfeatures
-        .filter(f => f.get('type') === 'CDS')
-        .sort((a, b) => a.get('start') - b.get('start'));
+export function formatFeatWithSubfeatures({ feature, minPos, geneName, }) {
+    const subfeatures = feature.get('subfeatures') ?? [];
+    const strand = feature.get('strand') ?? 0;
+    const key = insdcFeatureKey(`${feature.get('type')}`);
+    const exons = subfeatures.filter(f => f.get('type') === 'exon');
+    // A gene-group feature with children establishes the symbol, which is threaded
+    // down so every part of the gene shares one /gene qualifier.
+    const ownName = feature.get('name') ?? feature.get('id');
+    const gene = geneName ??
+        (GENE_GROUP_KEYS.has(key) && subfeatures.length > 0 && ownName
+            ? ownName
+            : undefined);
+    // A spliced transcript is rendered as join() of its exons rather than a
+    // single span, so external tools see the correct intron/exon structure.
+    const segments = exons.length > 0 ? exons : [feature];
+    const location = joinLoc(segments, strand, minPos);
+    const primary = [
+        featureLine(key, location),
+        ...formatTags({ feature, gene, key }),
+    ];
+    const cds = subfeatures.filter(f => f.get('type') === 'CDS');
     const sansCDS = subfeatures.filter(f => f.get('type') !== 'CDS' && f.get('type') !== 'exon');
-    const newParentId = feature.get('id');
-    const newParentType = feature.get('type');
-    const newParentStrand = feature.get('strand');
-    const cdsLines = cds.length > 0 && newParentId && newParentType
-        ? formatCDS(cds, newParentId, newParentType, newParentStrand, min)
-        : [];
+    const cdsLines = cds.length > 0 ? formatCDS({ feats: cds, gene, strand, minPos }) : [];
     return [
         ...primary,
         ...cdsLines,
-        ...sansCDS.flatMap(sub => formatFeatWithSubfeatures(sub, min, newParentId, newParentType)),
+        ...sansCDS.flatMap(sub => formatFeatWithSubfeatures({ feature: sub, minPos, geneName: gene })),
     ].join('\n');
 }
 function formatOrigin(sequence) {
@@ -106,34 +205,107 @@ function formatOrigin(sequence) {
     for (let i = 0; i < sequence.length; i += 60) {
         const pos = String(i + 1).padStart(9);
         const chunk = sequence.slice(i, i + 60).toLowerCase();
-        const groups = chunk.match(/.{1,10}/g) || [];
+        const groups = chunk.match(/.{1,10}/g) ?? [];
         lines.push(`${pos} ${groups.join(' ')}`);
     }
     lines.push('//');
     return lines;
 }
-export async function stringifyGBK({ features, assemblyName, session, }) {
-    if (!features.length) {
-        return '';
-    }
-    const date = '10-JAN-1970';
-    const start = min(features.map(f => f.get('start')));
-    const end = max(features.map(f => f.get('end')));
-    const length = end - start;
-    const refName = features[0].get('refName') || '';
-    const l1 = [
+// LOCUS line column layout per the GenBank flat-file spec. A positional parser
+// reads each field out of a fixed slot, so the widths below ARE the format:
+//
+//   1-5 LOCUS · 6-12 spaces · 13-28 name · 29 space · 30-40 length ·
+//   41-44 " bp " · 45-47 strandedness · 48-54 molecule · 55 space ·
+//   56-63 topology · 64 space · 65-67 division · 68 space · 69-79 date
+//
+// Molecule runs to 54 and topology starts at 56, which is one column right of
+// where it reads: every real NCBI record spells `DNA` then five spaces then
+// `circular`. Writing topology from 55 put a letter in the space at 55 and
+// Biopython refused all nine snapshot records, while the snapshot tests stayed
+// green because they pin the bytes rather than the format. `locusColumns` in
+// the test file is the check that names which slot moved.
+//
+// The name is the 16-column locus field, so it is the refName rather than the
+// region: `chr17:7,668,402..7,687,550` sanitizes to 22 characters and pushed
+// every field after it 6 columns right. The coordinates are on DEFINITION,
+// where the line is free text.
+const LOCUS_NAME_WIDTH = 16;
+function formatLocus(refName, length) {
+    const name = refName.replaceAll(/[^\w.]/g, '_').slice(0, LOCUS_NAME_WIDTH);
+    return [
         'LOCUS'.padEnd(12),
-        `${refName}:${start + 1}..${end}`.padEnd(20),
-        ` ${length} bp`.padEnd(15),
-        ` ${'DNA'.padEnd(10)}`,
-        'linear'.padEnd(10),
-        `UNK ${date}`,
+        name.padEnd(LOCUS_NAME_WIDTH),
+        ' ',
+        String(length).padStart(11),
+        ' bp ',
+        '   ',
+        'DNA'.padEnd(7),
+        ' ',
+        'linear'.padEnd(8),
+        ' ',
+        'UNK'.padEnd(3),
+        ' ',
+        DATE,
     ].join('');
-    const l2 = 'FEATURES             Location/Qualifiers';
-    const contig = (await fetchSequence({
+}
+// Metadata header plus the whole-sequence `source` feature that every GenBank
+// record carries.
+function formatHeader({ refName, region, assemblyName, length, }) {
+    return [
+        formatLocus(refName, length),
+        `DEFINITION  ${region} from ${assemblyName}.`,
+        `ACCESSION   ${refName}`,
+        `VERSION     ${refName}`,
+        'KEYWORDS    .',
+        `SOURCE      ${assemblyName}`,
+        `  ORGANISM  ${assemblyName}`,
+        '            .',
+        'FEATURES             Location/Qualifiers',
+        featureLine('source', `1..${length}`),
+        qualifier('organism', assemblyName),
+        `${QUALIFIER_INDENT}/mol_type="genomic DNA"`,
+        qualifier('chromosome', refName),
+    ];
+}
+// One LOCUS..ORIGIN..// record, spanning the features on a single reference
+// sequence. GenBank has no way to express a span that crosses one, which is why
+// this takes a refName rather than deriving it.
+async function formatRecord({ refName, features, assemblyName, session, signal, statusCallback, }) {
+    const minPos = min(features.map(f => f.get('start')));
+    const maxPos = max(features.map(f => f.get('end')));
+    const length = maxPos - minPos;
+    const region = `${refName}:${minPos + 1}..${maxPos}`;
+    const contig = await fetchSeq({
+        session,
+        assemblyName,
+        start: minPos,
+        end: maxPos,
+        refName,
+        signal,
+        statusCallback,
+    });
+    const header = formatHeader({ refName, region, assemblyName, length });
+    const body = features.map(feat => formatFeatWithSubfeatures({ feature: feat, minPos }));
+    return [...header, ...body, ...formatOrigin(contig)].join('\n');
+}
+export async function stringifyGBK({ features, assemblyName, session, signal, statusCallback, }) {
+    // A record per reference sequence, which is what GenBank is: a multi-region
+    // view used to take min(start)/max(end) across every feature and label the
+    // result with the first one's refName, so two contigs on screen produced one
+    // record spanning a stretch of sequence that does not exist, with an ORIGIN
+    // fetched over it.
+    const byRefName = groupBy(features, f => f.get('refName'));
+    // the records fetch their ORIGIN concurrently and all report the same phase,
+    // so each gets its own fan-out slot rather than the caller's raw callback —
+    // otherwise the first contig to finish blanks the label for the rest
+    const slot = createStatusFanOut(statusCallback);
+    const records = await Promise.all(Object.entries(byRefName).map(([refName, feats]) => formatRecord({
+        refName,
+        features: feats,
+        assemblyName,
         session,
-        region: { assemblyName, start, end, refName },
-    })) ?? '';
-    const lines = features.map(feat => formatFeatWithSubfeatures(feat, start));
-    return `${[l1, l2, ...lines, ...formatOrigin(contig)].join('\n')}\n`;
+        signal,
+        statusCallback: slot(),
+    })));
+    return records.join('\n');
 }

package/esm/pluggableElementTypes/models/saveTrackFileTypes/gff3.d.ts

@@ -1,5 +1,10 @@
 import type { Feature } from '@jbrowse/core/util';
-export declare function formatMultiLevelFeat(feature: Feature, parentId?: string, parentRef?: string): string;
+export declare function formatMultiLevelFeat({ feature, parentId, parentRef, cdsPhase, }: {
+    feature: Feature;
+    parentId?: string;
+    parentRef?: string;
+    cdsPhase?: number;
+}): string;
 export declare function stringifyGFF3({ features }: {
     features: Feature[];
 }): string;

package/esm/pluggableElementTypes/models/saveTrackFileTypes/gff3.js

@@ -1,19 +1,4 @@
-const coreFields = new Set([
-    'uniqueId',
-    'id',
-    'refName',
-    'source',
-    'type',
-    'start',
-    'end',
-    'strand',
-    'parent',
-    'parentId',
-    'score',
-    'subfeatures',
-    'phase',
-    '_lineHash',
-]);
+import { coreFeatureFields, formatAttributeValue, formatStrand, } from './util.js';
 const retitle = {
     name: 'Name',
     alias: 'Alias',
@@ -26,85 +11,96 @@ const retitle = {
     ontology_term: 'Ontology_term',
     is_circular: 'Is_circular',
 };
+const gff3Escapes = {
+    '%': '%25',
+    ';': '%3B',
+    '=': '%3D',
+    '&': '%26',
+    ',': '%2C',
+    '\t': '%09',
+    '\n': '%0A',
+    '\r': '%0D',
+};
 function encodeGFF3Value(str) {
-    return str
-        .replace(/%/g, '%25')
-        .replace(/;/g, '%3B')
-        .replace(/=/g, '%3D')
-        .replace(/&/g, '%26')
-        .replace(/,/g, '%2C')
-        .replace(/\t/g, '%09')
-        .replace(/\n/g, '%0A')
-        .replace(/\r/g, '%0D');
-}
-function fmt(obj) {
-    if (obj === null || obj === undefined) {
-        return undefined;
-    }
-    if (Array.isArray(obj)) {
-        const items = obj.map(o => fmt(o)).filter(o => o !== undefined);
-        return items.length > 0 ? items.join(',') : undefined;
-    }
-    if (typeof obj === 'object') {
-        return encodeGFF3Value(JSON.stringify(obj));
-    }
-    return encodeGFF3Value(String(obj));
+    return str.replaceAll(/[%;=&,\t\n\r]/g, c => gff3Escapes[c]);
 }
-function formatAttributes(f, parentId) {
+function formatAttributes(f, { id, parentId }) {
     const attributes = [];
-    const id = f.get('id');
     if (id) {
-        attributes.push(`ID=${encodeGFF3Value(String(id))}`);
+        attributes.push(`ID=${encodeGFF3Value(id)}`);
     }
     if (parentId) {
-        attributes.push(`Parent=${encodeGFF3Value(String(parentId))}`);
+        attributes.push(`Parent=${encodeGFF3Value(parentId)}`);
     }
-    const tags = Object.keys(f.toJSON()).filter(tag => !coreFields.has(tag));
+    const tags = Object.keys(f.toJSON()).filter(tag => !coreFeatureFields.has(tag));
     const hasDescription = tags.includes('description');
-    const hasNote = tags.includes('note');
     for (const tag of tags) {
-        const val = f.get(tag);
-        const formattedVal = fmt(val);
+        const formattedVal = formatAttributeValue(f.get(tag), encodeGFF3Value);
         if (formattedVal) {
-            let key = retitle[tag] || tag;
-            if (tag === 'note' && hasDescription && hasNote) {
-                key = 'note2';
-            }
+            // both note and description map to Note; keep note as note2 so the
+            // description-derived Note isn't clobbered
+            const key = tag === 'note' && hasDescription ? 'note2' : retitle[tag] || tag;
             attributes.push(`${key}=${formattedVal}`);
         }
     }
     return attributes.join(';');
 }
-function formatFeat(f, parentId, parentRef) {
-    const strand = f.get('strand');
-    const score = f.get('score');
-    const phase = f.get('phase');
+// GFF3 requires a phase (0|1|2) on CDS features. When a non-GFF3 source omits
+// it, derive it from the cumulative CDS length in translation order (sort
+// ascending on +, descending on -), assuming the 5'-most CDS begins in frame.
+// https://github.com/The-Sequence-Ontology/Specifications/blob/master/gff3.md
+function computeCdsPhases(subfeatures, strand) {
+    const cds = subfeatures
+        .filter(f => f.get('type') === 'CDS')
+        .sort((a, b) => strand === -1
+        ? b.get('start') - a.get('start')
+        : a.get('start') - b.get('start'));
+    const phases = new Map();
+    let cumulative = 0;
+    for (const f of cds) {
+        phases.set(f, (3 - (cumulative % 3)) % 3);
+        cumulative += f.get('end') - f.get('start');
+    }
+    return phases;
+}
+function formatFeat({ feature, id, parentId, refName, cdsPhase, }) {
+    const score = feature.get('score');
+    const phase = feature.get('phase') ?? cdsPhase;
     return [
-        f.get('refName') || parentRef,
-        f.get('source') || '.',
-        f.get('type') || '.',
-        f.get('start') + 1,
-        f.get('end'),
-        score !== undefined && score !== null ? score : '.',
-        strand === 1 ? '+' : strand === -1 ? '-' : '.',
-        phase !== undefined && phase !== null ? phase : '.',
-        formatAttributes(f, parentId),
+        refName,
+        feature.get('source') || '.',
+        feature.get('type') || '.',
+        feature.get('start') + 1,
+        feature.get('end'),
+        score ?? '.',
+        formatStrand(feature.get('strand')),
+        phase ?? '.',
+        formatAttributes(feature, { id, parentId }),
     ].join('\t');
 }
-export function formatMultiLevelFeat(feature, parentId, parentRef) {
-    const featureRefName = parentRef || feature.get('refName');
-    const featureId = feature.get('id');
-    const primary = formatFeat(feature, parentId, featureRefName);
+export function formatMultiLevelFeat({ feature, parentId, parentRef, cdsPhase, }) {
+    const refName = parentRef ?? feature.get('refName');
+    const subfeatures = feature.get('subfeatures');
+    // non-GFF3 sources (e.g. BigBed aggregated genes) synthesize parents with no
+    // id attribute; manufacture one from the uniqueId so children can Parent= it
+    const id = feature.get('id') ?? (subfeatures?.length ? feature.id() : undefined);
+    // fill in CDS phase when missing; feature.get('phase') still wins per-feature
+    const childPhases = subfeatures?.some(f => f.get('type') === 'CDS' && f.get('phase') === undefined)
+        ? computeCdsPhases(subfeatures, feature.get('strand'))
+        : undefined;
     return [
-        primary,
-        ...(feature
-            .get('subfeatures')
-            ?.map(sub => formatMultiLevelFeat(sub, featureId, featureRefName)) || []),
+        formatFeat({ feature, id, parentId, refName, cdsPhase }),
+        ...(subfeatures?.map(sub => formatMultiLevelFeat({
+            feature: sub,
+            parentId: id,
+            parentRef: refName,
+            cdsPhase: childPhases?.get(sub),
+        })) ?? []),
     ].join('\n');
 }
 export function stringifyGFF3({ features }) {
-    return `${[
+    return [
         '##gff-version 3',
-        ...features.map(f => formatMultiLevelFeat(f)),
-    ].join('\n')}\n`;
+        ...features.map(f => formatMultiLevelFeat({ feature: f })),
+    ].join('\n');
 }

package/esm/pluggableElementTypes/models/saveTrackFileTypes/types.d.ts

@@ -1,11 +1,19 @@
-import type { AbstractSessionModel, Feature } from '@jbrowse/core/util';
+import type { AbstractSessionModel, Feature, StatusCallback } from '@jbrowse/core/util';
 export interface FileTypeExporter {
     name: string;
     extension: string;
     helpText?: string;
+    /**
+     * The signal and status callback are the pair every RPC on the export
+     * path already carries. Most writers are string assembly and ignore both;
+     * GenBank fetches the ORIGIN sequence, and without them closing the dialog
+     * left a whole-gene read running with nothing waiting on it.
+     */
     callback: (arg: {
         features: Feature[];
         session: AbstractSessionModel;
         assemblyName: string;
+        signal?: AbortSignal;
+        statusCallback?: StatusCallback;
     }) => Promise<string> | string;
 }

package/esm/pluggableElementTypes/models/saveTrackFileTypes/util.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The feature fields these writers spend on a column of their own — position,
+ * identity, a link to a parent — and therefore do not repeat as an
+ * attribute/qualifier. GenBank adds `name`, which GFF3 keeps so it can retitle
+ * it to `Name`.
+ */
+export declare const coreFeatureFields: Set<string>;
+/**
+ * Column 6 of BED and column 7 of GFF3 are the same three tokens over the same
+ * 1/-1/0 a feature carries, so the convention gets one definition.
+ */
+export declare function formatStrand(strand: number | undefined): "+" | "-" | ".";
+/**
+ * Render an attribute value: an array joins on a comma, an object goes through
+ * JSON, anything else stringifies. Returns undefined for a value with nothing
+ * in it, so a caller can drop the attribute rather than write it empty.
+ *
+ * `encode` is the format's escaping, applied to each leaf — GFF3
+ * percent-encodes its delimiters, GenBank doubles quotes instead.
+ */
+export declare function formatAttributeValue(obj: unknown, encode?: (str: string) => string): string | undefined;