@jbrowse/core 5.0.0-beta.8 → 5.0.0-beta.9

package/esm/BaseFeatureWidget/BaseFeatureDetail/ArrayValue.d.ts

@@ -1,4 +1,4 @@
-import type { FeatureFormatter } from '../types.tsx';
+import type { FeatureFormatter, FieldActions } from '../types.tsx';
 /**
  * An array of objects renders each element as its own `Attributes` block and
  * draws no label row at this level; anything else is one labelled row like any
@@ -7,11 +7,12 @@ import type { FeatureFormatter } from '../types.tsx';
  * to make the same call.
  */
 export declare function isObjectArray(value: unknown[]): value is Record<string, unknown>[];
-export default function ArrayValue({ name, value, description, formatter, prefix, width, }: {
+export default function ArrayValue({ name, value, description, formatter, fieldActions, prefix, width, }: {
     description?: React.ReactNode;
     name: string;
     value: unknown[];
     formatter?: FeatureFormatter;
+    fieldActions?: FieldActions;
     prefix?: string[];
     width?: number;
 }): import("react").JSX.Element;

package/esm/BaseFeatureWidget/BaseFeatureDetail/ArrayValue.js

@@ -4,6 +4,7 @@ import { isObject } from '../../util/index.js';
 import { makeStyles } from '../../util/tss-react/index.js';
 import Attributes from './Attributes.js';
 import BasicValue from './BasicValue.js';
+import FieldActionsButton, { useRevealFieldActions, } from './FieldActionsButton.js';
 import FieldName from './FieldName.js';
 const MAX_ARRAY_LENGTH = 100;
 // Numeric arrays (e.g. base-modification probabilities, per-base scores) are
@@ -34,8 +35,9 @@ const useStyles = makeStyles()(theme => ({
 export function isObjectArray(value) {
     return value.every(isObject);
 }
-export default function ArrayValue({ name, value, description, formatter, prefix = [], width, }) {
-    const { classes } = useStyles();
+export default function ArrayValue({ name, value, description, formatter, fieldActions, prefix = [], width, }) {
+    const { classes, cx } = useStyles();
+    const reveal = useRevealFieldActions();
     const [showAll, setShowAll] = useState(false);
     const limit = value.every(v => typeof v === 'number')
         ? MAX_NUMERIC_ARRAY_LENGTH
@@ -44,7 +46,7 @@ export default function ArrayValue({ name, value, description, formatter, prefix
     const displayedValues = needsTruncation && !showAll ? value.slice(0, limit) : value;
     return isObjectArray(value) ? (value.length === 1 ? (_jsx(Attributes, { formatter: formatter, attributes: value[0], prefix: [...prefix, name] })) : (_jsx(_Fragment, { children: value.map((val, i) => (_jsx(Attributes
         // eslint-disable-next-line @eslint-react/no-array-index-key -- static positional list of attribute objects, no unique field available
-        , { formatter: formatter, attributes: val, prefix: [...prefix, `${name}-${i}`] }, i))) }))) : (_jsxs("div", { className: classes.field, children: [_jsx(FieldName, { prefix: prefix, description: description, name: name, width: width }), value.length === 1 ? (_jsx(BasicValue, { value: formatter ? formatter(value[0], name, 0) : value[0] })) : (_jsxs(_Fragment, { children: [displayedValues.map((val, i) => (_jsx("div", { className: classes.fieldSubvalue, children: _jsx(BasicValue, { value: formatter ? formatter(val, name, i) : val }) }, `${String(val)}-${i}`))), needsTruncation ? (_jsx("button", { type: "button", onClick: () => {
+        , { formatter: formatter, attributes: val, prefix: [...prefix, `${name}-${i}`] }, i))) }))) : (_jsxs("div", { className: cx(classes.field, reveal), children: [_jsx(FieldName, { prefix: prefix, description: description, name: name, width: width }), value.length === 1 ? (_jsxs(_Fragment, { children: [_jsx(BasicValue, { value: formatter ? formatter(value[0], name, 0) : value[0] }), _jsx(FieldActionsButton, { path: [...prefix, name], value: value[0], fieldActions: fieldActions })] })) : (_jsxs(_Fragment, { children: [displayedValues.map((val, i) => (_jsx("div", { className: classes.fieldSubvalue, children: _jsx(BasicValue, { value: formatter ? formatter(val, name, i) : val }) }, `${String(val)}-${i}`))), needsTruncation ? (_jsx("button", { type: "button", onClick: () => {
                             setShowAll(v => !v);
                         }, children: showAll
                             ? 'Show less'

package/esm/BaseFeatureWidget/BaseFeatureDetail/Attributes.d.ts

@@ -1,12 +1,10 @@
-import type { Descriptors, FeatureFormatter } from '../types.tsx';
+import type { Descriptors, FeatureFormatter, FieldActions } from '../types.tsx';
 export default function Attributes(props: {
-    attributes: {
-        [key: string]: unknown;
-        __jbrowsefmt?: Record<string, unknown>;
-    };
+    attributes: Record<string, unknown>;
     omit?: string[];
     omitSingleLevel?: string[];
     formatter?: FeatureFormatter;
+    fieldActions?: FieldActions;
     descriptions?: Descriptors;
     prefix?: string[];
     hideUris?: boolean;

package/esm/BaseFeatureWidget/BaseFeatureDetail/Attributes.js

@@ -4,7 +4,7 @@ import { isLocalPathLocation, isObject, isUriLocation, measureText, } from '../.
 import ArrayValue, { isObjectArray } from './ArrayValue.js';
 import SimpleField from './SimpleField.js';
 import UriAttribute from './UriField.js';
-import { accessNested, applyFeatureFormatting } from './util.js';
+import { accessNested } from './util.js';
 // Lazy: reaches @mui/x-data-grid, and this module sits on the eager startup
 // path via product-core's ui barrel (AboutDialog -> AboutDialogContents).
 // Only a homogeneous object array actually renders a grid.
@@ -27,7 +27,6 @@ function isHomogeneousObjectArray(arr) {
 }
 // these are always omitted as too detailed
 const globalOmit = [
-    '__jbrowsefmt',
     'length',
     'position',
     'subfeatures',
@@ -62,7 +61,7 @@ function measureLabels(attributes, opts) {
     const { omits, deepOmits, hideUris, prefix } = opts;
     let widest = 0;
     const measure = (key) => measureText([...prefix, key].join('.'), FIELD_NAME_FONT_SIZE);
-    for (const [key, value] of Object.entries(applyFeatureFormatting(attributes))) {
+    for (const [key, value] of Object.entries(attributes)) {
         if (value == null || omits.has(key)) {
             continue;
         }
@@ -96,9 +95,9 @@ function widestLabel(attributes, opts) {
     return Math.ceil(measureLabels(attributes, opts)) + FIELD_NAME_PADDING;
 }
 export default function Attributes(props) {
-    const { attributes, omit = [], omitSingleLevel = [], descriptions, formatter, hideUris, prefix = [], labelWidth, } = props;
+    const { attributes, omit = [], omitSingleLevel = [], descriptions, formatter, fieldActions, hideUris, prefix = [], labelWidth, } = props;
     const omits = new Set([...omit, ...globalOmit, ...omitSingleLevel]);
-    const filteredFormattedAttributes = Object.entries(applyFeatureFormatting(attributes)).filter(([k, v]) => v != null && !omits.has(k));
+    const shown = Object.entries(attributes).filter(([k, v]) => v != null && !omits.has(k));
     // Measured over the whole subtree on the outermost call, then handed down, so
     // one card has one label column. Per-level measurement put `type`/`trackId` in
     // a narrow column, `adapter.type` in a wider one and `adapter.craiLocation` in
@@ -115,13 +114,13 @@ export default function Attributes(props) {
             hideUris,
             prefix,
         }), MAX_FIELD_NAME_WIDTH);
-    return (_jsx(_Fragment, { children: filteredFormattedAttributes.map(([key, value]) => {
+    return (_jsx(_Fragment, { children: shown.map(([key, value]) => {
             const description = accessNested([...prefix, key], descriptions);
             if (Array.isArray(value)) {
                 // Only use the data grid when schemas are homogeneous enough;
                 // heterogeneous arrays fall through to ArrayValue which renders
                 // each object as individual field sections instead of disappearing
-                return isHomogeneousObjectArray(value) ? (_jsx(Suspense, { fallback: null, children: _jsx(DataGridDetails, { name: key, prefix: prefix, value: value }) }, key)) : (_jsx(ArrayValue, { name: key, value: value, formatter: formatter, description: description, prefix: prefix, width: width }, key));
+                return isHomogeneousObjectArray(value) ? (_jsx(Suspense, { fallback: null, children: _jsx(DataGridDetails, { name: key, prefix: prefix, value: value }) }, key)) : (_jsx(ArrayValue, { name: key, value: value, formatter: formatter, fieldActions: fieldActions, description: description, prefix: prefix, width: width }, key));
             }
             else if (isObject(value)) {
                 // hideUris means "don't show where the data sits". A LocalPathLocation
@@ -132,10 +131,10 @@ export default function Attributes(props) {
                     (isUriLocation(value) || isLocalPathLocation(value))) {
                     return null;
                 }
-                return isUriLocation(value) ? (_jsx(UriAttribute, { name: key, prefix: prefix, value: value, width: width }, key)) : (_jsx(Attributes, { attributes: value, omit: omit, descriptions: descriptions, formatter: formatter, hideUris: hideUris, prefix: [...prefix, key], labelWidth: width }, key));
+                return isUriLocation(value) ? (_jsx(UriAttribute, { name: key, prefix: prefix, value: value, width: width }, key)) : (_jsx(Attributes, { attributes: value, omit: omit, descriptions: descriptions, formatter: formatter, fieldActions: fieldActions, hideUris: hideUris, prefix: [...prefix, key], labelWidth: width }, key));
             }
             else {
-                return (_jsx(SimpleField, { name: key, formatter: formatter, value: value, description: description, prefix: prefix, width: width }, key));
+                return (_jsx(SimpleField, { name: key, formatter: formatter, fieldActions: fieldActions, value: value, description: description, prefix: prefix, width: width }, key));
             }
         }) }));
 }

package/esm/BaseFeatureWidget/BaseFeatureDetail/CoreDetails.js

@@ -2,21 +2,16 @@ import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-run
 import { toLocale } from '../../util/index.js';
 import Position from './Position.js';
 import SimpleField from './SimpleField.js';
-import { applyFeatureFormatting, isFormattedField } from './util.js';
 export default function CoreDetails(props) {
     const { feature } = props;
-    const formattedFeat = applyFeatureFormatting(feature);
-    const { start, end } = formattedFeat;
+    const { start, end } = feature;
+    // Length is derived from the coordinates unless a formatDetails callback
+    // named it, which is the only way a `length` key reaches the feature: an
+    // adapter's own bookkeeping field of that name is in Attributes' globalOmit
+    const length = 'length' in feature ? feature.length : end - start;
     const displayedDetails = {
-        ...formattedFeat,
-        // Length is derived, so it is computed rather than read off the feature --
-        // but a formatDetails callback that names `length` still wins (and
-        // `length: null` hides the row), like every other core field. The raw
-        // feature's own `length`, if any, stays ignored: it is in Attributes'
-        // globalOmit precisely because adapters use it as bookkeeping.
-        length: isFormattedField(feature, 'length')
-            ? formattedFeat.length
-            : toLocale(end - start),
+        ...feature,
+        length: typeof length === 'number' ? toLocale(length) : length,
     };
     // array (not object) so the display order is explicit, not reliant on JS key
     // insertion order
@@ -26,7 +21,7 @@ export default function CoreDetails(props) {
         ['length', 'Length'],
         ['type', 'Type'],
     ];
-    return (_jsxs(_Fragment, { children: [_jsx(SimpleField, { name: "Position", value: _jsx(Position, { ...props, feature: formattedFeat }) }), coreRenderedDetails
+    return (_jsxs(_Fragment, { children: [_jsx(SimpleField, { name: "Position", value: _jsx(Position, { ...props }) }), coreRenderedDetails
                 .filter(([key]) => displayedDetails[key] != null)
                 .map(([key, name]) => {
                 const value = displayedDetails[key];

package/esm/BaseFeatureWidget/BaseFeatureDetail/FeatureDetails.d.ts

@@ -1,5 +1,5 @@
 import type { SimpleFeatureSerialized } from '../../util/index.ts';
-import type { Descriptors, FeatureDetailsModel, FeatureFormatter } from '../types.tsx';
+import type { Descriptors, FeatureDetailsModel, FeatureFormatter, FieldActions } from '../types.tsx';
 interface FeatureDetailsProps {
     model: FeatureDetailsModel;
     feature: SimpleFeatureSerialized;
@@ -7,6 +7,7 @@ interface FeatureDetailsProps {
     omit?: string[];
     descriptions?: Descriptors;
     formatter?: FeatureFormatter;
+    fieldActions?: FieldActions;
 }
 declare const FeatureDetails: (props: FeatureDetailsProps) => import("react").JSX.Element;
 export default FeatureDetails;

package/esm/BaseFeatureWidget/BaseFeatureDetail/FeatureDetails.js

@@ -29,7 +29,7 @@ const coreDetails = [
     'type',
 ];
 const FeatureDetails = observer(function FeatureDetails(props) {
-    const { omit = [], model, feature, depth = 0, descriptions, formatter, } = props;
+    const { omit = [], model, feature, depth = 0, descriptions, formatter, fieldActions, } = props;
     const maxDepth = model.maxDepth ?? Infinity;
     const { mate: m, name = '', id = '', type = '', subfeatures, uniqueId, } = feature;
     // resolved rather than raw props: `depth` is what tells a registered panel
@@ -40,7 +40,7 @@ const FeatureDetails = observer(function FeatureDetails(props) {
     return (_jsxs(BaseCard, { title: generateTitle(name, id, type), children: [joinByDivider([
                 _jsxs(Fragment, { children: [_jsx(SectionHeader, { title: "Core details" }), _jsx(CoreDetails, { ...props })] }, "core"),
                 m ? (_jsxs(Fragment, { children: [_jsx(SectionHeader, { title: "Mate details" }), _jsx(CoreDetails, { ...props, feature: { ...m, uniqueId: `${uniqueId}-mate` } })] }, "mate")) : null,
-                _jsxs(Fragment, { children: [_jsx(SectionHeader, { title: "Attributes" }), _jsx(Attributes, { attributes: feature, omit: omit, omitSingleLevel: coreDetails, descriptions: descriptions, formatter: formatter })] }, "attributes"),
+                _jsxs(Fragment, { children: [_jsx(SectionHeader, { title: "Attributes" }), _jsx(Attributes, { attributes: feature, omit: omit, omitSingleLevel: coreDetails, descriptions: descriptions, formatter: formatter, fieldActions: fieldActions })] }, "attributes"),
             ].filter(Boolean)), _jsx(ErrorBoundary, { FallbackComponent: e => _jsx(ErrorBanner, { error: e.error }), children: _jsx(SequenceFeatureDetails, { ...props }) }), _jsx(PluggableComponents, { pluginManager: getEnv(model).pluginManager, 
                 /** #extensionPoint Core-extraFeaturePanel | sync | Add extra panels to the feature details widget */
                 name: "Core-extraFeaturePanel", props: panelProps }), depth < maxDepth && subfeatures?.length ? (_jsx(BaseCard, { title: "Subfeatures", defaultExpanded: depth === 0 && subfeatures.length <= 20, children: subfeatures.map((sub, idx) => (_jsx(FeatureDetails
@@ -53,6 +53,6 @@ const FeatureDetails = observer(function FeatureDetails(props) {
                     // descriptions and value formatter apply here too -- omitting
                     // them silently dropped e.g. VCF header descriptions and the
                     // truncating <Formatter> from every nested card
-                    descriptions: descriptions, formatter: formatter, omit: omit }, `${uniqueId}_${idx}`))) })) : null] }));
+                    descriptions: descriptions, formatter: formatter, fieldActions: fieldActions, omit: omit }, `${uniqueId}_${idx}`))) })) : null] }));
 });
 export default FeatureDetails;

package/esm/BaseFeatureWidget/BaseFeatureDetail/FieldActionsButton.d.ts

@@ -0,0 +1,8 @@
+import type { FieldActions } from '../types.tsx';
+/** A class for a field row that shows its FieldActionsButton on hover or focus. */
+export declare function useRevealFieldActions(): string;
+export default function FieldActionsButton({ path, value, fieldActions, }: {
+    path: string[];
+    value: unknown;
+    fieldActions?: FieldActions;
+}): import("react").JSX.Element | null;

package/esm/BaseFeatureWidget/BaseFeatureDetail/FieldActionsButton.js

@@ -0,0 +1,24 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import FilterListIcon from '@mui/icons-material/FilterList';
+import CascadingMenuButton from '../../ui/CascadingMenuButton.js';
+import { makeStyles } from '../../util/tss-react/index.js';
+// on a wrapper because MUI folds an Emotion class handed to one of its
+// components into a class of its own, which a selector naming it never matches
+const useStyles = makeStyles()({
+    reveal: {
+        opacity: 0,
+    },
+});
+/** A class for a field row that shows its FieldActionsButton on hover or focus. */
+export function useRevealFieldActions() {
+    const { classes, css } = useStyles();
+    const { reveal } = classes;
+    return css({
+        [`&:hover .${reveal}, &:focus-within .${reveal}`]: { opacity: 1 },
+    });
+}
+export default function FieldActionsButton({ path, value, fieldActions, }) {
+    const { classes } = useStyles();
+    const items = fieldActions?.(path, value) ?? [];
+    return items.length > 0 ? (_jsx("span", { className: classes.reveal, children: _jsx(CascadingMenuButton, { menuItems: items, size: "small", tooltip: "Filter by this value", style: { padding: 0 }, children: _jsx(FilterListIcon, { fontSize: "small" }) }) })) : null;
+}

package/esm/BaseFeatureWidget/BaseFeatureDetail/SimpleField.d.ts

@@ -1,9 +1,10 @@
-import type { FeatureFormatter } from '../types.tsx';
-export default function SimpleField({ name, value, description, prefix, width, formatter, }: {
+import type { FeatureFormatter, FieldActions } from '../types.tsx';
+export default function SimpleField({ name, value, description, prefix, width, formatter, fieldActions, }: {
     description?: React.ReactNode;
     name: string;
     value: unknown;
     prefix?: string[];
     width?: number;
     formatter?: FeatureFormatter;
+    fieldActions?: FieldActions;
 }): import("react").JSX.Element | null;

package/esm/BaseFeatureWidget/BaseFeatureDetail/SimpleField.js

@@ -1,6 +1,7 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { makeStyles } from '../../util/tss-react/index.js';
 import BasicValue from './BasicValue.js';
+import FieldActionsButton, { useRevealFieldActions, } from './FieldActionsButton.js';
 import FieldName from './FieldName.js';
 const useStyles = makeStyles()({
     field: {
@@ -8,7 +9,8 @@ const useStyles = makeStyles()({
         flexWrap: 'wrap',
     },
 });
-export default function SimpleField({ name, value, description, prefix, width, formatter, }) {
-    const { classes } = useStyles();
-    return value != null ? (_jsxs("div", { className: classes.field, children: [_jsx(FieldName, { prefix: prefix, description: description, name: name, width: width }), _jsx(BasicValue, { value: formatter ? formatter(value, name) : value })] })) : null;
+export default function SimpleField({ name, value, description, prefix, width, formatter, fieldActions, }) {
+    const { classes, cx } = useStyles();
+    const reveal = useRevealFieldActions();
+    return value != null ? (_jsxs("div", { className: cx(classes.field, reveal), children: [_jsx(FieldName, { prefix: prefix, description: description, name: name, width: width }), _jsx(BasicValue, { value: formatter ? formatter(value, name) : value }), _jsx(FieldActionsButton, { path: [...(prefix ?? []), name], value: value, fieldActions: fieldActions })] })) : null;
 }

package/esm/BaseFeatureWidget/BaseFeatureDetail/index.d.ts

@@ -6,3 +6,4 @@ export { default as BaseAttributes } from './BaseAttributes.tsx';
 export { default as BaseCoreDetails } from './BaseCoreDetails.tsx';
 export { default as FeatureDetails } from './FeatureDetails.tsx';
 export { default as FeatureWash } from './FeatureWash.tsx';
+export { filterByValueItems, jexlFilterDisplay } from './jexlFilterActions.ts';

package/esm/BaseFeatureWidget/BaseFeatureDetail/index.js

@@ -9,10 +9,6 @@ const BaseFeatureDetail = observer(function BaseFeatureDetail({ model, }) {
     const { error, featureData, parentFeature } = model;
     // annotated to shed the MST node brand types.frozen() carries on the instance
     const descriptions = model.descriptions;
-    // A field is hidden by a formatDetails callback returning undefined (jexl
-    // can't produce null); every detail component filters with `!= null`, so a
-    // field set to undefined (live) or null (round-tripped through a snapshot) is
-    // dropped identically.
     if (error) {
         return _jsx(ErrorBanner, { error: error });
     }
@@ -29,3 +25,4 @@ export { default as BaseAttributes } from './BaseAttributes.js';
 export { default as BaseCoreDetails } from './BaseCoreDetails.js';
 export { default as FeatureDetails } from './FeatureDetails.js';
 export { default as FeatureWash } from './FeatureWash.js';
+export { filterByValueItems, jexlFilterDisplay } from './jexlFilterActions.js';

package/esm/BaseFeatureWidget/BaseFeatureDetail/jexlFilterActions.d.ts

@@ -0,0 +1,16 @@
+import type { MenuItem } from '../../ui/MenuTypes.ts';
+import type { JexlFilterModel } from '../../util/jexlFilters.ts';
+import type { IStateTreeNode } from '@jbrowse/mobx-state-tree';
+export interface JexlFilterDisplay extends JexlFilterModel, IStateTreeNode {
+}
+export declare function isJexlFilterDisplay(thing: unknown): thing is JexlFilterDisplay;
+/** The first of a track's displays that takes jexl filters. */
+export declare function jexlFilterDisplay(track?: {
+    displays: readonly unknown[];
+}): JexlFilterDisplay | undefined;
+/**
+ * "Show only" and "Hide" items for one feature attribute's value, and "Show
+ * only ≥" for a number. Each appends a filter line to the display and offers
+ * an undo.
+ */
+export declare function filterByValueItems(display: JexlFilterDisplay, path: string[], value: unknown): MenuItem[];

package/esm/BaseFeatureWidget/BaseFeatureDetail/jexlFilterActions.js

@@ -0,0 +1,53 @@
+import { pathSubject, printCondition } from '@jbrowse/jexl';
+import { activeJexlFilters } from '../../util/jexlFilters.js';
+import { ensureJexlPrefix } from '../../util/jexlStrings.js';
+import { getNotificationSink } from '../../util/sessionServices.js';
+const MAX_LABEL_VALUE = 30;
+export function isJexlFilterDisplay(thing) {
+    return (typeof thing === 'object' &&
+        thing !== null &&
+        'setJexlFilters' in thing &&
+        'configuredFilters' in thing);
+}
+/** The first of a track's displays that takes jexl filters. */
+export function jexlFilterDisplay(track) {
+    return track?.displays.find(isJexlFilterDisplay);
+}
+/**
+ * "Show only" and "Hide" items for one feature attribute's value, and "Show
+ * only ≥" for a number. Each appends a filter line to the display and offers
+ * an undo.
+ */
+export function filterByValueItems(display, path, value) {
+    if (typeof value !== 'string' && typeof value !== 'number') {
+        return [];
+    }
+    const field = path.join('.');
+    const text = String(value);
+    const shown = text.length > MAX_LABEL_VALUE ? `${text.slice(0, MAX_LABEL_VALUE)}…` : text;
+    const add = (op) => () => {
+        const previous = display.jexlFiltersSetting;
+        const line = printCondition({
+            subject: pathSubject('feature', path),
+            op,
+            value,
+        });
+        display.setJexlFilters([
+            ...activeJexlFilters(display),
+            ensureJexlPrefix(line),
+        ]);
+        getNotificationSink(display).notify('Filter added', 'info', {
+            name: 'Undo',
+            onClick: () => {
+                display.setJexlFilters(previous && [...previous]);
+            },
+        });
+    };
+    return [
+        { label: `Show only ${field} = ${shown}`, onClick: add('==') },
+        { label: `Hide ${field} = ${shown}`, onClick: add('!=') },
+        ...(typeof value === 'number'
+            ? [{ label: `Show only ${field} ≥ ${shown}`, onClick: add('>=') }]
+            : []),
+    ];
+}

package/esm/BaseFeatureWidget/BaseFeatureDetail/util.d.ts

@@ -1,11 +1,3 @@
 export declare function isEmpty(obj: Record<string, unknown>): boolean;
-export declare function applyFeatureFormatting<T extends {
-    __jbrowsefmt?: Record<string, unknown>;
-}>(feature: T): T & {
-    [x: string]: unknown;
-};
-export declare function isFormattedField(feature: {
-    __jbrowsefmt?: Record<string, unknown>;
-}, key: string): boolean;
 export declare function generateTitle(name: unknown, id: unknown, type: unknown): string;
 export declare function accessNested(arr: string[], obj?: Record<string, unknown>): string | undefined;

package/esm/BaseFeatureWidget/BaseFeatureDetail/util.js

@@ -3,22 +3,6 @@ import { ellipses } from '../util.js';
 export function isEmpty(obj) {
     return Object.keys(obj).length === 0;
 }
-// The view the details panel renders: raw feature fields with the
-// formatDetails-callback output (`__jbrowsefmt`) merged on top, so a callback
-// value overrides the raw one. A field the callback sets to null/undefined then
-// drops out of the panel's `!= null` filters — this is how callbacks hide
-// fields. `__jbrowsefmt` itself is in Attributes' globalOmit, so it never
-// renders.
-export function applyFeatureFormatting(feature) {
-    return { ...feature, ...feature.__jbrowsefmt };
-}
-// Whether a formatDetails callback named `key` at all -- including setting it
-// to null/undefined, which is how a callback hides a field. Lets a derived row
-// (e.g. Length) defer to the callback without treating "hidden" as "absent".
-export function isFormattedField(feature, key) {
-    const fmt = feature.__jbrowsefmt;
-    return fmt !== undefined && key in fmt;
-}
 export function generateTitle(name, id, type) {
     const label = name || id;
     return [label ? ellipses(`${label}`) : '', type ? `${type}` : '']

package/esm/BaseFeatureWidget/SequenceFeatureDetails/SequenceContents.js

@@ -1,42 +1,14 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { observer } from 'mobx-react';
-import { getGeneticCode, parseTranslTable, relativizeTranslExcept, } from '../../util/geneticCodes.js';
+import { getGeneticCode } from '../../util/geneticCodes.js';
+import SimpleFeature from '../../util/simpleFeature.js';
+import { transcriptGeneticCodeId, transcriptTranslExcept, } from '../../util/translateTranscript.js';
 import { modeHasUpDownstream, modeSupportsRevcomp, resolveShowCoordinates, } from './featureTypeUtil.js';
 import CDNASequence from './seqtypes/CDNASequence.js';
 import CDSSequence from './seqtypes/CDSSequence.js';
 import GenomicSequence from './seqtypes/GenomicSequence.js';
 import ProteinSequence from './seqtypes/ProteinSequence.js';
 import { getSequenceData } from './useSequenceData.js';
-function findCdsSubfeature(feature) {
-    return feature.subfeatures?.find(f => f.type?.toLowerCase() === 'cds');
-}
-// CDS-bound translation reads `transl_table` off the CDS subfeature (or the
-// feature itself), so e.g. a mitochondrial gene translates with table 2 rather
-// than the standard code. When the feature carries no transl_table (e.g. UCSC
-// genePred-derived GFFs), fall back to the assembly-configured code for the
-// contig. Undefined falls back to the standard code.
-function proteinGeneticCode(feature, assemblyGeneticCodeId) {
-    const cds = findCdsSubfeature(feature);
-    const id = parseTranslTable(feature.transl_table) ??
-        parseTranslTable(cds?.transl_table) ??
-        assemblyGeneticCodeId;
-    return getGeneticCode(id);
-}
-// Parses transl_except from the feature or its CDS subfeature into the coordinate
-// system used by convertCodingSequenceToPeptides (feature-relative, reversed for
-// minus-strand genes).
-function featureTranslExcept(feature) {
-    const cds = findCdsSubfeature(feature);
-    const raw = feature.transl_except ?? cds?.transl_except;
-    return raw
-        ? relativizeTranslExcept({
-            raw,
-            featureStart: feature.start,
-            featureLength: feature.end - feature.start,
-            strand: feature.strand,
-        })
-        : [];
-}
 // Dispatches to the renderer for the current sequence type. An observer because
 // it reads showCoordinatesSetting: that setting moving relative<->genomic
 // leaves the coarse showCoordinates boolean every other observer here reads
@@ -60,9 +32,10 @@ const SequenceContents = observer(function SequenceContents({ mode, feature, seq
         case 'cds':
             return _jsx(CDSSequence, { model: model, cds: cds, sequence: seq });
         case 'protein': {
-            const translExcept = featureTranslExcept(feature);
-            const code = proteinGeneticCode(feature, assemblyGeneticCodeId);
-            return (_jsx(ProteinSequence, { model: model, cds: cds, sequence: seq, codonTable: code.codonTable, starts: code.starts, translExcept: translExcept.length ? translExcept : undefined }));
+            const transcript = new SimpleFeature(feature);
+            const translExcept = transcriptTranslExcept(transcript);
+            const code = getGeneticCode(transcriptGeneticCodeId(transcript, assemblyGeneticCodeId));
+            return (_jsx(ProteinSequence, { model: model, cds: cds, sequence: seq, codonTable: code.codonTable, starts: code.starts, translExcept: translExcept?.length ? translExcept : undefined }));
         }
         // cdna and the gene_* variants all render the spliced transcript; introns
         // and up/downstream flanks are toggled by the mode name

package/esm/BaseFeatureWidget/configSchema.d.ts

@@ -1,2 +1,2 @@
-declare const configSchema: import("../configuration/configurationSchema.ts").ConfigurationSchemaType<{}, import("../configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, undefined>>;
+declare const configSchema: import("../configuration/configurationSchema.ts").ConfigurationSchemaType<{}, import("../configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, undefined, undefined, import("../configuration/requirements.ts").ConfigurationSchemaRequirement<Partial<Record<string, string[]>>, string>>>;
 export { configSchema };

package/esm/BaseFeatureWidget/formatDetails.d.ts

@@ -1,38 +1,22 @@
 import type { AnyConfigurationModel } from '../configuration/index.ts';
 import type { SimpleFeatureSerialized } from '../util/index.ts';
-import type { IStateTreeNode } from '@jbrowse/mobx-state-tree';
 /**
- * Anything carrying a `formatDetails` sub-schema: the session (whose
- * `configuration.formatDetails` applies to every track) and the clicked
- * feature's track. The track is absent when the widget was opened without one,
- * or outlived the one it had -- it is a `safeReference` -- and the session-wide
- * tier still has to run in that case.
+ * The two config nodes carrying a `formatDetails` sub-schema. The session's
+ * applies to every track; the track's is absent when the widget was opened
+ * without one. The track's object spreads over the session's, and its numbers
+ * win.
  */
-export interface FormatDetailsHolder extends IStateTreeNode {
-    configuration: AnyConfigurationModel;
-}
 export interface FormatDetailsTiers {
-    session: FormatDetailsHolder;
-    track?: FormatDetailsHolder;
+    session: AnyConfigurationModel;
+    track?: AnyConfigurationModel;
 }
-/**
- * `depth` or `maxDepth`: the track's value when the track sets one, else the
- * session's, else unset.
- *
- * These override rather than merge, unlike the callback objects. That is only
- * expressible because both are `maybeNumber` slots with no `defaultValue` --
- * given a schema default the track reported a value whether or not anyone set
- * one, so the session-wide tier could never apply to a track, and every real
- * config has a track.
- */
+/** `depth` or `maxDepth`: the track's value when set, else the session's. */
 export declare function formatDetailsNumber(tiers: FormatDetailsTiers, slot: string): number | undefined;
 /**
- * A copy of the feature with each tier's callback output merged onto it (and
- * onto its subfeatures, down to `depth`) as `__jbrowsefmt`, which the detail
- * components spread over the raw fields at render.
- *
- * `__jbrowsefmt` is attached only where a callback produced something, so a
- * config with no `formatDetails` at all leaves the feature exactly as it came
- * in rather than stamping empty objects through the persisted snapshot.
+ * The feature as the details panel shows it: each tier's `feature` callback
+ * output spread over the clicked feature, and `subfeatures` output over each
+ * subfeature down to `depth`. A key set to null or undefined hides that row,
+ * since every detail component filters with `!= null`. A config declaring no
+ * callback gets the input back untouched.
  */
-export declare function applyFormatDetails(tiers: FormatDetailsTiers, featureData: SimpleFeatureSerialized): SimpleFeatureSerialized;
+export declare function applyFormatDetails(tiers: FormatDetailsTiers, feature: SimpleFeatureSerialized): SimpleFeatureSerialized;