@euphrasiologist/lwphylo 1.1.5 → 1.1.9

package/src/utils/edges.js

@@ -4,52 +4,23 @@
  * are the $edge slot. I think.
  */
 
-export default function (df, rectangular = false) {
-  var result = [],
-    parent
+export default function edges(df, rectangular = false) {
+  const rows = [...df].sort((a, b) => a.thisId - b.thisId);
+  const byId = new Map(rows.map((r) => [r.thisId, r]));
+  const result = [];
 
-  // make sure data frame is sorted
-  df.sort(function (a, b) {
-    return a.thisId - b.thisId;
-  });
-
-  for (const row of df) {
-    if (row.parentId === null) {
-      continue; // skip the root
-    }
-    parent = df[row.parentId];
-    if (parent === null || parent === undefined) continue;
+  for (const row of rows) {
+    if (row.parentId == null) continue;
+    const parent = byId.get(row.parentId);
+    if (!parent) continue;
 
     if (rectangular) {
-      var pair1 = {
-        x1: row.x,
-        y1: row.y,
-        id1: row.thisId,
-        x2: parent.x,
-        y2: row.y,
-        id2: undefined
-      };
-      result.push(pair1);
-      var pair2 = {
-        x1: parent.x,
-        y1: row.y,
-        id1: undefined,
-        x2: parent.x,
-        y2: parent.y,
-        id2: row.parentId
-      };
-      result.push(pair2);
+      result.push({ x1: row.x, y1: row.y, id1: row.thisId, x2: parent.x, y2: row.y, id2: undefined });
+      result.push({ x1: parent.x, y1: row.y, id1: undefined, x2: parent.x, y2: parent.y, id2: row.parentId });
     } else {
-      var pair3 = {
-        x1: row.x,
-        y1: row.y,
-        id1: row.thisId,
-        x2: parent.x,
-        y2: parent.y,
-        id2: row.parentId
-      };
-      result.push(pair3);
+      result.push({ x1: row.x, y1: row.y, id1: row.thisId, x2: parent.x, y2: parent.y, id2: row.parentId });
     }
   }
   return result;
-}
+}
+

package/src/utils/indexing.js

@@ -0,0 +1,64 @@
+/**
+ * Build quick indexes for a fortified data frame.
+ */
+export function indexTree(df) {
+  const byId = new Map(df.map(r => [r.thisId, r]));
+  const children = new Map(df.map(r => [r.thisId, []]));
+  let root = null;
+  for (const r of df) {
+    if (r.parentId == null) { root = r.thisId; continue; }
+    children.get(r.parentId).push(r.thisId);
+  }
+  // depths (BFS)
+  const depth = new Map(); if (root != null) depth.set(root, 0);
+  const q = root != null ? [root] : [];
+  while (q.length) {
+    const u = q.shift();
+    for (const v of (children.get(u) || [])) {
+      depth.set(v, (depth.get(u) || 0) + 1);
+      q.push(v);
+    }
+  }
+  return { byId, children, depth, root };
+}
+
+/**
+ * Compute the node->root path for highlighting (returns [tip,...,root]).
+ */
+export function pathToRoot(dfIndex, nodeId) {
+  const { byId } = dfIndex;
+  const path = [];
+  let cur = nodeId;
+  while (cur != null) {
+    path.push(cur);
+    const row = byId.get(cur);
+    cur = row?.parentId ?? null;
+  }
+  return path;
+}
+
+/**
+ * Convert a path (node ids) to parent-child edge pairs.
+ */
+export function edgesOnPath(pathIds) {
+  const pairs = [];
+  for (let i = 0; i < pathIds.length - 1; i++) {
+    const child = pathIds[i], parent = pathIds[i + 1];
+    pairs.push({ child, parent });
+  }
+  return pairs;
+}
+
+/**
+ * Optional: split segments at midpoints (useful for finer-grain highlighting).
+ */
+export function splitEdges(segments) {
+  const out = [];
+  for (const s of segments) {
+    const mx = (s.x1 + s.x2) / 2, my = (s.y1 + s.y2) / 2;
+    out.push({ ...s, x2: mx, y2: my, half: "proximal" });
+    out.push({ ...s, x1: mx, y1: my, half: "distal" });
+  }
+  return out;
+}
+

package/src/utils/meanAngle.js

@@ -6,40 +6,15 @@
 * e.g. if the start/end angles are equal to pi, the sign must be flipped.
 */
 
+export default function meanAngle(a, b) {
+  // normalize to [0, 2pi)
+  const norm = (θ) => (θ % (2*Math.PI) + 2*Math.PI) % (2*Math.PI);
+  a = norm(a); b = norm(b);
 
-export default function (start, end) {
-  // if the angles are exactly equal but opposite
-  // return Math.PI (else undefined is returned...)
-  if (
-    Math.sign(start) !== Math.sign(end) &&
-    Math.abs(start) === Math.abs(end)
-  ) {
-    return Math.PI;
-  }
+  // handle wraparound by averaging unit vectors
+  const X = (Math.cos(a) + Math.cos(b)) / 2;
+  const Y = (Math.sin(a) + Math.sin(b)) / 2;
+  if (X === 0 && Y === 0) return 0; // opposite directions, arbitrary
+  return norm(Math.atan2(Y, X));
+}
 
-  // calculate the average sin and cosine for the angles
-  const X = (Math.cos(start) + Math.cos(end)) / 2,
-    Y = (Math.sin(start) + Math.sin(end)) / 2;
-
-  const signX = Math.sign(X),
-    signY = Math.sign(Y);
-
-  var meanAngle;
-  // adjustments for the sign of each of X, Y
-  if (signX === 1 && signY === 1) {
-    meanAngle = Math.atan(Y / X);
-  } else if (signX === 1 && signY === -1) {
-    meanAngle = 2 * Math.PI - Math.atan(Y / X);
-  } else if (signX === -1 && signY === 1) {
-    meanAngle = Math.PI - Math.atan(Y / X);
-  } else if (signX === -1 && signY === -1) {
-    meanAngle = Math.PI + Math.atan(Y / X);
-  }
-
-  // if the start or end angles are equal to PI (or close approximations)
-  // flip the sign.
-  return start.toString().indexOf("3.14159") > -1 ||
-    end.toString().indexOf("3.14159") > -1
-    ? -meanAngle
-    : meanAngle;
-}

package/src/utils/numTips.js

@@ -4,29 +4,24 @@
  */
 
 function levelorder(root) {
-    // aka breadth-first search
-    var queue = [root],
-        result = [],
-        curnode;
-
-    while (queue.length > 0) {
-        curnode = queue.pop();
-        result.push(curnode);
-        for (const child of curnode.children) {
-            queue.push(child);
-        }
-    }
-    return (result);
+  const queue = [root], result = [];
+  while (queue.length) {
+    const curnode = queue.shift();         // <- FIFO
+    result.push(curnode);
+    for (const child of curnode.children) queue.push(child);
+  }
+  return result;
 }
 
+
 /**
  * Count the number of tips that descend from this node
  */
 
-export default function (thisnode) {
-    var result = 0;
-    for (const node of levelorder(thisnode)) {
-        if (node.children.length == 0) result++;
-    }
-    return (result);
-}
+export default function(thisnode) {
+  var result = 0;
+  for (const node of levelorder(thisnode)) {
+    if (node.children.length == 0) result++;
+  }
+  return (result);
+}

package/src/utils/parentFisheye.js

@@ -1,11 +1,9 @@
-// find the x & y coordinates of the parental species
-export default function (d, data /* e.g. lwPhylo.unrooted.data */) {
-  for (let i = 0; i < data.length; i++) {
-    if (d.parentId === data[i].thisId) {
-      return {
-        px: data[i].fisheye.x,
-        py: data[i].fisheye.y
-      };
-    }
-  }
-}
+export function makeIndexById(rows, key = "thisId") {
+  return new Map(rows.map(d => [d[key], d]));
+}
+export default function parentFisheye(d, data) {
+  const byId = makeIndexById(data);
+  const parent = byId.get(d.parentId);
+  return parent ? { px: parent.fisheye.x, py: parent.fisheye.y } : null;
+}
+

package/src/utils/preorder.js

@@ -1,11 +1,38 @@
 /**
- * Recursive function for pre-order traversal of tree
+ * Recursive function for pre-order traversal of tree (returns array)
  */
-
 export function preorder(node, list = []) {
-    list.push(node);
-    for (var i = 0; i < node.children.length; i++) {
-        list = preorder(node.children[i], list);
+  list.push(node);
+  for (let i = 0; i < (node.children?.length || 0); i++) {
+    list = preorder(node.children[i], list);
+  }
+  return list;
+}
+
+/**
+ * Iterative generator traversals (avoid recursion limits on large trees)
+ */
+export function* preorderIter(root) {
+  const stack = [root];
+  while (stack.length) {
+    const n = stack.pop();
+    yield n;
+    if (n.children) for (let i = n.children.length - 1; i >= 0; --i) stack.push(n.children[i]);
+  }
+}
+
+export function* postorderIter(root) {
+  const stack = [[root, 0]];
+  while (stack.length) {
+    const top = stack[stack.length - 1];
+    const [n, i] = top;
+    if (!n.children || i >= n.children.length) {
+      stack.pop();
+      yield n;
+    } else {
+      top[1] = i + 1;
+      stack.push([n.children[i], 0]);
     }
-    return (list);
+  }
 }
+

package/src/utils/readTree.js

@@ -1,74 +1,64 @@
 /**
- * Parse a Newick tree string into a doubly-linked
- * list of JS Objects.  Assigns node labels, branch
- * lengths and node IDs (numbering terminal before
- * internal nodes).
+ * Parse a Newick tree string into a doubly-linked list of JS Objects.
+ * Assigns labels, branch lengths, and node IDs (tips before internals if input emits them that way).
+ *
+ * Notes / limitations:
+ * - Quoted labels and NHX annotations are not fully supported.
+ * - Branch lengths in scientific notation are supported (parseFloat).
  */
 
-export default function (text) {
-    // remove whitespace
-    text = text.replace(/ \t/g, '');
+export default function readTree(text) {
+  // Remove all whitespace (space, tabs, newlines)
+  text = String(text).replace(/\s+/g, '');
 
-    var tokens = text.split(/(;|\(|\)|,)/),
-        root = { 'parent': null, 'children': [] },
-        curnode = root,
-        nodeId = 0;
+  const tokens = text.split(/(;|\(|\)|,)/);
+  const root = { parent: null, children: [] };
+  let curnode = root;
+  let nodeId = 0;
 
-    for (const token of tokens) {
-        if (token == "" || token == ';') {
-            continue
-        }
-        if (token == '(') {
-            // add a child to current node
-            let child = {
-                'parent': curnode,
-                'children': []
-            };
-            curnode.children.push(child);
-            curnode = child;  // climb up
-        }
-        else if (token == ',') {
-            // climb down, add another child to parent
-            curnode = curnode.parent;
-            let child = {
-                'parent': curnode,
-                'children': []
-            }
-            curnode.children.push(child);
-            curnode = child;  // climb up
-        }
-        else if (token == ')') {
-            // climb down twice
-            curnode = curnode.parent;
-            if (curnode === null) {
-                break;
-            }
-        }
-        else {
-            var nodeinfo = token.split(':');
+  for (const token of tokens) {
+    if (!token || token === ';') continue;
 
-            if (nodeinfo.length == 1) {
-                if (token.startsWith(':')) {
-                    curnode.label = "";
-                    curnode.branchLength = parseFloat(nodeinfo[0]);
-                } else {
-                    curnode.label = nodeinfo[0];
-                    curnode.branchLength = null;
-                }
-            }
-            else if (nodeinfo.length == 2) {
-                curnode.label = nodeinfo[0];
-                curnode.branchLength = parseFloat(nodeinfo[1]);
-            }
-            else {
-                // TODO: handle edge cases with >1 ":"
-                console.warn(token, "I don't know what to do with two colons!");
-            }
-            curnode.id = nodeId++;  // assign then increment
+    if (token === '(') {
+      const child = { parent: curnode, children: [] };
+      curnode.children.push(child);
+      curnode = child; // descend
+    } else if (token === ',') {
+      // back to parent, then create sibling
+      curnode = curnode.parent;
+      const child = { parent: curnode, children: [] };
+      curnode.children.push(child);
+      curnode = child;
+    } else if (token === ')') {
+      // ascend one level
+      curnode = curnode.parent;
+      if (curnode === null) break;
+    } else {
+      // label/branch-length chunk (e.g., "A:0.01" or "A")
+      const nodeinfo = token.split(':');
+      if (nodeinfo.length === 1) {
+        if (token.startsWith(':')) {
+          curnode.label = '';
+          curnode.branchLength = parseFloat(nodeinfo[0]);
+        } else {
+          curnode.label = nodeinfo[0];
+          curnode.branchLength = null;
         }
+      } else if (nodeinfo.length === 2) {
+        curnode.label = nodeinfo[0];
+        curnode.branchLength = parseFloat(nodeinfo[1]);
+      } else {
+        console.warn(token, "Unhandled token with multiple ':' characters");
+        curnode.label = nodeinfo[0] || '';
+        curnode.branchLength = parseFloat(nodeinfo[nodeinfo.length - 1]);
+      }
+      curnode.id = nodeId++; // assign then increment
     }
+  }
 
-    curnode.id = nodeId;
+  // Ensure root has an id if not assigned during parsing
+  if (root.id == null) root.id = nodeId;
 
-    return (root);
+  return root;
 }
+