@genome-spy/core 0.71.0 → 0.73.0

package/dist/src/data/formats/bedpe.js

@@ -0,0 +1,160 @@
+const blankLinePattern = /^\s*$/;
+const controlLinePattern = /^\s*(?:browser\b|track\b|#)/;
+
+const defaultColumns = [
+    "chrom1",
+    "start1",
+    "end1",
+    "chrom2",
+    "start2",
+    "end2",
+    "name",
+    "score",
+    "strand1",
+    "strand2",
+];
+
+const requiredColumns = defaultColumns.slice(0, 6);
+
+const normalizeNone = (/** @type {string} */ value) => value;
+const normalizeStringSentinel = (/** @type {string} */ value) =>
+    value == "." ? null : value;
+const normalizeStrand = (/** @type {string} */ value) => {
+    if (value == "+") {
+        return 1;
+    }
+    if (value == "-") {
+        return -1;
+    }
+    return 0;
+};
+const normalizeCoordinate = (/** @type {string} */ value) => {
+    if (value == "." || value == "-1" || value == "") {
+        return null;
+    }
+    const parsed = Number(value);
+    return Number.isInteger(parsed) ? parsed : null;
+};
+const normalizeScore = (/** @type {string} */ value) => {
+    if (value == "." || value == "") {
+        return null;
+    }
+    const parsed = Number(value);
+    return Number.isNaN(parsed) ? value : parsed;
+};
+
+/** @type {Record<string, (value: string) => any>} */
+const columnNormalizers = {
+    chrom1: normalizeStringSentinel,
+    chrom2: normalizeStringSentinel,
+    name: normalizeStringSentinel,
+    strand1: normalizeStrand,
+    strand2: normalizeStrand,
+    start1: normalizeCoordinate,
+    end1: normalizeCoordinate,
+    start2: normalizeCoordinate,
+    end2: normalizeCoordinate,
+    score: normalizeScore,
+};
+
+/**
+ * BEDPE has fixed required leading columns; optional tail columns vary by producer.
+ * Detect a header row by matching only the required prefix.
+ *
+ * @param {string[]} row
+ */
+function looksLikeHeaderRow(row) {
+    if (row.length < requiredColumns.length) {
+        return false;
+    }
+
+    for (let i = 0; i < requiredColumns.length; i++) {
+        if (row[i] != requiredColumns[i]) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+/**
+ * @param {string} data
+ * @param {{ columns?: string[] }} [format]
+ */
+export default function bedpe(data, format = {}) {
+    const lines = data.split(/\r?\n/);
+    const explicitColumns = format.columns;
+    let dataStarted = false;
+    let columnsInitialized = false;
+    let lineNumber = 0;
+
+    /** @type {string[]} */
+    const columns = [];
+    /** @type {((value: string) => any)[]} */
+    const normalizers = [];
+    /** @type {Record<string, any>[]} */
+    const rows = [];
+
+    for (const line of lines) {
+        lineNumber++;
+
+        if (line.length == 0) {
+            continue;
+        }
+
+        if (!dataStarted) {
+            if (blankLinePattern.test(line) || controlLinePattern.test(line)) {
+                continue;
+            }
+            dataStarted = true;
+        }
+
+        if (blankLinePattern.test(line)) {
+            continue;
+        }
+
+        const row = line.split("\t");
+
+        if (!columnsInitialized) {
+            const baseColumns = explicitColumns
+                ? explicitColumns
+                : looksLikeHeaderRow(row)
+                  ? row
+                  : defaultColumns;
+
+            for (const column of baseColumns) {
+                columns.push(column);
+                normalizers.push(columnNormalizers[column] ?? normalizeNone);
+            }
+
+            columnsInitialized = true;
+
+            if (!explicitColumns && baseColumns == row) {
+                continue;
+            }
+        }
+
+        while (columns.length < row.length) {
+            columns.push("field" + (columns.length + 1));
+            normalizers.push(normalizeNone);
+        }
+
+        if (row.length < requiredColumns.length) {
+            throw new Error(
+                `BEDPE line ${lineNumber} has ${row.length} columns, expected at least ${requiredColumns.length}.`
+            );
+        }
+
+        /** @type {Record<string, any>} */
+        const datum = {};
+
+        for (let i = 0; i < row.length; i++) {
+            const columnName = columns[i];
+            datum[columnName] = normalizers[i](row[i]);
+        }
+
+        rows.push(datum);
+    }
+
+    return rows;
+}

package/dist/src/data/formats/parquet.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Load a data set in Apache Parquet format for use in Vega.
+ * @param {ArrayBuffer|Uint8Array} data Parquet binary data.
+ * @returns {Promise<Record<string,any>[]>} A promise that resolves to an array of data objects representing
+ *  rows of a data table.
+ */
+declare function parquet(data: ArrayBuffer | Uint8Array): Promise<Record<string, any>[]>;
+declare namespace parquet {
+    let responseType: string;
+}
+export default parquet;
+//# sourceMappingURL=parquet.d.ts.map

package/dist/src/data/formats/parquet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parquet.d.ts","sourceRoot":"","sources":["../../../../src/data/formats/parquet.js"],"names":[],"mappings":"AAYA;;;;;GAKG;AACH,+BAJW,WAAW,GAAC,UAAU,GACpB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAC,GAAG,CAAC,EAAE,CAAC,CAWzC"}

package/dist/src/data/formats/parquet.js

@@ -0,0 +1,29 @@
+/*
+ * Adapted from: https://github.com/vega/vega-loader-parquet/blob/main/src/index.js
+ */
+
+/**
+ * @returns {Promise<typeof import("./parquetRead.js").parquetReadObjects>}
+ */
+async function loadParquetReadObjects() {
+    const { parquetReadObjects } = await import("./parquetRead.js");
+    return parquetReadObjects;
+}
+
+/**
+ * Load a data set in Apache Parquet format for use in Vega.
+ * @param {ArrayBuffer|Uint8Array} data Parquet binary data.
+ * @returns {Promise<Record<string,any>[]>} A promise that resolves to an array of data objects representing
+ *  rows of a data table.
+ */
+export default async function parquet(data) {
+    const parquetReadObjects = await loadParquetReadObjects();
+    const buffer =
+        data instanceof Uint8Array
+            ? /** @type {ArrayBuffer} */ (data.buffer)
+            : data;
+
+    return await parquetReadObjects({ file: buffer });
+}
+
+parquet.responseType = "arrayBuffer";

package/dist/src/data/formats/parquetRead.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @param {ObjectParquetReadOptions} options
+ * @returns {Promise<void>}
+ */
+export function parquetRead(options: ObjectParquetReadOptions): Promise<void>;
+/**
+ * @param {Omit<ObjectParquetReadOptions, "onComplete">} options
+ * @returns {Promise<Record<string, any>[]>}
+ */
+export function parquetReadObjects(options: Omit<ObjectParquetReadOptions, "onComplete">): Promise<Record<string, any>[]>;
+/**
+ * Object-row variant of Parquet read options used by this trimmed reader.
+ */
+export type ObjectParquetReadOptions = Omit<import("hyparquet").ParquetReadOptions, "rowFormat" | "filter" | "filterStrict" | "onComplete"> & {
+    onComplete?: (rows: Record<string, any>[]) => void;
+};
+export type RowGroupObjectBuilder = (groupData: Record<string, any>[], selectStart: number, selectCount: number, columnData: import("hyparquet").DecodedArray[], columnSkipped: number[]) => Record<string, any>[];
+//# sourceMappingURL=parquetRead.d.ts.map

package/dist/src/data/formats/parquetRead.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parquetRead.d.ts","sourceRoot":"","sources":["../../../../src/data/formats/parquetRead.js"],"names":[],"mappings":"AAqOA;;;GAGG;AACH,qCAHW,wBAAwB,GACtB,OAAO,CAAC,IAAI,CAAC,CAiFzB;AAED;;;GAGG;AACH,4CAHW,IAAI,CAAC,wBAAwB,EAAE,YAAY,CAAC,GAC1C,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,CAAC,CAS1C;;;;uCAlTY,IAAI,CAChB,OAAU,WAAW,EAAE,kBAAkB,EACzC,WAAc,GAAG,QAAQ,GAAG,cAAc,GAAG,YAAY,CACtD,GAAG;IACH,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,KAAK,IAAI,CAAA;CAClD;oCAIS,CACT,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,EAChC,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,MAAM,EACnB,UAAU,EAAE,OAAO,WAAW,EAAE,YAAY,EAAE,EAC9C,aAAa,EAAE,MAAM,EAAE,KACnB,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE"}

package/dist/src/data/formats/parquetRead.js

@@ -0,0 +1,326 @@
+/*
+ * Adapted from hyparquet internals:
+ * https://github.com/hyparam/hyparquet (notably src/read.js and src/rowgroup.js).
+ *
+ * GenomeSpy-specific changes in this copy:
+ * - object-row output only (array row format removed)
+ * - filtering support removed
+ * - hot row transpose path optimized with cached codegen for typical schemas
+ * - fallback to interpreted row builder for very wide schemas
+ */
+
+import { parquetMetadataAsync, parquetSchema } from "hyparquet/src/metadata.js";
+import { parquetPlan, prefetchAsyncBuffer } from "hyparquet/src/plan.js";
+import { assembleAsync, readRowGroup } from "hyparquet/src/rowgroup.js";
+import { concat } from "hyparquet/src/utils.js";
+
+/**
+ * Object-row variant of Parquet read options used by this trimmed reader.
+ *
+ * @typedef {Omit<
+ *  import("hyparquet").ParquetReadOptions,
+ *  "rowFormat" | "filter" | "filterStrict" | "onComplete"
+ * > & {
+ *  onComplete?: (rows: Record<string, any>[]) => void
+ * }} ObjectParquetReadOptions
+ */
+
+/**
+ * @typedef {(
+ *  groupData: Record<string, any>[],
+ *  selectStart: number,
+ *  selectCount: number,
+ *  columnData: import("hyparquet").DecodedArray[],
+ *  columnSkipped: number[]
+ * ) => Record<string, any>[]} RowGroupObjectBuilder
+ */
+
+/** @type {Map<string, RowGroupObjectBuilder>} */
+const rowGroupObjectBuilderCache = new Map();
+
+const MAX_CODEGEN_COLUMNS = 200;
+
+/**
+ * @param {ObjectParquetReadOptions} options
+ * @returns {import("hyparquet").AsyncRowGroup[]}
+ */
+function parquetReadAsync(options) {
+    if (!options.metadata) {
+        throw new Error("parquet requires metadata");
+    }
+
+    const plan = parquetPlan(options);
+    options.file = prefetchAsyncBuffer(options.file, plan);
+
+    return plan.groups.map((groupPlan) =>
+        readRowGroup(options, plan, groupPlan)
+    );
+}
+
+/**
+ * Flatten decoded data pages into a single decoded array.
+ * This local version avoids chunked slice/push overhead in hot paths.
+ *
+ * @param {import("hyparquet").DecodedArray[] | undefined} chunks
+ * @returns {import("hyparquet").DecodedArray}
+ */
+function flattenColumnChunks(chunks) {
+    if (!chunks) {
+        return [];
+    }
+
+    if (chunks.length === 1) {
+        return chunks[0];
+    }
+
+    let totalLength = 0;
+    for (const chunk of chunks) {
+        totalLength += chunk.length;
+    }
+
+    const output = Array(totalLength);
+    let offset = 0;
+    for (const chunk of chunks) {
+        for (let i = 0; i < chunk.length; i++) {
+            output[offset + i] = chunk[i];
+        }
+        offset += chunk.length;
+    }
+
+    return output;
+}
+
+/**
+ * @param {string[]} columnNames
+ * @returns {RowGroupObjectBuilder}
+ */
+function getRowGroupObjectBuilder(columnNames) {
+    // Compile one builder per column layout to keep object writes monomorphic.
+    const signature = columnNames.join("\u001f");
+    const cached = rowGroupObjectBuilderCache.get(signature);
+    if (cached) {
+        return cached;
+    }
+
+    const assignments = columnNames
+        .map(
+            (columnName, i) =>
+                JSON.stringify(columnName) +
+                ": columnData[" +
+                i +
+                "][row - columnSkipped[" +
+                i +
+                "]]"
+        )
+        .join(",\n");
+
+    const builder = /** @type {RowGroupObjectBuilder} */ (
+        new Function(
+            "groupData",
+            "selectStart",
+            "selectCount",
+            "columnData",
+            "columnSkipped",
+            // Keep generated code focused on the tight row loop only.
+            "for (let selectRow = 0; selectRow < selectCount; selectRow++) {\n" +
+                "    const row = selectStart + selectRow;\n" +
+                "    groupData[selectRow] = {\n" +
+                assignments +
+                "\n" +
+                "    };\n" +
+                "}\n" +
+                "return groupData;"
+        )
+    );
+
+    rowGroupObjectBuilderCache.set(signature, builder);
+
+    return builder;
+}
+
+/**
+ * @param {Record<string, any>[]} groupData
+ * @param {number} selectStart
+ * @param {number} selectCount
+ * @param {string[]} columnNames
+ * @param {import("hyparquet").DecodedArray[]} columnData
+ * @param {number[]} columnSkipped
+ * @returns {Record<string, any>[]}
+ */
+function buildRowsInterpreted(
+    groupData,
+    selectStart,
+    selectCount,
+    columnNames,
+    columnData,
+    columnSkipped
+) {
+    for (let selectRow = 0; selectRow < selectCount; selectRow++) {
+        const row = selectStart + selectRow;
+        /** @type {Record<string, any>} */
+        const rowData = {};
+        for (let i = 0; i < columnNames.length; i++) {
+            rowData[columnNames[i]] = columnData[i][row - columnSkipped[i]];
+        }
+        groupData[selectRow] = rowData;
+    }
+
+    return groupData;
+}
+
+/**
+ * Object-only copy of hyparquet's asyncGroupToRows.
+ *
+ * @param {import("hyparquet").AsyncRowGroup} asyncGroup
+ * @param {number} selectStart
+ * @param {number} selectEnd
+ * @returns {Promise<Record<string, any>[]>}
+ */
+async function asyncGroupToRowsObject(
+    { asyncColumns },
+    selectStart,
+    selectEnd
+) {
+    // Resolve all async column pages once before entering the hot transpose loop.
+    const pages = await Promise.all(asyncColumns.map((column) => column.data));
+    const columnCount = asyncColumns.length;
+
+    /** @type {string[]} */
+    const columnNames = Array(columnCount);
+    /** @type {import("hyparquet").DecodedArray[]} */
+    const columnData = Array(columnCount);
+    /** @type {number[]} */
+    const columnSkipped = Array(columnCount);
+
+    // Precompute all indirections outside the generated function.
+    for (let i = 0; i < columnCount; i++) {
+        columnNames[i] = asyncColumns[i].pathInSchema[0];
+        columnData[i] = flattenColumnChunks(pages[i].data);
+        columnSkipped[i] = pages[i].skipped;
+    }
+
+    const selectCount = selectEnd - selectStart;
+
+    /** @type {Record<string, any>[]} */
+    const groupData = Array(selectCount);
+
+    // Avoid excessively large generated functions for very wide schemas.
+    if (columnCount > MAX_CODEGEN_COLUMNS) {
+        return buildRowsInterpreted(
+            groupData,
+            selectStart,
+            selectCount,
+            columnNames,
+            columnData,
+            columnSkipped
+        );
+    }
+
+    const buildRows = getRowGroupObjectBuilder(columnNames);
+
+    return buildRows(
+        groupData,
+        selectStart,
+        selectCount,
+        columnData,
+        columnSkipped
+    );
+}
+
+/**
+ * @param {ObjectParquetReadOptions} options
+ * @returns {Promise<void>}
+ */
+export async function parquetRead(options) {
+    if ("rowFormat" in options) {
+        throw new Error(
+            'parquetRead supports only object rows; use rowFormat: "object" implicitly'
+        );
+    }
+    if ("filter" in options || "filterStrict" in options) {
+        throw new Error("parquetRead does not support filtering");
+    }
+
+    options.metadata ??= await parquetMetadataAsync(options.file, options);
+
+    const { rowStart = 0, rowEnd, onChunk, onComplete } = options;
+
+    const asyncGroups = parquetReadAsync(options);
+
+    if (!onComplete && !onChunk) {
+        for (const { asyncColumns } of asyncGroups) {
+            for (const { data } of asyncColumns) {
+                await data;
+            }
+        }
+        return;
+    }
+
+    const schemaTree = parquetSchema(options.metadata);
+    const assembled = asyncGroups.map((group) =>
+        assembleAsync(group, schemaTree, options.parsers)
+    );
+
+    if (onChunk) {
+        for (const asyncGroup of assembled) {
+            for (const asyncColumn of asyncGroup.asyncColumns) {
+                asyncColumn.data.then(
+                    /**
+                     * @param {{ data: import("hyparquet").DecodedArray[]; skipped: number }} chunk
+                     */
+                    (chunk) => {
+                        let chunkRowStart =
+                            asyncGroup.groupStart + chunk.skipped;
+                        for (const columnData of chunk.data) {
+                            onChunk({
+                                columnName: asyncColumn.pathInSchema[0],
+                                columnData,
+                                rowStart: chunkRowStart,
+                                rowEnd: chunkRowStart + columnData.length,
+                            });
+                            chunkRowStart += columnData.length;
+                        }
+                    }
+                );
+            }
+        }
+    }
+
+    if (onComplete) {
+        /** @type {Record<string, any>[]} */
+        const rows = [];
+        for (const asyncGroup of assembled) {
+            const selectStart = Math.max(rowStart - asyncGroup.groupStart, 0);
+            const selectEnd = Math.min(
+                (rowEnd ?? Infinity) - asyncGroup.groupStart,
+                asyncGroup.groupRows
+            );
+            const groupData = await asyncGroupToRowsObject(
+                asyncGroup,
+                selectStart,
+                selectEnd
+            );
+            concat(rows, groupData);
+        }
+        onComplete(rows);
+    } else {
+        for (const { asyncColumns } of assembled) {
+            for (const { data } of asyncColumns) {
+                await data;
+            }
+        }
+    }
+}
+
+/**
+ * @param {Omit<ObjectParquetReadOptions, "onComplete">} options
+ * @returns {Promise<Record<string, any>[]>}
+ */
+export function parquetReadObjects(options) {
+    return new Promise((onComplete, reject) => {
+        parquetRead({
+            ...options,
+            onComplete,
+        }).catch(reject);
+    });
+}

package/dist/src/data/sources/dataUtils.d.ts

@@ -17,8 +17,16 @@ export function getFormat(params: import("../../spec/data.js").DataSource, urls?
     type?: "json";
     property?: string;
     parse?: import("../../spec/data.js").Parse | null;
+} | {
+    type: "bed";
+    parse?: import("../../spec/data.js").Parse | null;
+} | {
+    type: "bedpe";
+    columns?: string[];
+    parse?: import("../../spec/data.js").Parse | null;
 } | {
     type: string;
+    parse?: import("../../spec/data.js").Parse | null;
 };
 /**
  * @param {string} type
@@ -29,6 +37,10 @@ export function responseType(type: string): string;
  * @param {string | string[]} url
  */
 export function extractTypeFromUrl(url: string | string[]): string;
+/**
+ * @param {string} url
+ */
+export function hasGzipExtension(url: string): boolean;
 /**
  * @param {import("../../spec/data.js").DataFormat} dataFormat
  * @return {dataFormat is import("../../spec/data.js").CsvDataFormat}
@@ -50,6 +62,10 @@ export function isJsonDataFormat(dataFormat: import("../../spec/data.js").DataFo
  * @return {dataSource is import("../../spec/data.js").UrlData}
  */
 export function isUrlData(dataSource: import("../../spec/data.js").DataSource): dataSource is import("../../spec/data.js").UrlData;
+/**
+ * @param {string | undefined} type
+ */
+export function isAutoParseFormat(type: string | undefined): boolean;
 export function makeWrapper(d: any): ((x: import("../../spec/channel.js").Scalar) => {
     data: import("../../spec/channel.js").Scalar;
 }) | ((x: import("../flowNode.js").Datum) => import("../flowNode.js").Datum);

package/dist/src/data/sources/dataUtils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dataUtils.d.ts","sourceRoot":"","sources":["../../../../src/data/sources/dataUtils.js"],"names":[],"mappings":"AAGA;;;;;;;GAOG;AACH,kCAJW,OAAO,oBAAoB,EAAE,UAAU,SAEvC,MAAM,GAAG,MAAM,EAAE;;;;;;;;;;;;;EAoB3B;AAED;;;GAGG;AACH,mCAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;GAEG;AACH,wCAFW,MAAM,GAAG,MAAM,EAAE,UAU3B;AAWD;;;GAGG;AACH,4CAHW,OAAO,oBAAoB,EAAE,UAAU,GACtC,UAAU,IAAI,OAAO,oBAAoB,EAAE,aAAa,CAInE;AAED;;;GAGG;AACH,4CAHW,OAAO,oBAAoB,EAAE,UAAU,GACtC,UAAU,IAAI,OAAO,oBAAoB,EAAE,aAAa,CAInE;AAED;;;GAGG;AACH,6CAHW,OAAO,oBAAoB,EAAE,UAAU,GACtC,UAAU,IAAI,OAAO,oBAAoB,EAAE,cAAc,CAIpE;AAED;;;;GAIG;AACH,sCAHW,OAAO,oBAAoB,EAAE,UAAU,GACtC,UAAU,IAAI,OAAO,oBAAoB,EAAE,OAAO,CAI7D;AAxCM,+BAAgC,GAAG,QAI3B,OAAO,uBAAuB,EAAE,MAAM;;UAGtB,OAAO,gBAAgB,EAAE,KAAK,qCANR"}
+{"version":3,"file":"dataUtils.d.ts","sourceRoot":"","sources":["../../../../src/data/sources/dataUtils.js"],"names":[],"mappings":"AAMA;;;;;;;GAOG;AACH,kCAJW,OAAO,oBAAoB,EAAE,UAAU,SAEvC,MAAM,GAAG,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;EAsB3B;AAED;;;GAGG;AACH,mCAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;GAEG;AACH,wCAFW,MAAM,GAAG,MAAM,EAAE,UA2B3B;AAED;;GAEG;AACH,sCAFW,MAAM,WAWhB;AAkBD;;;GAGG;AACH,4CAHW,OAAO,oBAAoB,EAAE,UAAU,GACtC,UAAU,IAAI,OAAO,oBAAoB,EAAE,aAAa,CAInE;AAED;;;GAGG;AACH,4CAHW,OAAO,oBAAoB,EAAE,UAAU,GACtC,UAAU,IAAI,OAAO,oBAAoB,EAAE,aAAa,CAInE;AAED;;;GAGG;AACH,6CAHW,OAAO,oBAAoB,EAAE,UAAU,GACtC,UAAU,IAAI,OAAO,oBAAoB,EAAE,cAAc,CAIpE;AAED;;;;GAIG;AACH,sCAHW,OAAO,oBAAoB,EAAE,UAAU,GACtC,UAAU,IAAI,OAAO,oBAAoB,EAAE,OAAO,CAI7D;AAED;;GAEG;AACH,wCAFW,MAAM,GAAG,SAAS,WAI5B;AA/CM,+BAAgC,GAAG,QAI3B,OAAO,uBAAuB,EAAE,MAAM;;UAGtB,OAAO,gBAAgB,EAAE,KAAK,qCANR"}

package/dist/src/data/sources/dataUtils.js

@@ -1,6 +1,9 @@
 import { formats } from "vega-loader";
 import { isInlineData } from "./inlineSource.js";
 
+const autoParseFormats = new Set(["csv", "tsv", "dsv"]);
+const compressionExtensions = new Set(["gz", "bgz", "bgzf"]);
+
 /**
  * Validates data source params, infers format if not specified explicitly,
  * returns a complete DataSource params object.
@@ -16,8 +19,10 @@ export function getFormat(params, urls = []) {
     const format = { ...params.format };
 
     format.type ??= isUrlData(params) && extractTypeFromUrl(urls);
-    // @ts-ignore TODO: Fix typing
-    format.parse ??= "auto";
+    if (format.parse === undefined && isAutoParseFormat(format.type)) {
+        // @ts-ignore TODO: Fix typing
+        format.parse = "auto";
+    }
 
     if (!format.type) {
         throw new Error(
@@ -46,8 +51,46 @@ export function extractTypeFromUrl(url) {
     }
 
     if (url) {
-        return url.match(/\.(csv|tsv|json)/)?.[1];
+        const path = stripUrlQueryAndHash(url).split("/").pop()?.toLowerCase();
+
+        if (!path) {
+            return;
+        }
+
+        const extensions = path.split(".");
+        while (
+            extensions.length > 1 &&
+            compressionExtensions.has(extensions.at(-1))
+        ) {
+            extensions.pop();
+        }
+
+        const extension = extensions.at(-1);
+        if (extension && formats(extension)) {
+            return extension;
+        }
+    }
+}
+
+/**
+ * @param {string} url
+ */
+export function hasGzipExtension(url) {
+    const path = stripUrlQueryAndHash(url).split("/").pop()?.toLowerCase();
+
+    if (!path) {
+        return false;
     }
+
+    const extension = path.split(".").at(-1);
+    return !!extension && compressionExtensions.has(extension);
+}
+
+/**
+ * @param {string} url
+ */
+function stripUrlQueryAndHash(url) {
+    return url.replace(/[?#].*$/, "");
 }
 
 export const makeWrapper = (/** @type {any} */ d) =>
@@ -91,3 +134,10 @@ export function isJsonDataFormat(dataFormat) {
 export function isUrlData(dataSource) {
     return "url" in dataSource;
 }
+
+/**
+ * @param {string | undefined} type
+ */
+export function isAutoParseFormat(type) {
+    return autoParseFormats.has(type);
+}

package/dist/src/data/sources/urlSource.d.ts

@@ -3,6 +3,10 @@
  * @returns {data is import("../../spec/data.js").UrlData}
  */
 export function isUrlData(data: Partial<import("../../spec/data.js").Data>): data is import("../../spec/data.js").UrlData;
+/**
+ * Loads eager data from URLs and transparently decompresses gzip-compatible
+ * payloads before handing them to the registered format reader.
+ */
 export default class UrlSource extends DataSource {
     /**
      * @param {import("../../spec/data.js").UrlData} params