@genome-spy/core 0.78.0 → 0.79.0

package/dist/src/data/transforms/truncateText.js

@@ -0,0 +1,94 @@
+import { BEHAVIOR_MODIFIES } from "../flowNode.js";
+import { field } from "../../utils/field.js";
+import Transform from "./transform.js";
+
+const DEFAULT_ELLIPSIS = "...";
+
+/**
+ * @param {string} text
+ * @param {number | undefined} limit
+ * @param {((text: string, fontSize?: number) => number) | undefined} measureWidth
+ * @param {number} fontSize
+ * @param {string} ellipsis
+ */
+export function truncateText(text, limit, measureWidth, fontSize, ellipsis) {
+    if (limit === undefined || !Number.isFinite(limit)) {
+        return text;
+    }
+
+    if (limit <= 0) {
+        return "";
+    }
+
+    if (!measureWidth || measureWidth(text, fontSize) <= limit) {
+        return text;
+    }
+
+    if (measureWidth(ellipsis, fontSize) > limit) {
+        return "";
+    }
+
+    let low = 0;
+    let high = text.length;
+    while (low < high) {
+        const mid = Math.ceil((low + high) / 2);
+        if (measureWidth(text.slice(0, mid) + ellipsis, fontSize) <= limit) {
+            low = mid;
+        } else {
+            high = mid - 1;
+        }
+    }
+
+    return text.slice(0, low) + ellipsis;
+}
+
+export default class TruncateTextTransform extends Transform {
+    get behavior() {
+        return BEHAVIOR_MODIFIES;
+    }
+
+    /**
+     * @param {import("../../spec/transform.js").TruncateTextParams} params
+     * @param {import("../flowNode.js").ParamRuntimeProvider} paramRuntimeProvider
+     */
+    constructor(params, paramRuntimeProvider) {
+        super(params, paramRuntimeProvider);
+
+        this.params = params;
+        this.accessor = field(params.field);
+        this.as = params.as ?? params.field;
+        this.fontSize = params.fontSize;
+        this.ellipsis = params.ellipsis ?? DEFAULT_ELLIPSIS;
+    }
+
+    initialize() {
+        const fontManager = this.paramRuntimeProvider.context.fontManager;
+        this.font = this.params.font
+            ? fontManager.getFont(
+                  this.params.font,
+                  this.params.fontStyle,
+                  this.params.fontWeight
+              )
+            : fontManager.getDefaultFont();
+    }
+
+    /**
+     * @param {any} datum
+     */
+    handle(datum) {
+        const value = this.accessor(datum);
+        if (value === undefined || value === null) {
+            datum[this.as] = "";
+        } else {
+            datum[this.as] = truncateText(
+                "" + value,
+                this.params.limit,
+                this.font.metrics?.measureWidth,
+                this.fontSize,
+                this.ellipsis
+            );
+        }
+
+        this._propagate(datum);
+    }
+}

package/dist/src/debug/dataflowDebugSnapshot.d.ts

@@ -0,0 +1,58 @@
+/**
+ * @typedef {object} DataflowDebugSnapshotOptions
+ * @prop {(object: object) => string} getDebugId
+ * @prop {import("../view/view.js").default} [rootView]
+ */
+/**
+ * @typedef {object} DataflowDebugSnapshot
+ * @prop {string[]} sourceIds
+ * @prop {DataflowDebugNode[]} nodes
+ * @prop {number} collectorCount
+ */
+/**
+ * @typedef {object} DataflowDebugNode
+ * @prop {string} id
+ * @prop {string | undefined} parentId
+ * @prop {string[]} childIds
+ * @prop {string} label
+ * @prop {number} count
+ * @prop {Record<string, any> | null} first
+ * @prop {boolean} completed
+ * @prop {boolean} initialized
+ * @prop {boolean} disposed
+ * @prop {Record<string, any> | undefined} params
+ * @prop {string | undefined} viewId
+ * @prop {string | undefined} viewPath
+ * @prop {string[]} domainSensitiveScaleChannels
+ */
+/**
+ * @param {import("../data/dataFlow.js").default | undefined} dataFlow
+ * @param {DataflowDebugSnapshotOptions} options
+ * @returns {DataflowDebugSnapshot}
+ */
+export function createDataflowDebugSnapshot(dataFlow: import("../data/dataFlow.js").default | undefined, options: DataflowDebugSnapshotOptions): DataflowDebugSnapshot;
+export type DataflowDebugSnapshotOptions = {
+    getDebugId: (object: object) => string;
+    rootView?: import("../view/view.js").default;
+};
+export type DataflowDebugSnapshot = {
+    sourceIds: string[];
+    nodes: DataflowDebugNode[];
+    collectorCount: number;
+};
+export type DataflowDebugNode = {
+    id: string;
+    parentId: string | undefined;
+    childIds: string[];
+    label: string;
+    count: number;
+    first: Record<string, any> | null;
+    completed: boolean;
+    initialized: boolean;
+    disposed: boolean;
+    params: Record<string, any> | undefined;
+    viewId: string | undefined;
+    viewPath: string | undefined;
+    domainSensitiveScaleChannels: string[];
+};
+//# sourceMappingURL=dataflowDebugSnapshot.d.ts.map

package/dist/src/debug/dataflowDebugSnapshot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dataflowDebugSnapshot.d.ts","sourceRoot":"","sources":["../../../src/debug/dataflowDebugSnapshot.js"],"names":[],"mappings":"AAEA;;;;GAIG;AAEH;;;;;GAKG;AAEH;;;;;;;;;;;;;;;GAeG;AAEH;;;;GAIG;AACH,sDAJW,OAAO,qBAAqB,EAAE,OAAO,GAAG,SAAS,WACjD,4BAA4B,GAC1B,qBAAqB,CAmCjC;;gBAlES,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM;eAC1B,OAAO,iBAAiB,EAAE,OAAO;;;eAKjC,MAAM,EAAE;WACR,iBAAiB,EAAE;oBACnB,MAAM;;;QAKN,MAAM;cACN,MAAM,GAAG,SAAS;cAClB,MAAM,EAAE;WACR,MAAM;WACN,MAAM;WACN,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,IAAI;eAC1B,OAAO;iBACP,OAAO;cACP,OAAO;YACP,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,SAAS;YAC/B,MAAM,GAAG,SAAS;cAClB,MAAM,GAAG,SAAS;kCAClB,MAAM,EAAE"}

package/dist/src/debug/dataflowDebugSnapshot.js

@@ -0,0 +1,159 @@
+import { previewValue } from "./valuePreview.js";
+
+/**
+ * @typedef {object} DataflowDebugSnapshotOptions
+ * @prop {(object: object) => string} getDebugId
+ * @prop {import("../view/view.js").default} [rootView]
+ */
+
+/**
+ * @typedef {object} DataflowDebugSnapshot
+ * @prop {string[]} sourceIds
+ * @prop {DataflowDebugNode[]} nodes
+ * @prop {number} collectorCount
+ */
+
+/**
+ * @typedef {object} DataflowDebugNode
+ * @prop {string} id
+ * @prop {string | undefined} parentId
+ * @prop {string[]} childIds
+ * @prop {string} label
+ * @prop {number} count
+ * @prop {Record<string, any> | null} first
+ * @prop {boolean} completed
+ * @prop {boolean} initialized
+ * @prop {boolean} disposed
+ * @prop {Record<string, any> | undefined} params
+ * @prop {string | undefined} viewId
+ * @prop {string | undefined} viewPath
+ * @prop {string[]} domainSensitiveScaleChannels
+ */
+
+/**
+ * @param {import("../data/dataFlow.js").default | undefined} dataFlow
+ * @param {DataflowDebugSnapshotOptions} options
+ * @returns {DataflowDebugSnapshot}
+ */
+export function createDataflowDebugSnapshot(dataFlow, options) {
+    if (!dataFlow) {
+        return {
+            sourceIds: [],
+            nodes: [],
+            collectorCount: 0,
+        };
+    }
+
+    /** @type {DataflowDebugNode[]} */
+    const nodes = [];
+    /** @type {string[]} */
+    const sourceIds = [];
+    const seen = new Set();
+    const flowNodeViewLookup = createFlowNodeViewLookup(options.rootView);
+
+    for (const source of dataFlow.dataSources) {
+        const node = visitFlowNode(
+            source,
+            undefined,
+            options,
+            nodes,
+            seen,
+            flowNodeViewLookup
+        );
+        sourceIds.push(node.id);
+    }
+
+    return {
+        sourceIds,
+        nodes,
+        collectorCount: dataFlow.collectors.length,
+    };
+}
+
+/**
+ * @param {import("../data/flowNode.js").default} flowNode
+ * @param {string | undefined} parentId
+ * @param {DataflowDebugSnapshotOptions} options
+ * @param {DataflowDebugNode[]} nodes
+ * @param {Set<object>} seen
+ * @param {WeakMap<object, import("../view/view.js").default>} flowNodeViewLookup
+ * @returns {DataflowDebugNode}
+ */
+function visitFlowNode(
+    flowNode,
+    parentId,
+    options,
+    nodes,
+    seen,
+    flowNodeViewLookup
+) {
+    const id = options.getDebugId(flowNode);
+    if (seen.has(flowNode)) {
+        const existing = nodes.find((node) => node.id === id);
+        if (!existing) {
+            throw new Error("Seen flow node missing from debug snapshot.");
+        }
+        return existing;
+    }
+
+    seen.add(flowNode);
+    const state = flowNode.getDebugState();
+    const view = state.view ?? flowNodeViewLookup.get(flowNode);
+    /** @type {string[]} */
+    const childIds = [];
+    const node = {
+        id,
+        parentId,
+        childIds,
+        label: state.label,
+        count: state.stats.count,
+        first: previewValue(state.stats.first),
+        completed: state.completed,
+        initialized: state.initialized,
+        disposed: state.disposed,
+        params: state.params ? previewValue(state.params) : undefined,
+        viewId: view ? options.getDebugId(view) : undefined,
+        viewPath: view ? view.getPathString() : undefined,
+        domainSensitiveScaleChannels: state.domainSensitiveScaleChannels,
+    };
+    nodes.push(node);
+
+    for (const child of state.children) {
+        const childNode = visitFlowNode(
+            child,
+            id,
+            options,
+            nodes,
+            seen,
+            flowNodeViewLookup
+        );
+        node.childIds.push(childNode.id);
+    }
+
+    return node;
+}
+
+/**
+ * @param {import("../view/view.js").default | undefined} root
+ * @returns {WeakMap<object, import("../view/view.js").default>}
+ */
+function createFlowNodeViewLookup(root) {
+    const lookup = new WeakMap();
+    if (!root) {
+        return lookup;
+    }
+
+    root.visit((view) => {
+        const flowHandle = view.flowHandle;
+        if (flowHandle?.dataSource) {
+            lookup.set(flowHandle.dataSource, view);
+        }
+        if (flowHandle?.node) {
+            lookup.set(flowHandle.node, view);
+        }
+        if (flowHandle?.collector) {
+            lookup.set(flowHandle.collector, view);
+        }
+    });
+    return lookup;
+}

package/dist/src/debug/markDebugSnapshot.d.ts

@@ -0,0 +1,54 @@
+/**
+ * @typedef {object} MarkDebugSnapshotOptions
+ * @prop {(object: object) => string} getDebugId
+ */
+/**
+ * @typedef {object} MarkDebugSnapshot
+ * @prop {MarkDebugNode[]} marks
+ */
+/**
+ * @typedef {object} MarkDebugNode
+ * @prop {string} viewId
+ * @prop {string} viewPath
+ * @prop {string} type
+ * @prop {boolean} ready
+ * @prop {boolean} pickingParticipant
+ * @prop {boolean} markUniformsAltered
+ * @prop {string[]} encodingChannels
+ * @prop {string[]} encoderChannels
+ * @prop {string[]} searchFields
+ * @prop {number | undefined} dataCount
+ * @prop {number | undefined} vertexCount
+ * @prop {number | undefined} allocatedVertices
+ * @prop {number} rangeCount
+ * @prop {Record<string, any>} properties
+ */
+/**
+ * @param {import("../view/view.js").default | undefined} root
+ * @param {MarkDebugSnapshotOptions} options
+ * @returns {MarkDebugSnapshot}
+ */
+export function createMarkDebugSnapshot(root: import("../view/view.js").default | undefined, options: MarkDebugSnapshotOptions): MarkDebugSnapshot;
+export type MarkDebugSnapshotOptions = {
+    getDebugId: (object: object) => string;
+};
+export type MarkDebugSnapshot = {
+    marks: MarkDebugNode[];
+};
+export type MarkDebugNode = {
+    viewId: string;
+    viewPath: string;
+    type: string;
+    ready: boolean;
+    pickingParticipant: boolean;
+    markUniformsAltered: boolean;
+    encodingChannels: string[];
+    encoderChannels: string[];
+    searchFields: string[];
+    dataCount: number | undefined;
+    vertexCount: number | undefined;
+    allocatedVertices: number | undefined;
+    rangeCount: number;
+    properties: Record<string, any>;
+};
+//# sourceMappingURL=markDebugSnapshot.d.ts.map

package/dist/src/debug/markDebugSnapshot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markDebugSnapshot.d.ts","sourceRoot":"","sources":["../../../src/debug/markDebugSnapshot.js"],"names":[],"mappings":"AAIA;;;GAGG;AAEH;;;GAGG;AAEH;;;;;;;;;;;;;;;;GAgBG;AAEH;;;;GAIG;AACH,8CAJW,OAAO,iBAAiB,EAAE,OAAO,GAAG,SAAS,WAC7C,wBAAwB,GACtB,iBAAiB,CAuC7B;;gBApES,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM;;;WAK1B,aAAa,EAAE;;;YAKf,MAAM;cACN,MAAM;UACN,MAAM;WACN,OAAO;wBACP,OAAO;yBACP,OAAO;sBACP,MAAM,EAAE;qBACR,MAAM,EAAE;kBACR,MAAM,EAAE;eACR,MAAM,GAAG,SAAS;iBAClB,MAAM,GAAG,SAAS;uBAClB,MAAM,GAAG,SAAS;gBAClB,MAAM;gBACN,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC"}

package/dist/src/debug/markDebugSnapshot.js

@@ -0,0 +1,100 @@
+import ContainerView from "../view/containerView.js";
+import { getEncodingSearchFields } from "../encoder/metadataChannels.js";
+import { previewValue } from "./valuePreview.js";
+
+/**
+ * @typedef {object} MarkDebugSnapshotOptions
+ * @prop {(object: object) => string} getDebugId
+ */
+
+/**
+ * @typedef {object} MarkDebugSnapshot
+ * @prop {MarkDebugNode[]} marks
+ */
+
+/**
+ * @typedef {object} MarkDebugNode
+ * @prop {string} viewId
+ * @prop {string} viewPath
+ * @prop {string} type
+ * @prop {boolean} ready
+ * @prop {boolean} pickingParticipant
+ * @prop {boolean} markUniformsAltered
+ * @prop {string[]} encodingChannels
+ * @prop {string[]} encoderChannels
+ * @prop {string[]} searchFields
+ * @prop {number | undefined} dataCount
+ * @prop {number | undefined} vertexCount
+ * @prop {number | undefined} allocatedVertices
+ * @prop {number} rangeCount
+ * @prop {Record<string, any>} properties
+ */
+
+/**
+ * @param {import("../view/view.js").default | undefined} root
+ * @param {MarkDebugSnapshotOptions} options
+ * @returns {MarkDebugSnapshot}
+ */
+export function createMarkDebugSnapshot(root, options) {
+    if (!root) {
+        return { marks: [] };
+    }
+
+    /** @type {MarkDebugNode[]} */
+    const marks = [];
+
+    visitViews(root, (view) => {
+        const mark =
+            /** @type {{ mark?: import("../marks/mark.js").default }} */ (
+                /** @type {unknown} */ (view)
+            ).mark;
+        if (!mark) {
+            return;
+        }
+
+        const state = mark.getDebugState();
+        marks.push({
+            viewId: options.getDebugId(view),
+            viewPath: view.getPathString(),
+            type: mark.getType(),
+            ready: Boolean(mark.isReady()),
+            pickingParticipant: mark.isPickingParticipant(),
+            markUniformsAltered: state.markUniformsAltered,
+            encodingChannels: Object.keys(mark.encoding),
+            encoderChannels: mark.encoders ? Object.keys(mark.encoders) : [],
+            searchFields: getEncodingSearchFields(view.getEncoding()) ?? [],
+            dataCount: getDataCount(view),
+            vertexCount: state.vertexCount,
+            allocatedVertices: state.allocatedVertices,
+            rangeCount: mark.rangeMap.size,
+            properties: previewValue(state.properties),
+        });
+    });
+
+    return { marks };
+}
+
+/**
+ * @param {import("../view/view.js").default} root
+ * @param {(view: import("../view/view.js").default) => void} visitor
+ */
+function visitViews(root, visitor) {
+    visitor(root);
+    if (root instanceof ContainerView) {
+        for (const child of root) {
+            visitViews(child, visitor);
+        }
+    }
+}
+
+/**
+ * @param {import("../view/view.js").default} view
+ * @returns {number | undefined}
+ */
+function getDataCount(view) {
+    const collector =
+        /** @type {{ getCollector?: () => import("../data/collector.js").default | undefined }} */ (
+            /** @type {unknown} */ (view)
+        ).getCollector?.();
+    return collector?.getItemCount();
+}

package/dist/src/debug/paramDebugSnapshot.d.ts

@@ -0,0 +1,53 @@
+/**
+ * @typedef {object} ParamDebugSnapshotOptions
+ * @prop {(object: object) => string} getDebugId
+ */
+/**
+ * @typedef {object} ParamDebugSnapshot
+ * @prop {ParamScopeDebugNode[]} scopes
+ */
+/**
+ * @typedef {object} ParamScopeDebugNode
+ * @prop {string} viewId
+ * @prop {string} viewPath
+ * @prop {string} scopeId
+ * @prop {boolean} disposed
+ * @prop {ParamDebugNode[]} params
+ */
+/**
+ * @typedef {object} ParamDebugNode
+ * @prop {string} name
+ * @prop {"auto" | "base" | "derived" | "selection" | "push"} kind
+ * @prop {any} value
+ * @prop {boolean} writable
+ * @prop {boolean} configured
+ * @prop {Record<string, any> | undefined} config
+ */
+/**
+ * @param {import("../view/view.js").default | undefined} root
+ * @param {ParamDebugSnapshotOptions} options
+ * @returns {ParamDebugSnapshot}
+ */
+export function createParamDebugSnapshot(root: import("../view/view.js").default | undefined, options: ParamDebugSnapshotOptions): ParamDebugSnapshot;
+export type ParamDebugSnapshotOptions = {
+    getDebugId: (object: object) => string;
+};
+export type ParamDebugSnapshot = {
+    scopes: ParamScopeDebugNode[];
+};
+export type ParamScopeDebugNode = {
+    viewId: string;
+    viewPath: string;
+    scopeId: string;
+    disposed: boolean;
+    params: ParamDebugNode[];
+};
+export type ParamDebugNode = {
+    name: string;
+    kind: "auto" | "base" | "derived" | "selection" | "push";
+    value: any;
+    writable: boolean;
+    configured: boolean;
+    config: Record<string, any> | undefined;
+};
+//# sourceMappingURL=paramDebugSnapshot.d.ts.map

package/dist/src/debug/paramDebugSnapshot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paramDebugSnapshot.d.ts","sourceRoot":"","sources":["../../../src/debug/paramDebugSnapshot.js"],"names":[],"mappings":"AAGA;;;GAGG;AAEH;;;GAGG;AAEH;;;;;;;GAOG;AAEH;;;;;;;;GAQG;AAEH;;;;GAIG;AACH,+CAJW,OAAO,iBAAiB,EAAE,OAAO,GAAG,SAAS,WAC7C,yBAAyB,GACvB,kBAAkB,CAqC9B;;gBAnES,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM;;;YAK1B,mBAAmB,EAAE;;;YAKrB,MAAM;cACN,MAAM;aACN,MAAM;cACN,OAAO;YACP,cAAc,EAAE;;;UAKhB,MAAM;UACN,MAAM,GAAG,MAAM,GAAG,SAAS,GAAG,WAAW,GAAG,MAAM;WAClD,GAAG;cACH,OAAO;gBACP,OAAO;YACP,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,SAAS"}

package/dist/src/debug/paramDebugSnapshot.js

@@ -0,0 +1,86 @@
+import ContainerView from "../view/containerView.js";
+import { previewValue } from "./valuePreview.js";
+
+/**
+ * @typedef {object} ParamDebugSnapshotOptions
+ * @prop {(object: object) => string} getDebugId
+ */
+
+/**
+ * @typedef {object} ParamDebugSnapshot
+ * @prop {ParamScopeDebugNode[]} scopes
+ */
+
+/**
+ * @typedef {object} ParamScopeDebugNode
+ * @prop {string} viewId
+ * @prop {string} viewPath
+ * @prop {string} scopeId
+ * @prop {boolean} disposed
+ * @prop {ParamDebugNode[]} params
+ */
+
+/**
+ * @typedef {object} ParamDebugNode
+ * @prop {string} name
+ * @prop {"auto" | "base" | "derived" | "selection" | "push"} kind
+ * @prop {any} value
+ * @prop {boolean} writable
+ * @prop {boolean} configured
+ * @prop {Record<string, any> | undefined} config
+ */
+
+/**
+ * @param {import("../view/view.js").default | undefined} root
+ * @param {ParamDebugSnapshotOptions} options
+ * @returns {ParamDebugSnapshot}
+ */
+export function createParamDebugSnapshot(root, options) {
+    if (!root) {
+        return { scopes: [] };
+    }
+
+    /** @type {ParamScopeDebugNode[]} */
+    const scopes = [];
+
+    visitViews(root, (view) => {
+        const state = view.paramRuntime.getDebugState();
+        scopes.push({
+            viewId: options.getDebugId(view),
+            viewPath: view.getPathString(),
+            scopeId: state.scopeId,
+            disposed: state.disposed,
+            params: state.params.map(
+                /**
+                 * @param {import("../paramRuntime/viewParamRuntime.js").ViewParamDebugState} param
+                 * @returns {ParamDebugNode}
+                 */
+                (param) => ({
+                    name: param.name,
+                    kind: param.kind,
+                    value: previewValue(param.value),
+                    writable: param.writable,
+                    configured: param.configured,
+                    config: param.config
+                        ? previewValue(param.config)
+                        : undefined,
+                })
+            ),
+        });
+    });
+
+    return { scopes };
+}
+
+/**
+ * @param {import("../view/view.js").default} root
+ * @param {(view: import("../view/view.js").default) => void} visitor
+ */
+function visitViews(root, visitor) {
+    visitor(root);
+    if (root instanceof ContainerView) {
+        for (const child of root) {
+            visitViews(child, visitor);
+        }
+    }
+}