@jbrowse/launch-args 5.0.0-beta.16 → 5.0.0-beta.18

package/esm/slotPath.js

@@ -0,0 +1,211 @@
+const UNSAFE_SEGMENTS = new Set(['__proto__', 'constructor', 'prototype']);
+function isPlainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function scalar(text) {
+    if (text === 'true' || text === 'false') {
+        return text === 'true';
+    }
+    const n = Number(text);
+    return text.trim() !== '' && Number.isFinite(n) ? n : text;
+}
+const LOCATION_SO_FAR = /^[^\s,:]+:[\d,-]*\d$/;
+// The comma at `i` groups a location's digits, as the app writes one:
+// `chr2:135,787,850-135,876,467`.
+function groupsDigits(text, start, i) {
+    return (LOCATION_SO_FAR.test(text.slice(start, i)) &&
+        /^\d{3}(?!\d)/.test(text.slice(i + 1)));
+}
+// A `jexl:` item runs to the first comma outside its own brackets and quotes,
+// since a jexl call separates its arguments with commas, and a location keeps
+// the commas grouping its digits.
+function listItems(text) {
+    const items = [];
+    let start = 0;
+    let depth = 0;
+    let quote;
+    for (let i = 0; i < text.length; i++) {
+        const c = text.charAt(i);
+        if (quote) {
+            if (c === '\\') {
+                i++;
+            }
+            else if (c === quote) {
+                quote = undefined;
+            }
+        }
+        else if (c === ',' && depth === 0 && !groupsDigits(text, start, i)) {
+            items.push(text.slice(start, i));
+            start = i + 1;
+        }
+        else if (text.startsWith('jexl:', start)) {
+            if (c === "'" || c === '"') {
+                quote = c;
+            }
+            else if ('([{'.includes(c)) {
+                depth++;
+            }
+            else if (')]}'.includes(c)) {
+                depth--;
+            }
+        }
+    }
+    items.push(text.slice(start));
+    return items;
+}
+/**
+ * The value of a `path=value` modifier: `true`/`false`, a number, a
+ * comma-separated list (a trailing comma makes a list of one, and a `jexl:`
+ * item keeps the commas inside its own brackets and quotes), or the text as
+ * written.
+ */
+export function slotValue(text) {
+    const items = listItems(text);
+    return items.length > 1
+        ? items.filter(item => item !== '').map(scalar)
+        : scalar(text);
+}
+/** Whether a track option is a `path=value` slot write rather than a named modifier. */
+export function isSlotPathOption(opt) {
+    return /^[A-Za-z_][\w.]*=/.test(opt);
+}
+/**
+ * Whether a slot write names a member of a setting, `encoding.color.field=…`,
+ * rather than a whole setting, `height=…`.
+ */
+export function isMemberWrite(opt) {
+    return isSlotPathOption(opt) && opt.slice(0, opt.indexOf('=')).includes('.');
+}
+/**
+ * Merge `patch` into `target`, object into object and anything else replacing
+ * what was there, so `encoding.color.field=…` and
+ * `encoding.color.scale.range=…` fill one object in either order.
+ */
+export function mergeSettings(target, patch) {
+    for (const [key, value] of Object.entries(patch)) {
+        if (UNSAFE_SEGMENTS.has(key)) {
+            throw new Error(`Invalid track option key "${key}"`);
+        }
+        const existing = target[key];
+        if (isPlainObject(value) && isPlainObject(existing)) {
+            mergeSettings(existing, value);
+        }
+        else {
+            target[key] = isPlainObject(value) ? mergeSettings({}, value) : value;
+        }
+    }
+    return target;
+}
+/**
+ * `encoding.color.scale.range=tan,teal` and `marks.0.encoding.y=score`, read
+ * apart.
+ */
+export function slotWrite(opt) {
+    const eq = opt.indexOf('=');
+    const segments = opt.slice(0, eq).split('.');
+    if (segments.includes('')) {
+        throw new Error(`Invalid track option "${opt}": an empty path segment`);
+    }
+    for (const segment of segments) {
+        if (UNSAFE_SEGMENTS.has(segment)) {
+            throw new Error(`Invalid track option key "${segment}"`);
+        }
+    }
+    return { opt, segments, value: slotValue(opt.slice(eq + 1)) };
+}
+// A segment of digits indexes a list, anything else names a member.
+function indexOf(segment) {
+    return /^\d+$/.test(segment) ? Number(segment) : undefined;
+}
+// Where a segment lands: a key on an object, an index on a list. An index past
+// the end would leave a hole no schema accepts, so it names the entry that has
+// to be written first instead.
+function slotAt(container, segment, { opt }) {
+    if (!Array.isArray(container)) {
+        return segment;
+    }
+    const i = indexOf(segment);
+    if (i === undefined) {
+        throw new Error(`Invalid track option "${opt}": "${segment}" names a member of a list; use an index`);
+    }
+    if (i > container.length) {
+        throw new Error(`Invalid track option "${opt}": index ${i} is past the end of a list of ${container.length}; write index ${container.length} first`);
+    }
+    return i;
+}
+function readSlot(container, at) {
+    return Array.isArray(container)
+        ? container[at]
+        : container[at];
+}
+function setSlot(container, at, value) {
+    if (Array.isArray(container)) {
+        container[at] = value;
+    }
+    else {
+        container[at] = value;
+    }
+}
+// The container to walk into under `segment`, made to the shape the NEXT
+// segment asks for. A scalar there is replaced — a path keeps the rest of a
+// setting, and a scalar has no rest to keep — but a list where the path wants
+// an object, or the reverse, is two writes disagreeing about one setting, and
+// carrying on would drop whichever came first.
+function containerUnder(container, at, wantsList, { opt }) {
+    const existing = readSlot(container, at);
+    if (wantsList ? Array.isArray(existing) : isPlainObject(existing)) {
+        return existing;
+    }
+    if (isPlainObject(existing) || Array.isArray(existing)) {
+        throw new Error(`Invalid track option "${opt}": "${at}" is ${wantsList ? 'a setting, not a list' : 'a list, not a setting'}`);
+    }
+    const made = wantsList ? [] : {};
+    setSlot(container, at, made);
+    return made;
+}
+/**
+ * Apply one `path=value` write to `target`, creating the objects and lists the
+ * path walks through and leaving everything beside them alone, so the writes of
+ * one command line compose whatever order they come in.
+ *
+ * Indexing a list is what carries the grammar: `marks`, the `transform` steps
+ * under a mark and an aggregate's `ops` are all lists of objects, and while a
+ * path stopped at the first of them a declared figure could only be written as
+ * raw JSON.
+ */
+export function applySlotWrite(target, write) {
+    const { segments, value } = write;
+    let container = target;
+    for (const [i, segment] of segments.slice(0, -1).entries()) {
+        container = containerUnder(container, slotAt(container, segment, write), indexOf(segments[i + 1]) !== undefined, write);
+    }
+    setSlot(container, slotAt(container, segments.at(-1), write), value);
+    return target;
+}
+/**
+ * The settings `--view`'s tokens write onto the view, as a session spec's view
+ * object holds them: `mark.interpolate=bump`, `filter.0.field=length`, or a
+ * JSON object merged in whole.
+ */
+export function viewSettings(tokens) {
+    const settings = {};
+    for (const token of tokens) {
+        if (token.startsWith('{')) {
+            let parsed;
+            try {
+                parsed = JSON.parse(token);
+            }
+            catch (e) {
+                throw new Error(`--view ${token} is not valid JSON`, { cause: e });
+            }
+            mergeSettings(settings, parsed);
+        }
+        else if (isSlotPathOption(token)) {
+            applySlotWrite(settings, slotWrite(token));
+        }
+        else {
+            throw new Error(`--view "${token}" is not a setting: write one as path=value (mark.interpolate=bump) or as a JSON object`);
+        }
+    }
+    return settings;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jbrowse/launch-args",
-  "version": "5.0.0-beta.16",
+  "version": "5.0.0-beta.18",
   "type": "module",
   "description": "The command-line grammar jbrowse-img, jb2capture and JBrowse Desktop share: data files, a genome, a location and tracks, turned into JBrowse config",
   "keywords": [
@@ -21,16 +21,19 @@
   "types": "esm/index.d.ts",
   "exports": {
     ".": "./esm/index.js",
-    "./trackIds": "./esm/trackIds.js"
+    "./trackIds": "./esm/trackIds.js",
+    "./hostedGenomes": "./esm/hostedGenomes.js",
+    "./displaySettings": "./esm/displaySettings.js"
   },
   "files": [
     "esm"
   ],
   "dependencies": {
-    "@jbrowse/add-track-core": "^5.0.0-beta.16"
+    "@jbrowse/add-track-core": "^5.0.0-beta.18",
+    "@jbrowse/cigar-utils": "^5.0.0-beta.18"
   },
   "devDependencies": {
-    "@jbrowse/core": "^5.0.0-beta.16"
+    "@jbrowse/core": "^5.0.0-beta.18"
   },
   "publishConfig": {
     "access": "public"