Read only requested samples

Author: cmdcolin

src/BgzipTaffyAdapter/BgzipTaffyAdapter.ts

@@ -19,6 +19,7 @@ import { parseAssemblyAndChrSimple } from '../util/parseAssemblyName'
 
 import type { RowInstruction } from './rowInstructions'
 import type { AlignmentRecord, IndexData } from './types'
+import type { MafAdapterOptions } from '../types'
 
 // Represents a row in the alignment (like Alignment_Row in C)
 interface RowState {
@@ -159,6 +160,7 @@ export default class BgzipTaffyAdapter extends BaseFeatureDataAdapter {
   *parseTafBlocksStreaming(
     buffer: Uint8Array,
     runLengthEncodeBases: boolean,
+    sampleFilter?: Set<string>,
   ): Generator<TafFeature> {
     let pBlock: AlignmentBlock | undefined
     let currentBlock: AlignmentBlock | undefined
@@ -182,7 +184,7 @@ export default class BgzipTaffyAdapter extends BaseFeatureDataAdapter {
         // If we have a current block with columns, finalize and yield it
         if (currentBlock && columns.length > 0) {
           this.finalizeBlock(currentBlock, columns)
-          const feature = this.blockToFeature(currentBlock)
+          const feature = this.blockToFeature(currentBlock, sampleFilter)
           if (feature) {
             yield feature
           }
@@ -234,7 +236,7 @@ export default class BgzipTaffyAdapter extends BaseFeatureDataAdapter {
     // Finalize and yield last block
     if (currentBlock && columns.length > 0) {
       this.finalizeBlock(currentBlock, columns)
-      const feature = this.blockToFeature(currentBlock)
+      const feature = this.blockToFeature(currentBlock, sampleFilter)
       if (feature) {
         yield feature
       }
@@ -246,8 +248,15 @@ export default class BgzipTaffyAdapter extends BaseFeatureDataAdapter {
     buffer: Uint8Array,
     runLengthEncodeBases: boolean,
     _opts?: BaseOptions,
+    sampleFilter?: Set<string>,
   ): TafFeature[] {
-    return [...this.parseTafBlocksStreaming(buffer, runLengthEncodeBases)]
+    return [
+      ...this.parseTafBlocksStreaming(
+        buffer,
+        runLengthEncodeBases,
+        sampleFilter,
+      ),
+    ]
   }
 
   // TextDecoder for efficient string building from typed array
@@ -280,7 +289,10 @@ export default class BgzipTaffyAdapter extends BaseFeatureDataAdapter {
     }
   }
 
-  blockToFeature(block: AlignmentBlock): TafFeature | undefined {
+  blockToFeature(
+    block: AlignmentBlock,
+    sampleFilter?: Set<string>,
+  ): TafFeature | undefined {
     if (block.rows.length === 0 || block.columnNumber === 0) {
       return undefined
     }
@@ -290,6 +302,9 @@ export default class BgzipTaffyAdapter extends BaseFeatureDataAdapter {
 
     for (const row of block.rows) {
       const { assemblyName, chr } = parseAssemblyAndChrSimple(row.sequenceName)
+      if (sampleFilter && !sampleFilter.has(assemblyName)) {
+        continue
+      }
       alignments[assemblyName] = {
         chr,
         start: row.start,
@@ -392,12 +407,16 @@ export default class BgzipTaffyAdapter extends BaseFeatureDataAdapter {
     return entries
   }
 
-  getFeatures(query: Region, opts?: BaseOptions) {
+  getFeatures(query: Region, opts?: MafAdapterOptions) {
     const { statusCallback = () => {} } = opts || {}
     return ObservableCreate<Feature>(async observer => {
       try {
         const { index, runLengthEncodeBases } = await this.setup(opts)
 
+        const sampleFilter = opts?.samples
+          ? new Set(opts.samples.map(s => s.id))
+          : undefined
+
         // Get byte range for this query
         const records = index[query.refName]
         if (!records || records.length === 0) {
@@ -447,6 +466,7 @@ export default class BgzipTaffyAdapter extends BaseFeatureDataAdapter {
         for (const feat of this.parseTafBlocksStreaming(
           slice,
           runLengthEncodeBases,
+          sampleFilter,
         )) {
           // Filter features that overlap with query region
           if (feat.end > query.start && feat.start < query.end) {

src/BigMafAdapter/BigMafAdapter.ts

@@ -9,8 +9,7 @@ import { normalize } from '../util'
 import { subscribeToObservable } from '../util/observableUtils'
 import { parseAssemblyAndChrSimple } from '../util/parseAssemblyName'
 
-import type { AlignmentRecord } from '../types'
-import type { BaseOptions } from '@jbrowse/core/data_adapters/BaseAdapter'
+import type { AlignmentRecord, MafAdapterOptions } from '../types'
 import type { Feature, Region } from '@jbrowse/core/util'
 export default class BigMafAdapter extends BaseFeatureDataAdapter {
   public setupP?: Promise<{ adapter: BaseFeatureDataAdapter }>
@@ -46,12 +45,16 @@ export default class BigMafAdapter extends BaseFeatureDataAdapter {
     return adapter.getHeader()
   }
 
-  getFeatures(query: Region, opts?: BaseOptions) {
+  getFeatures(query: Region, opts?: MafAdapterOptions) {
     const WHITESPACE_REGEX = / +/
 
     return ObservableCreate<Feature>(async observer => {
       const { adapter } = await this.setupPre()
 
+      const sampleFilter = opts?.samples
+        ? new Set(opts.samples.map(s => s.id))
+        : undefined
+
       await subscribeToObservable(adapter.getFeatures(query, opts), feature => {
         const maf = feature.get('mafBlock') as string
         const blocks = maf.split(';')
@@ -64,12 +67,16 @@ export default class BigMafAdapter extends BaseFeatureDataAdapter {
             const sequence = parts[6]!
             const organismChr = parts[1]!
 
+            const { assemblyName: org, chr } =
+              parseAssemblyAndChrSimple(organismChr)
+
             if (referenceSeq === undefined) {
               referenceSeq = sequence
             }
 
-            const { assemblyName: org, chr } =
-              parseAssemblyAndChrSimple(organismChr)
+            if (sampleFilter && !sampleFilter.has(org)) {
+              continue
+            }
 
             alignments[org] = {
               chr,

src/LinearMafRenderer/LinearMafRenderer.ts

@@ -56,11 +56,28 @@ export default class LinearMafRenderer extends FeatureRendererType {
     const height = samples.length * rowHeight + 100
     const width = (region.end - region.start) / bpPerPx
 
+    const scaledWidth = Math.ceil(width * highResolutionScaling)
+    const scaledHeight = Math.ceil(height * highResolutionScaling)
+
+    if (scaledWidth > 16384 || scaledHeight > 16384) {
+      console.warn(
+        '[LinearMafRenderer] Canvas dimensions may exceed browser limits:',
+        {
+          width,
+          height,
+          scaledWidth,
+          scaledHeight,
+          highResolutionScaling,
+          bpPerPx,
+          regionSize: region.end - region.start,
+          samplesCount: samples.length,
+          rowHeight,
+        },
+      )
+    }
+
     // Create canvas with high resolution scaling support
-    const canvas = createCanvas(
-      Math.ceil(width * highResolutionScaling),
-      Math.ceil(height * highResolutionScaling),
-    )
+    const canvas = createCanvas(scaledWidth, scaledHeight)
     const ctx = canvas.getContext('2d')
     if (!ctx) {
       throw new Error('Could not get canvas context')

src/MafTabixAdapter/MafTabixAdapter.ts

@@ -16,7 +16,7 @@ import {
   selectReferenceSequenceString,
 } from '../util/parseAssemblyName'
 
-import type { AlignmentRecord } from '../types'
+import type { AlignmentRecord, MafAdapterOptions } from '../types'
 
 export default class MafTabixAdapter extends BaseFeatureDataAdapter {
   public setupP?: Promise<{ adapter: BaseFeatureDataAdapter }>
@@ -61,12 +61,16 @@ export default class MafTabixAdapter extends BaseFeatureDataAdapter {
     return adapter.getHeader()
   }
 
-  getFeatures(query: Region, opts?: BaseOptions) {
+  getFeatures(query: Region, opts?: MafAdapterOptions) {
     return ObservableCreate<Feature>(async observer => {
       const { adapter } = await this.setup(opts)
       let firstAssemblyNameFound = ''
       const refAssemblyName = this.getConf('refAssemblyName')
 
+      const sampleFilter = opts?.samples
+        ? new Set(opts.samples.map(s => s.id))
+        : undefined
+
       await subscribeToObservable(adapter.getFeatures(query, opts), feature => {
         const data = (feature.get('field5') as string).split(',')
         const alignments = {} as Record<string, AlignmentRecord>
@@ -95,6 +99,10 @@ export default class MafTabixAdapter extends BaseFeatureDataAdapter {
               firstAssemblyNameFound = assemblyName
             }
 
+            if (sampleFilter && !sampleFilter.has(assemblyName)) {
+              continue
+            }
+
             alignments[assemblyName] = {
               chr,
               start: +startStr!,

src/types.ts

@@ -1,7 +1,18 @@
+import type { BaseOptions } from '@jbrowse/core/data_adapters/BaseAdapter'
+
 /**
  * Shared types for MAF alignment data
  */
 
+/**
+ * Options for MAF adapter getFeatures call.
+ * Extends BaseOptions with optional samples filter for subtree optimization.
+ */
+export interface MafAdapterOptions extends BaseOptions {
+  /** If provided, only parse alignments for these sample IDs */
+  samples?: Sample[]
+}
+
 /**
  * Represents a single organism's alignment within a MAF block.
  * Used by adapters to return alignment data and by rendering code.

src/util/fastaUtils.test.ts

@@ -296,3 +296,131 @@ test('includeInsertions with no insertions present', () => {
   // Should behave same as without includeInsertions since there are none
   expect(result).toMatchSnapshot()
 })
+
+test('includeInsertions - insertion only in non-visible sample should not add gaps', () => {
+  // This tests the bug fix where insertions from non-visible samples were
+  // causing gaps to be added to visible samples.
+  //
+  // Scenario: 3 samples exist, but only 2 are selected for display.
+  // The 3rd (non-visible) sample has an insertion, which creates a gap in the
+  // reference sequence. The visible samples should NOT have extra gaps added.
+  //
+  // seq:       AC--GTAC (reference has gap due to assembly3's insertion)
+  // assembly1: AC--GTAC (no insertion, just gaps where assembly3 has insertion)
+  // assembly2: AC--GTAC (no insertion, just gaps where assembly3 has insertion)
+  // assembly3: ACTTGTAC (has TT insertion) - NOT in samples list
+  const mockFeature = new SimpleFeature({
+    uniqueId: '123',
+    refName: 'abc',
+    start: 100,
+    end: 106,
+    seq: 'AC--GTAC',
+    alignments: {
+      assembly1: {
+        chr: 'chr1',
+        start: 100,
+        seq: 'AC--GTAC',
+        strand: 1,
+      },
+      assembly2: {
+        chr: 'chr2',
+        start: 200,
+        seq: 'AC--GTAC',
+        strand: 1,
+      },
+      assembly3: {
+        chr: 'chr3',
+        start: 300,
+        seq: 'ACTTGTAC',
+        strand: 1,
+      },
+    },
+  })
+
+  // Only include assembly1 and assembly2, NOT assembly3
+  const result = processFeaturesToFasta({
+    features: makeMap([mockFeature]),
+    samples: [{ id: 'assembly1' }, { id: 'assembly2' }],
+    includeInsertions: true,
+    showAllLetters: true,
+    regions: [
+      {
+        refName: 'chr1',
+        start: 100,
+        end: 106,
+        assemblyName: 'assembly1',
+      },
+    ],
+  })
+
+  // Since neither visible sample has an actual insertion (both have only gaps
+  // at the insertion position), no insertion columns should be added.
+  // The output should be 6 characters (the reference length), not 8.
+  expect(result[0]).toBe('acgtac')
+  expect(result[1]).toBe('acgtac')
+  expect(result[0]).toHaveLength(6)
+  expect(result[1]).toHaveLength(6)
+})
+
+test('includeInsertions - mixed visible/non-visible insertions', () => {
+  // Scenario: Reference has a gap. One visible sample has an insertion,
+  // another visible sample doesn't, and a non-visible sample also has an
+  // insertion. Only the visible sample's insertion should be included.
+  //
+  // seq:       AC---GTAC (reference has 3-bp gap)
+  // assembly1: AC-T-GTAC (has T insertion, 1 bp) - visible
+  // assembly2: AC---GTAC (no insertion) - visible
+  // assembly3: ACTTTGTAC (has TTT insertion, 3 bp) - NOT visible
+  const mockFeature = new SimpleFeature({
+    uniqueId: '123',
+    refName: 'abc',
+    start: 100,
+    end: 106,
+    seq: 'AC---GTAC',
+    alignments: {
+      assembly1: {
+        chr: 'chr1',
+        start: 100,
+        seq: 'AC-T-GTAC',
+        strand: 1,
+      },
+      assembly2: {
+        chr: 'chr2',
+        start: 200,
+        seq: 'AC---GTAC',
+        strand: 1,
+      },
+      assembly3: {
+        chr: 'chr3',
+        start: 300,
+        seq: 'ACTTTGTAC',
+        strand: 1,
+      },
+    },
+  })
+
+  // Only include assembly1 and assembly2, NOT assembly3
+  const result = processFeaturesToFasta({
+    features: makeMap([mockFeature]),
+    samples: [{ id: 'assembly1' }, { id: 'assembly2' }],
+    includeInsertions: true,
+    showAllLetters: true,
+    regions: [
+      {
+        refName: 'chr1',
+        start: 100,
+        end: 106,
+        assemblyName: 'assembly1',
+      },
+    ],
+  })
+
+  // assembly1 has a 1-bp insertion (t), so the max insertion length is 1
+  // (not 3, because assembly3's insertion should be ignored)
+  // assembly1: act-gtac -> with insertion expanded: actgtac (7 chars)
+  // assembly2: ac--gtac -> with insertion expanded: ac-gtac (7 chars)
+  expect(result[0]).toBe('actgtac')
+  expect(result[1]).toBe('ac-gtac')
+  expect(result[0]).toHaveLength(7)
+  expect(result[1]).toHaveLength(7)
+})

src/util/fastaUtils.ts

@@ -85,7 +85,10 @@ export function processFeaturesToFasta({
           }
           i--
 
-          if (insertionSequence.length > 0) {
+          // Only add insertion if it contains at least one actual base (not
+          // just gaps). This filters out insertions that only exist in samples
+          // that aren't currently visible.
+          if (insertionSequence.length > 0 && /[^-]/.test(insertionSequence)) {
             const insertPos = leftCoord + o - region.start
             if (insertPos >= 0 && insertPos <= rlen) {
               const existing = insertionsAtPosition.get(insertPos) || []