@jbrowse/cli 5.0.0-beta.13 → 5.0.0-beta.14

package/dist/commands/validate/markRules/markVocabulary.js

@@ -1,10 +1,12 @@
 // Generated by scripts/generateMarkRules.ts from plugins/marks/src/LinearMarkDisplay/markVocabulary.ts: do not edit, `pnpm autogen` rewrites it.
 /**
  * The names a `marks` list is written in and the ones a slot left off reads
- * as, in a module that imports nothing: the config schema declares its
+ * as, in a module that imports only the rule list's seam: the config schema declares its
  * enumerations and defaults from here, the rule list reads the same constants,
- * and `jbrowse validate` carries a copy of both.
+ * and `jbrowse validate` carries a copy of both. What a step writes, and
+ * the defaults it writes under, are the step table's.
  */
+export { BIN_OVERLAP_FIELD, DEFAULT_AGGREGATE_OP, DEFAULT_BIN_AS, DEFAULT_COVERAGE_AS, DEFAULT_FORMULA_AS, DEFAULT_PILEUP_AS, } from './markRuleFacts.js';
 export const MARK_TYPES = [
     'bar',
     'point',
@@ -26,34 +28,29 @@ export const DEFAULT_LINK_SHAPE = 'dome';
 export const DEFAULT_LINK_STROKE_PX = 2;
 /** The fraction of its row a span fills where its `rowProportion` is left unwritten. */
 export const DEFAULT_ROW_PROPORTION = 1;
-/** The cuts a threshold colour paints, render-core's `MAX_COLOR_CUTS`. */
+/** The cuts a threshold color paints, render-core's `MAX_COLOR_CUTS`. */
 export const MAX_THRESHOLD_CUTS = 8;
 export const SIZE_SCALES = ['linear', 'log'];
-export const MARK_SOURCES = ['features', 'density'];
-export const DEFAULT_MARK_SOURCE = 'features';
-export const DEFAULT_FORMULA_AS = 'value';
 export const DEFAULT_BIN_FIELD = 'start';
-export const DEFAULT_BIN_AS = ['start', 'end'];
-/** What a `bin` over `fields` writes on each piece: the bases of its interval inside its bin. */
-export const BIN_OVERLAP_FIELD = 'overlap';
-export const DEFAULT_COVERAGE_AS = 'coverage';
 export const DEFAULT_FLATTEN_FIELD = 'subfeatures';
 export const DEFAULT_CELLS_FIELD = 'seq';
-/** What a `cells` step writes: `state` on every cell, `base` on a mismatch or an insertion, `match` off a gap or a reference `N`, `length` on an insertion. */
-export const CELLS_FIELDS = ['state', 'base', 'match', 'length'];
-export const DEFAULT_PILEUP_AS = 'row';
+/** The rows before and after each row a `window` reads: a moving average over 21. */
+export const DEFAULT_WINDOW_FRAME = [-10, 10];
+/**
+ * Whether a `window`'s `frame` is what the step reads: two whole row offsets,
+ * either `null` for unbounded, the first not past the second.
+ */
+export function isWindowFrame(frame) {
+    if (!Array.isArray(frame) || frame.length !== 2) {
+        return false;
+    }
+    const [before, after] = frame;
+    const end = (v) => v === null || Number.isInteger(v);
+    return (end(before) &&
+        end(after) &&
+        (before === null || after === null || Number(before) <= Number(after)));
+}
 export const DEFAULT_PILEUP_FIELDS = ['start', 'end'];
 export const DEFAULT_TEXT_FIELD = 'name';
 export const DEFAULT_X2 = 'end';
-/** What a `mate` step writes on every feature it answers. */
-export const MATE_FIELDS = [
-    'mate.refName',
-    'mate.start',
-    'mate.end',
-    'mate.mateDirection',
-    'mateDirection',
-    'alt',
-    'svType',
-];
 export const AGGREGATE_OPS = ['count', 'sum', 'mean', 'min', 'max'];
-export const DEFAULT_AGGREGATE_OP = 'count';

package/dist/commands/validate/markRules/stepChannels.js

@@ -1,55 +1,21 @@
 // Generated by scripts/generateMarkRules.ts from plugins/marks/src/LinearMarkDisplay/stepChannels.ts: do not edit, `pnpm autogen` rewrites it.
-import { aggregateFieldName } from './markRuleFacts.js';
-import { DEFAULT_AGGREGATE_OP, DEFAULT_COVERAGE_AS, DEFAULT_PILEUP_AS, } from './markVocabulary.js';
+import { stepsOutput } from './markRuleFacts.js';
 /** The far end a `mate` step writes, as `x2` reads a position on another sequence. */
 export const MATE_X2 = { chrom: 'mate.refName', pos: 'mate.start' };
-function outputOf(step, fallback) {
-    return typeof step.as === 'string' && step.as !== '' ? step.as : fallback;
-}
 /**
  * What {@link StepChannels} a mark's steps leave it, read over the display's,
- * the facet's and then the mark's own steps in the order they run. An
- * `aggregate` or `coverage` makes its features anew, so it clears the row and
- * the other end a step before it wrote, and an aggregate writing two
- * summaries names no `y`.
+ * the facet's and then the mark's own steps in the order they run. A step
+ * that makes its features anew keeps a channel only where it keeps the field
+ * that channel read, as an `aggregate` grouped by a pileup's `row` does.
  */
 export function stepChannels(steps) {
-    let channels = {};
-    for (const step of steps) {
-        switch (step?.type) {
-            case undefined: {
-                break;
-            }
-            case 'coverage': {
-                channels = { y: outputOf(step, DEFAULT_COVERAGE_AS) };
-                break;
-            }
-            case 'aggregate': {
-                const [only, ...rest] = step.ops ?? [];
-                channels =
-                    only && rest.length === 0
-                        ? {
-                            y: aggregateFieldName({
-                                op: only.op ?? DEFAULT_AGGREGATE_OP,
-                                field: only.field,
-                                as: only.as,
-                            }),
-                        }
-                        : {};
-                break;
-            }
-            case 'pileup': {
-                channels = { ...channels, row: outputOf(step, DEFAULT_PILEUP_AS) };
-                break;
-            }
-            case 'mate': {
-                channels = { ...channels, x2: MATE_X2 };
-                break;
-            }
-            default: {
-                break;
-            }
-        }
-    }
-    return channels;
+    const { channels, surviving } = stepsOutput(steps);
+    const y = channels.get('y');
+    const row = channels.get('row');
+    const x2 = channels.has('x2') && (!surviving || surviving.has(MATE_X2.pos));
+    return {
+        ...(y === undefined ? {} : { y }),
+        ...(row === undefined ? {} : { row }),
+        ...(x2 ? { x2: MATE_X2 } : {}),
+    };
 }

package/dist/commands/validate/markRules/stepOutputs.js

@@ -0,0 +1,202 @@
+// Generated by scripts/generateMarkRules.ts from packages/core/src/util/stepOutputs.ts: do not edit, `pnpm autogen` rewrites it.
+/**
+ * What each transform step does to the rows it reads, stated once for the
+ * runtime's facet split, the validator, the field pickers and the channels a
+ * mark adopts by default. Imports nothing, so the validator's copy of the mark
+ * rule list carries it unchanged.
+ *
+ * Every step type answers three things:
+ * - `rowwise`: it answers each row from that row alone and in order, so a
+ *   facet split may run ahead of it.
+ * - `replacesRows`: it makes its rows anew (an aggregate, a coverage), so a
+ *   field survives it only where it writes that field or keeps it as a group.
+ * - `writes`: the fields it sets, each with the kind of value it holds and the
+ *   channel a mark leaving that channel unwritten reads it through.
+ */
+/** The field an aggregate op writes: `as` where named, else `count` for a count, else `<op>_<field>`. */
+export function aggregateFieldName({ op, field, as, }) {
+    return as || (op === 'count' || !field ? op : `${op}_${field}`);
+}
+export const DEFAULT_FORMULA_AS = 'value';
+export const DEFAULT_COVERAGE_AS = 'coverage';
+export const DEFAULT_PILEUP_AS = 'row';
+export const DEFAULT_AGGREGATE_OP = 'count';
+export const DEFAULT_BIN_AS = ['start', 'end'];
+/** What a `bin` over `fields` writes on each piece: the bases of its interval inside its bin. */
+export const BIN_OVERLAP_FIELD = 'overlap';
+/** What a `cells` step writes: `state` on every cell, `base` on a mismatch or an insertion, `match` off a gap or a reference `N`, `length` on an insertion. */
+export const CELLS_FIELDS = ['state', 'base', 'match', 'length'];
+/** What a `mate` step writes on every feature it answers. */
+export const MATE_FIELDS = [
+    'mate.refName',
+    'mate.start',
+    'mate.end',
+    'mate.mateDirection',
+    'mateDirection',
+    'alt',
+    'svType',
+];
+/** Where a row stands, which every row keeps through every step. */
+export const POSITION_FIELDS = ['refName', 'start', 'end'];
+function named(as, fallback) {
+    return typeof as === 'string' && as !== '' ? as : fallback;
+}
+function binEdges(step) {
+    const { as } = step;
+    return Array.isArray(as) && as.length === 2 ? as : DEFAULT_BIN_AS;
+}
+// A single op names the `y` its mark reads; two leave the mark to choose.
+function summaries(step) {
+    const ops = step.ops ?? [];
+    return ops.map(({ op = DEFAULT_AGGREGATE_OP, field, as }) => ({
+        field: aggregateFieldName({ op, field, as }),
+        kind: 'numeric',
+        ...(ops.length === 1 ? { fills: 'y' } : {}),
+    }));
+}
+const kept = (field) => ({ field, kind: 'unknown' });
+export const STEP_OUTPUTS = {
+    filter: { rowwise: true, replacesRows: false, writes: () => [] },
+    formula: {
+        rowwise: true,
+        replacesRows: false,
+        writes: step => [
+            { field: named(step.as, DEFAULT_FORMULA_AS), kind: 'numeric' },
+        ],
+    },
+    bin: {
+        rowwise: true,
+        replacesRows: false,
+        writes: step => [
+            ...binEdges(step).map(field => ({ field, kind: 'numeric' })),
+            ...(step.fields?.length === 2
+                ? [{ field: BIN_OVERLAP_FIELD, kind: 'numeric' }]
+                : []),
+        ],
+    },
+    cells: {
+        rowwise: true,
+        replacesRows: false,
+        writes: () => [
+            { field: 'start', kind: 'numeric' },
+            { field: 'end', kind: 'numeric' },
+            { field: 'state', kind: 'categorical' },
+            { field: 'base', kind: 'categorical' },
+            { field: 'match', kind: 'numeric' },
+            { field: 'length', kind: 'numeric' },
+        ],
+    },
+    aggregate: {
+        rowwise: false,
+        replacesRows: true,
+        writes: (step, edges) => [
+            ...(step.groupby?.length ? step.groupby : edges).map(kept),
+            ...summaries(step),
+        ],
+    },
+    window: { rowwise: false, replacesRows: false, writes: summaries },
+    coverage: {
+        rowwise: false,
+        replacesRows: true,
+        writes: step => [
+            {
+                field: named(step.as, DEFAULT_COVERAGE_AS),
+                kind: 'numeric',
+                fills: 'y',
+            },
+        ],
+    },
+    pileup: {
+        rowwise: false,
+        replacesRows: false,
+        writes: step => [
+            {
+                field: named(step.as, DEFAULT_PILEUP_AS),
+                kind: 'numeric',
+                fills: 'row',
+            },
+        ],
+    },
+    flatten: {
+        rowwise: false,
+        replacesRows: false,
+        writes: step => [
+            ...(step.index ? [{ field: step.index, kind: 'numeric' }] : []),
+            ...(step.key ? [{ field: step.key, kind: 'categorical' }] : []),
+        ],
+    },
+    mate: {
+        rowwise: false,
+        replacesRows: false,
+        writes: () => MATE_FIELDS.map(field => ({
+            field,
+            kind: field === 'mate.start' || field === 'mate.end'
+                ? 'numeric'
+                : 'categorical',
+            ...(field === 'mate.refName' ? { fills: 'x2' } : {}),
+        })),
+    },
+};
+function outputOf(step) {
+    return Object.hasOwn(STEP_OUTPUTS, step.type)
+        ? STEP_OUTPUTS[step.type]
+        : undefined;
+}
+/**
+ * The fields one step writes. A step this table does not know writes nothing
+ * it can name.
+ */
+export function stepWrites(step, edges = DEFAULT_BIN_AS) {
+    return outputOf(step)?.writes(step, edges) ?? [];
+}
+/** Whether a step answers each row from that row alone, in order. */
+export function isRowwise(step) {
+    return outputOf(step)?.rowwise ?? false;
+}
+/**
+ * What a run of steps leaves: every field written, the last write of each
+ * winning, and, where a step made the rows anew, the only fields that survive
+ * it (`undefined` while the input's own fields all do). `channels` are what
+ * the output fills where a mark leaves them unwritten.
+ */
+export function stepsOutput(steps) {
+    let edges = DEFAULT_BIN_AS;
+    let surviving;
+    const written = new Map();
+    let channels = new Map();
+    for (const step of steps) {
+        const output = step && outputOf(step);
+        if (!step || !output) {
+            continue;
+        }
+        const writes = output.writes(step, edges);
+        if (output.replacesRows) {
+            surviving = new Set(POSITION_FIELDS);
+            for (const [field] of written) {
+                if (!writes.some(w => w.field === field)) {
+                    written.delete(field);
+                }
+            }
+            for (const w of writes) {
+                surviving.add(w.field);
+            }
+            channels = new Map([...channels].filter(([, f]) => surviving.has(f)));
+        }
+        else {
+            for (const w of writes) {
+                surviving?.add(w.field);
+            }
+        }
+        for (const w of writes) {
+            const held = written.get(w.field);
+            written.set(w.field, w.kind === 'unknown' && held ? { ...held, field: w.field } : w);
+            if (w.fills) {
+                channels.set(w.fills, w.field);
+            }
+        }
+        if (step.type === 'bin') {
+            edges = binEdges(step);
+        }
+    }
+    return { written: [...written.values()], surviving, channels };
+}

package/dist/commands/validate/schemaValidate.js

@@ -175,8 +175,8 @@ function unknownKeyMessage(key, schema, accepted) {
     if (title.endsWith('TrackEntry')) {
         return `"${key}" is neither a config slot nor a property of ${title.replace(/TrackEntry$/, '')}${guess} — the entry's keys are folded onto that display, and one it does not declare silently does nothing`;
     }
-    if (schema['x-closed'] === true) {
-        return `unknown slot "${key}"${guess} — ${title} takes ${listed(accepted)}, and JBrowse refuses to load it rather than drop a key it does not declare`;
+    if (schema['x-closed']) {
+        return `unknown slot "${key}"${guess} — ${title} takes ${listed(accepted)}; JBrowse warns on the console and loads without it, so this setting does nothing`;
     }
     return `unknown slot "${key}"${guess} — JBrowse ignores keys it does not declare, so this setting silently does nothing`;
 }
@@ -422,4 +422,7 @@ export function hasDeclaredShape(data, pointer) {
  * beside them, the way `LinearGenomeViewPlugin` is core's.
  */
 export const rootConfigurationSlots = new Set(Object.keys(defs.RootConfiguration.properties));
+export function hasSchemaDefinition(name) {
+    return Object.hasOwn(defs, name);
+}
 export { schemaId as configSchemaUrl };

package/dist/commands/validate/validateConfig.js

@@ -3,16 +3,17 @@
 // cross-references a schema cannot express and the warnings for stale
 // spellings a migration still rewrites.
 //
-// Why a validator at all, given MST type-checks a config on load: MST models
-// ignore snapshot keys they do not declare, so a misspelt slot leaves the track
-// loading normally with the setting doing nothing.
+// Why a validator at all, given MST type-checks a config on load: a key no
+// schema declares does nothing, named on the console by a display and dropped
+// in silence by a track, an adapter or a session snapshot, so a misspelt slot
+// leaves the track loading normally.
 //
 // Pure: no filesystem, no process exit. The command wrapper owns both.
-import { fileNameOf, isLooseTrackConfig, matchFormat, } from '@jbrowse/add-track-core';
+import { fileNameOf, isLooseTrackConfig, matchFormat, trackTypeForAdapter, } from '@jbrowse/add-track-core';
 import { configManifest } from './configManifest.generated.js';
 import { displayDefaultsForTrackType } from './displayDefaultKeys.js';
 import { isRecord, liftToSnapshot } from './liftConfig.js';
-import { colorProblems, colorSlotsOf, scaleEndProblems, scaleEndsOf, } from './markRules/colorScale.js';
+import { colorProblems, colorSlotsOf, scaleEndProblems, scaleEndsOf, withImpliedField, } from './markRules/colorScale.js';
 import { markProblems } from './markRules/markProblems.js';
 import { hasDeclaredShape, rootConfigurationSlots, schemaProblems, } from './schemaValidate.js';
 import { didYouMean } from './suggest.js';
@@ -44,6 +45,12 @@ class Report {
 const SELF_SUPPLIED = {
     sequenceAdapter: '`sequenceAdapter` is set by hand. JBrowse takes the sequence from the assembly the track is displayed against, so this is only needed to read some OTHER sequence — and it pins the track to that source even when the assembly changes. Delete it unless that is what you meant',
 };
+// What replaced a dropped legacy key, where there is something to say: a
+// config written before v4 carries a `sequenceAdapter` on its BAM and CRAM
+// adapters.
+const DROPPED = {
+    sequenceAdapter: 'JBrowse takes the sequence from the assembly the track is displayed against. ',
+};
 // The warnings a slot table carries: a legacy key or value a migration
 // rewrites, and a declared key JBrowse fills in for itself.
 function warnSlots(obj, entry, where, report) {
@@ -56,7 +63,9 @@ function warnSlots(obj, entry, where, report) {
             report.warn(`${where}.${key}`, `${JSON.stringify(value)} is a legacy value of "${key}" that a migration rewrites — the config loads, but the current spelling is one of the enum's members`);
         }
         else if (!declared.has(key) && entry.legacyKeys?.includes(key)) {
-            report.warn(`${where}.${key}`, `"${key}" is a legacy key that a migration rewrites into current slots — the config loads, but check the settings inside it landed`);
+            report.warn(`${where}.${key}`, entry.droppedKeys?.includes(key)
+                ? `"${key}" is a legacy key that is never read. ${DROPPED[key] ?? ''}The config loads, and the key can be deleted`
+                : `"${key}" is a legacy key that a migration rewrites into current slots — the config loads, but check the settings inside it landed`);
         }
     }
     for (const slot of entry.slots) {
@@ -337,7 +346,7 @@ function checkMarkDisplay(display, manifest, where, report) {
         });
     }
 }
-// A problem the colour and scale rules and the mark rule list both reach, such
+// A problem the color and scale rules and the mark rule list both reach, such
 // as scales.y's ends on a mark display, is reported once.
 function pushOnce(report, problem) {
     if (!report.problems.some(p => p.where === problem.where && p.rule === problem.rule)) {
@@ -352,7 +361,7 @@ function declaredMembers(written, slot) {
     const declared = new Set((slot.subSlots ?? []).map(s => s.name));
     return Object.fromEntries(Object.entries(written).filter(([key]) => declared.has(key)));
 }
-// What the display's colour objects and its value scale say together that it
+// What the display's color objects and its value scale say together that it
 // cannot draw as written: its schema's fieldPresets stand in for the plugin
 // code the CLI does not run, and every quantitative scale's ends answer to
 // one rule.
@@ -376,9 +385,9 @@ function checkScaleSlots(display, slots, where, report) {
         }
         const members = declaredMembers(written, slot);
         if (slot.fieldPresets) {
-            for (const problem of colorProblems(colorSlotsOf(name => name === 'field'
+            for (const problem of colorProblems(withImpliedField(colorSlotsOf(name => name === 'field'
                 ? (members.field ?? slot.fieldDefault)
-                : members[name]), slot.fieldPresets)) {
+                : members[name]), slot.impliedField), slot.fieldPresets)) {
                 warn(`${where}.${slot.name}`, problem);
             }
         }
@@ -395,6 +404,30 @@ function checkScaleSlots(display, slots, where, report) {
 // entry. Only a mark display declares `marks`, so the walk is over the whole
 // file, past a place where the schema refused the key: a session display node
 // drops it.
+// a track's type as written, or as a loose `{ trackId, uri }` entry's file
+// name decides it, the way add-track does
+function trackTypeOf(node) {
+    if (typeof node.type === 'string') {
+        return node.type;
+    }
+    if (typeof node.uri !== 'string') {
+        return undefined;
+    }
+    const fileName = fileNameOf(node.uri);
+    const format = matchFormat(fileName, typeof node.adapterType === 'string' ? node.adapterType : undefined);
+    return (format?.trackType ??
+        (format && 'adapterType' in format.spec
+            ? trackTypeForAdapter(format.spec.adapterType, fileName)
+            : undefined));
+}
+// The shorthand router hands a `displayDefaults` key only to the displays
+// whose slot takes its value (`collectDisplayOverrides`), so a categorical
+// color on a FeatureTrack never reaches its quantitative display's `score`
+// presets. The same cut here, through each display's own schema branch.
+function displayDefaultsReaching(display, defaults) {
+    return Object.fromEntries(Object.entries(defaults).filter(([key, value]) => schemaProblems({ type: display, [key]: value }, `/$defs/${display}`)
+        .length === 0));
+}
 function checkMarkDisplays(node, manifest, where, report) {
     if (Array.isArray(node)) {
         for (const [i, item] of node.entries()) {
@@ -408,10 +441,11 @@ function checkMarkDisplays(node, manifest, where, report) {
         if (slots) {
             checkScaleSlots(node, slots, where, report);
         }
-        if (typeof node.type === 'string' && isRecord(node.displayDefaults)) {
-            for (const display of displayDefaultsForTrackType(node.type, manifest)
+        const trackType = trackTypeOf(node);
+        if (trackType && isRecord(node.displayDefaults)) {
+            for (const display of displayDefaultsForTrackType(trackType, manifest)
                 .displayTypes) {
-                checkScaleSlots(node.displayDefaults, manifest.displays[display]?.slots ?? [], `${where}.displayDefaults`, report);
+                checkScaleSlots(displayDefaultsReaching(display, node.displayDefaults), manifest.displays[display]?.slots ?? [], `${where}.displayDefaults`, report);
             }
         }
         if (holdsMarkRules(node, manifest) &&

package/dist/index.js

@@ -51,7 +51,7 @@ const registry = [
     },
     {
         name: 'make-density',
-        summary: 'Counts feature starts per bin into a bigWig density sidecar, with bedGraphToBigWig',
+        summary: 'Counts feature starts per bin into a bigWig, with bedGraphToBigWig',
         load: () => import('./commands/make-density/index.js').then(m => m.run),
     },
     {

package/dist/version.js

@@ -1 +1 @@
-export const version = '5.0.0-beta.13';
+export const version = '5.0.0-beta.14';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jbrowse/cli",
-  "version": "5.0.0-beta.13",
+  "version": "5.0.0-beta.14",
   "type": "module",
   "description": "A command line tool for working with JBrowse 2",
   "keywords": [
@@ -31,9 +31,9 @@
     "cli-progress": "^3.12.0",
     "serve-handler": "^6.1.7",
     "tmp": "^0.2.7",
-    "@jbrowse/cigar-utils": "^5.0.0-beta.13",
-    "@jbrowse/add-track-core": "^5.0.0-beta.13",
-    "@jbrowse/text-indexing-core": "^5.0.0-beta.13"
+    "@jbrowse/add-track-core": "^5.0.0-beta.14",
+    "@jbrowse/cigar-utils": "^5.0.0-beta.14",
+    "@jbrowse/text-indexing-core": "^5.0.0-beta.14"
   },
   "publishConfig": {
     "access": "public"

package/dist/commands/shared/density.js

@@ -1,12 +0,0 @@
-/**
- * Where the density sidecar for a data file lives: `<file>.density.bw`, with a
- * `.gz`/`.bgz` stripped first so `genes.gff3.gz` yields `genes.gff3.density.bw`
- * rather than a name carrying the compression of a file it is not compressed
- * like.
- *
- * One rule, two commands: `make-density` writes here by default and `add-track`
- * probes here, so a sidecar built with no `--out` is the one the track picks up.
- */
-export function densitySidecarPath(file) {
-    return `${file.replace(/\.b?gz$/i, '')}.density.bw`;
-}

package/dist/commands/validate/markRules/aggregateFieldName.js

@@ -1,9 +0,0 @@
-// Generated by scripts/generateMarkRules.ts from packages/core/src/util/aggregateFieldName.ts: do not edit, `pnpm autogen` rewrites it.
-/**
- * The field an aggregate op writes: `as` where named, else `count` for a
- * count, else `<op>_<field>`. Imports nothing, so the validator's copy of the
- * mark rule list carries it unchanged.
- */
-export function aggregateFieldName({ op, field, as, }) {
-    return as || (op === 'count' || !field ? op : `${op}_${field}`);
-}