@jbrowse/core 4.3.0 → 5.0.0-beta.10

package/esm/configuration/configurationSlot.js

@@ -1,239 +1,246 @@
 import { types } from '@jbrowse/mobx-state-tree';
-import { getEnv } from "../util/index.js";
-import { stringToJexlExpression } from "../util/jexlStrings.js";
-import { FileLocation } from "../util/types/mst.js";
-function isValidColorString(_str) {
-    return true;
+import { isCssColor } from '../util/cssColorParse.js';
+import { isJexl, stringToJexlExpression } from '../util/jexlStrings.js';
+import { FileLocation, JexlExpressionString } from '../util/types/mst.js';
+import { isCallbackValue } from './slotValueUtils.js';
+// What a color slot admits is what the painters parse (`isCssColor`), plus the
+// empty string a slot such as `outlineColor` spells "none" with; a field name
+// written where a color goes used to load and paint the invalid sentinel.
+function notAColor(value) {
+    return `${JSON.stringify(value)} is not a color. A color is a CSS color: a name like "red" or "steelblue", "#rgb" / "#rrggbb" / "#rrggbbaa", "rgb()" / "rgba()" / "hsl()" / "hsla()", or "transparent"; a color computed per feature is a "jexl:" callback, in a slot that takes one`;
 }
-const typeModels = {
-    stringArray: types.array(types.string),
-    stringArrayMap: types.map(types.array(types.string)),
-    numberMap: types.map(types.number),
-    boolean: types.boolean,
-    color: types.refinement('Color', types.string, isValidColorString),
-    integer: types.integer,
-    number: types.number,
-    string: types.string,
-    text: types.string,
-    fileLocation: FileLocation,
-    frozen: types.frozen(),
-};
-const fallbackDefaults = {
-    stringArray: [],
-    stringArrayMap: {},
-    numberMap: {},
-    boolean: true,
-    color: 'black',
-    integer: 1,
-    number: 1,
-    string: '',
-    text: '',
-    fileLocation: { uri: '/path/to/resource.txt', locationType: 'UriLocation' },
-    frozen: {},
-};
-const literalJSON = (self) => ({
-    views: {
-        get valueJSON() {
-            return self.value;
-        },
-    },
+const CssColorType = types.refinement('CssColor', types.string, value => value === '' || isCssColor(value), notAColor);
+// An entry of a colour list has no "none" to spell, so '' is refused with the
+// rest of what is not a colour.
+const CssColorEntryType = types.refinement('CssColorEntry', types.string, isCssColor, notAColor);
+const MaybeFileLocation = types.snapshotProcessor(types.maybe(FileLocation), {
+    preProcessor: (snap) => snap && 'uri' in snap && snap.uri === '' ? undefined : snap,
 });
-const objectJSON = (self) => ({
-    views: {
-        get valueJSON() {
-            return JSON.stringify(self.value);
-        },
+// Single source of truth for the builtin slot type names, pairing each with its
+// MST value type and its editor fallback default. Keeping model + fallback in
+// one table means adding a slot type is one edit and can't half-register.
+//
+// `satisfies` rather than an annotation: a `Record<string, …>` annotation
+// widens the keys to `string`, which is what let `type: 'enum'` — a name this
+// table has never had — compile for years and silently lose the config
+// editor's dropdown. The literal keys are what `ConfigSlotType` below is made
+// of.
+const slotTypes = {
+    stringArray: { model: types.array(types.string), fallbackDefault: [] },
+    expressionArray: {
+        model: types.array(JexlExpressionString),
+        fallbackDefault: [],
     },
-});
-const typeModelExtensions = {
-    fileLocation: objectJSON,
-    number: literalJSON,
-    integer: literalJSON,
-    boolean: literalJSON,
-    frozen: objectJSON,
-    stringArray: (self) => ({
-        views: {
-            get valueJSON() {
-                return JSON.stringify(self.value);
-            },
-        },
-        actions: {
-            add(val) {
-                self.value.push(val);
-            },
-            removeAtIndex(idx) {
-                self.value.splice(idx, 1);
-            },
-            setAtIndex(idx, val) {
-                self.value[idx] = val;
-            },
-        },
-    }),
-    stringArrayMap: (self) => ({
-        views: {
-            get valueJSON() {
-                return JSON.stringify(self.value);
-            },
-        },
-        actions: {
-            add(key, val) {
-                self.value.set(key, val);
-            },
-            remove(key) {
-                self.value.delete(key);
-            },
-            addToKey(key, val) {
-                const ar = self.value.get(key);
-                if (!ar) {
-                    throw new Error(`${key} not found`);
-                }
-                ar.push(val);
-            },
-            removeAtKeyIndex(key, idx) {
-                const ar = self.value.get(key);
-                if (!ar) {
-                    throw new Error(`${key} not found`);
-                }
-                ar.splice(idx, 1);
-            },
-            setAtKeyIndex(key, idx, val) {
-                const ar = self.value.get(key);
-                if (!ar) {
-                    throw new Error(`${key} not found`);
-                }
-                ar[idx] = val;
-            },
-        },
-    }),
-    numberMap: (self) => ({
-        views: {
-            get valueJSON() {
-                return JSON.stringify(self.value);
-            },
-        },
-        actions: {
-            add(key, val) {
-                self.value.set(key, val);
-            },
-            remove(key) {
-                self.value.delete(key);
-            },
+    colorArray: { model: types.array(CssColorEntryType), fallbackDefault: [] },
+    stringArrayMap: {
+        model: types.map(types.array(types.string)),
+        fallbackDefault: {},
+    },
+    numberMap: { model: types.map(types.number), fallbackDefault: {} },
+    stringMap: { model: types.map(types.string), fallbackDefault: {} },
+    boolean: { model: types.boolean, fallbackDefault: true },
+    color: { model: CssColorType, fallbackDefault: 'black' },
+    integer: { model: types.integer, fallbackDefault: 1 },
+    number: { model: types.number, fallbackDefault: 1 },
+    // The `maybe*` types spend `undefined` on "not explicitly set", which is the
+    // one value no config can spell and so the only reliable way to say it — a
+    // computed/auto fallback, e.g. a drag-resized track height.
+    maybeNumber: { model: types.maybe(types.number) },
+    maybeBoolean: { model: types.maybe(types.boolean) },
+    // for a slot whose unset state means "decide from the data" — a feature's own
+    // BED itemRgb, say
+    maybeColor: { model: types.maybe(CssColorType) },
+    // object-valued, e.g. alignments `sortedBy`
+    maybeFrozen: { model: types.maybe(types.frozen()) },
+    // for text whose unset state is a third thing beside some text and none: an
+    // axis title is derived while unset, and drawn bare once it is ''
+    maybeString: { model: types.maybe(types.string) },
+    string: { model: types.string, fallbackDefault: '' },
+    text: { model: types.string, fallbackDefault: '' },
+    // a field the display reads per feature: a name, a dotted path, or a
+    // `jexl:` expression, which the display evaluates and the reader never does
+    featureField: { model: types.string, fallbackDefault: '' },
+    fileLocation: {
+        model: FileLocation,
+        fallbackDefault: {
+            uri: '/path/to/resource.txt',
+            locationType: 'UriLocation',
         },
-    }),
+    },
+    // for a sidecar the adapter works without: unset means no file is
+    // configured, and so does the `{ uri: '' }` a cleared URL field in the
+    // config editor writes
+    maybeFileLocation: { model: MaybeFileLocation },
+    frozen: { model: types.frozen(), fallbackDefault: {} },
 };
-const JexlStringType = types.refinement('JexlString', types.string, str => str.startsWith('jexl:'));
-function json(value) {
-    return value?.toJSON ? value.toJSON() : `"${value}"`;
+// The types with no builtin table entry, because the author supplies the
+// `types.enumeration` as `model` and `ConfigSlot` wraps it: in `types.maybe`
+// for `maybeStringEnum`, in `types.array` for `stringEnumArray`. Named once,
+// and spliced into both the type union and the runtime set below so those two
+// cannot drift apart.
+const ENUM_SLOT_TYPES = [
+    'stringEnum',
+    'maybeStringEnum',
+    'stringEnumArray',
+];
+/**
+ * The same closed set, at runtime, because the type alone does not close it for
+ * the callers that matter most: `ConfigSlot` is plugin-facing, and a JS plugin
+ * or one built against an older core reaches it with no checking at all. Those
+ * are exactly the callers that hit the silent-degradation trap above, and
+ * `type: 'enum'` — a name this table has never had — is the one that did.
+ *
+ * Typed `Set<string>` rather than `Set<ConfigSlotType>` so the membership test
+ * stays a question TypeScript has not already answered for in-tree callers. It
+ * is a real runtime check, not a restatement of the signature.
+ */
+const CONFIG_SLOT_TYPE_NAMES = new Set([
+    ...Object.keys(slotTypes),
+    ...ENUM_SLOT_TYPES,
+]);
+// Lookup view over the table. The two enum types are legal `ConfigSlotType`s
+// with no entry, so indexing by the union has to tolerate a miss — this states
+// that in the type rather than casting it away at each call.
+const builtinSlotTypes = slotTypes;
+// The slot types whose default is `undefined` — the genuine "unset" state,
+// distinguishable from every value a config can spell. Mostly derived from the
+// table above (they're exactly the entries with no `fallbackDefault`, since
+// "unset" is their fixed form) so the two can't drift. `maybeStringEnum` is
+// named explicitly because, like plain `stringEnum`, it has no builtin model:
+// the author supplies the enumeration and `ConfigSlot` wraps it in
+// `types.maybe`.
+const MAYBE_TYPES = new Set([
+    ...Object.entries(slotTypes)
+        .filter(([, spec]) => spec.fallbackDefault === undefined)
+        .map(([name]) => name),
+    'maybeStringEnum',
+]);
+const JexlStringType = types.refinement('JexlString', types.string, isJexl);
+const CALLBACK_SLOTS = 'a slot that takes a callback declares the names it reads, which its config docs list as callback args';
+function notACallbackSlot(value) {
+    return `${JSON.stringify(value)} is a jexl: callback, and this slot takes a value: ${CALLBACK_SLOTS}`;
 }
-export default function ConfigSlot(slotName, { description = '', model, type, defaultValue, contextVariable = [], }) {
-    if (!type) {
-        throw new Error('type name required');
-    }
-    if (!model) {
-        model = typeModels[type];
+/** Why the slot `name`, of type `type`, refuses `value` on a write. */
+export function slotWriteRefusal(name, type, value) {
+    const bare = type === 'expressionArray' && Array.isArray(value)
+        ? value.find(entry => !isJexl(entry))
+        : undefined;
+    return isJexl(value)
+        ? `${name} takes no jexl: callback, and ${JSON.stringify(value)} is one: ${CALLBACK_SLOTS}`
+        : bare !== undefined
+            ? `${name} takes jexl: expressions, and ${JSON.stringify(bare)} is not an expression: write it with its prefix, as "jexl:${String(bare)}"`
+            : `${name} is a ${type} slot and cannot take ${JSON.stringify(value)}`;
+}
+function refusingCallbacks(model) {
+    return types.refinement(model, value => !isJexl(value), notACallbackSlot);
+}
+/**
+ * A configuration slot is a plain MST property holding the slot's value type,
+ * or, where the slot declares a `contextVariable`, that or a `jexl:...`
+ * callback string. Every other slot refuses a `jexl:` string, so a callback
+ * the reader would evaluate is one the schema says it takes. A `featureField`
+ * holds a `jexl:` expression as its value, which the display evaluates per
+ * feature. The value lives directly on the parent configuration model — there
+ * is no per-slot sub-model. `types.stripDefault` omits the property from the
+ * parent snapshot when it equals the default, so saved sessions stay minimal.
+ * Per-slot metadata (type/description/defaultValue/contextVariable) lives in
+ * the schema registry (a WeakMap keyed by the MST type, see
+ * schemaRegistry.ts); jexl callbacks are evaluated on read by
+ * `readConfObject`.
+ *
+ * Interning the returned type on `(type, model, defaultValue)` was prototyped
+ * and declined: a session builds 1197 slot types for 222 distinct ones, and
+ * removing the repeats moves neither the time nor the heap
+ * (`config-schema-construction`, published in `reference/EAGER_BUNDLE.md`).
+ */
+export default function ConfigSlot(definition) {
+    const { model, type, defaultValue } = definition;
+    if (!CONFIG_SLOT_TYPE_NAMES.has(type)) {
+        throw new Error(`config slot needs a known type name, got ${JSON.stringify(type)}`);
     }
-    if (!model) {
+    const valueModel = model ?? builtinSlotTypes[type]?.model;
+    if (!valueModel) {
         throw new Error(`no builtin config slot type "${type}", and no 'model' param provided`);
     }
-    if (defaultValue === undefined) {
+    // the `maybe*` types intentionally default to `undefined` (the "unset"
+    // state); every other slot type must declare a concrete default so a missing
+    // one is caught as an authoring mistake.
+    if (defaultValue === undefined && !MAYBE_TYPES.has(type)) {
         throw new Error("no 'defaultValue' provided");
     }
-    const configSlotModelName = `${slotName.charAt(0).toUpperCase()}${slotName.slice(1)}ConfigSlot`;
-    let slot = types
-        .model(configSlotModelName, {
-        name: types.literal(slotName),
-        description: types.literal(description),
-        type: types.literal(type),
-        value: types.optional(types.union(JexlStringType, model), defaultValue),
-    })
-        .volatile(() => ({
-        contextVariable,
-    }))
-        .views(self => ({
-        get isCallback() {
-            return String(self.value).startsWith('jexl:');
-        },
-    }))
-        .views(self => ({
-        get expr() {
-            return self.isCallback
-                ? stringToJexlExpression(String(self.value), getEnv(self).pluginManager.jexl)
-                : {
-                    eval: () => self.value,
-                };
-        },
-        get valueJSON() {
-            return self.isCallback ? undefined : json(self.value);
-        },
-    }))
-        .views(self => ({
-        getValue(args = {}) {
-            const v = self.value;
-            return typeof v === 'string' && v.startsWith('jexl:')
-                ? self.expr.eval(args)
-                : v;
-        },
-    }))
-        .preProcessSnapshot(val => typeof val === 'object' && val.name === slotName
-        ? val
-        : {
-            name: slotName,
-            description,
-            type,
-            value: val,
-        })
-        .postProcessSnapshot(snap => {
-        if (typeof snap.value === 'object') {
-            return JSON.stringify(snap.value) !== JSON.stringify(defaultValue)
-                ? snap.value
-                : undefined;
+    // The inverse of the `defaultValue === undefined` check above, and the half
+    // that had no guard. A `maybe*` slot whose default is concrete can never *be*
+    // unset — no config can spell `undefined` — so the unset state such a slot
+    // exists to express (auto-fit, decide-from-the-data, inherit) is unreachable
+    // and the branch reading it never runs. There is no symptom: the slot reads as
+    // a perfectly good value everywhere.
+    //
+    // The way this happens is **inheritance**, which is why the type can't catch
+    // it: a `maybe*` override of a plain base slot inherits the base's concrete
+    // default through the definition spread, and the override's own literal looks
+    // right. `LinearMafDisplay.height` over `BaseLinearDisplay`'s `number`/100 is
+    // the case in the repo, and only that display's own tests noticed.
+    if (defaultValue !== undefined && MAYBE_TYPES.has(type)) {
+        throw new Error(`a "${type}" slot cannot have a concrete defaultValue (${JSON.stringify(defaultValue)}): unset is the state a maybe* slot exists for, and no config can spell undefined, so it would be unreachable. If this slot overrides a base slot, the base's defaultValue merged in — state 'defaultValue: undefined' to overwrite it. Otherwise use the non-maybe form of the type.`);
+    }
+    const callback = !!definition.contextVariable?.length;
+    if (type === 'featureField' && callback) {
+        throw new Error('a "featureField" slot names a field the display reads per feature, and its jexl: expression is evaluated there, never called with a contextVariable. If this slot overrides a base callback slot, state \'contextVariable: undefined\'.');
+    }
+    if (!callback && isJexl(defaultValue)) {
+        throw new Error(`the defaultValue ${JSON.stringify(defaultValue)} is a jexl: callback, so the slot declares the contextVariable names it reads`);
+    }
+    const value = enumShaped(type, valueModel);
+    return types.stripDefault(callback
+        ? types.union(JexlStringType, value)
+        : type === 'featureField'
+            ? value
+            : refusingCallbacks(value), defaultValue);
+}
+// The author writes an enum slot's plain vocabulary, and the slot's shape
+// around it is added here.
+function enumShaped(type, model) {
+    return type === 'maybeStringEnum'
+        ? types.maybe(model)
+        : type === 'stringEnumArray'
+            ? types.array(model)
+            : model;
+}
+/**
+ * New value when converting a fixed-value slot to a jexl callback. Already-
+ * callback values are returned unchanged.
+ *
+ * A single JSON.stringify covers every type: `jexl:${42}` and
+ * `jexl:${JSON.stringify(42)}` are identical for numbers/booleans, and the rest
+ * need the quoting/serialization anyway.
+ */
+export function toCallbackValue(value) {
+    return isCallbackValue(value) ? value : `jexl:${JSON.stringify(value)}`;
+}
+/**
+ * New value when converting a jexl callback back to a fixed value: try
+ * evaluating with no args, else fall back to the slot default (and to the slot
+ * type's `fallbackDefault` if the default is itself a callback).
+ */
+export function toFixedValue(value, type, defaultValue, jexl) {
+    if (!isCallbackValue(value)) {
+        return value;
+    }
+    try {
+        const result = stringToJexlExpression(value, jexl).eval();
+        if (result !== undefined) {
+            return result;
         }
-        return snap.value !== defaultValue ? snap.value : undefined;
-    })
-        .actions(self => ({
-        set(newVal) {
-            self.value = newVal;
-        },
-        reset() {
-            self.value = defaultValue;
-        },
-        convertToCallback() {
-            if (self.isCallback) {
-                return;
-            }
-            self.value = `jexl:${self.valueJSON || "''"}`;
-        },
-        convertToValue() {
-            if (!self.isCallback) {
-                return;
-            }
-            try {
-                const funcResult = self.expr.eval();
-                if (funcResult !== undefined) {
-                    self.value = funcResult;
-                    return;
-                }
-            }
-            catch (e) {
-            }
-            self.value = defaultValue;
-            if (!(type in fallbackDefaults)) {
-                throw new Error(`no fallbackDefault defined for type ${type}`);
-            }
-            self.value = fallbackDefaults[type];
-        },
-    }));
-    if (typeModelExtensions[type]) {
-        slot = slot.extend(typeModelExtensions[type]);
     }
-    const completeModel = types.optional(slot, {
-        name: slotName,
-        type,
-        description,
-        value: defaultValue,
-    });
-    Object.defineProperty(completeModel, 'isJBrowseConfigurationSlot', {
-        value: true,
-    });
-    return completeModel;
+    catch {
+        /* fall through to default */
+    }
+    if (isCallbackValue(defaultValue)) {
+        const spec = builtinSlotTypes[type];
+        if (spec?.fallbackDefault === undefined) {
+            throw new Error(`no fallbackDefault defined for type ${type}`);
+        }
+        return spec.fallbackDefault;
+    }
+    return defaultValue;
 }

package/esm/configuration/fillLocations.d.ts

@@ -0,0 +1,14 @@
+/**
+ * A shorthand snapshot with its location slots filled in: `derived` supplies
+ * what the shorthand implies, and any key the config spells out for itself
+ * wins.
+ *
+ * Spread the other way round — derived over the snapshot — a config naming both
+ * a `uri` and a location that is not the sibling of it, `{ uri: 'x.fa',
+ * faiLocation: { uri: 'custom.fai' } }`, silently lost the index it named to
+ * the one the shorthand invents. Every adapter's normalizer had its own copy of
+ * the spread, so the precedence had to be got right 30-odd times.
+ */
+export declare function fillLocations(snap: Record<string, unknown>, derived: Record<string, unknown>): {
+    [x: string]: unknown;
+};

package/esm/configuration/fillLocations.js

@@ -0,0 +1,14 @@
+/**
+ * A shorthand snapshot with its location slots filled in: `derived` supplies
+ * what the shorthand implies, and any key the config spells out for itself
+ * wins.
+ *
+ * Spread the other way round — derived over the snapshot — a config naming both
+ * a `uri` and a location that is not the sibling of it, `{ uri: 'x.fa',
+ * faiLocation: { uri: 'custom.fai' } }`, silently lost the index it named to
+ * the one the shorthand invents. Every adapter's normalizer had its own copy of
+ * the spread, so the precedence had to be got right 30-odd times.
+ */
+export function fillLocations(snap, derived) {
+    return { ...derived, ...snap };
+}

package/esm/configuration/formatAboutConfigSchema.d.ts

@@ -0,0 +1,41 @@
+/**
+ * #config FormatAbout
+ * #category root
+ * jexl callbacks that add, rewrite or hide fields in a track's About dialog.
+ * The same schema hangs off every track and off the session as
+ * `configuration.formatAbout`, which applies to every track at once. Where both
+ * are set the track's object is spread over the session's, so a track can
+ * override individual keys the global callback added.
+ *
+ * #example
+ * On a track. The callback's variable is `config`, not `feature`, since the
+ * dialog shows the track's own configuration rather than a feature:
+ * ```js
+ * {
+ *   type: 'FeatureTrack',
+ *   trackId: 'genes',
+ *   name: 'Genes',
+ *   assemblyNames: ['hg38'],
+ *   adapter: {
+ *     type: 'Gff3TabixAdapter',
+ *     uri: 'https://example.com/genes.gff.gz',
+ *   },
+ *   formatAbout: {
+ *     hideUris: true,
+ *     config: "jexl:{Source:'GENCODE v44', adapter:undefined}",
+ *   },
+ * }
+ * ```
+ */
+export declare function FormatAboutConfigSchemaFactory(): import("./configurationSchema.ts").ConfigurationSchemaType<{
+    readonly config: {
+        type: "frozen";
+    } & {
+        defaultValue: unknown;
+    };
+    readonly hideUris: {
+        type: "boolean";
+    } & {
+        defaultValue: boolean;
+    };
+}, import("./configurationSchema.ts").ConfigurationSchemaOptions<undefined, undefined, undefined, import("./requirements.ts").ConfigurationSchemaRequirement<Partial<Record<string, string[]>>, string>, any>>;

package/esm/configuration/formatAboutConfigSchema.js

@@ -0,0 +1,58 @@
+import { ConfigurationSchema } from './configurationSchema.js';
+/**
+ * #config FormatAbout
+ * #category root
+ * jexl callbacks that add, rewrite or hide fields in a track's About dialog.
+ * The same schema hangs off every track and off the session as
+ * `configuration.formatAbout`, which applies to every track at once. Where both
+ * are set the track's object is spread over the session's, so a track can
+ * override individual keys the global callback added.
+ *
+ * #example
+ * On a track. The callback's variable is `config`, not `feature`, since the
+ * dialog shows the track's own configuration rather than a feature:
+ * ```js
+ * {
+ *   type: 'FeatureTrack',
+ *   trackId: 'genes',
+ *   name: 'Genes',
+ *   assemblyNames: ['hg38'],
+ *   adapter: {
+ *     type: 'Gff3TabixAdapter',
+ *     uri: 'https://example.com/genes.gff.gz',
+ *   },
+ *   formatAbout: {
+ *     hideUris: true,
+ *     config: "jexl:{Source:'GENCODE v44', adapter:undefined}",
+ *   },
+ * }
+ * ```
+ */
+export function FormatAboutConfigSchemaFactory() {
+    return ConfigurationSchema('FormatAbout', {
+        /**
+         * #slot formatAbout.config
+         * callback returning an object of fields to merge over the config shown
+         */
+        config: {
+            type: 'frozen',
+            description: 'formats configuration object in about dialog',
+            defaultValue: {},
+            contextVariable: ['config'],
+        },
+        /**
+         * #slot formatAbout.hideUris
+         * leave file locations out of the About dialog, for a deployment that would
+         * rather not show users where the data sits. Hides URIs and local paths
+         * alike, drops the "Copy config" button, and suppresses the File info panel
+         * — a BAM's `@SQ UR:` and `@PG CL:` lines are locations too. "Show ref
+         * names" stays, since it exposes none. The two tiers are OR'd, so a
+         * session-wide `true` cannot be turned back on by a track. It hides the
+         * locations from the dialog only, not from `config.json`
+         */
+        hideUris: {
+            type: 'boolean',
+            defaultValue: false,
+        },
+    });
+}

package/esm/configuration/formatDetailsConfigSchema.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Levels of subfeature the `subfeatures` callback runs on when no tier sets
+ * `depth`. Applied by the reader rather than as the slot's `defaultValue`, so
+ * the slot can still read as unset and the session's value reach a track.
+ */
+export declare const DEFAULT_FORMAT_DETAILS_DEPTH = 2;
+/**
+ * #config FormatDetails
+ * #category root
+ * jexl callbacks that add, rewrite or hide fields in the feature-details panel.
+ * The same schema hangs off every track and off the session as
+ * `configuration.formatDetails`, which applies to every track at once. Where
+ * both are set, the callbacks merge with the track's object over the session's,
+ * so a track can override individual keys the global callback added, and the
+ * numeric slots take the track's value when the track sets one.
+ *
+ * #example
+ * On a track. The callback returns an object merged over the feature: a new key
+ * adds a row, an existing key rewrites it, and `undefined` hides it. A bare URL
+ * is turned into a link for you, so no `<a>` markup is needed:
+ * ```js
+ * {
+ *   type: 'FeatureTrack',
+ *   trackId: 'genes',
+ *   name: 'Genes',
+ *   assemblyNames: ['hg38'],
+ *   adapter: {
+ *     type: 'Gff3TabixAdapter',
+ *     uri: 'https://example.com/genes.gff.gz',
+ *   },
+ *   formatDetails: {
+ *     feature: "jexl:{ncbi:'https://www.ncbi.nlm.nih.gov/gene/?term='+feature.name, phase:undefined}",
+ *   },
+ * }
+ * ```
+ */
+export declare function FormatDetailsConfigSchemaFactory(): import("./configurationSchema.ts").ConfigurationSchemaType<{
+    readonly feature: {
+        type: "frozen";
+    } & {
+        defaultValue: unknown;
+    };
+    readonly subfeatures: {
+        type: "frozen";
+    } & {
+        defaultValue: unknown;
+    };
+    readonly depth: {
+        type: "maybeNumber";
+    };
+    readonly maxDepth: {
+        type: "maybeNumber";
+    };
+}, import("./configurationSchema.ts").ConfigurationSchemaOptions<undefined, undefined, undefined, import("./requirements.ts").ConfigurationSchemaRequirement<Partial<Record<string, string[]>>, string>, any>>;