@genome-spy/app 0.75.0 → 0.77.0

package/src/state/paramProvenanceTypes.d.ts

@@ -0,0 +1,215 @@
+import type { Scalar } from "@genome-spy/core/spec/channel.js";
+import type { ChromosomalLocus } from "@genome-spy/core/spec/genome.js";
+import type {
+    ParamSelector,
+    ViewSelector,
+} from "@genome-spy/core/view/viewUtilTypes.d.ts";
+import type {
+    SelectionExpansionPredicate,
+    SelectionExpansionRule,
+} from "./selectionExpansionTypes.d.ts";
+
+/**
+ * Shared type aliases for param provenance payloads.
+ *
+ * These types describe the bookmarkable selection state that can be replayed
+ * and surfaced to the agent.
+ */
+export type ParamValueLiteral = {
+    /**
+     * Literal param value.
+     */
+    type: "value";
+
+    /**
+     * Stored literal value.
+     */
+    value: any;
+};
+
+export type ParamValueInterval = {
+    /**
+     * Interval selection value.
+     */
+    type: "interval";
+
+    /**
+     * Interval endpoints keyed by encoding channel.
+     */
+    intervals: Partial<
+        Record<
+            "x" | "y",
+            [number, number] | [ChromosomalLocus, ChromosomalLocus] | null
+        >
+    >;
+};
+
+export type ParamValuePoint = {
+    /**
+     * Point selection value.
+     */
+    type: "point";
+
+    /**
+     * Fields used to identify selected points.
+     */
+    keyFields: string[];
+
+    /**
+     * Selected key tuples.
+     */
+    keys: Scalar[][];
+};
+
+/**
+ * Origin of a param value derived from a datum or interval lookup.
+ */
+export type ParamOrigin = {
+    /**
+     * Origin type.
+     */
+    type: "datum";
+
+    /**
+     * View that contributed the value.
+     */
+    view: ViewSelector;
+
+    /**
+     * Field that supplied the value.
+     */
+    keyField: string;
+
+    /**
+     * Scalar value captured from the source datum.
+     */
+    key: Scalar;
+
+    /**
+     * Optional interval sources used for replay and diagnostics.
+     */
+    intervalSources?: Record<string, { start?: string; end?: string }>;
+};
+
+/**
+ * Back-reference for point selection expansion.
+ */
+export type PointExpandOrigin = {
+    /**
+     * View that produced the point selection.
+     */
+    view: ViewSelector;
+
+    /**
+     * Selected tuple captured at expansion time.
+     */
+    keyTuple: Scalar[];
+
+    /**
+     * Legacy support: older bookmarks may include these.
+     * New payloads should omit them.
+     */
+    keyFields?: string[];
+
+    /**
+     * Legacy datum marker retained for old bookmarks.
+     */
+    type?: "datum";
+};
+
+/**
+ * Matcher used to expand a point selection either by rule or predicate.
+ */
+export type PointExpandMatcher =
+    | { rule: SelectionExpansionRule; predicate?: never }
+    | { predicate: SelectionExpansionPredicate; rule?: never };
+
+/**
+ * Expanded point selection value stored in provenance.
+ */
+export type ParamValuePointExpand = {
+    /**
+     * Expanded point-selection value.
+     */
+    type: "pointExpand";
+
+    /**
+     * Operation applied to the current selection.
+     */
+    operation: "replace" | "add" | "remove" | "toggle";
+
+    /**
+     * Optional partitioning fields used during expansion.
+     */
+    partitionBy?: string[];
+
+    /**
+     * Original point selection that was expanded.
+     */
+    origin: PointExpandOrigin;
+} & PointExpandMatcher;
+
+/**
+ * Bookmarkable param value stored in provenance.
+ */
+export type ParamValue =
+    | ParamValueLiteral
+    | ParamValueInterval
+    | ParamValuePoint
+    | ParamValuePointExpand;
+
+/**
+ * Payload for creating or updating a reactive selection or parameter value,
+ * including point selections, interval selections, and genomic-region
+ * selections.
+ */
+export interface ParamProvenanceEntry {
+    /**
+     * Structured selector for the parameter.
+     */
+    selector: ParamSelector;
+
+    /**
+     * Serialized parameter value.
+     */
+    value: ParamValue;
+
+    /**
+     * Optional datum origin for replayable values.
+     */
+    origin?: ParamOrigin;
+}
+
+/**
+ * Payload for expanding a point selection.
+ */
+export type ExpandPointSelectionActionPayload = {
+    /**
+     * Target param selector.
+     */
+    selector: ParamSelector;
+
+    /**
+     * Expansion operation.
+     */
+    operation: "replace" | "add" | "remove" | "toggle";
+
+    /**
+     * Optional partitioning fields for the expansion.
+     */
+    partitionBy?: string[];
+
+    /**
+     * Back-reference to the point selection origin.
+     */
+    origin: PointExpandOrigin;
+    // TODO(app): Consider optional replay-drift diagnostics here, for example
+    // expectedMatchCount/sourceDataFingerprint, if semantic replay warnings are needed.
+} & PointExpandMatcher;
+
+/**
+ * Param provenance map keyed by selector key.
+ */
+export type ParamProvenanceState = {
+    entries: Record<string, ParamProvenanceEntry>;
+};

package/src/state/selectionExpansionTypes.d.ts

@@ -0,0 +1,77 @@
+import type { Scalar } from "@genome-spy/core/spec/channel.js";
+
+export type SelectionLeafValue = Scalar | null;
+
+export type SelectionExpansionLeafPredicate =
+    | {
+          field: string;
+          op: "eq";
+          value: SelectionLeafValue;
+      }
+    | {
+          field: string;
+          op: "eq";
+          valueFromField: string;
+      }
+    | {
+          field: string;
+          op: "in";
+          values: SelectionLeafValue[];
+      };
+
+export type LogicalAnd = {
+    and: SelectionExpansionPredicate[];
+};
+
+export type LogicalOr = {
+    or: SelectionExpansionPredicate[];
+};
+
+export type LogicalNot = {
+    not: SelectionExpansionPredicate;
+};
+
+export type SelectionExpansionPredicate =
+    | SelectionExpansionLeafPredicate
+    | LogicalAnd
+    | LogicalOr
+    | LogicalNot;
+
+export type SelectionExpansionRule = {
+    kind: "sameFieldValue";
+    field: string;
+};
+
+export type SelectionExpansionMatcher =
+    | SelectionExpansionPredicate
+    | SelectionExpansionRule;
+
+export type ResolvedSelectionExpansionLeafPredicate =
+    | {
+          field: string;
+          op: "eq";
+          value: SelectionLeafValue;
+      }
+    | {
+          field: string;
+          op: "in";
+          values: SelectionLeafValue[];
+      };
+
+export type ResolvedLogicalAnd = {
+    and: ResolvedSelectionExpansionPredicate[];
+};
+
+export type ResolvedLogicalOr = {
+    or: ResolvedSelectionExpansionPredicate[];
+};
+
+export type ResolvedLogicalNot = {
+    not: ResolvedSelectionExpansionPredicate;
+};
+
+export type ResolvedSelectionExpansionPredicate =
+    | ResolvedSelectionExpansionLeafPredicate
+    | ResolvedLogicalAnd
+    | ResolvedLogicalOr
+    | ResolvedLogicalNot;

package/src/state.d.ts

@@ -0,0 +1,97 @@
+import { StateWithHistory } from "redux-undo";
+import { SampleHierarchy } from "./sampleView/state/sampleState.js";
+import {
+    ParamSelector,
+    ViewSelector,
+} from "@genome-spy/core/view/viewUtilTypes.d.ts";
+import { Scalar } from "@genome-spy/core/spec/channel.js";
+import { ChromosomalLocus } from "@genome-spy/core/spec/genome.js";
+
+export interface ParamValueLiteral {
+    type: "value";
+    value: any;
+}
+
+export interface ParamValueInterval {
+    type: "interval";
+    intervals: Partial<
+        Record<
+            "x" | "y",
+            [number, number] | [ChromosomalLocus, ChromosomalLocus] | null
+        >
+    >;
+}
+
+export interface ParamValuePoint {
+    type: "point";
+    keyFields: string[];
+    keys: Scalar[][];
+}
+
+export type ParamValue =
+    | ParamValueLiteral
+    | ParamValueInterval
+    | ParamValuePoint;
+
+export interface ParamOrigin {
+    type: "datum";
+    view: ViewSelector;
+    keyField: string;
+    key: Scalar;
+    intervalSources?: Record<string, { start?: string; end?: string }>;
+}
+
+export interface ParamProvenanceEntry {
+    selector: ParamSelector;
+    value: ParamValue;
+    origin?: ParamOrigin;
+}
+
+export interface ParamProvenanceState {
+    entries: Record<string, ParamProvenanceEntry>;
+}
+
+export interface ViewSettings {
+    /**
+     * Visibilities of views keyed by selector keys. The keys are derived from
+     * view selectors and may also include legacy view names from old bookmarks.
+     */
+    visibilities: Record<string, boolean>;
+}
+
+export interface ViewVisibilityEntry {
+    scope: string[];
+    view: string;
+    visible: boolean;
+}
+
+export type ViewVisibilityWire =
+    | ViewVisibilityEntry[]
+    | Record<string, boolean>;
+
+export interface ViewSettingsPayload {
+    visibilities?: ViewVisibilityWire;
+}
+
+export interface State {
+    viewSettings: ViewSettings;
+    /**
+     * Tracks async intent status and records provenance indices for rollback.
+     */
+    intentStatus?: {
+        status: "idle" | "running" | "error" | "canceled";
+        submissionKind?: "user" | "agent" | "bookmark";
+        startIndex?: number;
+        lastSuccessfulIndex?: number;
+        totalActions?: number;
+        currentIndex?: number;
+        currentAction?: import("@reduxjs/toolkit").Action;
+        failedAction?: import("@reduxjs/toolkit").Action;
+        error?: string;
+    };
+    provenance?: StateWithHistory<{
+        sampleView: SampleHierarchy;
+        paramProvenance: ParamProvenanceState;
+        lastAction: import("@reduxjs/toolkit").Action;
+    }>;
+}

package/src/types/lz-string.d.ts

@@ -0,0 +1,24 @@
+/*
+ * Source: https://github.com/pieroxy/lz-string/blob/master/typings/lz-string.d.ts
+
+ * The original typings didn't resolve for some reason
+ */
+
+declare module "lz-string" {
+    export function compressToBase64(input: string): string;
+    export function decompressFromBase64(input: string): string;
+
+    export function compressToUTF16(input: string): string;
+    export function decompressFromUTF16(compressed: string): string;
+
+    export function compressToUint8Array(uncompressed: string): Uint8Array;
+    export function decompressFromUint8Array(compressed: Uint8Array): string;
+
+    export function compressToEncodedURIComponent(input: string): string;
+    export function decompressFromEncodedURIComponent(
+        compressed: string
+    ): string;
+
+    export function compress(input: string): string;
+    export function decompress(compressed: string): string;
+}

package/src/types/vega-loader.d.ts

@@ -0,0 +1 @@
+declare module "vega-loader";

package/src/utils/colorScaleSummary.d.ts

@@ -0,0 +1,15 @@
+export interface ConcreteColorScale {
+    domain: unknown[];
+    range: string[];
+}
+
+export declare function getConcreteColorScale(
+    scale: unknown
+): ConcreteColorScale | undefined;
+
+export declare function addValueColors<T>(
+    items: T[],
+    getValue: (item: T) => unknown,
+    domain: unknown,
+    range: unknown
+): Array<T & { color?: string }>;

package/src/utils/statistics/fieldSummary.d.ts

@@ -0,0 +1,49 @@
+export interface QuantitativeFieldSummary {
+    nonMissingCount: number;
+    missingCount: number;
+    min?: number;
+    max?: number;
+    mean?: number;
+    median?: number;
+    p05?: number;
+    p95?: number;
+    q1?: number;
+    q3?: number;
+    iqr?: number;
+}
+
+export interface CategoryCountSummary {
+    value: unknown;
+    count: number;
+    share: number;
+}
+
+export interface CategoricalFieldSummary {
+    nonMissingCount: number;
+    missingCount: number;
+    distinctCount: number;
+    categories: CategoryCountSummary[];
+    truncated: boolean;
+    otherCount?: number;
+    otherShare?: number;
+}
+
+export declare function buildQuantitativeFieldSummary(
+    values: unknown[]
+): QuantitativeFieldSummary;
+
+export declare function buildCategoricalFieldSummary(
+    values: unknown[]
+): CategoricalFieldSummary;
+
+export declare function buildCategoricalCountsSummary(
+    counts: Map<unknown, number>,
+    nonMissingCount: number,
+    missingCount: number,
+    maxCategories?: number
+): CategoricalFieldSummary;
+
+export declare function buildTopCategorySummary(
+    counts: Map<unknown, number>,
+    nonMissingCount: number
+): CategoryCountSummary | undefined;

package/src/vite-env.d.ts

@@ -0,0 +1,6 @@
+/* eslint-disable no-unused-vars */
+/// <reference types="vite/client" />
+
+interface ImportMetaEnv {
+    readonly VITE_AGENT_BASE_URL?: string;
+}

package/dist/browser-Dvlo92rx.js

@@ -1,126 +0,0 @@
-import { n as e } from "./chunk-CPXzm0be.js";
-//#region ../../node_modules/generic-filehandle2/esm/blobFile.js
-var t = class {
-	constructor(e) {
-		this.blob = e;
-	}
-	async read(e, t = 0) {
-		if (!e) return new Uint8Array();
-		let n = t, r = n + e, i = this.blob.slice(n, r);
-		return i.bytes ? i.bytes() : new Uint8Array(await i.arrayBuffer());
-	}
-	async readFile(e) {
-		let t = typeof e == "string" ? e : e?.encoding;
-		if (t === "utf8") return this.blob.text();
-		if (t) throw Error(`unsupported encoding: ${t}`);
-		return this.blob.bytes ? this.blob.bytes() : new Uint8Array(await this.blob.arrayBuffer());
-	}
-	async stat() {
-		return { size: this.blob.size };
-	}
-	async close() {}
-};
-//#endregion
-//#region ../../node_modules/generic-filehandle2/esm/remoteFile.js
-function n(e) {
-	return (typeof e == "object" && e && "message" in e ? e.message : `${e}`).replace(/\.$/, "");
-}
-var r = class {
-	constructor(e, t = {}) {
-		this.baseOverrides = {}, this.url = e;
-		let n = t.fetch || globalThis.fetch.bind(globalThis);
-		t.overrides && (this.baseOverrides = t.overrides), this.fetchImplementation = n;
-	}
-	async fetch(e, t) {
-		let r = (t) => Error(`${n(t)} fetching ${e}`, { cause: t }), i;
-		try {
-			i = await this.fetchImplementation(e, t);
-		} catch (n) {
-			if (`${n}`.includes("Failed to fetch")) {
-				console.warn(`generic-filehandle: refetching ${e} to attempt to work around chrome CORS header caching bug`);
-				try {
-					i = await this.fetchImplementation(e, {
-						...t,
-						cache: "reload"
-					});
-				} catch (e) {
-					throw r(e);
-				}
-			} else throw r(n);
-		}
-		return i;
-	}
-	async read(e, t, n = {}) {
-		if (e === 0) return new Uint8Array();
-		let { headers: r = {}, signal: i, overrides: a = {} } = n;
-		e < Infinity ? r.range = `bytes=${t}-${t + e - 1}` : e === Infinity && t !== 0 && (r.range = `bytes=${t}-`);
-		let o = await this.fetch(this.url, {
-			...this.baseOverrides,
-			...a,
-			headers: {
-				...this.baseOverrides.headers,
-				...a.headers,
-				...r
-			},
-			method: "GET",
-			redirect: "follow",
-			mode: "cors",
-			signal: i
-		});
-		if (!o.ok) throw Error(`HTTP ${o.status} fetching ${this.url}`);
-		if (o.status === 200 && t === 0 || o.status === 206) {
-			let t = o.headers.get("content-range"), n = /\/(\d+)$/.exec(t || "");
-			n?.[1] && (this._stat = { size: parseInt(n[1], 10) });
-			let r = o.bytes ? await o.bytes() : new Uint8Array(await o.arrayBuffer());
-			return r.byteLength <= e ? r : r.subarray(0, e);
-		}
-		throw Error(o.status === 200 ? `${this.url} fetch returned status 200, expected 206` : `HTTP ${o.status} fetching ${this.url}`);
-	}
-	async readFile(e = {}) {
-		let t, n;
-		if (typeof e == "string") t = e, n = {};
-		else {
-			t = e.encoding;
-			let { encoding: r, ...i } = e;
-			n = i;
-		}
-		let { headers: r = {}, signal: i, overrides: a = {} } = n, o = await this.fetch(this.url, {
-			...this.baseOverrides,
-			...a,
-			headers: {
-				...this.baseOverrides.headers,
-				...a.headers,
-				...r
-			},
-			method: "GET",
-			redirect: "follow",
-			mode: "cors",
-			signal: i
-		});
-		if (!o.ok) throw Error(`HTTP ${o.status} fetching ${this.url}`);
-		if (t === "utf8") return o.text();
-		if (t) throw Error(`unsupported encoding: ${t}`);
-		return o.bytes ? o.bytes() : new Uint8Array(await o.arrayBuffer());
-	}
-	async stat() {
-		if (!this._stat && (await this.read(10, 0), !this._stat)) throw Error(`unable to determine size of file at ${this.url}`);
-		return this._stat;
-	}
-	async close() {}
-}, i = /* @__PURE__ */ e({
-	BlobFile: () => t,
-	LocalFile: () => a,
-	RemoteFile: () => r
-}), a = class {
-	readFile() {
-		throw Error("unimplemented");
-	}
-	read() {
-		throw Error("unimplemented");
-	}
-	close() {
-		throw Error("unimplemented");
-	}
-};
-//#endregion
-export { i as n, r, a as t };