@jbrowse/cli 5.0.0-beta.1 → 5.0.0-beta.2

package/dist/commands/validate/validateConfig.js

@@ -344,9 +344,101 @@ function checkSessionViewTracks(view, manifest, where, report) {
         }
     }
 }
-// A view's `init` names tracks and an assembly by id. Nothing validates those at
-// load: a trackId that does not exist simply fails to open, which reads as a
-// rendering bug rather than a typo.
+// A view node in a session — `defaultSession.views[]` — is instantiated by the
+// view's STATE MODEL, and a view has no config schema at all, so every setting
+// an author writes lands on that node: the properties MST restores, plus the
+// launch keys a launcher resolves (`assembly`, `loc`, `tracks`). Those two
+// together are the whole accepted set, which is what makes this check
+// exhaustive rather than a guess — anything else is dropped exactly like a
+// misspelling, and the view opens on its defaults with nothing said.
+//
+// The same trap checkSessionDisplay catches one level down, and the same three
+// diagnoses: a real key in the wrong place, a stale spelling that still works,
+// and a key nothing anywhere reads.
+function checkSessionViewKeys(view, entry, manifest, where, report) {
+    const accepted = [
+        ...entry.stateModelProps,
+        ...entry.launchKeys,
+        ...(entry.passThrough ?? []),
+    ];
+    for (const key of Object.keys(view)) {
+        // `init` gets its own message from checkSessionView below
+        if (accepted.includes(key) || key === 'init') {
+            continue;
+        }
+        // Whichever other view types do read the key. `assembly` on a DotplotView is
+        // not a misspelling and no suggestion reaches it, so naming the views that
+        // take it is the only thing that tells the author what they wrote.
+        const elsewhere = Object.entries(manifest.views)
+            .filter(([name, other]) => name !== entry.canonicalName &&
+            [...other.stateModelProps, ...other.launchKeys].includes(key))
+            .map(([name]) => name);
+        report.error(`${where}.${key}`, elsewhere.length
+            ? `"${key}" is a setting of ${elsewhere.join(', ')}, not of ${entry.canonicalName}${didYouMean(key, accepted)} — a session snapshot drops keys the view does not declare, so this setting silently does nothing`
+            : `unknown view key "${key}"${didYouMean(key, accepted)} — a session snapshot drops keys the view does not declare, so this setting silently does nothing`);
+    }
+}
+// The ids a view names, which nothing validates at load: a trackId that does not
+// exist simply fails to open, which reads as a rendering bug rather than a typo.
+function checkViewReferences(view, where, report, ctx) {
+    const assembly = view.assembly;
+    if (typeof assembly === 'string' && !ctx.assemblyNames.has(assembly)) {
+        report.error(`${where}.assembly`, `assembly "${assembly}" is not defined in this config${didYouMean(assembly, [...ctx.assemblyNames])}`);
+    }
+    if (!Array.isArray(view.tracks)) {
+        return;
+    }
+    // A LinearSyntenyView's `tracks` is one array PER LEVEL (`[[a], [b]]`) — the
+    // multi-way form — so flatten one level before reading entries. Treating those
+    // inner arrays as track entries reported every genome row of every synteny
+    // demo as a track with no trackId.
+    const entries = view.tracks.flatMap((t) => Array.isArray(t) ? t : [t]);
+    for (const [j, entry] of entries.entries()) {
+        // A built track snapshot names its config through `configuration` rather
+        // than `trackId`, and is state MST restores rather than a reference to open.
+        if (isRecord(entry) && !('trackId' in entry)) {
+            continue;
+        }
+        const trackId = isRecord(entry) ? entry.trackId : entry;
+        if (typeof trackId !== 'string') {
+            report.error(`${where}.tracks[${j}]`, 'track entry has no trackId');
+        }
+        else if (!ctx.seenTrackIds.has(trackId) &&
+            !ctx.sequenceTrackIds.has(trackId)) {
+            report.error(`${where}.tracks[${j}]`, `trackId "${trackId}" is not defined in this config${didYouMean(trackId, [...ctx.seenTrackIds, ...ctx.sequenceTrackIds])}`);
+        }
+    }
+}
+function checkSessionView(view, manifest, where, report, ctx) {
+    const entry = resolveType(view, manifest.views, 'view', `${where}.type`, report);
+    // A view type the manifest doesn't know (a plugin's) is already a warning from
+    // resolveType, and its keys are unknowable here.
+    if (!entry) {
+        return;
+    }
+    checkSessionViewKeys(view, entry, manifest, where, report);
+    checkViewReferences(view, where, report, ctx);
+    // A warning, not an error: v5 unwraps the nesting on the way in, so the
+    // settings do arrive. The keys inside get the same check the flat ones do,
+    // since that is where they land.
+    if (view.init !== undefined) {
+        report.warn(`${where}.init`, 'settings nested under "init", which is deprecated: write every setting directly on the view object');
+        if (isRecord(view.init)) {
+            checkSessionViewKeys(view.init, entry, manifest, `${where}.init`, report);
+            checkViewReferences(view.init, `${where}.init`, report, ctx);
+        }
+    }
+    // A synteny or breakpoint row is a whole view snapshot of its own. Only a row
+    // carrying a `type` can be checked: a row written as a recipe names no view
+    // type, and which one it becomes is the parent launcher's business.
+    if (Array.isArray(view.views)) {
+        for (const [i, row] of view.views.entries()) {
+            if (isRecord(row) && typeof row.type === 'string') {
+                checkSessionView(row, manifest, `${where}.views[${i}]`, report, ctx);
+            }
+        }
+    }
+}
 function checkSession(session, manifest, report, ctx) {
     if (!isRecord(session) || !Array.isArray(session.views)) {
         return;
@@ -355,35 +447,8 @@ function checkSession(session, manifest, report, ctx) {
         checkSessionViewTracks(view, manifest, `defaultSession.views[${i}]`, report);
     }
     for (const [i, view] of session.views.entries()) {
-        if (!isRecord(view) || !isRecord(view.init)) {
-            continue;
-        }
-        const init = view.init;
-        const where = `defaultSession.views[${i}].init`;
-        if (typeof init.assembly === 'string' &&
-            !ctx.assemblyNames.has(init.assembly)) {
-            report.error(`${where}.assembly`, `assembly "${init.assembly}" is not defined in this config${didYouMean(init.assembly, [...ctx.assemblyNames])}`);
-        }
-        if (Array.isArray(init.tracks)) {
-            // A LinearSyntenyView's `tracks` is one array PER LEVEL (`[[a], [b]]`) —
-            // the multi-way form — so flatten one level before reading entries.
-            // Treating those inner arrays as track entries reported every genome row
-            // of every synteny demo as a track with no trackId.
-            const entries = init.tracks.flatMap((t) => Array.isArray(t) ? t : [t]);
-            for (const [j, entry] of entries.entries()) {
-                const trackId = typeof entry === 'string'
-                    ? entry
-                    : isRecord(entry)
-                        ? entry.trackId
-                        : undefined;
-                if (typeof trackId !== 'string') {
-                    report.error(`${where}.tracks[${j}]`, 'track entry has no trackId');
-                }
-                else if (!ctx.seenTrackIds.has(trackId) &&
-                    !ctx.sequenceTrackIds.has(trackId)) {
-                    report.error(`${where}.tracks[${j}]`, `trackId "${trackId}" is not defined in this config${didYouMean(trackId, [...ctx.seenTrackIds, ...ctx.sequenceTrackIds])}`);
-                }
-            }
+        if (isRecord(view)) {
+            checkSessionView(view, manifest, `defaultSession.views[${i}]`, report, ctx);
         }
     }
 }

package/dist/index.js

@@ -49,6 +49,11 @@ const registry = [
         summary: 'Creates pairwise indexed PAF (PIF), with bgzip and tabix',
         load: () => import('./commands/make-pif/index.js').then(m => m.run),
     },
+    {
+        name: 'make-density',
+        summary: 'Counts feature starts per bin into a bigWig density sidecar, with bedGraphToBigWig',
+        load: () => import('./commands/make-density/index.js').then(m => m.run),
+    },
     {
         name: 'sort-gff',
         summary: 'Sort a GFF/GTF for tabix: sort -k1,1 -k4,4n, header kept on top',

package/dist/version.js

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

package/package.json

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

package/dist/commands/make-pif/cigar-utils.js

@@ -1,67 +0,0 @@
-// Walk a CIGAR and split the alignment wherever an insertion or deletion is at
-// least `splitGap` bp, so each coarse-tier row's bounding box stays tight.
-// Returns one segment per contiguous run; `splitGap` must be positive (the
-// caller keeps the whole row when there is nothing to split on).
-// PAF semantics: qstart < qend always; '-' strand CIGAR walks query backward.
-export function splitCigarOnLargeGaps({ cigar, strand, tstart, tend, qstart, qend, splitGap, }) {
-    const qStep = strand === '-' ? -1 : 1;
-    let tCursor = tstart;
-    let qCursor = strand === '-' ? qend : qstart;
-    let segTStart = tCursor;
-    let segQAnchor = qCursor;
-    let segBlockLen = 0;
-    const out = [];
-    const emit = () => {
-        if (tCursor > segTStart || qCursor !== segQAnchor) {
-            out.push({
-                tstart: segTStart,
-                tend: tCursor,
-                qstart: Math.min(segQAnchor, qCursor),
-                qend: Math.max(segQAnchor, qCursor),
-                blockLen: segBlockLen,
-            });
-        }
-    };
-    // Parse CIGAR directly to avoid intermediate array + string-to-number conversions
-    let i = 0;
-    while (i < cigar.length) {
-        let len = 0;
-        while (i < cigar.length &&
-            cigar.charCodeAt(i) >= 48 &&
-            cigar.charCodeAt(i) <= 57) {
-            len = len * 10 + cigar.charCodeAt(i++) - 48;
-        }
-        const op = cigar[i++];
-        if ('M=X'.includes(op)) {
-            tCursor += len;
-            qCursor += len * qStep;
-            segBlockLen += len;
-        }
-        else if ('DIN'.includes(op)) {
-            const isLarge = len >= splitGap;
-            if (isLarge) {
-                emit();
-            }
-            if (op === 'I') {
-                qCursor += len * qStep;
-            }
-            else {
-                tCursor += len;
-            }
-            if (isLarge) {
-                segTStart = tCursor;
-                segQAnchor = qCursor;
-                segBlockLen = 0;
-            }
-            else {
-                segBlockLen += len;
-            }
-        }
-        // S/H/P (clipping/padding) don't consume target or forward-strand query in PAF
-    }
-    emit();
-    return {
-        segments: out,
-        closed: tCursor === tend && qCursor === (strand === '-' ? qstart : qend),
-    };
-}