@jbrowse/core 5.0.0-beta.1 → 5.0.0-beta.10

package/esm/configuration/schemaTypes.js

@@ -5,75 +5,50 @@
  * schema construction, every reader, and the config editor — so "is this a
  * config schema?" and "what kind of entry is this?" have one answer everywhere.
  */
-import { getType, isArrayType, isLateType, isMapType, isModelType, isOptionalType, isStateTreeNode, isType, isUnionType, } from '@jbrowse/mobx-state-tree';
-import { getDefaultValue, getSubType, getUnionSubTypes, resolveLateType, } from '../util/mst-reflection.js';
-import { isRegisteredConfigurationSchema } from './schemaRegistry.js';
+import { asArrayType, asMapType, getType, getUnionSubtypes, isStateTreeNode, isType, isUnionType, } from '@jbrowse/mobx-state-tree';
+import { getConfigurationSchemaMetadata, isRegisteredConfigurationSchema, } from './schemaRegistry.js';
 /**
- * given a union of explicitly typed configuration schema types,
- * extract an array of the type names contained in the union
- *
- * @param unionType -
- * @returns Array of type names contained in the union
+ * The names an explicitly typed union's members answer to, each the name its
+ * schema was given, read through whatever wraps the union — a pluggable
+ * union's `snapshotProcessor`, a `maybe`, a `types.late`. A member that is
+ * itself a union contributes its own; a member with no type of its own throws.
  */
 export function getTypeNamesFromExplicitlyTypedUnion(maybeUnionType) {
-    if (isType(maybeUnionType)) {
-        const resolved = resolveLateType(maybeUnionType);
-        if (isUnionType(resolved)) {
-            const typeNames = [];
-            for (const subType of getUnionSubTypes(resolved)) {
-                const resolvedSub = resolveLateType(subType);
-                // a nested union contributes its own names; otherwise the subtype is a
-                // single explicitly-typed schema whose name is its default's `type`
-                const nested = getTypeNamesFromExplicitlyTypedUnion(resolvedSub);
-                if (nested.length) {
-                    typeNames.push(...nested);
-                }
-                else {
-                    const typeName = getDefaultValue(resolvedSub).type;
-                    if (!typeName) {
-                        throw new Error(`invalid config schema type ${resolvedSub}`);
-                    }
-                    typeNames.push(typeName);
-                }
-            }
-            return typeNames;
-        }
+    if (!isType(maybeUnionType) || !isUnionType(maybeUnionType)) {
+        return [];
     }
-    return [];
-}
-export function isBareConfigurationSchemaType(thing) {
-    if (isType(thing)) {
-        if (isModelType(thing) && isRegisteredConfigurationSchema(thing)) {
-            return true;
+    return getUnionSubtypes(maybeUnionType).flatMap(member => {
+        const meta = getConfigurationSchemaMetadata(member);
+        if (meta?.options.explicitlyTyped) {
+            return [meta.name];
         }
-        // if it's a late type, assume its a config schema
-        if (isLateType(thing)) {
-            return true;
+        if (isUnionType(member)) {
+            return getTypeNamesFromExplicitlyTypedUnion(member);
         }
-    }
-    return false;
+        // the branch a `maybe`-like union adds so the slot can be absent
+        if (member.name === 'undefined') {
+            return [];
+        }
+        throw new Error(`invalid config schema type ${member.name}`);
+    });
+}
+/** The type `ConfigurationSchema()` built, by any handle on it (`schemaRegistry.ts`). */
+export function isBareConfigurationSchemaType(thing) {
+    return isType(thing) && isRegisteredConfigurationSchema(thing);
 }
+/** A schema, or a union, array or map of them. */
 export function isConfigurationSchemaType(thing) {
-    // written as a series of if-statements instead of a big logical because this
-    // construction gives much better debugging backtraces.
-    // also, note that the order of these statements matters, because for example
-    // some union types are also optional types
     if (!isType(thing)) {
         return false;
     }
-    else if (isBareConfigurationSchemaType(thing)) {
+    if (isBareConfigurationSchemaType(thing)) {
         return true;
     }
-    else if (isUnionType(thing)) {
-        return getUnionSubTypes(thing).every(t => isConfigurationSchemaType(t) || t.name === 'undefined');
-    }
-    else if ((isOptionalType(thing) || isArrayType(thing) || isMapType(thing)) &&
-        isConfigurationSchemaType(getSubType(thing))) {
-        return true;
-    }
-    else {
-        return false;
+    if (isUnionType(thing)) {
+        return getUnionSubtypes(thing).every(t => isConfigurationSchemaType(t) || t.name === 'undefined');
     }
+    const collection = asArrayType(thing) ?? asMapType(thing);
+    return !!collection && isConfigurationSchemaType(collection.getChildType());
 }
 /**
  * A configuration schema definition maps each key to exactly one of three kinds
@@ -92,3 +67,39 @@ export function isSlotDefinitionEntry(def) {
 export function isConfigurationModel(thing) {
     return isStateTreeNode(thing) && isConfigurationSchemaType(getType(thing));
 }
+const NUMBER_SLOT_TYPES = new Set(['number', 'integer', 'maybeNumber']);
+/**
+ * The slot a bare value of each form lifts into, off a `shorthand` option:
+ * each slot it names takes the form its own type holds, a number where it
+ * holds one (`rules: [7.3]`) and a string otherwise (`color: 'red'`), so a
+ * width naming `value` and `field` reads `size: 3` as the one and
+ * `size: 'score'` as the other.
+ */
+export function shorthandTargetsOf(definition, shorthand) {
+    const slots = shorthand === undefined
+        ? []
+        : typeof shorthand === 'string'
+            ? [shorthand]
+            : shorthand;
+    return Object.fromEntries(slots.map(slot => {
+        const entry = definition[slot];
+        return [
+            isSlotDefinitionEntry(entry) && NUMBER_SLOT_TYPES.has(entry.type)
+                ? 'number'
+                : 'string',
+            slot,
+        ];
+    }));
+}
+/** The shorthand form of a bare value, or undefined for any other value. */
+export function bareFormOf(value) {
+    return typeof value === 'string'
+        ? 'string'
+        : typeof value === 'number'
+            ? 'number'
+            : undefined;
+}
+/** {@link shorthandTargetsOf} a registered schema. */
+export function shorthandTargets({ definition, options, }) {
+    return shorthandTargetsOf(definition, options.shorthand);
+}

package/esm/configuration/slotFacade.d.ts

@@ -1,24 +1,19 @@
 import type PluginManager from '../PluginManager.ts';
 import type { ConfigSlotDefinition, ConfigSlotType } from './configurationSlot.ts';
 import type { AnyConfigurationModel } from './types.ts';
+import type { IAnyType } from '@jbrowse/mobx-state-tree';
 /**
  * Whether `slotName` on a config node is a slot (vs a nested sub-schema or a
  * string/number constant).
  */
 export declare function isConfigurationSlot(node: AnyConfigurationModel, slotName: string): boolean;
 /**
- * Run `node`'s own schema `preProcessSnapshot` over a partial bag of slot
- * values headed for that config.
- *
- * A config.json snapshot gets this for free on `create`, but the session/URL
- * path writes slots one `setSlot` at a time onto an already-created config, so
- * without this a schema's shorthand expansions and legacy-key migrations apply
- * to `config.json` and silently no-op in a session spec, share link, or embed —
- * the surfaces that are supposed to speak the same vocabulary. The hooks are
- * written to normalize whatever subset of keys they're handed, so a partial bag
- * is the same shape they already tolerate.
+ * Why a config of type `schema` cannot hold `value` at `key`, or undefined
+ * when it can: the schema's own lift first, then the slot's type, or a
+ * sub-schema's lift and checks. Also undefined for a key the schema does not
+ * declare, which is a question for its caller.
  */
-export declare function preProcessSlotValues(node: AnyConfigurationModel, values: Record<string, unknown>): Record<string, unknown>;
+export declare function slotValueRefusal(schema: IAnyType, key: string, value: unknown): string | undefined;
 /**
  * The duck-typed object the config editor's leaf components consume. They never
  * touch MST internals — only this shape (see ColorEditor.test.tsx, which passes
@@ -33,20 +28,9 @@ export interface SlotFacade {
     contextVariable: string[];
     defaultValue: unknown;
     /**
-     * For a `promotable` slot, the value its unset state resolves to when nothing
-     * is promoted (see `promotableResolve.ts`). Undefined on a plain slot, whose
-     * `defaultValue` is already the concrete value.
-     *
-     * Here because a promotable slot's `defaultValue` is always the `undefined`
-     * inherit sentinel, so an editor rendering `defaultValue` for an unset slot
-     * shows nothing at all — for a `maybeBoolean` that reads as a concrete
-     * `false`, which is wrong for every slot whose base is `true`. The editor
-     * still cannot see the *session* tier of the cascade (its target is often a
-     * detached config node), so this is the honest answer it can give: what unset
-     * means with nothing promoted.
+     * enum choices, present only for the enum slot types; a `stringEnumArray`'s
+     * are the choices of each entry
      */
-    promotedBase?: unknown;
-    /** enum choices, present only for `stringEnum`/`maybeStringEnum` slots */
     choices?: string[];
     pluginManager: PluginManager;
     readonly value: unknown;
@@ -54,17 +38,16 @@ export interface SlotFacade {
      * Whether the slot holds a non-default value. Each slot is `stripDefault`-
      * wrapped, so an at-default slot is omitted from the config snapshot — the
      * same signal the persistence/delta layer uses (robust for map/array slots
-     * where a live-value `deepEqual` against the plain default would misfire). For
-     * a promotable slot, "non-default" means customized rather than inheriting.
+     * where a live-value `deepEqual` against the plain default would misfire).
      */
     readonly modified: boolean;
     set: (val: unknown) => void;
 }
 /**
  * The vocabulary an enum slot offers, or undefined for any other slot. Reads the
- * author's own `types.enumeration` off `model` — `stringEnum` and
- * `maybeStringEnum` are the only two types the editor takes choices from, so a
- * slot typed anything else renders as free text however valid its `model` is.
+ * author's own `types.enumeration` off `model` — the enum types are the only
+ * ones the editor takes choices from, so a slot typed anything else renders as
+ * free text however valid its `model` is.
  *
  * Shared by the config editor's facade below and by
  * `ConfigSlotDefaults.test.ts`, which snapshots every schema's vocabularies:

package/esm/configuration/slotFacade.js

@@ -1,8 +1,11 @@
-import { getSnapshot } from '@jbrowse/mobx-state-tree';
+import { asModelType, getSnapshot } from '@jbrowse/mobx-state-tree';
 import { getEnumerationValues } from '../util/mst-reflection.js';
 import { getEnv } from '../util/mstUtils.js';
-import { getConfigurationSchemaDefinition, getConfigurationSchemaOptions, } from './schemaRegistry.js';
-import { isSlotDefinitionEntry } from './schemaTypes.js';
+import { slotWriteRefusal } from './configurationSlot.js';
+import { setConf } from './getConf.js';
+import { getConfigurationSchemaDefinition, getConfigurationSchemaMetadata, } from './schemaRegistry.js';
+import { isConfigurationSchemaType, isSlotDefinitionEntry, } from './schemaTypes.js';
+import { preProcessSnapshotWith } from './snapshotPreprocess.js';
 /**
  * The slot's metadata entry, or undefined when `slotName` names a nested
  * sub-schema or a string/number constant rather than a slot.
@@ -19,26 +22,42 @@ export function isConfigurationSlot(node, slotName) {
     return !!slotDefinition(node, slotName);
 }
 /**
- * Run `node`'s own schema `preProcessSnapshot` over a partial bag of slot
- * values headed for that config.
- *
- * A config.json snapshot gets this for free on `create`, but the session/URL
- * path writes slots one `setSlot` at a time onto an already-created config, so
- * without this a schema's shorthand expansions and legacy-key migrations apply
- * to `config.json` and silently no-op in a session spec, share link, or embed —
- * the surfaces that are supposed to speak the same vocabulary. The hooks are
- * written to normalize whatever subset of keys they're handed, so a partial bag
- * is the same shape they already tolerate.
+ * Why a config of type `schema` cannot hold `value` at `key`, or undefined
+ * when it can: the schema's own lift first, then the slot's type, or a
+ * sub-schema's lift and checks. Also undefined for a key the schema does not
+ * declare, which is a question for its caller.
  */
-export function preProcessSlotValues(node, values) {
-    const preProcess = getConfigurationSchemaOptions(node)?.preProcessSnapshot;
-    return preProcess ? preProcess(values) : values;
+export function slotValueRefusal(schema, key, value) {
+    const meta = getConfigurationSchemaMetadata(schema);
+    const entry = meta?.definition[key];
+    if (!meta || entry === undefined) {
+        return undefined;
+    }
+    const subSchema = isConfigurationSchemaType(entry)
+        ? entry
+        : undefined;
+    // the slot's own property type, built once with the schema: what `setSlot`
+    // checks a write against
+    const slotType = asModelType(schema)?.properties[key];
+    try {
+        const lifted = preProcessSnapshotWith(meta, { [key]: value })[key];
+        if (subSchema) {
+            subSchema.create(lifted);
+        }
+        else if (isSlotDefinitionEntry(entry) && !slotType?.is(lifted)) {
+            return slotWriteRefusal(`${meta.name}.${key}`, entry.type, value);
+        }
+        return undefined;
+    }
+    catch (e) {
+        return e instanceof Error ? e.message : String(e);
+    }
 }
 /**
  * The vocabulary an enum slot offers, or undefined for any other slot. Reads the
- * author's own `types.enumeration` off `model` — `stringEnum` and
- * `maybeStringEnum` are the only two types the editor takes choices from, so a
- * slot typed anything else renders as free text however valid its `model` is.
+ * author's own `types.enumeration` off `model` — the enum types are the only
+ * ones the editor takes choices from, so a slot typed anything else renders as
+ * free text however valid its `model` is.
  *
  * Shared by the config editor's facade below and by
  * `ConfigSlotDefaults.test.ts`, which snapshots every schema's vocabularies:
@@ -47,7 +66,10 @@ export function preProcessSlotValues(node, values) {
  */
 export function slotChoices(def) {
     const { type, model } = def;
-    return (type === 'stringEnum' || type === 'maybeStringEnum') && model
+    return (type === 'stringEnum' ||
+        type === 'maybeStringEnum' ||
+        type === 'stringEnumArray') &&
+        model
         ? getEnumerationValues(model)
         : undefined;
 }
@@ -66,14 +88,13 @@ export function getSlotDefinition(node, slotName) {
 }
 export function makeSlotFacade(node, slotName) {
     const definition = getSlotDefinition(node, slotName);
-    const { type, description = '', defaultValue, promotedBase, contextVariable = [], } = definition;
+    const { type, description = '', defaultValue, contextVariable = [], } = definition;
     return {
         name: slotName,
         description,
         type,
         contextVariable,
         defaultValue,
-        promotedBase,
         choices: slotChoices(definition),
         pluginManager: getEnv(node).pluginManager,
         get value() {
@@ -83,7 +104,7 @@ export function makeSlotFacade(node, slotName) {
             return slotName in getSnapshot(node);
         },
         set(val) {
-            node.setSlot(slotName, val);
+            setConf(node, slotName, val);
         },
     };
 }

package/esm/configuration/snapshotPreprocess.d.ts

@@ -0,0 +1,43 @@
+import type { RetiredSpelling } from './configurationSchema.ts';
+import type { ConfigurationSchemaMetadata } from './schemaRegistry.ts';
+import type { IAnyType } from '@jbrowse/mobx-state-tree';
+export declare function listed(keys: readonly string[]): string;
+/**
+ * The snapshot with each spelling `retired` names rewritten: a lift's members
+ * take the old key's place, and what the snapshot already spells wins, member
+ * by member inside an object, since writing the current name is the stronger
+ * statement — so a retired flag lifting into `scales.y` lands beside a
+ * `scales.y` the snapshot writes. The old key goes whether or not it carried a
+ * value, so a `closed` schema never meets it. Where two retired names lift
+ * onto one member — a slot the entry spelt directly and the same slot inside a
+ * retired `renderer` — the one declared first wins.
+ */
+export declare function liftRetiredSpellings(schema: ConfigurationSchemaMetadata, snapshot: Record<string, unknown>): Record<string, unknown>;
+/**
+ * `liftRetiredSpellings` over a map directly, for a schema whose own
+ * `preProcessSnapshot` uncovers a retired name the pass above could not see —
+ * one that arrives out of a legacy sub-config rather than off the entry.
+ * Applying the same map twice costs nothing, since a lift deletes the name it
+ * reads.
+ */
+export declare function applyRetiredSpellings(retired: Record<string, RetiredSpelling>, snapshot: Record<string, unknown>): Record<string, unknown>;
+/**
+ * What a schema does to every snapshot on its way in, whichever door it
+ * arrives by (`create`, `applySnapshot`, `setSubschema`, a settings bag): a
+ * bare string or number lifts into the `shorthand` slot taking its form, beside any
+ * `shorthandWith` slots, and `null` into the empty object that clears it; a
+ * `null` member reads as unset, except in a frozen-family slot, which stores
+ * it; a `retired` spelling becomes the members that replaced it; a `closed`
+ * schema refuses a key it does not declare, then the schema's
+ * own `preProcessSnapshot` runs, and a `jexl:` callback in a slot declaring no
+ * `contextVariable` is refused. A bare value the shorthand does not lift
+ * passes through for MST to refuse.
+ */
+export declare function preProcessSnapshotWith(schema: ConfigurationSchemaMetadata, snapshot: unknown): Record<string, unknown>;
+/**
+ * #api core/configuration
+ * A snapshot as `type` admits it: the same lift and checks `type.create`
+ * applies, so a dialog or a validator refuses exactly what a config file
+ * cannot hold. Throws what the schema's `preProcessSnapshot` throws.
+ */
+export declare function preProcessConfigSnapshot(type: IAnyType, snapshot: unknown): Record<string, unknown>;

package/esm/configuration/snapshotPreprocess.js

@@ -0,0 +1,161 @@
+import { isJexl } from '../util/jexlStrings.js';
+import { slotWriteRefusal } from './configurationSlot.js';
+import { getConfigurationSchemaMetadata } from './schemaRegistry.js';
+import { bareFormOf, isConstantEntry, shorthandTargets } from './schemaTypes.js';
+// the keys a config file may annotate any object with, as the JSON schema's
+// `patternProperties` admits them
+const COMMENT_KEY = /^_+comment/;
+export function listed(keys) {
+    return keys.length > 1
+        ? `${keys.slice(0, -1).join(', ')} and ${keys.at(-1)}`
+        : (keys[0] ?? 'nothing');
+}
+function refuseUndeclaredKeys({ name, definition, options }, snapshot) {
+    const id = options.explicitIdentifier;
+    const declared = [
+        ...Object.keys(definition).filter(key => !isConstantEntry(definition[key])),
+        ...(options.explicitlyTyped ? ['type'] : []),
+        ...(id ? [id] : []),
+    ];
+    const unknown = typeof snapshot === 'string'
+        ? [JSON.stringify(snapshot)]
+        : Object.keys(snapshot ?? {}).filter(key => !declared.includes(key) && !COMMENT_KEY.test(key));
+    if (unknown.length > 0) {
+        throw new Error(`${name} takes ${listed(declared)}, not ${unknown.join(', ')}`);
+    }
+}
+// Checked here as well as by each slot's MST type because this runs on every
+// create, where MST's own check is off in a build that has not enabled it
+function refuseCallbacks({ name, takesNoCallback }, snapshot) {
+    if (typeof snapshot === 'object' && snapshot !== null) {
+        for (const key in snapshot) {
+            const type = takesNoCallback.get(key);
+            const value = snapshot[key];
+            if (type !== undefined && isJexl(value)) {
+                throw new Error(slotWriteRefusal(`${name}.${key}`, type, value));
+            }
+        }
+    }
+}
+// ADR-146's reset, on the snapshot path: the member keeps its key, so a
+// settings bag still resets it, and `create` reads `undefined` as the default
+function nullMembersAsUnset(snapshot, storesNull) {
+    let out = snapshot;
+    for (const key in snapshot) {
+        if (snapshot[key] === null && !storesNull.has(key)) {
+            out = out === snapshot ? { ...snapshot } : out;
+            out[key] = undefined;
+        }
+    }
+    return out;
+}
+/**
+ * A schema reads its own entry alone. A `displays` union runs every member's
+ * preprocessor over every entry while it works out which display an entry is,
+ * so an entry naming another type is left as it was, and one naming no type is
+ * a bag headed here.
+ */
+function isOwnSnapshot({ name, options }, snapshot) {
+    return (!options.explicitlyTyped ||
+        snapshot.type === undefined ||
+        snapshot.type === name);
+}
+function isPlainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+// `lifted` under `written`: what the snapshot spells wins, member by member
+// where both are objects.
+function underWritten(written, lifted) {
+    if (written === undefined) {
+        return lifted;
+    }
+    if (isPlainObject(written) && isPlainObject(lifted)) {
+        const out = { ...written };
+        for (const [key, value] of Object.entries(lifted)) {
+            out[key] = underWritten(written[key], value);
+        }
+        return out;
+    }
+    return written;
+}
+/**
+ * The snapshot with each spelling `retired` names rewritten: a lift's members
+ * take the old key's place, and what the snapshot already spells wins, member
+ * by member inside an object, since writing the current name is the stronger
+ * statement — so a retired flag lifting into `scales.y` lands beside a
+ * `scales.y` the snapshot writes. The old key goes whether or not it carried a
+ * value, so a `closed` schema never meets it. Where two retired names lift
+ * onto one member — a slot the entry spelt directly and the same slot inside a
+ * retired `renderer` — the one declared first wins.
+ */
+export function liftRetiredSpellings(schema, snapshot) {
+    const { retired } = schema.options;
+    return retired && isOwnSnapshot(schema, snapshot)
+        ? applyRetiredSpellings(retired, snapshot)
+        : snapshot;
+}
+/**
+ * `liftRetiredSpellings` over a map directly, for a schema whose own
+ * `preProcessSnapshot` uncovers a retired name the pass above could not see —
+ * one that arrives out of a legacy sub-config rather than off the entry.
+ * Applying the same map twice costs nothing, since a lift deletes the name it
+ * reads.
+ */
+export function applyRetiredSpellings(retired, snapshot) {
+    const present = Object.keys(retired).filter(key => key in snapshot);
+    if (present.length === 0) {
+        return snapshot;
+    }
+    const out = { ...snapshot };
+    for (const key of present) {
+        delete out[key];
+    }
+    for (const key of present.filter(key => snapshot[key] !== undefined)) {
+        const lifted = retired[key](snapshot[key]);
+        for (const [name, value] of Object.entries(lifted)) {
+            out[name] = underWritten(out[name], value);
+        }
+    }
+    return out;
+}
+/**
+ * What a schema does to every snapshot on its way in, whichever door it
+ * arrives by (`create`, `applySnapshot`, `setSubschema`, a settings bag): a
+ * bare string or number lifts into the `shorthand` slot taking its form, beside any
+ * `shorthandWith` slots, and `null` into the empty object that clears it; a
+ * `null` member reads as unset, except in a frozen-family slot, which stores
+ * it; a `retired` spelling becomes the members that replaced it; a `closed`
+ * schema refuses a key it does not declare, then the schema's
+ * own `preProcessSnapshot` runs, and a `jexl:` callback in a slot declaring no
+ * `contextVariable` is refused. A bare value the shorthand does not lift
+ * passes through for MST to refuse.
+ */
+export function preProcessSnapshotWith(schema, snapshot) {
+    const { shorthandWith, closed, preProcessSnapshot } = schema.options;
+    const form = bareFormOf(snapshot);
+    const target = form && shorthandTargets(schema)[form];
+    const lifted = snapshot === null
+        ? {}
+        : target !== undefined
+            ? { ...shorthandWith, [target]: snapshot }
+            : nullMembersAsUnset(snapshot, schema.storesNull);
+    const named = liftRetiredSpellings(schema, lifted);
+    if (closed) {
+        refuseUndeclaredKeys(schema, named);
+    }
+    const processed = preProcessSnapshot ? preProcessSnapshot(named) : named;
+    refuseCallbacks(schema, processed);
+    return processed;
+}
+/**
+ * #api core/configuration
+ * A snapshot as `type` admits it: the same lift and checks `type.create`
+ * applies, so a dialog or a validator refuses exactly what a config file
+ * cannot hold. Throws what the schema's `preProcessSnapshot` throws.
+ */
+export function preProcessConfigSnapshot(type, snapshot) {
+    const schema = getConfigurationSchemaMetadata(type);
+    return schema
+        ? preProcessSnapshotWith(schema, snapshot)
+        : snapshot;
+}

package/esm/configuration/tabixIndexFields.d.ts

@@ -14,7 +14,7 @@
  *   two slots in the opposite order
  * - `PairwiseIndexedPAFAdapter`'s prose said `<file>.pif.gz.tbi` while its
  *   default said `my.paf.gz.tbi`
- * - `PlinkLDTabixAdapter` dropped the `(or .csi)` clause
+ * - `PlinkLDTabixAdapter`'s description dropped a clause the other eight carried
  * - the placeholder extensions disagreed with each other for no reason
  *
  * The description is written for every tabix adapter rather than naming one
@@ -24,14 +24,15 @@
  *
  * **BAM is deliberately not here.** Its index is BAI/CSI rather than TBI/CSI, so
  * it is a different enumeration with a different default, and folding the two
- * would mean a slot whose vocabulary depends on its adapter.
+ * would mean a slot whose vocabulary depends on its adapter. `bamIndexFields`
+ * is the same pair over that enumeration, and the two share `fillIndexType`.
  */
 export declare const tabixIndexFields: {
     readonly indexType: {
         readonly model: import("@jbrowse/mobx-state-tree").ISimpleType<"CSI" | "TBI">;
         readonly type: 'stringEnum';
         readonly defaultValue: 'TBI';
-        readonly description: '`TBI` is the usual `tabix` output. `CSI` is required for a reference longer than 512 Mb, which TBI cannot address.';
+        readonly description: '`TBI` is the usual `tabix` output. `CSI` is required for a reference longer than 512 Mb, which TBI cannot address. Derived from the index file name where the config names a `.csi` and leaves this unset.';
     };
     readonly location: {
         readonly type: 'fileLocation';
@@ -39,6 +40,31 @@ export declare const tabixIndexFields: {
             readonly uri: '/path/to/my.gz.tbi';
             readonly locationType: 'UriLocation';
         };
-        readonly description: 'location of the tabix index. Only needed when it is not named `<file>.tbi` (or `.csi`), which is what the `uri` shorthand assumes.';
+        readonly description: 'location of the tabix index. Only needed when it is not named `<file>.tbi`, which is what the `uri` shorthand assumes — a `.csi` beside the file is reached with `csi: true` rather than by spelling this out.';
     };
 };
+/**
+ * #config TabixIndex
+ * #category adapter
+ * The `index` every tabix-indexed adapter hangs off itself: where the index is,
+ * and which of the two kinds it is. `indexType` is derived from the index file's
+ * own name where the config names a `.csi` and leaves it unset, so the usual
+ * config states neither — the `uri` shorthand derives both, and `csi: true`
+ * beside it switches the pair together. Spell `location` out for an index that
+ * does not sit beside its data file; a `.csi` named there is read as a CSI
+ * without `indexType` as well.
+ */
+export declare function tabixIndexSchema(): import("./configurationSchema.ts").ConfigurationSchemaType<{
+    readonly indexType: {
+        type: "stringEnum";
+    } & {
+        model: import("@jbrowse/mobx-state-tree").ISimpleType<"CSI" | "TBI">;
+    } & {
+        defaultValue: string;
+    };
+    readonly location: {
+        type: "fileLocation";
+    } & {
+        defaultValue: unknown;
+    };
+}, import("./configurationSchema.ts").ConfigurationSchemaOptions<undefined, undefined, undefined, import("./requirements.ts").ConfigurationSchemaRequirement<Partial<Record<string, string[]>>, string>, any>>;

package/esm/configuration/tabixIndexFields.js

@@ -1,4 +1,6 @@
 import { types } from '@jbrowse/mobx-state-tree';
+import { ConfigurationSchema } from './configurationSchema.js';
+import { fillIndexType } from './indexType.js';
 /**
  * The `index` sub-schema every tabix-indexed adapter declares: which index kind,
  * and where it is.
@@ -15,7 +17,7 @@ import { types } from '@jbrowse/mobx-state-tree';
  *   two slots in the opposite order
  * - `PairwiseIndexedPAFAdapter`'s prose said `<file>.pif.gz.tbi` while its
  *   default said `my.paf.gz.tbi`
- * - `PlinkLDTabixAdapter` dropped the `(or .csi)` clause
+ * - `PlinkLDTabixAdapter`'s description dropped a clause the other eight carried
  * - the placeholder extensions disagreed with each other for no reason
  *
  * The description is written for every tabix adapter rather than naming one
@@ -25,14 +27,15 @@ import { types } from '@jbrowse/mobx-state-tree';
  *
  * **BAM is deliberately not here.** Its index is BAI/CSI rather than TBI/CSI, so
  * it is a different enumeration with a different default, and folding the two
- * would mean a slot whose vocabulary depends on its adapter.
+ * would mean a slot whose vocabulary depends on its adapter. `bamIndexFields`
+ * is the same pair over that enumeration, and the two share `fillIndexType`.
  */
 export const tabixIndexFields = {
     indexType: {
         model: types.enumeration('IndexType', ['TBI', 'CSI']),
         type: 'stringEnum',
         defaultValue: 'TBI',
-        description: '`TBI` is the usual `tabix` output. `CSI` is required for a reference longer than 512 Mb, which TBI cannot address.',
+        description: '`TBI` is the usual `tabix` output. `CSI` is required for a reference longer than 512 Mb, which TBI cannot address. Derived from the index file name where the config names a `.csi` and leaves this unset.',
     },
     location: {
         type: 'fileLocation',
@@ -40,6 +43,20 @@ export const tabixIndexFields = {
             uri: '/path/to/my.gz.tbi',
             locationType: 'UriLocation',
         },
-        description: 'location of the tabix index. Only needed when it is not named `<file>.tbi` (or `.csi`), which is what the `uri` shorthand assumes.',
+        description: 'location of the tabix index. Only needed when it is not named `<file>.tbi`, which is what the `uri` shorthand assumes — a `.csi` beside the file is reached with `csi: true` rather than by spelling this out.',
     },
 };
+/**
+ * #config TabixIndex
+ * #category adapter
+ * The `index` every tabix-indexed adapter hangs off itself: where the index is,
+ * and which of the two kinds it is. `indexType` is derived from the index file's
+ * own name where the config names a `.csi` and leaves it unset, so the usual
+ * config states neither — the `uri` shorthand derives both, and `csi: true`
+ * beside it switches the pair together. Spell `location` out for an index that
+ * does not sit beside its data file; a `.csi` named there is read as a CSI
+ * without `indexType` as well.
+ */
+export function tabixIndexSchema() {
+    return ConfigurationSchema('TabixIndex', { ...tabixIndexFields }, { preProcessSnapshot: fillIndexType });
+}