@jbrowse/core 4.3.0 → 5.0.0-beta.10

package/esm/util/jexlFilterRows.js

@@ -0,0 +1,252 @@
+import { callSubject, conditions, pathSubject, print, printCondition, } from '@jbrowse/jexl';
+import { JEXL_PREFIX, ensureJexlPrefix, isJexl } from './jexlStrings.js';
+export const OPERATORS = {
+    number: [
+        { op: '>', label: '>' },
+        { op: '>=', label: '≥' },
+        { op: '<', label: '<' },
+        { op: '<=', label: '≤' },
+        { op: '==', label: '=' },
+        { op: '!=', label: '≠' },
+    ],
+    text: [
+        { op: '==', label: 'is' },
+        { op: '!=', label: 'is not' },
+        { op: 'in', label: 'is one of' },
+        { op: '~', label: 'matches' },
+    ],
+    flag: [
+        { op: 'set', label: 'is set' },
+        { op: '!set', label: 'is not set' },
+    ],
+    any: [
+        { op: '==', label: 'is' },
+        { op: '!=', label: 'is not' },
+        { op: '>', label: '>' },
+        { op: '>=', label: '≥' },
+        { op: '<', label: '<' },
+        { op: '<=', label: '≤' },
+        { op: 'in', label: 'is one of' },
+        { op: '~', label: 'matches' },
+    ],
+};
+const ROW = 'feature';
+function subjectKey(subject) {
+    return JSON.stringify(subject.kind === 'path'
+        ? ['path', ...subject.path]
+        : ['call', subject.name, ...subject.args]);
+}
+export function resolveFields(fields) {
+    return fields.map(({ label, type, group, description, multi, values, ...source }) => {
+        const subject = 'call' in source
+            ? callSubject(ROW, source.call)
+            : pathSubject(ROW, source.path);
+        return {
+            key: subjectKey(subject),
+            label,
+            type,
+            group,
+            description,
+            multi,
+            values,
+            subject,
+        };
+    });
+}
+// a feature carries these as refName, start and end
+const BED_LOCUS_COLUMNS = new Set(['chrom', 'chromStart', 'chromEnd']);
+/**
+ * The columns an adapter's metadata describes as `{column: description}`, as
+ * a BigBed's autoSql does, less those `fields` already lists. Any other
+ * metadata describes none.
+ */
+export function describedColumns(metadata, fields) {
+    const entries = metadata && typeof metadata === 'object' ? Object.entries(metadata) : [];
+    const listed = new Set(fields.map(field => field.label));
+    return entries.every((entry) => typeof entry[1] === 'string')
+        ? entries
+            .filter(([name]) => !listed.has(name) && !BED_LOCUS_COLUMNS.has(name))
+            .map(([name, description]) => ({
+            label: name,
+            path: [name],
+            description: description || undefined,
+        }))
+        : [];
+}
+/** A field typed into the picker rather than chosen, read as a dotted path. */
+export function typedField(text) {
+    const subject = pathSubject(ROW, text.split('.'));
+    return { key: subjectKey(subject), label: text, subject };
+}
+export function stripJexlPrefix(line) {
+    return isJexl(line) ? line.slice(JEXL_PREFIX.length) : line;
+}
+/** A field of no known type writes a value that reads as a number as one. */
+function scalar(type, text) {
+    const number = Number(text);
+    return type === 'number' ||
+        (!type && text.trim() !== '' && Number.isFinite(number))
+        ? number
+        : text;
+}
+function subjectLabel(subject) {
+    return subject.kind === 'path'
+        ? subject.path
+            .map((key, i) => typeof key === 'number' ? `[${key}]` : i === 0 ? key : `.${key}`)
+            .join('')
+        : print(subject.node);
+}
+function conditionRow(c, choices, id, line) {
+    const value = 'value' in c ? c.value : undefined;
+    const key = subjectKey(c.subject);
+    const field = choices.find(f => f.key === key) ?? {
+        key,
+        label: subjectLabel(c.subject),
+        type: value === undefined ? 'flag' : undefined,
+        subject: c.subject,
+    };
+    const op = c.op;
+    const values = value === undefined ? [] : [value].flat();
+    const writesBack = (v) => op === '~' ? typeof v === 'string' : scalar(field.type, String(v)) === v;
+    return OPERATORS[field.type ?? 'any'].some(o => o.op === op) &&
+        values.every(writesBack)
+        ? {
+            kind: 'condition',
+            id,
+            line,
+            field,
+            op,
+            value: Array.isArray(value) ? value.map(String) : String(value ?? ''),
+        }
+        : undefined;
+}
+function parseConditions(text, parser, calls) {
+    try {
+        return conditions(parser.parse(text), {
+            row: ROW,
+            accessors: { get: [] },
+            calls,
+        });
+    }
+    catch {
+        return undefined;
+    }
+}
+export function readFilterRows(lines, parser, choices) {
+    const calls = choices.flatMap(f => f.subject.kind === 'call' ? [f.subject.name] : []);
+    const rows = [];
+    for (const [line, stored] of lines.entries()) {
+        const text = stripJexlPrefix(stored);
+        const id = rows.length;
+        const read = parseConditions(text, parser, calls)?.map((c, i) => conditionRow(c, choices, id + i, line));
+        rows.push(...(read?.every(row => row !== undefined)
+            ? read
+            : [{ kind: 'text', id, line, text: text.trim() }]));
+    }
+    return { lines, rows };
+}
+function nextId(rows) {
+    return rows.reduce((max, row) => Math.max(max, row.id + 1), 0);
+}
+function emptyRow(id) {
+    return { kind: 'condition', id, op: '==', value: '' };
+}
+export function addRow(state) {
+    return { ...state, rows: [...state.rows, emptyRow(nextId(state.rows))] };
+}
+function detach(rows, id) {
+    const line = rows.find(row => row.id === id)?.line;
+    return line === undefined
+        ? rows
+        : rows.map(row => (row.line === line ? { ...row, line: undefined } : row));
+}
+export function replaceRow(state, row) {
+    return {
+        ...state,
+        rows: detach(state.rows, row.id).map(r => r.id === row.id ? { ...row, line: undefined } : r),
+    };
+}
+export function removeRow(state, id) {
+    return {
+        ...state,
+        rows: detach(state.rows, id).filter(row => row.id !== id),
+    };
+}
+export function withField(row, field) {
+    const sameType = row.field?.type === field.type;
+    const ops = OPERATORS[field.type ?? 'any'];
+    return {
+        ...row,
+        field,
+        op: sameType ? row.op : ops[0].op,
+        value: sameType ? row.value : '',
+    };
+}
+export function withOp(row, op) {
+    const { value } = row;
+    return {
+        ...row,
+        op,
+        value: op === 'in'
+            ? Array.isArray(value)
+                ? value
+                : value
+                    ? [value]
+                    : []
+            : Array.isArray(value)
+                ? (value[0] ?? '')
+                : value,
+    };
+}
+function writeCondition({ field, op, value }) {
+    if (!field) {
+        return undefined;
+    }
+    const { subject, type } = field;
+    const usable = (v) => v.trim() !== '' && (type !== 'number' || Number.isFinite(Number(v)));
+    if (op === 'set' || op === '!set') {
+        return printCondition({ subject, op });
+    }
+    if (op === 'in') {
+        const list = [value].flat().filter(usable);
+        return list.length > 0
+            ? printCondition({
+                subject,
+                op,
+                value: list.map(v => scalar(type, v)),
+            })
+            : undefined;
+    }
+    const text = [value].flat()[0] ?? '';
+    return !usable(text)
+        ? undefined
+        : op === '~'
+            ? printCondition({ subject, op, value: text })
+            : printCondition({ subject, op, value: scalar(type, text) });
+}
+function writeRow(row) {
+    const text = row.kind === 'text' ? row.text.trim() || undefined : writeCondition(row);
+    return text === undefined ? undefined : ensureJexlPrefix(text);
+}
+/**
+ * The stored filters: an untouched line as it was, and every row of an edited
+ * line as a line of its own, which is equivalent because lines AND together.
+ * Rows left incomplete are dropped.
+ */
+export function writeFilterRows({ lines, rows }) {
+    const out = [];
+    let previous;
+    for (const row of rows) {
+        if (row.line === undefined) {
+            const text = writeRow(row);
+            if (text !== undefined) {
+                out.push(text);
+            }
+        }
+        else if (row.line !== previous) {
+            out.push(lines[row.line]);
+        }
+        previous = row.line;
+    }
+    return out;
+}

package/esm/util/jexlFilters.d.ts

@@ -0,0 +1,68 @@
+import { getConf } from '../configuration/getConf.ts';
+import type { Reversible } from '../ui/filterMenuItems.ts';
+/**
+ * The two-tier feature-filter contract, shared by every display offering a
+ * "Filter by..." row. Two tiers because the setting has two authors:
+ *
+ * - the **`filter` config slot**, which an admin declares in a track config:
+ *   `jexlFilterConfigSchemaFields` in display-kit, spread by the canvas base
+ *   display schema, the mark display schema and the shared multi-sample
+ *   variant schema — the three whose models read it.
+ * - the **`filterSetting` display property**, which the dialog writes. Set —
+ *   *even to an empty list* — it replaces the config tier entirely, which is
+ *   what makes "clear the filters an admin declared" expressible.
+ *
+ * Both hold `jexl:` expressions and refuse a bare string.
+ */
+export interface JexlFilterSource {
+    /**
+     * The dialog's override. `undefined` means "follow the config slot"; an
+     * empty array means "the user cleared them".
+     */
+    filterSetting?: readonly string[];
+    /**
+     * The config tier — in practice `configuredJexlFilters(self)`. A member rather than a read this module does
+     * itself, so the two things that consume this contract off a **duck-typed**
+     * model — LD's structural menu builder and its shape test — need no live
+     * config node to answer a count with.
+     */
+    configuredFilters: () => string[];
+}
+/**
+ * The writing half, for the dialog and the menu's clear row. Separate from
+ * {@link JexlFilterSource} because a display declares `activeFilters()` in an
+ * earlier `.views()` block than the `.actions()` block declaring its setter, so
+ * requiring the setter to *read* the filters would put the two in an order MST
+ * cannot satisfy.
+ */
+export interface JexlFilterModel extends JexlFilterSource {
+    setFilter: (filters?: string[]) => void;
+}
+/** The `filterSetting` property, for a display model to declare. */
+export declare const FilterSetting: import("@jbrowse/mobx-state-tree").IMaybe<import("@jbrowse/mobx-state-tree").IArrayType<import("@jbrowse/mobx-state-tree").ISimpleType<string>>>;
+/**
+ * A snapshot's v4 `jexlFiltersSetting` as `filterSetting`, for the
+ * `preProcessSnapshot` of the model declaring {@link FilterSetting}.
+ */
+export declare function liftRetiredFilterSetting<T>(snap: T): T;
+/** What the `filter` config slot alone declares: a display's `configuredFilters`. */
+export declare function configuredJexlFilters(self: Parameters<typeof getConf>[0]): string[];
+/**
+ * The filters actually applied — the single source of truth
+ * for the worker (via `rpcProps`), for the "Filter by..." dialog (so config
+ * filters show up and are editable), and for the narrowing count below.
+ */
+export declare function activeJexlFilters(self: JexlFilterSource): string[];
+/**
+ * The `Reversible` a display declares for its jexl filters.
+ *
+ * The count is whether the override **differs from the configured baseline**,
+ * not the number of expressions: a filter an admin declared is not something
+ * the user narrowed, and "Clear all filters" could not undo it anyway. It
+ * counts in both directions when they differ — narrowing further, and (emptied
+ * over a slot that declares filters) widening past what the config asked for.
+ *
+ * No per-item row: a list of jexl expressions has no recovery to name beyond
+ * restoring the config default, which the group clear already is.
+ */
+export declare function jexlFilterNarrowing(self: JexlFilterModel): Reversible;

package/esm/util/jexlFilters.js

@@ -0,0 +1,61 @@
+// own module, not the configuration barrel: that barrel re-exports modules
+// which import this one, and a value import back into it is the cycle shape
+// `openFeatureWidget` documents
+import { types } from '@jbrowse/mobx-state-tree';
+import { getConf } from '../configuration/getConf.js';
+import { ensureJexlPrefix } from './jexlStrings.js';
+import { JexlExpressionString } from './types/mst.js';
+/** The `filterSetting` property, for a display model to declare. */
+export const FilterSetting = types.maybe(types.array(JexlExpressionString));
+/**
+ * A snapshot's v4 `jexlFiltersSetting` as `filterSetting`, for the
+ * `preProcessSnapshot` of the model declaring {@link FilterSetting}.
+ */
+export function liftRetiredFilterSetting(snap) {
+    if (!snap || typeof snap !== 'object' || !('jexlFiltersSetting' in snap)) {
+        return snap;
+    }
+    const { jexlFiltersSetting, ...rest } = snap;
+    return (Array.isArray(jexlFiltersSetting) && !('filterSetting' in rest)
+        ? { ...rest, filterSetting: jexlFiltersSetting.map(ensureJexlPrefix) }
+        : rest);
+}
+/** What the `filter` config slot alone declares: a display's `configuredFilters`. */
+export function configuredJexlFilters(self) {
+    return getConf(self, 'filter');
+}
+/**
+ * The filters actually applied — the single source of truth
+ * for the worker (via `rpcProps`), for the "Filter by..." dialog (so config
+ * filters show up and are editable), and for the narrowing count below.
+ */
+export function activeJexlFilters(self) {
+    const { filterSetting } = self;
+    return filterSetting ? [...filterSetting] : self.configuredFilters();
+}
+/**
+ * The `Reversible` a display declares for its jexl filters.
+ *
+ * The count is whether the override **differs from the configured baseline**,
+ * not the number of expressions: a filter an admin declared is not something
+ * the user narrowed, and "Clear all filters" could not undo it anyway. It
+ * counts in both directions when they differ — narrowing further, and (emptied
+ * over a slot that declares filters) widening past what the config asked for.
+ *
+ * No per-item row: a list of jexl expressions has no recovery to name beyond
+ * restoring the config default, which the group clear already is.
+ */
+export function jexlFilterNarrowing(self) {
+    const override = self.filterSetting;
+    const configured = self.configuredFilters();
+    return {
+        count: override !== undefined &&
+            (override.length !== configured.length ||
+                override.some((f, i) => f !== configured[i]))
+            ? 1
+            : 0,
+        clear: () => {
+            self.setFilter(undefined);
+        },
+    };
+}

package/esm/util/jexlStrings.d.ts

@@ -1 +1,21 @@
-export declare function stringToJexlExpression(str: string, jexl?: any): any;
+export interface JexlExpression {
+    eval(context?: Record<string, unknown>): unknown;
+    readonly source?: string;
+}
+export interface JexlInstance {
+    compile(code: string): JexlExpression;
+}
+/** The `jexl:` prefix marks a config value as a deferred callback expression. */
+export declare const JEXL_PREFIX = "jexl:";
+export declare function isJexl(str: unknown): str is string;
+/** Add the `jexl:` prefix unless the string already carries it. */
+export declare function ensureJexlPrefix(code: string): string;
+/**
+ * Compile a `jexl:...` string to an Expression. The jexl instance caches
+ * compilation, so this only strips the prefix.
+ *
+ * @param str - string of code like `jexl:...`
+ * @param jexl - the instance whose registered functions the expression may call
+ *   (`pluginManager.jexl` on eval paths)
+ */
+export declare function stringToJexlExpression(str: string, jexl: JexlInstance): JexlExpression;

package/esm/util/jexlStrings.js

@@ -1,17 +1,23 @@
-import createJexlInstance from "./jexl.js";
-const compilationCache = {};
+/** The `jexl:` prefix marks a config value as a deferred callback expression. */
+export const JEXL_PREFIX = 'jexl:';
+export function isJexl(str) {
+    return typeof str === 'string' && str.startsWith(JEXL_PREFIX);
+}
+/** Add the `jexl:` prefix unless the string already carries it. */
+export function ensureJexlPrefix(code) {
+    return isJexl(code) ? code : `${JEXL_PREFIX}${code}`;
+}
+/**
+ * Compile a `jexl:...` string to an Expression. The jexl instance caches
+ * compilation, so this only strips the prefix.
+ *
+ * @param str - string of code like `jexl:...`
+ * @param jexl - the instance whose registered functions the expression may call
+ *   (`pluginManager.jexl` on eval paths)
+ */
 export function stringToJexlExpression(str, jexl) {
-    const cacheKey = `nosig|${str}`;
-    if (!compilationCache[cacheKey]) {
-        const match = str.startsWith('jexl:');
-        if (!match) {
-            throw new Error('string does not appear to be in jexl format');
-        }
-        const code = str.split('jexl:')[1];
-        const compiled = jexl
-            ? jexl.compile(code)
-            : createJexlInstance().compile(code);
-        compilationCache[cacheKey] = compiled;
+    if (!isJexl(str)) {
+        throw new Error('string does not appear to be in jexl format');
     }
-    return compilationCache[cacheKey];
+    return jexl.compile(str.slice(JEXL_PREFIX.length));
 }

package/esm/util/layouts/GranularRectLayout.d.ts

@@ -1,37 +1,32 @@
-import type { BaseLayout, RectTuple, Rectangle, SerializedLayout } from './BaseLayout.ts';
-export default class GranularRectLayout<T> implements BaseLayout<T> {
+export default class GranularRectLayout {
     private pitchX;
     private pitchY;
     private hardRowLimit;
     private bitmap;
     private rectangles;
-    maxHeightReached: boolean;
     private maxHeight;
-    private displayMode;
-    private pTotalHeight;
-    constructor({ pitchX, pitchY, maxHeight, hardRowLimit, displayMode, }?: {
+    /**
+     * pitchX - layout grid pitch in the X direction
+     * pitchY - layout grid pitch in the Y direction
+     * maxHeight - maximum layout height in pixels, default 10000
+     */
+    constructor({ pitchX, pitchY, maxHeight, hardRowLimit, }?: {
         pitchX?: number;
         pitchY?: number;
         maxHeight?: number;
-        displayMode?: string;
         hardRowLimit?: number;
     });
-    addRect(id: string, left: number, right: number, height: number, data?: T, serializableData?: T, startingRow?: number): number | null;
-    collides(rect: Rectangle<T>, top: number): boolean;
-    addRectToBitmap(rect: Rectangle<T>): void;
-    discardRange(left: number, right: number): void;
-    hasSeen(id: string): boolean;
-    getByCoord(x: number, y: number): string | Record<string, T> | undefined;
-    getByID(id: string): RectTuple | undefined;
-    getDataByID(id: string): T | undefined;
-    getSerializableDataByID(id: string): T | undefined;
-    cleanup(): void;
-    getTotalHeight(): number;
-    get totalHeight(): number;
-    getRectangles(): Map<string, RectTuple>;
-    serializeRegion(region: {
-        start: number;
-        end: number;
-    }): SerializedLayout;
-    toJSON(): SerializedLayout;
+    /**
+     * `lower` gives the rows lying wholly at or past `lower.top` px below the
+     * rect's top a span of their own.
+     *
+     * @returns top position for the rect, or Null if laying
+     *  out the rect would exceed maxHeight
+     */
+    addRect(id: string, left: number, right: number, height: number, lower?: {
+        top: number;
+        left: number;
+        right: number;
+    }): number | null;
+    private getOrCreateRow;
 }