gramene-search 2.20.2 → 2.22.0

package/dist/index.js

@@ -849,6 +849,43 @@ function $af4441dd29af05df$var$markSubtree(node, source, invert) {
         $af4441dd29af05df$var$markSubtree(child, source, invert);
     });
 }
+const $af4441dd29af05df$export$6b95404109a3e2ec = 'Genomic intervals';
+function $af4441dd29af05df$export$634f7214da1b780a({ map: map, region: region, start: start, end: end }) {
+    return `(map:${map} AND region:${region}` + ` AND start:[* TO ${end}] AND end:[${start} TO *])`;
+}
+function $af4441dd29af05df$export$535c09441f37845d({ mapLabel: mapLabel, map: map, region: region, start: start, end: end }) {
+    return `${mapLabel || map} ${region}:${Number(start).toLocaleString()}-${Number(end).toLocaleString()}`;
+}
+// Note the field order is inverted relative to the interval: `start` carries the
+// interval's END and `end` carries its START, because the pair is an overlap test.
+const $af4441dd29af05df$var$INTERVAL_RE = /^\(map:(\S+) AND region:(\S+) AND start:\[\* TO (\d+)\] AND end:\[(\d+) TO \*\]\)$/;
+function $af4441dd29af05df$export$67920d3e3cb3f136(fqValue) {
+    const m = $af4441dd29af05df$var$INTERVAL_RE.exec(String(fqValue || ''));
+    if (!m) return null;
+    return {
+        map: m[1],
+        region: m[2],
+        end: Number(m[3]),
+        start: Number(m[4])
+    };
+}
+/** `[lo TO hi]`, as produced by the expression brush and the Location tab. */ const $af4441dd29af05df$var$RANGE_RE = /^\[\s*(\S+)\s+TO\s+(\S+)\s*\]$/;
+function $af4441dd29af05df$export$9ee0ceaa589fc567(fqValue) {
+    const m = $af4441dd29af05df$var$RANGE_RE.exec(String(fqValue || ''));
+    return m ? {
+        lo: m[1],
+        hi: m[2]
+    } : null;
+}
+function $af4441dd29af05df$export$cd9b2ffd001c6d65(lo, hi) {
+    return `[${lo} TO ${hi}]`;
+}
+function $af4441dd29af05df$export$a7f4fa59930e5088(node) {
+    if (!node || node.hasOwnProperty('children')) return null;
+    if ($af4441dd29af05df$export$67920d3e3cb3f136(node.fq_value)) return 'interval';
+    if ($af4441dd29af05df$export$9ee0ceaa589fc567(node.fq_value)) return 'range';
+    return 'value';
+}
 const $af4441dd29af05df$export$da3188ffd2da2525 = {
     orthologs: {
         label: 'orthologs',
@@ -1037,6 +1074,81 @@ const $af4441dd29af05df$var$grameneFilters = {
                         return newState;
                     }
                     break;
+                case 'GRAMENE_FILTER_INTERVAL_ADDED':
+                    {
+                        // Intervals accumulate into a single OR group, because ANDing two
+                        // disjoint intervals matches nothing — no gene sits in both. The group
+                        // is tagged with `category`, one of the keys viewSnapshot keeps, so a
+                        // restored view merges into it instead of starting a second group; were
+                        // that tag ever lost the worst case is an extra group, never a corrupt
+                        // tree.
+                        newState = Object.assign({}, state, {
+                            status: 'search',
+                            showMarked: true,
+                            searchOffset: 0
+                        });
+                        const { map: map, mapLabel: mapLabel, region: region, start: start, end: end } = payload;
+                        // One leaf per interval, not four. getQuery has a raw-passthrough branch
+                        // for a `location` leaf whose value starts with "(map:" — every other
+                        // branch would escape the colons — so the whole clause rides in one node
+                        // and the Filters panel shows one readable row per interval.
+                        //
+                        // Overlap, not containment: start <= interval end AND end >= interval
+                        // start, so a gene that merely crosses the boundary still matches.
+                        const intervalNode = {
+                            fq_field: 'location',
+                            fq_value: $af4441dd29af05df$export$634f7214da1b780a({
+                                map: map,
+                                region: region,
+                                start: start,
+                                end: end
+                            }),
+                            name: $af4441dd29af05df$export$535c09441f37845d({
+                                mapLabel: mapLabel,
+                                map: map,
+                                region: region,
+                                start: start,
+                                end: end
+                            }),
+                            category: 'Genomic interval',
+                            negate: false,
+                            showMenu: false
+                        };
+                        let group = (newState.children || []).find((c)=>c && c.category === $af4441dd29af05df$export$6b95404109a3e2ec && Array.isArray(c.children));
+                        if (group) group.children.push(intervalNode);
+                        else newState.children.push({
+                            operation: 'OR',
+                            category: $af4441dd29af05df$export$6b95404109a3e2ec,
+                            negate: false,
+                            showMenu: false,
+                            children: [
+                                intervalNode
+                            ]
+                        });
+                        // Inserting a nested subtree invalidates the hand-computed indices the
+                        // append actions rely on, so renumber the whole tree.
+                        $af4441dd29af05df$var$reindexTree(newState, 0);
+                        $af4441dd29af05df$var$markSubtree(newState, newState, false);
+                        return newState;
+                    }
+                case 'GRAMENE_FILTER_EDITED':
+                    {
+                        // Edits only rewrite a leaf's value and label. The node keeps its place,
+                        // its negate flag and any expansion, and the tree shape is untouched — so
+                        // unlike an insert there is nothing to reindex.
+                        newState = Object.assign({}, state, {
+                            status: 'search',
+                            showMarked: true,
+                            searchOffset: 0
+                        });
+                        const node = $af4441dd29af05df$var$findNodeWithLeftIdx(newState, payload.leftIdx);
+                        if (!node || node.hasOwnProperty('children')) break;
+                        node.fq_value = payload.fq_value;
+                        if (payload.name !== undefined) node.name = payload.name;
+                        node.showMenu = false;
+                        $af4441dd29af05df$var$markSubtree(newState, node, false);
+                        return newState;
+                    }
                 case 'GRAMENE_FILTER_EXPANSION_SET':
                     {
                         // Setting or clearing an expansion is just a field on the node — the tree
@@ -1353,6 +1465,47 @@ const $af4441dd29af05df$var$grameneFilters = {
                 ]
             });
         },
+    // Add one genomic interval. Accumulates into a single OR group; see the
+    // GRAMENE_FILTER_INTERVAL_ADDED reducer for why they cannot be ANDed.
+    doAddGrameneInterval: (interval)=>({ dispatch: dispatch })=>{
+            dispatch({
+                type: 'BATCH_ACTIONS',
+                actions: [
+                    {
+                        type: 'GRAMENE_SEARCH_CLEARED'
+                    },
+                    {
+                        type: 'GRAMENE_TAXONOMY_CLEARED'
+                    },
+                    {
+                        type: 'GRAMENE_FILTER_INTERVAL_ADDED',
+                        payload: interval
+                    }
+                ]
+            });
+        },
+    // Replace one leaf's value in place, keeping its position in the tree.
+    doEditGrameneFilter: (filter, fq_value, name)=>({ dispatch: dispatch })=>{
+            dispatch({
+                type: 'BATCH_ACTIONS',
+                actions: [
+                    {
+                        type: 'GRAMENE_SEARCH_CLEARED'
+                    },
+                    {
+                        type: 'GRAMENE_TAXONOMY_CLEARED'
+                    },
+                    {
+                        type: 'GRAMENE_FILTER_EDITED',
+                        payload: {
+                            leftIdx: filter.leftIdx,
+                            fq_value: fq_value,
+                            name: name
+                        }
+                    }
+                ]
+            });
+        },
     doToggleGrameneFilterMenu: (node)=>({ dispatch: dispatch })=>{
             dispatch({
                 type: 'GRAMENE_FILTER_MENU_TOGGLED',
@@ -20789,6 +20942,350 @@ var $7d7b7dad5e71dfd3$export$2e2bcd8739ae039 = $7d7b7dad5e71dfd3$var$Facets;
 
 
 
+// Sequences that aren't a placed chromosome. Excluded from the dropdown because
+// an interval on them is not something a user can reason about positionally.
+// Organelles (C, M, Mt, Pt, mitochondrion_genome) are deliberately kept — they
+// are real, coordinate-addressable sequences.
+const $909272efb41be16f$var$UNPLACED = /^(unanchored|u)$/i;
+function $909272efb41be16f$export$ac97d17982e0cb21(grameneMaps, targetTaxonId) {
+    const genomes = Object.values(grameneMaps || {}).filter((m)=>m && m._id && m.regions);
+    const byLabel = (a, b)=>String(a.display_name || '').localeCompare(String(b.display_name || ''));
+    const reference = genomes.filter((m)=>String(m.taxon_id) === String(targetTaxonId));
+    const refIds = new Set(reference.map((m)=>m.taxon_id));
+    const anchors = genomes.filter((m)=>m.is_anchor && !refIds.has(m.taxon_id)).sort(byLabel);
+    const anchorIds = new Set(anchors.map((m)=>m.taxon_id));
+    const rest = genomes.filter((m)=>!refIds.has(m.taxon_id) && !anchorIds.has(m.taxon_id)).sort(byLabel);
+    return {
+        reference: reference,
+        anchors: anchors,
+        rest: rest
+    };
+}
+function $909272efb41be16f$export$94955a075dcb14b2(genome) {
+    const regions = genome && genome.regions || {};
+    const names = regions.names || [];
+    const lengths = regions.lengths || [];
+    return names.map((name, i)=>({
+            name: name,
+            length: lengths[i]
+        })).filter((r)=>!$909272efb41be16f$var$UNPLACED.test(String(r.name)));
+}
+const $909272efb41be16f$export$4fa3dba3103266ea = ({ grameneMaps: grameneMaps, targetTaxonId: targetTaxonId, initial: initial, submitLabel: submitLabel, onSubmit: onSubmit, onCancel: onCancel })=>{
+    const [taxonId, setTaxonId] = (0, $gXNCa$react.useState)('');
+    const [region, setRegion] = (0, $gXNCa$react.useState)(initial ? String(initial.region) : '');
+    const [start, setStart] = (0, $gXNCa$react.useState)(initial ? String(initial.start) : '');
+    const [end, setEnd] = (0, $gXNCa$react.useState)(initial ? String(initial.end) : '');
+    const { reference: reference, anchors: anchors, rest: rest } = (0, $gXNCa$react.useMemo)(()=>$909272efb41be16f$export$ac97d17982e0cb21(grameneMaps, targetTaxonId), [
+        grameneMaps,
+        targetTaxonId
+    ]);
+    // An edit starts on the filter's own genome; a new interval starts on the
+    // site's reference. `initial.map` is an assembly accession, so find its genome.
+    const initialTaxon = (0, $gXNCa$react.useMemo)(()=>{
+        if (!initial) return '';
+        const hit = Object.values(grameneMaps || {}).find((m)=>m && m._id === initial.map);
+        return hit ? String(hit.taxon_id) : '';
+    }, [
+        initial,
+        grameneMaps
+    ]);
+    const effectiveTaxon = taxonId || initialTaxon || reference[0] && String(reference[0].taxon_id) || '';
+    const genome = effectiveTaxon ? (grameneMaps || {})[effectiveTaxon] : null;
+    const chromosomes = (0, $gXNCa$react.useMemo)(()=>$909272efb41be16f$export$94955a075dcb14b2(genome), [
+        genome
+    ]);
+    const effectiveRegion = region || chromosomes[0] && chromosomes[0].name || '';
+    const chrLength = (chromosomes.find((c)=>String(c.name) === String(effectiveRegion)) || {}).length;
+    const s = start === '' ? null : Number(start);
+    const e = end === '' ? null : Number(end);
+    // Validated against the assembly's own region lengths, so the message can name
+    // the actual limit rather than just refusing.
+    const error = (()=>{
+        if (!genome || s === null || e === null) return null;
+        if (!Number.isFinite(s) || !Number.isFinite(e)) return 'Positions must be numbers.';
+        if (s < 1 || e < 1) return 'Positions start at 1.';
+        if (s > e) return 'Start must not be greater than end.';
+        if (chrLength && e > chrLength) return `${effectiveRegion} is ${chrLength.toLocaleString()} bp; end is beyond it.`;
+        return null;
+    })();
+    const ready = !!genome && !!effectiveRegion && s !== null && e !== null && !error;
+    const submit = ()=>{
+        if (!ready) return;
+        onSubmit({
+            map: genome._id,
+            mapLabel: genome.display_name || genome._id,
+            region: effectiveRegion,
+            start: s,
+            end: e
+        });
+        if (!initial) {
+            setStart('');
+            setEnd('');
+        }
+    };
+    const genomeOption = (m)=>/*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)("option", {
+            value: m.taxon_id,
+            children: m.display_name || m.system_name
+        }, m.taxon_id);
+    return /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsxs)("div", {
+        className: "gramene-interval-form",
+        children: [
+            /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsxs)((0, $gXNCa$reactbootstrap.Form).Select, {
+                size: "sm",
+                className: "mb-1",
+                value: effectiveTaxon,
+                onChange: (ev)=>{
+                    setTaxonId(ev.target.value);
+                    setRegion('');
+                },
+                children: [
+                    reference.map(genomeOption),
+                    anchors.length > 0 && /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)("optgroup", {
+                        label: "Reference genomes",
+                        children: anchors.map(genomeOption)
+                    }),
+                    rest.length > 0 && /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)("optgroup", {
+                        label: "Other genomes",
+                        children: rest.map(genomeOption)
+                    })
+                ]
+            }),
+            /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)((0, $gXNCa$reactbootstrap.Form).Select, {
+                size: "sm",
+                className: "mb-1",
+                value: effectiveRegion,
+                onChange: (ev)=>setRegion(ev.target.value),
+                children: chromosomes.map((c)=>/*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsxs)("option", {
+                        value: c.name,
+                        children: [
+                            c.name,
+                            c.length ? ` (${Math.round(c.length / 1e6)} Mb)` : ''
+                        ]
+                    }, c.name))
+            }),
+            /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsxs)("div", {
+                className: "gramene-interval-range",
+                children: [
+                    /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)((0, $gXNCa$reactbootstrap.Form).Control, {
+                        size: "sm",
+                        type: "number",
+                        min: "1",
+                        placeholder: "start",
+                        value: start,
+                        onChange: (ev)=>setStart(ev.target.value)
+                    }),
+                    /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)("span", {
+                        className: "gramene-interval-dash",
+                        children: "\u2013"
+                    }),
+                    /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)((0, $gXNCa$reactbootstrap.Form).Control, {
+                        size: "sm",
+                        type: "number",
+                        min: "1",
+                        placeholder: "end",
+                        value: end,
+                        onChange: (ev)=>setEnd(ev.target.value),
+                        onKeyDown: (ev)=>{
+                            if (ev.key === 'Enter') submit();
+                        }
+                    })
+                ]
+            }),
+            error && /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)("div", {
+                className: "gramene-interval-error",
+                children: error
+            }),
+            /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsxs)("div", {
+                className: "gramene-interval-actions",
+                children: [
+                    /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)((0, $gXNCa$reactbootstrap.Button), {
+                        size: "sm",
+                        variant: "primary",
+                        className: "gramene-interval-submit",
+                        disabled: !ready,
+                        onClick: submit,
+                        children: submitLabel || 'Add interval'
+                    }),
+                    onCancel && /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)((0, $gXNCa$reactbootstrap.Button), {
+                        size: "sm",
+                        variant: "link",
+                        className: "gramene-interval-cancel",
+                        onClick: onCancel,
+                        children: "cancel"
+                    })
+                ]
+            })
+        ]
+    });
+};
+/** The collapsible "Add genomic interval" entry at the foot of the Filters panel. */ const $909272efb41be16f$var$GenomicIntervalForm = ({ grameneMaps: grameneMaps, targetTaxonId: targetTaxonId, onAdd: onAdd })=>{
+    const [open, setOpen] = (0, $gXNCa$react.useState)(false);
+    return /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsxs)("div", {
+        className: "gramene-interval",
+        children: [
+            /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsxs)("div", {
+                className: "gramene-interval-toggle",
+                onClick: ()=>setOpen(!open),
+                children: [
+                    open ? /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)((0, $gXNCa$reacticonsbs.BsChevronDown), {}) : /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)((0, $gXNCa$reacticonsbs.BsChevronRight), {}),
+                    " Add genomic interval"
+                ]
+            }),
+            open && /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)($909272efb41be16f$export$4fa3dba3103266ea, {
+                grameneMaps: grameneMaps,
+                targetTaxonId: targetTaxonId,
+                onSubmit: onAdd
+            })
+        ]
+    });
+};
+var $909272efb41be16f$export$2e2bcd8739ae039 = $909272efb41be16f$var$GenomicIntervalForm;
+
+
+
+
+
+
+
+/**
+ * Edit one filter leaf in place, with a form shaped to what that leaf actually is:
+ * a genomic interval gets the genome/chromosome/start/end fields, a `[lo TO hi]`
+ * range gets two number boxes, anything else gets its raw value.
+ *
+ * Groups are not editable — their only parameter is the operator, which the menu
+ * already exposes as "convert to".
+ *
+ * The plain-value case is honest but limited: many leaves carry an opaque id (a
+ * pathway number, an ontology term, a saved-search hash) whose replacement a user
+ * has no way to know. It is offered because a typo in a gene name or a term is
+ * worth fixing without deleting and starting over.
+ */ const $91efc9c46e3775e3$var$FilterEditor = ({ node: node, grameneMaps: grameneMaps, targetTaxonId: targetTaxonId, onSave: onSave, onCancel: onCancel })=>{
+    const kind = (0, $af4441dd29af05df$export$a7f4fa59930e5088)(node);
+    const range = kind === 'range' ? (0, $af4441dd29af05df$export$9ee0ceaa589fc567)(node.fq_value) : null;
+    const [lo, setLo] = (0, $gXNCa$react.useState)(range ? range.lo : '');
+    const [hi, setHi] = (0, $gXNCa$react.useState)(range ? range.hi : '');
+    const [value, setValue] = (0, $gXNCa$react.useState)(kind === 'value' ? String(node.fq_value ?? '') : '');
+    if (!kind) return null;
+    if (kind === 'interval') {
+        const initial = (0, $af4441dd29af05df$export$67920d3e3cb3f136)(node.fq_value);
+        return /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)("div", {
+            className: "gramene-filter-editor",
+            children: /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)((0, $909272efb41be16f$export$4fa3dba3103266ea), {
+                grameneMaps: grameneMaps,
+                targetTaxonId: targetTaxonId,
+                initial: initial,
+                submitLabel: "Save",
+                onCancel: onCancel,
+                onSubmit: (iv)=>onSave((0, $af4441dd29af05df$export$634f7214da1b780a)(iv), (0, $af4441dd29af05df$export$535c09441f37845d)(iv))
+            })
+        });
+    }
+    if (kind === 'range') {
+        const ok = lo !== '' && hi !== '';
+        const save = ()=>{
+            if (ok) onSave((0, $af4441dd29af05df$export$cd9b2ffd001c6d65)(lo, hi), `${lo}-${hi}`);
+        };
+        return /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsxs)("div", {
+            className: "gramene-filter-editor",
+            children: [
+                /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsxs)("div", {
+                    className: "gramene-interval-range",
+                    children: [
+                        /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)((0, $gXNCa$reactbootstrap.Form).Control, {
+                            size: "sm",
+                            value: lo,
+                            onChange: (e)=>setLo(e.target.value),
+                            placeholder: "from"
+                        }),
+                        /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)("span", {
+                            className: "gramene-interval-dash",
+                            children: "\u2013"
+                        }),
+                        /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)((0, $gXNCa$reactbootstrap.Form).Control, {
+                            size: "sm",
+                            value: hi,
+                            onChange: (e)=>setHi(e.target.value),
+                            placeholder: "to",
+                            onKeyDown: (e)=>{
+                                if (e.key === 'Enter') save();
+                            }
+                        })
+                    ]
+                }),
+                /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsxs)("div", {
+                    className: "gramene-interval-actions",
+                    children: [
+                        /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)((0, $gXNCa$reactbootstrap.Button), {
+                            size: "sm",
+                            variant: "primary",
+                            className: "gramene-interval-submit",
+                            disabled: !ok,
+                            onClick: save,
+                            children: "Save"
+                        }),
+                        /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)((0, $gXNCa$reactbootstrap.Button), {
+                            size: "sm",
+                            variant: "link",
+                            className: "gramene-interval-cancel",
+                            onClick: onCancel,
+                            children: "cancel"
+                        })
+                    ]
+                })
+            ]
+        });
+    }
+    const ok = String(value).trim() !== '';
+    // Keep the node's own label in step with its value, unless the label was
+    // something other than the value to begin with (a suggestion's display name),
+    // in which case leave it alone rather than overwriting it with a raw id.
+    const save = ()=>{
+        if (!ok) return;
+        const v = String(value).trim();
+        const nameFollowedValue = String(node.name ?? '') === String(node.fq_value ?? '');
+        onSave(v, nameFollowedValue ? v : undefined);
+    };
+    return /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsxs)("div", {
+        className: "gramene-filter-editor",
+        children: [
+            /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)((0, $gXNCa$reactbootstrap.Form).Control, {
+                size: "sm",
+                value: value,
+                onChange: (e)=>setValue(e.target.value),
+                onKeyDown: (e)=>{
+                    if (e.key === 'Enter') save();
+                }
+            }),
+            /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsxs)("div", {
+                className: "gramene-interval-actions",
+                children: [
+                    /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)((0, $gXNCa$reactbootstrap.Button), {
+                        size: "sm",
+                        variant: "primary",
+                        className: "gramene-interval-submit",
+                        disabled: !ok,
+                        onClick: save,
+                        children: "Save"
+                    }),
+                    /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)((0, $gXNCa$reactbootstrap.Button), {
+                        size: "sm",
+                        variant: "link",
+                        className: "gramene-interval-cancel",
+                        onClick: onCancel,
+                        children: "cancel"
+                    })
+                ]
+            })
+        ]
+    });
+};
+var $91efc9c46e3775e3$export$2e2bcd8739ae039 = $91efc9c46e3775e3$var$FilterEditor;
+
+
+
+
+
+
 
 
 
@@ -21234,6 +21731,7 @@ function $693dd8c7a5607c3a$var$logAction(action) {
     });
 }
 const $693dd8c7a5607c3a$var$Filter = ({ node: node, moveCopyMode: moveCopyMode, showMarked: showMarked, actions: actions })=>{
+    const [editing, setEditing] = (0, $gXNCa$react.useState)(false);
     let classes = 'gramene-filter gramene-filter';
     if (node.operation) classes = `${classes}-${(0, $af4441dd29af05df$export$c8b6102be216752a)(node.operation)}`;
     // An expansion decorates whatever node it sits on, leaf or group — same as negate.
@@ -21293,6 +21791,14 @@ const $693dd8c7a5607c3a$var$Filter = ({ node: node, moveCopyMode: moveCopyMode,
                 ]
             }, key++));
         });
+        if ((0, $af4441dd29af05df$export$a7f4fa59930e5088)(node)) menuItems.push(/*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)("li", {
+            onClick: ()=>{
+                $693dd8c7a5607c3a$var$logAction(`Edit filter`);
+                actions.toggleMenu(node);
+                setEditing(true);
+            },
+            children: "edit"
+        }, key++));
         if (node.leftIdx > 0) {
             menuItems.push(/*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)("li", {
                 onClick: ()=>{
@@ -21401,12 +21907,23 @@ const $693dd8c7a5607c3a$var$Filter = ({ node: node, moveCopyMode: moveCopyMode,
             })
         ]
     });
+    const editor = editing ? /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)((0, $91efc9c46e3775e3$export$2e2bcd8739ae039), {
+        node: node,
+        grameneMaps: actions.grameneMaps,
+        targetTaxonId: actions.targetTaxonId,
+        onCancel: ()=>setEditing(false),
+        onSave: (fq_value, name)=>{
+            setEditing(false);
+            actions.editNode(node, fq_value, name);
+        }
+    }) : null;
     return /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsxs)("div", {
         className: classes,
         onClick: (e)=>$693dd8c7a5607c3a$var$handleClick(e, moveCopyMode, showMarked, node, actions),
         children: [
             content,
             menu,
+            editor,
             children
         ]
     }, node.leftIdx);
@@ -21421,12 +21938,22 @@ const $693dd8c7a5607c3a$var$FiltersCmp = (props)=>{
         selectTarget: props.doMoveOrCopyGrameneFilter,
         markTargets: props.doMarkGrameneFilterTargets,
         unmarkTargets: props.doUnmarkGrameneFilterTargets,
-        toggleMenu: props.doToggleGrameneFilterMenu
+        toggleMenu: props.doToggleGrameneFilterMenu,
+        editNode: props.doEditGrameneFilter,
+        // Carried alongside the actions so every nested Filter can reach them without
+        // threading two more props through the recursion.
+        grameneMaps: props.grameneMaps,
+        targetTaxonId: props.targetTaxonId
     };
+    const intervalForm = /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)((0, $909272efb41be16f$export$2e2bcd8739ae039), {
+        grameneMaps: props.grameneMaps,
+        targetTaxonId: props.targetTaxonId,
+        onAdd: props.doAddGrameneInterval
+    });
     const containerClass = props.configuration.id === 'sorghum' ? 'sorghumbase-filter-container' : 'gramene-filter-container';
     if (props.grameneFilters.rightIdx > 1) return /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)("div", {
         className: containerClass,
-        children: /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)($693dd8c7a5607c3a$var$CollapsibleSection, {
+        children: /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsxs)($693dd8c7a5607c3a$var$CollapsibleSection, {
             title: "Filters",
             extra: /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)("span", {
                 style: {
@@ -21439,26 +21966,32 @@ const $693dd8c7a5607c3a$var$FiltersCmp = (props)=>{
                 },
                 children: /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)((0, $gXNCa$reacticonsbs.BsTrash), {})
             }),
-            children: /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)($693dd8c7a5607c3a$var$Filter, {
-                node: props.grameneFilters,
-                moveCopyMode: props.grameneFilters.moveCopyMode,
-                showMarked: props.grameneFilters.showMarked,
-                actions: actions
-            })
+            children: [
+                /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)($693dd8c7a5607c3a$var$Filter, {
+                    node: props.grameneFilters,
+                    moveCopyMode: props.grameneFilters.moveCopyMode,
+                    showMarked: props.grameneFilters.showMarked,
+                    actions: actions
+                }),
+                intervalForm
+            ]
         })
     });
     else return /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)("div", {
         className: containerClass,
-        children: /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)($693dd8c7a5607c3a$var$CollapsibleSection, {
+        children: /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsxs)($693dd8c7a5607c3a$var$CollapsibleSection, {
             title: "Filters",
-            children: /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)("div", {
-                className: "gramene-filter gramene-filter-AND",
-                children: "No filters defined"
-            })
+            children: [
+                /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)("div", {
+                    className: "gramene-filter gramene-filter-AND",
+                    children: "No filters defined"
+                }),
+                intervalForm
+            ]
         })
     });
 };
-const $693dd8c7a5607c3a$export$92a576f896a9bf72 = (0, $gXNCa$reduxbundlerreact.connect)('selectGrameneFilters', 'selectConfiguration', 'doNegateGrameneFilter', 'doDeleteGrameneFilter', 'doChangeGrameneFilterOperation', 'doExpandGrameneFilter', 'doRemoveGrameneExpansion', 'doMoveOrCopyGrameneFilter', 'doMarkGrameneFilterTargets', 'doUnmarkGrameneFilterTargets', 'doToggleGrameneFilterMenu', 'doClearGrameneFilters', $693dd8c7a5607c3a$var$FiltersCmp);
+const $693dd8c7a5607c3a$export$92a576f896a9bf72 = (0, $gXNCa$reduxbundlerreact.connect)('selectGrameneFilters', 'selectConfiguration', 'doNegateGrameneFilter', 'doDeleteGrameneFilter', 'doChangeGrameneFilterOperation', 'doExpandGrameneFilter', 'doRemoveGrameneExpansion', 'doMoveOrCopyGrameneFilter', 'doMarkGrameneFilterTargets', 'doUnmarkGrameneFilterTargets', 'doToggleGrameneFilterMenu', 'selectGrameneMaps', 'selectTargetTaxonId', 'doAddGrameneInterval', 'doEditGrameneFilter', 'doClearGrameneFilters', $693dd8c7a5607c3a$var$FiltersCmp);
 const $693dd8c7a5607c3a$var$ResultsCmp = (props)=>{
     let activeViews = props.grameneViews.options;
     return props.grameneFilters.rightIdx > 0 ? /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)("div", {