react-msaview 5.6.1 → 5.6.3

package/src/propertyConservation.ts

@@ -1,3 +1,7 @@
+import { numResidueSlots, residueSlotOfLetter } from './columnCounts.ts'
+
+import type { ColumnCounts } from './columnCounts.ts'
+
 // Disjoint physicochemical classes for the 20 standard amino acids. Property
 // conservation asks a different question than identity conservation: a column
 // can vary in exact residue yet stay within one property class (a conservative
@@ -29,8 +33,15 @@ const aminoPropertyClass: Record<string, string> = {
   P: 'special',
 }
 
-const numPropertyClasses = new Set(Object.values(aminoPropertyClass)).size
-const maxPropertyEntropy = Math.log2(numPropertyClasses)
+const propertyClasses = [...new Set(Object.values(aminoPropertyClass))]
+const maxPropertyEntropy = Math.log2(propertyClasses.length)
+
+// residue slot -> index into propertyClasses (-1 for residues with no class,
+// e.g. X or '*'), so the per-column tally needs no string lookups
+const classOfSlot = new Int8Array(numResidueSlots).fill(-1)
+for (const [letter, cls] of Object.entries(aminoPropertyClass)) {
+  classOfSlot[residueSlotOfLetter(letter)] = propertyClasses.indexOf(cls)
+}
 
 /**
  * Per-column property conservation using Shannon entropy over physicochemical
@@ -38,36 +49,34 @@ const maxPropertyEntropy = Math.log2(numPropertyClasses)
  * residue shares one property class. Mirrors the identity-conservation formula
  * so the two tracks are directly comparable: (1 - H/Hmax) * (1 - gapFraction).
  */
-export function calculatePropertyConservation(
-  colStats: Record<string, number>[],
-  colStatsSums: number[],
-) {
-  return colStats.map((stats, i) => {
-    const total = colStatsSums[i]
-    if (!total) {
-      return 0
-    }
-
-    let nonGapTotal = 0
-    const classCounts: Record<string, number> = {}
-    for (const [letter, count] of Object.entries(stats)) {
-      const cls = aminoPropertyClass[letter]
-      if (cls) {
-        classCounts[cls] = (classCounts[cls] ?? 0) + count
-        nonGapTotal += count
+export function calculatePropertyConservation(counts: ColumnCounts) {
+  const classCounts = new Float64Array(propertyClasses.length)
+  return Array.from({ length: counts.numColumns }, (_, col) => {
+    const total = counts.total(col)
+    let score = 0
+    if (total) {
+      classCounts.fill(0)
+      let nonGapTotal = 0
+      counts.forEachResidue(col, (slot, count) => {
+        const cls = classOfSlot[slot]!
+        if (cls >= 0) {
+          classCounts[cls]! += count
+          nonGapTotal += count
+        }
+      })
+      if (nonGapTotal > 0) {
+        let entropy = 0
+        for (const count of classCounts) {
+          if (count > 0) {
+            const freq = count / nonGapTotal
+            entropy -= freq * Math.log2(freq)
+          }
+        }
+        const gapFraction = (total - nonGapTotal) / total
+        score =
+          Math.max(0, 1 - entropy / maxPropertyEntropy) * (1 - gapFraction)
       }
     }
-    if (nonGapTotal === 0) {
-      return 0
-    }
-
-    let entropy = 0
-    for (const count of Object.values(classCounts)) {
-      const freq = count / nonGapTotal
-      entropy -= freq * Math.log2(freq)
-    }
-
-    const gapFraction = (total - nonGapTotal) / total
-    return Math.max(0, 1 - entropy / maxPropertyEntropy) * (1 - gapFraction)
+    return score
   })
 }

package/src/rowSpace.test.ts

@@ -0,0 +1,46 @@
+// @vitest-environment jsdom
+import { expect, test } from 'vitest'
+
+import MSAModelF from './model.ts'
+
+// the tree names a tip the alignment has no sequence for. It still occupies a
+// row of vertical space (drawn blank), so anything that maps y-pixels to rows has
+// to count it, or the last row becomes unhoverable and fit-to-height overshoots.
+const msa = `>a
+ACGT
+>b
+ACGT`
+const tree = '((a:1,b:1):1,ghost:1);'
+
+function makeModel() {
+  const model = MSAModelF().create({
+    id: 'row-space-test',
+    type: 'MsaView',
+    msaFormat: 'fasta',
+    height: 400,
+    data: { msa, tree },
+  })
+  model.setWidth(800)
+  return model
+}
+
+test('row space counts tree leaves, not just rows with sequence', () => {
+  const model = makeModel()
+  expect(model.rowNames).toEqual(['a', 'b', 'ghost'])
+  expect(model.rows.map(r => r[0])).toEqual(['a', 'b'])
+  expect(model.numRows).toBe(3)
+  expect(model.totalHeight).toBe(3 * model.rowHeight)
+})
+
+test('the last row is addressable', () => {
+  const model = makeModel()
+  const lastRow = model.numRows - 1
+  model.setMousePos(0, lastRow)
+  expect(model.mouseOverRowName).toBe('ghost')
+})
+
+test('fit vertically leaves every row on screen', () => {
+  const model = makeModel()
+  model.fitVertically()
+  expect(model.totalHeight).toBeLessThanOrEqual(model.msaAreaHeight)
+})

package/src/seqPosToGlobalCol.ts

@@ -15,6 +15,24 @@ import { isBlank } from './util.ts'
  * seqPosToGlobalCol({ row: "A-TG-C", seqPos: 2 }) // → 3 (G)
  * seqPosToGlobalCol({ row: "A-TG-C", seqPos: 3 }) // → 5 (C)
  */
+/**
+ * The global column of every ungapped sequence position in a row, i.e.
+ * index[seqPos] is the column holding the seqPos-th non-gap character. Amortizes
+ * repeated seqPosToGlobalCol lookups (the domain overlay does one per feature
+ * per row) into a single pass per row.
+ */
+export function buildSeqPosIndex(row: string) {
+  const index = new Int32Array(row.length)
+  let n = 0
+  for (let col = 0; col < row.length; col++) {
+    // bit trick: (code - 45) >>> 0 <= 1 checks for '-' (45) or '.' (46)
+    if (!((row.charCodeAt(col) - 45) >>> 0 <= 1)) {
+      index[n++] = col
+    }
+  }
+  return index.subarray(0, n)
+}
+
 export function seqPosToGlobalCol({
   row,
   seqPos,

package/src/stripDefault.test.ts

@@ -0,0 +1,48 @@
+import { getSnapshot, types } from '@jbrowse/mobx-state-tree'
+import { afterEach, expect, test } from 'vitest'
+
+import { stripDefault } from './stripDefault.ts'
+
+const real = types.stripDefault
+
+afterEach(() => {
+  types.stripDefault = real
+})
+
+test('strips defaults from the snapshot when the host mst supports it', () => {
+  const model = types
+    .model({ a: stripDefault(types.boolean, false) })
+    .create({})
+  expect(model.a).toBe(false)
+  expect(getSnapshot(model).a).toBeUndefined()
+})
+
+// The path that actually runs inside every RELEASED jbrowse-web: the host
+// supplies its own mobx-state-tree, and stripDefault only exists in the copy
+// that ships with unreleased @jbrowse/core. Calling it there used to throw while
+// the model was built, which error-paged the whole app. dev has the API, so
+// without stubbing it away this path is never exercised.
+test('falls back to types.optional when the host mst lacks stripDefault', () => {
+  // @ts-expect-error deleting it is the point: simulate an older host
+  delete types.stripDefault
+  const model = types
+    .model({ a: stripDefault(types.boolean, false) })
+    .create({})
+  expect(model.a).toBe(false)
+  // the only difference: the default is serialized rather than omitted
+  expect(getSnapshot(model).a).toBe(false)
+})
+
+test('non-default values survive both paths', () => {
+  const withApi = types
+    .model({ a: stripDefault(types.number, 1) })
+    .create({ a: 5 })
+  expect(getSnapshot(withApi).a).toBe(5)
+
+  // @ts-expect-error see above
+  delete types.stripDefault
+  const without = types
+    .model({ a: stripDefault(types.number, 1) })
+    .create({ a: 5 })
+  expect(getSnapshot(without).a).toBe(5)
+})

package/src/stripDefault.ts

@@ -0,0 +1,35 @@
+import { types } from '@jbrowse/mobx-state-tree'
+
+import type {
+  IAnyType,
+  IOptionalIType,
+  OptionalDefaultValueOrFunction,
+} from '@jbrowse/mobx-state-tree'
+
+/**
+ * `types.stripDefault`, degrading to `types.optional` on hosts that lack it.
+ *
+ * stripDefault keeps defaulted properties out of snapshots, but it exists only
+ * in the mobx-state-tree that ships with unreleased @jbrowse/core. This package
+ * declares `@jbrowse/mobx-state-tree: ^5.0.0`, and inside jbrowse-web the host
+ * supplies its own copy at runtime -- the plugin bundle externalizes it -- so we
+ * genuinely do not know which version we are calling until we are running.
+ *
+ * Calling it where it is absent throws while the model is being constructed,
+ * which in a plugin bundle means PluginLoader rejects and the entire app renders
+ * its error page. Losing minimal snapshots is a far better failure than losing
+ * the session, so this degrades instead.
+ *
+ * The two signatures are identical, so behaviour differs only in that defaults
+ * reappear in snapshots on older hosts (bigger session snapshots and shared
+ * URLs, nothing incorrect). stripDefaultSnapshot.test.ts still pins the stripped
+ * behaviour, since dev runs against a version that has it.
+ */
+export function stripDefault<IT extends IAnyType>(
+  type: IT,
+  defaultValue: OptionalDefaultValueOrFunction<IT>,
+): IOptionalIType<IT, [undefined]> {
+  return typeof types.stripDefault === 'function'
+    ? types.stripDefault(type, defaultValue)
+    : types.optional(type, defaultValue)
+}

package/src/types.ts

@@ -26,6 +26,29 @@ export interface BasicTrack {
   model: TextTrackModel & BarTrackModel
 }
 
+// one InterProScan/GFF annotation location flattened onto a single row, as
+// produced by the model's tidyInterProAnnotations
+export interface TidyDomainAnnotation {
+  id: string
+  name: string
+  accession: string
+  description: string
+  featureType?: string
+  start: number
+  end: number
+  strand?: number
+}
+
+// a tidy annotation resolved to the visible column span it is drawn across.
+// stackIndex is its position within its row's annotation list, which the
+// sub-row layout uses to stack boxes.
+export interface DomainBand {
+  annotation: TidyDomainAnnotation
+  startCol: number
+  endCol: number
+  stackIndex: number
+}
+
 export interface Node {
   children?: Node[]
   name?: string

package/src/version.ts

@@ -1 +1 @@
-export const version = '5.6.1'
+export const version = '5.6.3'

package/dist/components/msa/getVisibleLeaves.d.ts

@@ -1,6 +0,0 @@
-import type { MsaViewModel } from '../../model.ts';
-export declare function getVisibleLeaves({ model, offsetY, blockSizeY, }: {
-    model: MsaViewModel;
-    offsetY: number;
-    blockSizeY: number;
-}): import("../../hierarchy.ts").HierarchyNode<import("../../types.ts").NodeWithIdsAndLength>[];

package/dist/components/msa/getVisibleLeaves.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"getVisibleLeaves.js","sourceRoot":"","sources":["../../../src/components/msa/getVisibleLeaves.ts"],"names":[],"mappings":"AAEA,2EAA2E;AAC3E,2DAA2D;AAC3D,MAAM,UAAU,gBAAgB,CAAC,EAC/B,KAAK,EACL,OAAO,EACP,UAAU,GAKX;IACC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,GAAG,KAAK,CAAA;IACnC,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,OAAO,GAAG,SAAS,CAAC,GAAG,SAAS,CAAC,CAAC,CAAA;IACzE,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,CACnB,CAAC,EACD,IAAI,CAAC,IAAI,CAAC,CAAC,OAAO,GAAG,UAAU,GAAG,SAAS,CAAC,GAAG,SAAS,CAAC,CAC1D,CAAA;IACD,OAAO,MAAM,CAAC,KAAK,CAAC,MAAM,EAAE,IAAI,CAAC,CAAA;AACnC,CAAC"}

package/dist/useDevicePixelRatio.d.ts

@@ -1 +0,0 @@
-export declare function useDevicePixelRatio(): number;

package/dist/useDevicePixelRatio.js

@@ -1,27 +0,0 @@
-import { useSyncExternalStore } from 'react';
-// Subscribes to devicePixelRatio changes (moving the window between monitors,
-// browser zoom). The matchMedia query is pinned to the current ratio, so on each
-// change we re-register against the new ratio to keep tracking subsequent moves.
-function subscribe(callback) {
-    if (typeof window === 'undefined') {
-        return () => { };
-    }
-    let mql = window.matchMedia(`(resolution: ${window.devicePixelRatio}dppx)`);
-    function onChange() {
-        callback();
-        mql.removeEventListener('change', onChange);
-        mql = window.matchMedia(`(resolution: ${window.devicePixelRatio}dppx)`);
-        mql.addEventListener('change', onChange);
-    }
-    mql.addEventListener('change', onChange);
-    return () => {
-        mql.removeEventListener('change', onChange);
-    };
-}
-function getSnapshot() {
-    return typeof window === 'undefined' ? 1 : window.devicePixelRatio;
-}
-export function useDevicePixelRatio() {
-    return useSyncExternalStore(subscribe, getSnapshot, () => 1);
-}
-//# sourceMappingURL=useDevicePixelRatio.js.map

package/dist/useDevicePixelRatio.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useDevicePixelRatio.js","sourceRoot":"","sources":["../src/useDevicePixelRatio.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,OAAO,CAAA;AAE5C,8EAA8E;AAC9E,iFAAiF;AACjF,iFAAiF;AACjF,SAAS,SAAS,CAAC,QAAoB;IACrC,IAAI,OAAO,MAAM,KAAK,WAAW,EAAE,CAAC;QAClC,OAAO,GAAG,EAAE,GAAE,CAAC,CAAA;IACjB,CAAC;IACD,IAAI,GAAG,GAAG,MAAM,CAAC,UAAU,CAAC,gBAAgB,MAAM,CAAC,gBAAgB,OAAO,CAAC,CAAA;IAC3E,SAAS,QAAQ;QACf,QAAQ,EAAE,CAAA;QACV,GAAG,CAAC,mBAAmB,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAA;QAC3C,GAAG,GAAG,MAAM,CAAC,UAAU,CAAC,gBAAgB,MAAM,CAAC,gBAAgB,OAAO,CAAC,CAAA;QACvE,GAAG,CAAC,gBAAgB,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAA;IAC1C,CAAC;IACD,GAAG,CAAC,gBAAgB,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAA;IACxC,OAAO,GAAG,EAAE;QACV,GAAG,CAAC,mBAAmB,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAA;IAC7C,CAAC,CAAA;AACH,CAAC;AAED,SAAS,WAAW;IAClB,OAAO,OAAO,MAAM,KAAK,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,gBAAgB,CAAA;AACpE,CAAC;AAED,MAAM,UAAU,mBAAmB;IACjC,OAAO,oBAAoB,CAAC,SAAS,EAAE,WAAW,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC,CAAA;AAC9D,CAAC"}

package/src/useDevicePixelRatio.ts

@@ -1,29 +0,0 @@
-import { useSyncExternalStore } from 'react'
-
-// Subscribes to devicePixelRatio changes (moving the window between monitors,
-// browser zoom). The matchMedia query is pinned to the current ratio, so on each
-// change we re-register against the new ratio to keep tracking subsequent moves.
-function subscribe(callback: () => void) {
-  if (typeof window === 'undefined') {
-    return () => {}
-  }
-  let mql = window.matchMedia(`(resolution: ${window.devicePixelRatio}dppx)`)
-  function onChange() {
-    callback()
-    mql.removeEventListener('change', onChange)
-    mql = window.matchMedia(`(resolution: ${window.devicePixelRatio}dppx)`)
-    mql.addEventListener('change', onChange)
-  }
-  mql.addEventListener('change', onChange)
-  return () => {
-    mql.removeEventListener('change', onChange)
-  }
-}
-
-function getSnapshot() {
-  return typeof window === 'undefined' ? 1 : window.devicePixelRatio
-}
-
-export function useDevicePixelRatio() {
-  return useSyncExternalStore(subscribe, getSnapshot, () => 1)
-}