react-msaview 5.4.0 → 5.4.1

package/src/model.ts

@@ -249,6 +249,15 @@ function stateModelFactory() {
          * #property
          */
         relativeTo: types.maybe(types.string),
+        /**
+         * #property
+         * declarative seed for the highlighted-columns overlay (visible column
+         * indices). Unlike the volatile `highlightedColumns` (driven by
+         * transient genome-hover sync), this persists in the snapshot/URL so a
+         * shared link can open with specific columns highlighted. Applied once
+         * in afterCreate.
+         */
+        highlightColumns: types.frozen<number[] | undefined>(),
       }),
     )
     .volatile(() => ({
@@ -944,7 +953,10 @@ function stateModelFactory() {
       get colConsensus() {
         const { colStats, colStatsSums } = this
         return colStats.map((stats, i) => {
-          const total = colStatsSums[i]!
+          const total = colStatsSums[i]
+          if (!total) {
+            return { letter: '', color: undefined }
+          }
           let maxCount = 0
           let letter = ''
           for (const [key, val] of Object.entries(stats)) {
@@ -1259,12 +1271,8 @@ function stateModelFactory() {
        */
       zoomIn() {
         transaction(() => {
-          self.colWidth = Math.min(maxCellSize, Math.ceil(self.colWidth * 1.5))
-          self.rowHeight = Math.min(
-            maxCellSize,
-            Math.ceil(self.rowHeight * 1.5),
-          )
-          self.scrollX = clamp(self.scrollX, self.maxScrollX, 0)
+          this.zoomInHorizontal()
+          this.zoomInVertical()
         })
       },
       /**
@@ -1272,15 +1280,8 @@ function stateModelFactory() {
        */
       zoomOut() {
         transaction(() => {
-          self.colWidth = Math.max(
-            minColWidth,
-            Math.floor(self.colWidth * 0.75),
-          )
-          self.rowHeight = Math.max(
-            minRowHeight,
-            Math.floor(self.rowHeight * 0.75),
-          )
-          self.scrollX = clamp(self.scrollX, self.maxScrollX, 0)
+          this.zoomOutHorizontal()
+          this.zoomOutVertical()
         })
       },
       /**
@@ -1314,9 +1315,13 @@ function stateModelFactory() {
           )
 
           const anchoredScrollY = offsetY - rowInView * self.rowHeight
-          const overflow = Math.max(0, self.totalHeight - self.height)
+          // maxScrollY is -(totalHeight - visibleMsaHeight) when the alignment
+          // overflows, so -maxScrollY is exactly that overflow past the
+          // scrollable MSA viewport (0 when it fits)
+          const overflow = Math.max(0, -self.maxScrollY)
+          const visibleHeight = self.totalHeight - overflow
           const topBias =
-            self.height > 0 ? clamp(1 - overflow / self.height, 0, 1) : 0
+            visibleHeight > 0 ? clamp(1 - overflow / visibleHeight, 0, 1) : 1
           self.scrollY = clamp(
             anchoredScrollY * (1 - topBias),
             self.maxScrollY,
@@ -1703,22 +1708,8 @@ function stateModelFactory() {
        * #action
        */
       fit() {
-        if (self.numRows > 0) {
-          self.rowHeight = clamp(
-            self.msaAreaHeight / self.numRows,
-            minRowHeight,
-            maxCellSize,
-          )
-        }
-        if (self.numColumns > 0) {
-          self.colWidth = clamp(
-            self.msaAreaWidth / self.numColumns,
-            minColWidth,
-            maxCellSize,
-          )
-        }
-        self.scrollX = 0
-        self.scrollY = 0
+        this.fitVertically()
+        this.fitHorizontally()
       },
       /**
        * #action
@@ -1748,6 +1739,13 @@ function stateModelFactory() {
       },
 
       afterCreate() {
+        // seed the highlighted-columns overlay from the declarative property so
+        // a shared snapshot/URL opens with those columns highlighted (the
+        // volatile highlightedColumns can later be driven by genome-hover sync)
+        if (self.highlightColumns?.length) {
+          self.setHighlightedColumns(self.highlightColumns)
+        }
+
         addDisposer(
           self,
           autorun(() => {

package/src/neighborJoining.ts

@@ -194,16 +194,10 @@ function neighborJoining(distances: number[][], names: string[]): NJNode {
     const ri = r.get(minI)!
     const rj = r.get(minJ)!
 
-    let limbI: number
-    let limbJ: number
-
-    if (remaining > 2) {
-      limbI = dij / 2 + (ri - rj) / (2 * (remaining - 2))
-      limbJ = dij - limbI
-    } else {
-      limbI = dij / 2
-      limbJ = dij / 2
-    }
+    // remaining is always > 2 inside this loop; the final two nodes are
+    // connected after it
+    let limbI = dij / 2 + (ri - rj) / (2 * (remaining - 2))
+    let limbJ = dij - limbI
 
     // Ensure non-negative branch lengths
     limbI = Math.max(0, limbI)
@@ -217,19 +211,18 @@ function neighborJoining(distances: number[][], names: string[]): NJNode {
       rightLength: limbJ,
     }
 
-    // Update distance matrix
-    const newIdx = minI
+    // Update distance matrix, reusing minI's slot for the merged node
     for (const k of active) {
       if (k !== minI && k !== minJ) {
         const newDist = (D[minI]![k]! + D[minJ]![k]! - dij) / 2
-        D[newIdx]![k] = Math.max(0, newDist)
-        D[k]![newIdx] = Math.max(0, newDist)
+        D[minI]![k] = Math.max(0, newDist)
+        D[k]![minI] = Math.max(0, newDist)
       }
     }
 
     // Mark minJ as removed
     nodes[minJ] = undefined
-    nodes[newIdx] = newNode
+    nodes[minI] = newNode
 
     remaining--
   }
@@ -257,25 +250,45 @@ function neighborJoining(distances: number[][], names: string[]): NJNode {
   return nodes[finalActive[0]!]!
 }
 
-function nodeToNewick(node: NJNode, branchLength?: number): string {
-  let result: string
-
-  if (node.name !== undefined && !node.left && !node.right) {
-    const quotedName = node.name.replaceAll("'", "''")
-    result = `'${quotedName}'`
-  } else {
-    const leftNewick = node.left ? nodeToNewick(node.left, node.leftLength) : ''
-    const rightNewick = node.right
-      ? nodeToNewick(node.right, node.rightLength)
-      : ''
-    result = `(${leftNewick},${rightNewick})`
-  }
+function withBranchLength(newick: string, branchLength?: number) {
+  return branchLength === undefined
+    ? newick
+    : `${newick}:${branchLength.toFixed(6)}`
+}
 
-  if (branchLength !== undefined) {
-    result += `:${branchLength.toFixed(6)}`
+// Emit Newick iteratively rather than recursively: an NJ tree of N leaves can
+// be a caterpillar of depth ~N, so recursion risks a stack overflow on large
+// alignments (matching the iterative-traversal convention in hierarchy.ts).
+function nodeToNewick(root: NJNode): string {
+  const postOrder: NJNode[] = []
+  const stack: NJNode[] = [root]
+  while (stack.length > 0) {
+    const node = stack.pop()!
+    postOrder.push(node)
+    if (node.left) {
+      stack.push(node.left)
+    }
+    if (node.right) {
+      stack.push(node.right)
+    }
   }
 
-  return result
+  const newickByNode = new Map<NJNode, string>()
+  for (let i = postOrder.length - 1; i >= 0; i--) {
+    const node = postOrder[i]!
+    if (node.name !== undefined && !node.left && !node.right) {
+      newickByNode.set(node, `'${node.name.replaceAll("'", "''")}'`)
+    } else {
+      const left = node.left
+        ? withBranchLength(newickByNode.get(node.left)!, node.leftLength)
+        : ''
+      const right = node.right
+        ? withBranchLength(newickByNode.get(node.right)!, node.rightLength)
+        : ''
+      newickByNode.set(node, `(${left},${right})`)
+    }
+  }
+  return newickByNode.get(root)!
 }
 
 export function calculateNeighborJoiningTree(

package/src/version.ts

@@ -1 +1 @@
-export const version = '5.4.0'
+export const version = '5.4.1'